/* 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 '@getflip/swirl-components';


@ProxyCmp({
  inputs: ['multiExpand'],
  methods: ['collapseItem', 'expandItem']
})
@Component({
  selector: 'swirl-accordion',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['multiExpand'],
  standalone: false
})
export class SwirlAccordion {
  protected el: HTMLSwirlAccordionElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['expandedItemChange']);
  }
}


export declare interface SwirlAccordion extends Components.SwirlAccordion {

  expandedItemChange: EventEmitter<CustomEvent<string>>;
}


@ProxyCmp({
  inputs: ['description', 'disabled', 'heading', 'headingLevel', 'initiallyOpen', 'itemId'],
  methods: ['collapse', 'expand', 'toggle']
})
@Component({
  selector: 'swirl-accordion-item',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['description', 'disabled', { name: 'heading', required: true }, 'headingLevel', 'initiallyOpen', 'itemId'],
  standalone: false
})
export class SwirlAccordionItem {
  protected el: HTMLSwirlAccordionItemElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['expansionChange']);
  }
}


export declare interface SwirlAccordionItem extends Components.SwirlAccordionItem {

  expansionChange: EventEmitter<CustomEvent<boolean>>;
}


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


export declare interface SwirlActionList extends Components.SwirlActionList {}


@ProxyCmp({
  inputs: ['badge', 'description', 'disabled', 'icon', 'iconBadge', 'intent', 'label', 'size', 'suffix', 'swirlAriaExpanded', 'swirlAriaHaspopup', 'truncateLabel']
})
@Component({
  selector: 'swirl-action-list-item',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['badge', 'description', 'disabled', 'icon', 'iconBadge', 'intent', { name: 'label', required: true }, 'size', 'suffix', 'swirlAriaExpanded', 'swirlAriaHaspopup', 'truncateLabel'],
  standalone: false
})
export class SwirlActionListItem {
  protected el: HTMLSwirlActionListItemElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlActionListItem extends Components.SwirlActionListItem {}


@ProxyCmp({
  inputs: ['hasSeparator', 'label', 'separatorSpacing', 'spacing']
})
@Component({
  selector: 'swirl-action-list-section',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['hasSeparator', { name: 'label', required: true }, 'separatorSpacing', 'spacing'],
  standalone: false
})
export class SwirlActionListSection {
  protected el: HTMLSwirlActionListSectionElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlActionListSection extends Components.SwirlActionListSection {}


@ProxyCmp({
  inputs: ['backButtonLabel', 'closeButtonIcon', 'closeButtonLabel', 'paddingInlineEnd', 'paddingInlineStart', 'showBackButton', 'showCloseButton', 'showHeading', 'showStepperControls', 'stepDownButtonLabel', 'stepUpButtonLabel']
})
@Component({
  selector: 'swirl-app-bar',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['backButtonLabel', 'closeButtonIcon', 'closeButtonLabel', 'paddingInlineEnd', 'paddingInlineStart', 'showBackButton', 'showCloseButton', 'showHeading', 'showStepperControls', 'stepDownButtonLabel', 'stepUpButtonLabel'],
  standalone: false
})
export class SwirlAppBar {
  protected el: HTMLSwirlAppBarElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['backButtonClick', 'closeButtonClick', 'stepUpButtonClick', 'stepDownButtonClick']);
  }
}


export declare interface SwirlAppBar extends Components.SwirlAppBar {

  backButtonClick: EventEmitter<CustomEvent<MouseEvent>>;

  closeButtonClick: EventEmitter<CustomEvent<MouseEvent>>;

  stepUpButtonClick: EventEmitter<CustomEvent<MouseEvent>>;

  stepDownButtonClick: EventEmitter<CustomEvent<MouseEvent>>;
}


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


export declare interface SwirlAppIcon extends Components.SwirlAppIcon {}


@ProxyCmp({
  inputs: ['appName', 'backToNavigationViewButtonLabel', 'collapsibleNavigation', 'ctaIcon', 'ctaLabel', 'hasNavigation', 'hideAppBar', 'initialMobileView', 'navigationBackButtonLabel', 'navigationExpansionStateStorageKey', 'navigationLabel', 'navigationOverlayLabel', 'navigationToggleLabel', 'preventContentOverflow', 'roundedCorners', 'showNavigationBackButton', 'sidebarCloseButtonLabel', 'sidebarHeading', 'sidebarPositioning', 'sidebarWidth', 'transitionStyle'],
  methods: ['showSidebar', 'hideSidebar', 'toggleSidebar', 'getCollapsibleNavigationState', 'setCollapsibleNavigationState', 'getScrollContainer', 'changeMobileView']
})
@Component({
  selector: 'swirl-app-layout',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: [{ name: 'appName', required: true }, 'backToNavigationViewButtonLabel', 'collapsibleNavigation', 'ctaIcon', 'ctaLabel', 'hasNavigation', 'hideAppBar', 'initialMobileView', 'navigationBackButtonLabel', 'navigationExpansionStateStorageKey', 'navigationLabel', 'navigationOverlayLabel', 'navigationToggleLabel', 'preventContentOverflow', 'roundedCorners', 'showNavigationBackButton', 'sidebarCloseButtonLabel', 'sidebarHeading', 'sidebarPositioning', 'sidebarWidth', 'transitionStyle'],
  standalone: false
})
export class SwirlAppLayout {
  protected el: HTMLSwirlAppLayoutElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['ctaClick', 'mobileViewChange', 'navigationBackButtonClick', 'navigationExpansionStateChange', 'sidebarToggle']);
  }
}


import type { SwirlAppLayoutMobileView as ISwirlAppLayoutSwirlAppLayoutMobileView } from '@getflip/swirl-components';
import type { SwirlAppLayoutNavigationExpansionState as ISwirlAppLayoutSwirlAppLayoutNavigationExpansionState } from '@getflip/swirl-components';

export declare interface SwirlAppLayout extends Components.SwirlAppLayout {

  ctaClick: EventEmitter<CustomEvent<MouseEvent>>;

  mobileViewChange: EventEmitter<CustomEvent<ISwirlAppLayoutSwirlAppLayoutMobileView>>;

  navigationBackButtonClick: EventEmitter<CustomEvent<MouseEvent>>;

  navigationExpansionStateChange: EventEmitter<CustomEvent<ISwirlAppLayoutSwirlAppLayoutNavigationExpansionState>>;

  sidebarToggle: EventEmitter<CustomEvent<boolean>>;
}


@ProxyCmp({
  inputs: ['autoSelect', 'clearButtonLabel', 'clearable', 'disabled', 'generateSuggestions', 'inline', 'invalid', 'maxLength', 'menuLabel', 'mode', 'multiSelect', 'placeholder', 'required', 'spellCheck', 'swirlAriaDescribedby', 'value']
})
@Component({
  selector: 'swirl-autocomplete',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['autoSelect', 'clearButtonLabel', 'clearable', 'disabled', 'generateSuggestions', 'inline', 'invalid', 'maxLength', 'menuLabel', 'mode', 'multiSelect', 'placeholder', 'required', 'spellCheck', 'swirlAriaDescribedby', 'value'],
  standalone: false
})
export class SwirlAutocomplete {
  protected el: HTMLSwirlAutocompleteElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['valueChange']);
  }
}


import type { SwirlAutocompleteValue as ISwirlAutocompleteSwirlAutocompleteValue } from '@getflip/swirl-components';

export declare interface SwirlAutocomplete extends Components.SwirlAutocomplete {

  valueChange: EventEmitter<CustomEvent<ISwirlAutocompleteSwirlAutocompleteValue>>;
}


@ProxyCmp({
  inputs: ['badge', 'badgePosition', 'color', 'icon', 'initials', 'interactive', 'label', 'loading', 'showLabel', 'size', 'src', 'toolPosition', 'variant']
})
@Component({
  selector: 'swirl-avatar',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['badge', 'badgePosition', 'color', 'icon', 'initials', 'interactive', { name: 'label', required: true }, 'loading', 'showLabel', 'size', 'src', 'toolPosition', 'variant'],
  standalone: false
})
export class SwirlAvatar {
  protected el: HTMLSwirlAvatarElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['imageError', 'imageLoad']);
  }
}


export declare interface SwirlAvatar extends Components.SwirlAvatar {

  imageError: EventEmitter<CustomEvent<void>>;

  imageLoad: EventEmitter<CustomEvent<void>>;
}


@ProxyCmp({
  inputs: ['badge', 'label', 'layout', 'semantics']
})
@Component({
  selector: 'swirl-avatar-group',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['badge', 'label', 'layout', 'semantics'],
  standalone: false
})
export class SwirlAvatarGroup {
  protected el: HTMLSwirlAvatarGroupElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlAvatarGroup extends Components.SwirlAvatarGroup {}


@ProxyCmp({
  inputs: ['icon', 'intent', 'label', 'size', 'variant']
})
@Component({
  selector: 'swirl-badge',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['icon', 'intent', { name: 'label', required: true }, 'size', 'variant'],
  standalone: false
})
export class SwirlBadge {
  protected el: HTMLSwirlBadgeElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlBadge extends Components.SwirlBadge {}


@ProxyCmp({
  inputs: ['actionLabel', 'content', 'dismissLabel', 'dismissable', 'icon', 'importance', 'intent', 'showIcon', 'size']
})
@Component({
  selector: 'swirl-banner',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['actionLabel', { name: 'content', required: true }, 'dismissLabel', 'dismissable', 'icon', 'importance', 'intent', 'showIcon', 'size'],
  standalone: false
})
export class SwirlBanner {
  protected el: HTMLSwirlBannerElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['action', 'dismiss']);
  }
}


export declare interface SwirlBanner extends Components.SwirlBanner {

  action: EventEmitter<CustomEvent<MouseEvent>>;

  dismiss: EventEmitter<CustomEvent<MouseEvent>>;
}


@ProxyCmp({
  inputs: ['basis', 'borderColor', 'borderRadius', 'borderRadiusEndEnd', 'borderRadiusEndStart', 'borderRadiusStartEnd', 'borderRadiusStartStart', 'bordered', 'borderedBlockEnd', 'borderedBlockEndWhenScrolled', 'borderedBlockStart', 'borderedBlockStartWhenScrolled', 'borderedInlineEnd', 'borderedInlineStart', 'bottom', 'centerBlock', 'centerInline', 'cover', 'grow', 'height', 'hideScrollbar', 'left', 'maxHeight', 'maxWidth', 'minHeight', 'minWidth', 'overflow', 'overflowX', 'overflowY', 'padding', 'paddingBlockEnd', 'paddingBlockStart', 'paddingInlineEnd', 'paddingInlineStart', 'position', 'right', 'shrink', 'top', 'width', 'zIndex']
})
@Component({
  selector: 'swirl-box',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['basis', 'borderColor', 'borderRadius', 'borderRadiusEndEnd', 'borderRadiusEndStart', 'borderRadiusStartEnd', 'borderRadiusStartStart', 'bordered', 'borderedBlockEnd', 'borderedBlockEndWhenScrolled', 'borderedBlockStart', 'borderedBlockStartWhenScrolled', 'borderedInlineEnd', 'borderedInlineStart', 'bottom', 'centerBlock', 'centerInline', 'cover', 'grow', 'height', 'hideScrollbar', 'left', 'maxHeight', 'maxWidth', 'minHeight', 'minWidth', 'overflow', 'overflowX', 'overflowY', 'padding', 'paddingBlockEnd', 'paddingBlockStart', 'paddingInlineEnd', 'paddingInlineStart', 'position', 'right', 'shrink', 'top', 'width', 'zIndex'],
  standalone: false
})
export class SwirlBox {
  protected el: HTMLSwirlBoxElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['componentLoad']);
  }
}


export declare interface SwirlBox extends Components.SwirlBox {

  componentLoad: EventEmitter<CustomEvent<void>>;
}


@ProxyCmp({
  inputs: ['cursor', 'disabled', 'download', 'elevated', 'form', 'hideLabel', 'href', 'icon', 'iconPosition', 'inheritFontSize', 'intent', 'label', 'name', 'pill', 'pressed', 'size', 'swirlAriaControls', 'swirlAriaCurrent', 'swirlAriaDescribedby', 'swirlAriaExpanded', 'swirlAriaHaspopup', 'swirlAriaLabel', 'target', 'textAlign', 'type', 'value', 'variant']
})
@Component({
  selector: 'swirl-button',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['cursor', 'disabled', 'download', 'elevated', 'form', 'hideLabel', 'href', 'icon', 'iconPosition', 'inheritFontSize', 'intent', { name: 'label', required: true }, 'name', 'pill', 'pressed', 'size', 'swirlAriaControls', 'swirlAriaCurrent', 'swirlAriaDescribedby', 'swirlAriaExpanded', 'swirlAriaHaspopup', 'swirlAriaLabel', 'target', 'textAlign', 'type', 'value', 'variant'],
  standalone: false
})
export class SwirlButton {
  protected el: HTMLSwirlButtonElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlButton extends Components.SwirlButton {}


@ProxyCmp({
  inputs: ['orientation', 'segmented', 'spacing', 'stretch', 'wrap']
})
@Component({
  selector: 'swirl-button-group',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['orientation', 'segmented', 'spacing', 'stretch', 'wrap'],
  standalone: false
})
export class SwirlButtonGroup {
  protected el: HTMLSwirlButtonGroupElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlButtonGroup extends Components.SwirlButtonGroup {}


@ProxyCmp({
  inputs: ['as', 'borderRadius', 'customBackdropFilter', 'customBackgroundColor', 'elevated', 'elevationLevel', 'height', 'highlighted', 'href', 'imageAspectRatio', 'intent', 'interactive', 'isBorderless', 'justifyContent', 'linkTarget', 'minHeight', 'overflow', 'padding', 'paddingBlockEnd', 'paddingBlockStart', 'paddingInlineEnd', 'paddingInlineStart', 'swirlAriaCurrent', 'swirlAriaLabel', 'swirlAriaLabelledby', 'translucent'],
  methods: ['flash']
})
@Component({
  selector: 'swirl-card',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['as', 'borderRadius', 'customBackdropFilter', 'customBackgroundColor', 'elevated', 'elevationLevel', 'height', 'highlighted', 'href', 'imageAspectRatio', 'intent', 'interactive', 'isBorderless', 'justifyContent', 'linkTarget', 'minHeight', 'overflow', 'padding', 'paddingBlockEnd', 'paddingBlockStart', 'paddingInlineEnd', 'paddingInlineStart', 'swirlAriaCurrent', 'swirlAriaLabel', 'swirlAriaLabelledby', 'translucent'],
  standalone: false
})
export class SwirlCard {
  protected el: HTMLSwirlCardElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['componentLoad']);
  }
}


export declare interface SwirlCard extends Components.SwirlCard {

  componentLoad: EventEmitter<CustomEvent<void>>;
}


@ProxyCmp({
  inputs: ['fade', 'fadeColor', 'label', 'loopAround', 'nextSlideButtonLabel', 'padding', 'paddingBlockEnd', 'paddingBlockStart', 'paddingInlineEnd', 'paddingInlineStart', 'previousSlideButtonLabel', 'spacing'],
  methods: ['scrollToSlide']
})
@Component({
  selector: 'swirl-carousel',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['fade', 'fadeColor', { name: 'label', required: true }, 'loopAround', 'nextSlideButtonLabel', 'padding', 'paddingBlockEnd', 'paddingBlockStart', 'paddingInlineEnd', 'paddingInlineStart', 'previousSlideButtonLabel', 'spacing'],
  standalone: false
})
export class SwirlCarousel {
  protected el: HTMLSwirlCarouselElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['activeSlidesChange']);
  }
}


export declare interface SwirlCarousel extends Components.SwirlCarousel {

  activeSlidesChange: EventEmitter<CustomEvent<HTMLSwirlCarouselSlideElement[]>>;
}


@ProxyCmp({
  inputs: ['aspectRatio', 'label', 'minHeight', 'width']
})
@Component({
  selector: 'swirl-carousel-slide',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['aspectRatio', 'label', 'minHeight', 'width'],
  standalone: false
})
export class SwirlCarouselSlide {
  protected el: HTMLSwirlCarouselSlideElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlCarouselSlide extends Components.SwirlCarouselSlide {}


@ProxyCmp({
  inputs: ['checked', 'description', 'disabled', 'inputId', 'inputName', 'invalid', 'label', 'labelWeight', 'swirlAriaDescribedby', 'swirlAriaLabel', 'value', 'variant']
})
@Component({
  selector: 'swirl-checkbox',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['checked', 'description', 'disabled', { name: 'inputId', required: true }, { name: 'inputName', required: true }, 'invalid', 'label', 'labelWeight', 'swirlAriaDescribedby', 'swirlAriaLabel', 'value', 'variant'],
  standalone: false
})
export class SwirlCheckbox {
  protected el: HTMLSwirlCheckboxElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['valueChange']);
  }
}


export declare interface SwirlCheckbox extends Components.SwirlCheckbox {

  valueChange: EventEmitter<CustomEvent<boolean>>;
}


@ProxyCmp({
  inputs: ['borderRadius', 'icon', 'iconColor', 'intent', 'interactive', 'label', 'pressed', 'progress', 'progressBarLabel', 'removable', 'removeButtonLabel', 'size', 'trailingIcon', 'variant']
})
@Component({
  selector: 'swirl-chip',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['borderRadius', 'icon', 'iconColor', 'intent', 'interactive', { name: 'label', required: true }, 'pressed', 'progress', 'progressBarLabel', 'removable', 'removeButtonLabel', 'size', 'trailingIcon', 'variant'],
  standalone: false
})
export class SwirlChip {
  protected el: HTMLSwirlChipElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['chipClick', 'remove']);
  }
}


export declare interface SwirlChip extends Components.SwirlChip {

  chipClick: EventEmitter<CustomEvent<MouseEvent>>;

  remove: EventEmitter<CustomEvent<MouseEvent>>;
}


@ProxyCmp({
  inputs: ['autoFocus', 'autoSelect', 'disabled', 'inline', 'invalid', 'pickerButtonLabel', 'pickerLabel', 'placeholder', 'readonly', 'required', 'swirlAriaDescribedby', 'value']
})
@Component({
  selector: 'swirl-color-input',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['autoFocus', 'autoSelect', 'disabled', 'inline', 'invalid', 'pickerButtonLabel', 'pickerLabel', 'placeholder', 'readonly', 'required', 'swirlAriaDescribedby', 'value'],
  standalone: false
})
export class SwirlColorInput {
  protected el: HTMLSwirlColorInputElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['inputBlur', 'inputFocus', 'valueChange']);
  }
}


export declare interface SwirlColorInput extends Components.SwirlColorInput {

  inputBlur: EventEmitter<CustomEvent<FocusEvent>>;

  inputFocus: EventEmitter<CustomEvent<FocusEvent>>;

  valueChange: EventEmitter<CustomEvent<string>>;
}


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


export declare interface SwirlColumns extends Components.SwirlColumns {}


@ProxyCmp({
  inputs: ['appName', 'backButonLabel', 'heading', 'helpButonLabel', 'hideContentHeader', 'hideNavigationButtonLabel', 'logoText', 'maxContentWidth', 'navigationLabel', 'showBackButton', 'showHelpButton', 'showNavigationButtonLabel', 'subheading'],
  methods: ['toggleSidebar', 'showSidebar', 'hideSidebar']
})
@Component({
  selector: 'swirl-console-layout',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['appName', 'backButonLabel', 'heading', 'helpButonLabel', 'hideContentHeader', 'hideNavigationButtonLabel', 'logoText', 'maxContentWidth', 'navigationLabel', 'showBackButton', 'showHelpButton', 'showNavigationButtonLabel', 'subheading'],
  standalone: false
})
export class SwirlConsoleLayout {
  protected el: HTMLSwirlConsoleLayoutElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['backButtonClick', 'helpButtonClick']);
  }
}


export declare interface SwirlConsoleLayout extends Components.SwirlConsoleLayout {

  backButtonClick: EventEmitter<CustomEvent<MouseEvent>>;

  helpButtonClick: EventEmitter<CustomEvent<MouseEvent>>;
}


@ProxyCmp({
  inputs: ['intent', 'label', 'tooltip', 'value', 'vertical']
})
@Component({
  selector: 'swirl-data-cell',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['intent', 'label', 'tooltip', 'value', 'vertical'],
  standalone: false
})
export class SwirlDataCell {
  protected el: HTMLSwirlDataCellElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['valueChange']);
  }
}


export declare interface SwirlDataCell extends Components.SwirlDataCell {

  valueChange: EventEmitter<CustomEvent<MouseEvent>>;
}


@ProxyCmp({
  inputs: ['description', 'hideLabel', 'label']
})
@Component({
  selector: 'swirl-data-cell-stack',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['description', 'hideLabel', 'label'],
  standalone: false
})
export class SwirlDataCellStack {
  protected el: HTMLSwirlDataCellStackElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlDataCellStack extends Components.SwirlDataCellStack {}


@ProxyCmp({
  inputs: ['autoFocus', 'autoSelect', 'datePickerDisableDate', 'datePickerLabel', 'datePickerTriggerLabel', 'disabled', 'firstDayOfWeek', 'format', 'inline', 'invalid', 'labels', 'locale', 'placeholder', 'preferredInputMode', 'readonly', 'required', 'swirlAriaDescribedby', 'value'],
  methods: ['openPicker']
})
@Component({
  selector: 'swirl-date-input',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['autoFocus', 'autoSelect', 'datePickerDisableDate', 'datePickerLabel', 'datePickerTriggerLabel', 'disabled', 'firstDayOfWeek', 'format', 'inline', 'invalid', 'labels', 'locale', 'placeholder', 'preferredInputMode', 'readonly', 'required', 'swirlAriaDescribedby', 'value'],
  standalone: false
})
export class SwirlDateInput {
  protected el: HTMLSwirlDateInputElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['invalidInput', 'valueChange']);
  }
}


export declare interface SwirlDateInput extends Components.SwirlDateInput {

  invalidInput: EventEmitter<CustomEvent<string>>;

  valueChange: EventEmitter<CustomEvent<string>>;
}


@ProxyCmp({
  inputs: ['disableDate', 'firstDayOfWeek', 'fixedAspectRatio', 'fixedMaxWidth', 'labels', 'locale', 'range', 'startDate', 'value']
})
@Component({
  selector: 'swirl-date-picker',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['disableDate', 'firstDayOfWeek', 'fixedAspectRatio', 'fixedMaxWidth', 'labels', 'locale', 'range', 'startDate', 'value'],
  standalone: false
})
export class SwirlDatePicker {
  protected el: HTMLSwirlDatePickerElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['valueChange']);
  }
}


export declare interface SwirlDatePicker extends Components.SwirlDatePicker {

  valueChange: EventEmitter<CustomEvent<Date | Date[]>>;
}


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


export declare interface SwirlDescriptionList extends Components.SwirlDescriptionList {}


@ProxyCmp({
  inputs: ['bordered', 'maxWidth', 'term', 'tooltip']
})
@Component({
  selector: 'swirl-description-list-item',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['bordered', 'maxWidth', { name: 'term', required: true }, 'tooltip'],
  standalone: false
})
export class SwirlDescriptionListItem {
  protected el: HTMLSwirlDescriptionListItemElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlDescriptionListItem extends Components.SwirlDescriptionListItem {}


@ProxyCmp({
  inputs: ['actionsOrientation', 'hideLabel', 'intent', 'label', 'primaryActionLabel', 'returnFocusTo', 'secondaryActionLabel', 'size'],
  methods: ['open', 'close']
})
@Component({
  selector: 'swirl-dialog',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['actionsOrientation', 'hideLabel', 'intent', { name: 'label', required: true }, 'primaryActionLabel', 'returnFocusTo', 'secondaryActionLabel', 'size'],
  standalone: false
})
export class SwirlDialog {
  protected el: HTMLSwirlDialogElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['dialogClose', 'dialogOpen', 'primaryAction', 'secondaryAction', 'toggleDialog']);
  }
}


import type { SwirlDialogToggleEvent as ISwirlDialogSwirlDialogToggleEvent } from '@getflip/swirl-components';

export declare interface SwirlDialog extends Components.SwirlDialog {

  dialogClose: EventEmitter<CustomEvent<void>>;

  dialogOpen: EventEmitter<CustomEvent<void>>;

  primaryAction: EventEmitter<CustomEvent<MouseEvent>>;

  secondaryAction: EventEmitter<CustomEvent<MouseEvent>>;

  toggleDialog: EventEmitter<CustomEvent<ISwirlDialogSwirlDialogToggleEvent>>;
}


@ProxyCmp({
  inputs: ['label', 'name', 'size']
})
@Component({
  selector: 'swirl-emoji',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['label', { name: 'name', required: true }, 'size'],
  standalone: false
})
export class SwirlEmoji {
  protected el: HTMLSwirlEmojiElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlEmoji extends Components.SwirlEmoji {}


@ProxyCmp({
  inputs: ['label', 'size']
})
@Component({
  selector: 'swirl-emoji-clap',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['label', 'size'],
  standalone: false
})
export class SwirlEmojiClap {
  protected el: HTMLSwirlEmojiClapElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlEmojiClap extends Components.SwirlEmojiClap {}


@ProxyCmp({
  inputs: ['label', 'size']
})
@Component({
  selector: 'swirl-emoji-happy',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['label', 'size'],
  standalone: false
})
export class SwirlEmojiHappy {
  protected el: HTMLSwirlEmojiHappyElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlEmojiHappy extends Components.SwirlEmojiHappy {}


@ProxyCmp({
  inputs: ['label', 'size']
})
@Component({
  selector: 'swirl-emoji-idea',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['label', 'size'],
  standalone: false
})
export class SwirlEmojiIdea {
  protected el: HTMLSwirlEmojiIdeaElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlEmojiIdea extends Components.SwirlEmojiIdea {}


@ProxyCmp({
  inputs: ['label', 'size']
})
@Component({
  selector: 'swirl-emoji-love',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['label', 'size'],
  standalone: false
})
export class SwirlEmojiLove {
  protected el: HTMLSwirlEmojiLoveElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlEmojiLove extends Components.SwirlEmojiLove {}


@ProxyCmp({
  inputs: ['label', 'size']
})
@Component({
  selector: 'swirl-emoji-sad',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['label', 'size'],
  standalone: false
})
export class SwirlEmojiSad {
  protected el: HTMLSwirlEmojiSadElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlEmojiSad extends Components.SwirlEmojiSad {}


@ProxyCmp({
  inputs: ['label', 'size']
})
@Component({
  selector: 'swirl-emoji-thumbs-up',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['label', 'size'],
  standalone: false
})
export class SwirlEmojiThumbsUp {
  protected el: HTMLSwirlEmojiThumbsUpElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlEmojiThumbsUp extends Components.SwirlEmojiThumbsUp {}


@ProxyCmp({
  inputs: ['heading', 'headingLevel', 'illustration']
})
@Component({
  selector: 'swirl-empty-state',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['heading', 'headingLevel', 'illustration'],
  standalone: false
})
export class SwirlEmptyState {
  protected el: HTMLSwirlEmptyStateElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlEmptyState extends Components.SwirlEmptyState {}


@ProxyCmp({
  inputs: ['deleteButtonLabel', 'description', 'downloadButtonLabel', 'errorLabel', 'hasError', 'loading', 'loadingLabel', 'name', 'previewButtonLabel', 'showDeleteButton', 'showDownloadButton', 'showPreviewButton', 'skipNativeDownload', 'type', 'url']
})
@Component({
  selector: 'swirl-file-chip',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['deleteButtonLabel', 'description', 'downloadButtonLabel', 'errorLabel', 'hasError', 'loading', 'loadingLabel', { name: 'name', required: true }, 'previewButtonLabel', 'showDeleteButton', 'showDownloadButton', 'showPreviewButton', 'skipNativeDownload', { name: 'type', required: true }, { name: 'url', required: true }],
  standalone: false
})
export class SwirlFileChip {
  protected el: HTMLSwirlFileChipElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['delete', 'download', 'preview']);
  }
}


export declare interface SwirlFileChip extends Components.SwirlFileChip {

  delete: EventEmitter<CustomEvent<void>>;

  download: EventEmitter<CustomEvent<void>>;

  preview: EventEmitter<CustomEvent<void>>;
}


@ProxyCmp({
  inputs: ['accept', 'ctaLabel', 'description', 'descriptionAllowHtml', 'disabled', 'dragDropLabel', 'hideLabel', 'inputId', 'inputName', 'label', 'multiple', 'showDropzone', 'uploadButtonIcon', 'uploadButtonLabel', 'uploadButtonVariant'],
  methods: ['reset']
})
@Component({
  selector: 'swirl-file-uploader',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['accept', 'ctaLabel', 'description', 'descriptionAllowHtml', 'disabled', 'dragDropLabel', 'hideLabel', { name: 'inputId', required: true }, { name: 'inputName', required: true }, { name: 'label', required: true }, 'multiple', 'showDropzone', 'uploadButtonIcon', 'uploadButtonLabel', 'uploadButtonVariant'],
  standalone: false
})
export class SwirlFileUploader {
  protected el: HTMLSwirlFileUploaderElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['valueChange']);
  }
}


export declare interface SwirlFileUploader extends Components.SwirlFileUploader {

  valueChange: EventEmitter<CustomEvent<FileList>>;
}


@ProxyCmp({
  inputs: ['active', 'autoplay', 'description', 'disableDownload', 'disablePrint', 'errorMessage', 'file', 'fileName', 'pdfWorkerSrc', 'skipNativeDownload', 'thumbnailUrl', 'type', 'typeUnsupportedMessage', 'viewMode', 'zoom'],
  methods: ['download', 'print']
})
@Component({
  selector: 'swirl-file-viewer',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['active', 'autoplay', 'description', 'disableDownload', 'disablePrint', 'errorMessage', { name: 'file', required: true }, 'fileName', 'pdfWorkerSrc', 'skipNativeDownload', 'thumbnailUrl', { name: 'type', required: true }, 'typeUnsupportedMessage', 'viewMode', 'zoom'],
  standalone: false
})
export class SwirlFileViewer {
  protected el: HTMLSwirlFileViewerElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['activate', 'visiblePagesChange', 'downloadStart']);
  }
}


export declare interface SwirlFileViewer extends Components.SwirlFileViewer {

  activate: EventEmitter<CustomEvent<HTMLElement>>;

  visiblePagesChange: EventEmitter<CustomEvent<number[]>>;

  downloadStart: EventEmitter<CustomEvent<void>>;
}


@ProxyCmp({
  inputs: ['autoplay', 'file']
})
@Component({
  selector: 'swirl-file-viewer-audio',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['autoplay', { name: 'file', required: true }],
  standalone: false
})
export class SwirlFileViewerAudio {
  protected el: HTMLSwirlFileViewerAudioElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['activate']);
  }
}


export declare interface SwirlFileViewerAudio extends Components.SwirlFileViewerAudio {

  activate: EventEmitter<CustomEvent<HTMLElement>>;
}


@ProxyCmp({
  inputs: ['errorMessage', 'file']
})
@Component({
  selector: 'swirl-file-viewer-csv',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['errorMessage', { name: 'file', required: true }],
  standalone: false
})
export class SwirlFileViewerCsv {
  protected el: HTMLSwirlFileViewerCsvElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['activate']);
  }
}


export declare interface SwirlFileViewerCsv extends Components.SwirlFileViewerCsv {

  activate: EventEmitter<CustomEvent<HTMLElement>>;
}


@ProxyCmp({
  inputs: ['disableDownload', 'downloadButtonLabel', 'file', 'fileName']
})
@Component({
  selector: 'swirl-file-viewer-fallback',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['disableDownload', 'downloadButtonLabel', { name: 'file', required: true }, 'fileName'],
  standalone: false
})
export class SwirlFileViewerFallback {
  protected el: HTMLSwirlFileViewerFallbackElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['activate', 'download']);
  }
}


export declare interface SwirlFileViewerFallback extends Components.SwirlFileViewerFallback {

  activate: EventEmitter<CustomEvent<HTMLElement>>;

  download: EventEmitter<CustomEvent<void>>;
}


@ProxyCmp({
  inputs: ['description', 'errorMessage', 'file', 'maxZoom'],
  methods: ['getZoom', 'resetZoom']
})
@Component({
  selector: 'swirl-file-viewer-image',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['description', 'errorMessage', { name: 'file', required: true }, 'maxZoom'],
  standalone: false
})
export class SwirlFileViewerImage {
  protected el: HTMLSwirlFileViewerImageElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['activate']);
  }
}


export declare interface SwirlFileViewerImage extends Components.SwirlFileViewerImage {

  activate: EventEmitter<CustomEvent<HTMLElement>>;
}


@ProxyCmp({
  inputs: ['errorMessage', 'file', 'singlePageMode', 'viewMode', 'wasmUrl', 'workerSrc', 'zoom'],
  methods: ['getThumbnails', 'print', 'nextPage', 'previousPage', 'setPage']
})
@Component({
  selector: 'swirl-file-viewer-pdf',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['errorMessage', { name: 'file', required: true }, 'singlePageMode', 'viewMode', 'wasmUrl', 'workerSrc', 'zoom'],
  standalone: false
})
export class SwirlFileViewerPdf {
  protected el: HTMLSwirlFileViewerPdfElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['activate', 'visiblePagesChange']);
  }
}


export declare interface SwirlFileViewerPdf extends Components.SwirlFileViewerPdf {

  activate: EventEmitter<CustomEvent<HTMLElement>>;

  visiblePagesChange: EventEmitter<CustomEvent<number[]>>;
}


@ProxyCmp({
  inputs: ['errorMessage', 'file']
})
@Component({
  selector: 'swirl-file-viewer-text',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['errorMessage', { name: 'file', required: true }],
  standalone: false
})
export class SwirlFileViewerText {
  protected el: HTMLSwirlFileViewerTextElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['activate']);
  }
}


export declare interface SwirlFileViewerText extends Components.SwirlFileViewerText {

  activate: EventEmitter<CustomEvent<HTMLElement>>;
}


@ProxyCmp({
  inputs: ['autoplay', 'disableDownload', 'file']
})
@Component({
  selector: 'swirl-file-viewer-video',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['autoplay', 'disableDownload', { name: 'file', required: true }],
  standalone: false
})
export class SwirlFileViewerVideo {
  protected el: HTMLSwirlFileViewerVideoElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['activate']);
  }
}


export declare interface SwirlFileViewerVideo extends Components.SwirlFileViewerVideo {

  activate: EventEmitter<CustomEvent<HTMLElement>>;
}


@ProxyCmp({
  inputs: ['description', 'disabled', 'errorMessage', 'fontSize', 'hideLabel', 'icon', 'inline', 'invalid', 'label', 'labelPosition', 'readonly', 'secondaryLabel', 'tooltip']
})
@Component({
  selector: 'swirl-form-control',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['description', 'disabled', 'errorMessage', 'fontSize', 'hideLabel', 'icon', 'inline', 'invalid', { name: 'label', required: true }, 'labelPosition', 'readonly', 'secondaryLabel', 'tooltip'],
  standalone: false
})
export class SwirlFormControl {
  protected el: HTMLSwirlFormControlElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlFormControl extends Components.SwirlFormControl {}


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


export declare interface SwirlFormGroup extends Components.SwirlFormGroup {}


@ProxyCmp({
  inputs: ['align', 'as', 'balance', 'headingId', 'level', 'lines', 'text', 'truncate']
})
@Component({
  selector: 'swirl-heading',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['align', 'as', 'balance', 'headingId', 'level', 'lines', { name: 'text', required: true }, 'truncate'],
  standalone: false
})
export class SwirlHeading {
  protected el: HTMLSwirlHeadingElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlHeading extends Components.SwirlHeading {}


@ProxyCmp({
  inputs: ['color', 'glyph', 'label', 'size', 'wrapperColor', 'wrapperSize']
})
@Component({
  selector: 'swirl-icon',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', { name: 'glyph', required: true }, 'label', 'size', 'wrapperColor', 'wrapperSize'],
  standalone: false
})
export class SwirlIcon {
  protected el: HTMLSwirlIconElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIcon extends Components.SwirlIcon {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-add',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconAdd {
  protected el: HTMLSwirlIconAddElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconAdd extends Components.SwirlIconAdd {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-add-box',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconAddBox {
  protected el: HTMLSwirlIconAddBoxElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconAddBox extends Components.SwirlIconAddBox {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-add-moderator',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconAddModerator {
  protected el: HTMLSwirlIconAddModeratorElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconAddModerator extends Components.SwirlIconAddModerator {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-add-photo',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconAddPhoto {
  protected el: HTMLSwirlIconAddPhotoElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconAddPhoto extends Components.SwirlIconAddPhoto {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-add-reaction',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconAddReaction {
  protected el: HTMLSwirlIconAddReactionElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconAddReaction extends Components.SwirlIconAddReaction {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-admin-panel-settings',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconAdminPanelSettings {
  protected el: HTMLSwirlIconAdminPanelSettingsElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconAdminPanelSettings extends Components.SwirlIconAdminPanelSettings {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-ai',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconAi {
  protected el: HTMLSwirlIconAiElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconAi extends Components.SwirlIconAi {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-ai-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconAiFilled {
  protected el: HTMLSwirlIconAiFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconAiFilled extends Components.SwirlIconAiFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-apparel',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconApparel {
  protected el: HTMLSwirlIconApparelElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconApparel extends Components.SwirlIconApparel {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-apps',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconApps {
  protected el: HTMLSwirlIconAppsElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconApps extends Components.SwirlIconApps {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-arrow-back',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconArrowBack {
  protected el: HTMLSwirlIconArrowBackElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconArrowBack extends Components.SwirlIconArrowBack {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-arrow-downward',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconArrowDownward {
  protected el: HTMLSwirlIconArrowDownwardElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconArrowDownward extends Components.SwirlIconArrowDownward {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-arrow-forward',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconArrowForward {
  protected el: HTMLSwirlIconArrowForwardElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconArrowForward extends Components.SwirlIconArrowForward {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-arrow-left',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconArrowLeft {
  protected el: HTMLSwirlIconArrowLeftElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconArrowLeft extends Components.SwirlIconArrowLeft {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-arrow-right',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconArrowRight {
  protected el: HTMLSwirlIconArrowRightElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconArrowRight extends Components.SwirlIconArrowRight {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-arrow-right-small',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconArrowRightSmall {
  protected el: HTMLSwirlIconArrowRightSmallElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconArrowRightSmall extends Components.SwirlIconArrowRightSmall {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-arrow-upward',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconArrowUpward {
  protected el: HTMLSwirlIconArrowUpwardElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconArrowUpward extends Components.SwirlIconArrowUpward {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-aspect-ratio',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconAspectRatio {
  protected el: HTMLSwirlIconAspectRatioElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconAspectRatio extends Components.SwirlIconAspectRatio {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-attachment',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconAttachment {
  protected el: HTMLSwirlIconAttachmentElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconAttachment extends Components.SwirlIconAttachment {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-audio-file',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconAudioFile {
  protected el: HTMLSwirlIconAudioFileElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconAudioFile extends Components.SwirlIconAudioFile {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-autorenew',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconAutorenew {
  protected el: HTMLSwirlIconAutorenewElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconAutorenew extends Components.SwirlIconAutorenew {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-bar-chart',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconBarChart {
  protected el: HTMLSwirlIconBarChartElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconBarChart extends Components.SwirlIconBarChart {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-beach-access',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconBeachAccess {
  protected el: HTMLSwirlIconBeachAccessElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconBeachAccess extends Components.SwirlIconBeachAccess {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-beach-access-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconBeachAccessFilled {
  protected el: HTMLSwirlIconBeachAccessFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconBeachAccessFilled extends Components.SwirlIconBeachAccessFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-block',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconBlock {
  protected el: HTMLSwirlIconBlockElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconBlock extends Components.SwirlIconBlock {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-bold',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconBold {
  protected el: HTMLSwirlIconBoldElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconBold extends Components.SwirlIconBold {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-bookmark',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconBookmark {
  protected el: HTMLSwirlIconBookmarkElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconBookmark extends Components.SwirlIconBookmark {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-bookmark-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconBookmarkFilled {
  protected el: HTMLSwirlIconBookmarkFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconBookmarkFilled extends Components.SwirlIconBookmarkFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-calendar-add-on-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCalendarAddOnFilled {
  protected el: HTMLSwirlIconCalendarAddOnFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCalendarAddOnFilled extends Components.SwirlIconCalendarAddOnFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-calendar-respond',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCalendarRespond {
  protected el: HTMLSwirlIconCalendarRespondElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCalendarRespond extends Components.SwirlIconCalendarRespond {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-calendar-today',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCalendarToday {
  protected el: HTMLSwirlIconCalendarTodayElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCalendarToday extends Components.SwirlIconCalendarToday {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-call',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCall {
  protected el: HTMLSwirlIconCallElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCall extends Components.SwirlIconCall {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-call-end',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCallEnd {
  protected el: HTMLSwirlIconCallEndElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCallEnd extends Components.SwirlIconCallEnd {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-cancel',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCancel {
  protected el: HTMLSwirlIconCancelElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCancel extends Components.SwirlIconCancel {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-cancel-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCancelFilled {
  protected el: HTMLSwirlIconCancelFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCancelFilled extends Components.SwirlIconCancelFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-cancel-outline',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCancelOutline {
  protected el: HTMLSwirlIconCancelOutlineElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCancelOutline extends Components.SwirlIconCancelOutline {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-chat-bubble',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconChatBubble {
  protected el: HTMLSwirlIconChatBubbleElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconChatBubble extends Components.SwirlIconChatBubble {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-chats',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconChats {
  protected el: HTMLSwirlIconChatsElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconChats extends Components.SwirlIconChats {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-chats-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconChatsFilled {
  protected el: HTMLSwirlIconChatsFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconChatsFilled extends Components.SwirlIconChatsFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-check',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCheck {
  protected el: HTMLSwirlIconCheckElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCheck extends Components.SwirlIconCheck {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-check-circle',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCheckCircle {
  protected el: HTMLSwirlIconCheckCircleElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCheckCircle extends Components.SwirlIconCheckCircle {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-check-circle-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCheckCircleFilled {
  protected el: HTMLSwirlIconCheckCircleFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCheckCircleFilled extends Components.SwirlIconCheckCircleFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-check-small',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCheckSmall {
  protected el: HTMLSwirlIconCheckSmallElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCheckSmall extends Components.SwirlIconCheckSmall {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-check-strong',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCheckStrong {
  protected el: HTMLSwirlIconCheckStrongElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCheckStrong extends Components.SwirlIconCheckStrong {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-checkbox-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCheckboxFilled {
  protected el: HTMLSwirlIconCheckboxFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCheckboxFilled extends Components.SwirlIconCheckboxFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-chevron-left',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconChevronLeft {
  protected el: HTMLSwirlIconChevronLeftElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconChevronLeft extends Components.SwirlIconChevronLeft {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-chevron-right',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconChevronRight {
  protected el: HTMLSwirlIconChevronRightElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconChevronRight extends Components.SwirlIconChevronRight {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-close',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconClose {
  protected el: HTMLSwirlIconCloseElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconClose extends Components.SwirlIconClose {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-close-fullscreen',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCloseFullscreen {
  protected el: HTMLSwirlIconCloseFullscreenElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCloseFullscreen extends Components.SwirlIconCloseFullscreen {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-close-small',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCloseSmall {
  protected el: HTMLSwirlIconCloseSmallElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCloseSmall extends Components.SwirlIconCloseSmall {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-cloud-upload',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCloudUpload {
  protected el: HTMLSwirlIconCloudUploadElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCloudUpload extends Components.SwirlIconCloudUpload {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-co-present',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCoPresent {
  protected el: HTMLSwirlIconCoPresentElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCoPresent extends Components.SwirlIconCoPresent {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-column',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconColumn {
  protected el: HTMLSwirlIconColumnElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconColumn extends Components.SwirlIconColumn {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-comment',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconComment {
  protected el: HTMLSwirlIconCommentElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconComment extends Components.SwirlIconComment {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-contract-edit',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconContractEdit {
  protected el: HTMLSwirlIconContractEditElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconContractEdit extends Components.SwirlIconContractEdit {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-contrast',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconContrast {
  protected el: HTMLSwirlIconContrastElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconContrast extends Components.SwirlIconContrast {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-copy',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCopy {
  protected el: HTMLSwirlIconCopyElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCopy extends Components.SwirlIconCopy {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-crop',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconCrop {
  protected el: HTMLSwirlIconCropElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconCrop extends Components.SwirlIconCrop {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-dark-mode',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDarkMode {
  protected el: HTMLSwirlIconDarkModeElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDarkMode extends Components.SwirlIconDarkMode {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-date-range',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDateRange {
  protected el: HTMLSwirlIconDateRangeElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDateRange extends Components.SwirlIconDateRange {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-delete',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDelete {
  protected el: HTMLSwirlIconDeleteElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDelete extends Components.SwirlIconDelete {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-deployed-code',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDeployedCode {
  protected el: HTMLSwirlIconDeployedCodeElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDeployedCode extends Components.SwirlIconDeployedCode {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-description',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDescription {
  protected el: HTMLSwirlIconDescriptionElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDescription extends Components.SwirlIconDescription {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-desktop',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDesktop {
  protected el: HTMLSwirlIconDesktopElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDesktop extends Components.SwirlIconDesktop {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-destruction',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDestruction {
  protected el: HTMLSwirlIconDestructionElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDestruction extends Components.SwirlIconDestruction {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-directory',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDirectory {
  protected el: HTMLSwirlIconDirectoryElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDirectory extends Components.SwirlIconDirectory {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-directory-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDirectoryFilled {
  protected el: HTMLSwirlIconDirectoryFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDirectoryFilled extends Components.SwirlIconDirectoryFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-discover',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDiscover {
  protected el: HTMLSwirlIconDiscoverElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDiscover extends Components.SwirlIconDiscover {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-dock-left',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDockLeft {
  protected el: HTMLSwirlIconDockLeftElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDockLeft extends Components.SwirlIconDockLeft {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-dock-left-collapse',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDockLeftCollapse {
  protected el: HTMLSwirlIconDockLeftCollapseElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDockLeftCollapse extends Components.SwirlIconDockLeftCollapse {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-dock-left-expand',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDockLeftExpand {
  protected el: HTMLSwirlIconDockLeftExpandElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDockLeftExpand extends Components.SwirlIconDockLeftExpand {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-door-open',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDoorOpen {
  protected el: HTMLSwirlIconDoorOpenElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDoorOpen extends Components.SwirlIconDoorOpen {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-dot',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDot {
  protected el: HTMLSwirlIconDotElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDot extends Components.SwirlIconDot {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-double-arrow-left',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDoubleArrowLeft {
  protected el: HTMLSwirlIconDoubleArrowLeftElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDoubleArrowLeft extends Components.SwirlIconDoubleArrowLeft {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-double-arrow-right',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDoubleArrowRight {
  protected el: HTMLSwirlIconDoubleArrowRightElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDoubleArrowRight extends Components.SwirlIconDoubleArrowRight {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-download',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDownload {
  protected el: HTMLSwirlIconDownloadElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDownload extends Components.SwirlIconDownload {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-drag-handle',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconDragHandle {
  protected el: HTMLSwirlIconDragHandleElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconDragHandle extends Components.SwirlIconDragHandle {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-edit',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconEdit {
  protected el: HTMLSwirlIconEditElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconEdit extends Components.SwirlIconEdit {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-edit-note',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconEditNote {
  protected el: HTMLSwirlIconEditNoteElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconEditNote extends Components.SwirlIconEditNote {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-emoji-mood',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconEmojiMood {
  protected el: HTMLSwirlIconEmojiMoodElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconEmojiMood extends Components.SwirlIconEmojiMood {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-emoji-satisfied',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconEmojiSatisfied {
  protected el: HTMLSwirlIconEmojiSatisfiedElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconEmojiSatisfied extends Components.SwirlIconEmojiSatisfied {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-emoji-symbols',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconEmojiSymbols {
  protected el: HTMLSwirlIconEmojiSymbolsElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconEmojiSymbols extends Components.SwirlIconEmojiSymbols {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-end-series',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconEndSeries {
  protected el: HTMLSwirlIconEndSeriesElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconEndSeries extends Components.SwirlIconEndSeries {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-error',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconError {
  protected el: HTMLSwirlIconErrorElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconError extends Components.SwirlIconError {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-expand-less',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconExpandLess {
  protected el: HTMLSwirlIconExpandLessElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconExpandLess extends Components.SwirlIconExpandLess {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-expand-more',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconExpandMore {
  protected el: HTMLSwirlIconExpandMoreElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconExpandMore extends Components.SwirlIconExpandMore {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-experiment',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconExperiment {
  protected el: HTMLSwirlIconExperimentElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconExperiment extends Components.SwirlIconExperiment {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-file',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconFile {
  protected el: HTMLSwirlIconFileElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconFile extends Components.SwirlIconFile {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-file-copy',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconFileCopy {
  protected el: HTMLSwirlIconFileCopyElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconFileCopy extends Components.SwirlIconFileCopy {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-filter',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconFilter {
  protected el: HTMLSwirlIconFilterElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconFilter extends Components.SwirlIconFilter {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-folder',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconFolder {
  protected el: HTMLSwirlIconFolderElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconFolder extends Components.SwirlIconFolder {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-folder-shared',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconFolderShared {
  protected el: HTMLSwirlIconFolderSharedElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconFolderShared extends Components.SwirlIconFolderShared {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-format-h-one',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconFormatHOne {
  protected el: HTMLSwirlIconFormatHOneElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconFormatHOne extends Components.SwirlIconFormatHOne {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-format-list-bulleted',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconFormatListBulleted {
  protected el: HTMLSwirlIconFormatListBulletedElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconFormatListBulleted extends Components.SwirlIconFormatListBulleted {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-format-list-numbered',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconFormatListNumbered {
  protected el: HTMLSwirlIconFormatListNumberedElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconFormatListNumbered extends Components.SwirlIconFormatListNumbered {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-forward',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconForward {
  protected el: HTMLSwirlIconForwardElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconForward extends Components.SwirlIconForward {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-fullscreen',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconFullscreen {
  protected el: HTMLSwirlIconFullscreenElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconFullscreen extends Components.SwirlIconFullscreen {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-fullscreen-exit',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconFullscreenExit {
  protected el: HTMLSwirlIconFullscreenExitElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconFullscreenExit extends Components.SwirlIconFullscreenExit {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-gif',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconGif {
  protected el: HTMLSwirlIconGifElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconGif extends Components.SwirlIconGif {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-group-add',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconGroupAdd {
  protected el: HTMLSwirlIconGroupAddElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconGroupAdd extends Components.SwirlIconGroupAdd {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-group-assign',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconGroupAssign {
  protected el: HTMLSwirlIconGroupAssignElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconGroupAssign extends Components.SwirlIconGroupAssign {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-groups',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconGroups {
  protected el: HTMLSwirlIconGroupsElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconGroups extends Components.SwirlIconGroups {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-groups-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconGroupsFilled {
  protected el: HTMLSwirlIconGroupsFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconGroupsFilled extends Components.SwirlIconGroupsFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-hamburger-menu',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconHamburgerMenu {
  protected el: HTMLSwirlIconHamburgerMenuElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconHamburgerMenu extends Components.SwirlIconHamburgerMenu {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-health-and-safety',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconHealthAndSafety {
  protected el: HTMLSwirlIconHealthAndSafetyElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconHealthAndSafety extends Components.SwirlIconHealthAndSafety {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-help',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconHelp {
  protected el: HTMLSwirlIconHelpElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconHelp extends Components.SwirlIconHelp {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-help-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconHelpFilled {
  protected el: HTMLSwirlIconHelpFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconHelpFilled extends Components.SwirlIconHelpFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-highlight',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconHighlight {
  protected el: HTMLSwirlIconHighlightElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconHighlight extends Components.SwirlIconHighlight {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-history',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconHistory {
  protected el: HTMLSwirlIconHistoryElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconHistory extends Components.SwirlIconHistory {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-home',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconHome {
  protected el: HTMLSwirlIconHomeElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconHome extends Components.SwirlIconHome {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-home-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconHomeFilled {
  protected el: HTMLSwirlIconHomeFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconHomeFilled extends Components.SwirlIconHomeFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-hr-resting',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconHrResting {
  protected el: HTMLSwirlIconHrRestingElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconHrResting extends Components.SwirlIconHrResting {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-image',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconImage {
  protected el: HTMLSwirlIconImageElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconImage extends Components.SwirlIconImage {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-improve-text',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconImproveText {
  protected el: HTMLSwirlIconImproveTextElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconImproveText extends Components.SwirlIconImproveText {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-info',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconInfo {
  protected el: HTMLSwirlIconInfoElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconInfo extends Components.SwirlIconInfo {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-insert-below',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconInsertBelow {
  protected el: HTMLSwirlIconInsertBelowElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconInsertBelow extends Components.SwirlIconInsertBelow {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-insert-chart',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconInsertChart {
  protected el: HTMLSwirlIconInsertChartElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconInsertChart extends Components.SwirlIconInsertChart {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-insert-on-top',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconInsertOnTop {
  protected el: HTMLSwirlIconInsertOnTopElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconInsertOnTop extends Components.SwirlIconInsertOnTop {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-inventory',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconInventory {
  protected el: HTMLSwirlIconInventoryElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconInventory extends Components.SwirlIconInventory {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-inventory-off',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconInventoryOff {
  protected el: HTMLSwirlIconInventoryOffElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconInventoryOff extends Components.SwirlIconInventoryOff {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-iphone',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconIphone {
  protected el: HTMLSwirlIconIphoneElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconIphone extends Components.SwirlIconIphone {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-italic',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconItalic {
  protected el: HTMLSwirlIconItalicElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconItalic extends Components.SwirlIconItalic {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-key',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconKey {
  protected el: HTMLSwirlIconKeyElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconKey extends Components.SwirlIconKey {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-keyboard',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconKeyboard {
  protected el: HTMLSwirlIconKeyboardElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconKeyboard extends Components.SwirlIconKeyboard {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-keyboard-hide',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconKeyboardHide {
  protected el: HTMLSwirlIconKeyboardHideElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconKeyboardHide extends Components.SwirlIconKeyboardHide {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-language',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconLanguage {
  protected el: HTMLSwirlIconLanguageElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconLanguage extends Components.SwirlIconLanguage {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-light-mode',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconLightMode {
  protected el: HTMLSwirlIconLightModeElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconLightMode extends Components.SwirlIconLightMode {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-like',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconLike {
  protected el: HTMLSwirlIconLikeElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconLike extends Components.SwirlIconLike {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-link',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconLink {
  protected el: HTMLSwirlIconLinkElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconLink extends Components.SwirlIconLink {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-list-alt-check',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconListAltCheck {
  protected el: HTMLSwirlIconListAltCheckElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconListAltCheck extends Components.SwirlIconListAltCheck {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-live',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconLive {
  protected el: HTMLSwirlIconLiveElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconLive extends Components.SwirlIconLive {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-load',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconLoad {
  protected el: HTMLSwirlIconLoadElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconLoad extends Components.SwirlIconLoad {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-location-on',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconLocationOn {
  protected el: HTMLSwirlIconLocationOnElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconLocationOn extends Components.SwirlIconLocationOn {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-lock',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconLock {
  protected el: HTMLSwirlIconLockElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconLock extends Components.SwirlIconLock {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-lock-open',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconLockOpen {
  protected el: HTMLSwirlIconLockOpenElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconLockOpen extends Components.SwirlIconLockOpen {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-lock-person',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconLockPerson {
  protected el: HTMLSwirlIconLockPersonElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconLockPerson extends Components.SwirlIconLockPerson {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-login',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconLogin {
  protected el: HTMLSwirlIconLoginElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconLogin extends Components.SwirlIconLogin {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-logout',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconLogout {
  protected el: HTMLSwirlIconLogoutElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconLogout extends Components.SwirlIconLogout {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-long-text',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconLongText {
  protected el: HTMLSwirlIconLongTextElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconLongText extends Components.SwirlIconLongText {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-mail',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconMail {
  protected el: HTMLSwirlIconMailElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconMail extends Components.SwirlIconMail {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-manage-accounts',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconManageAccounts {
  protected el: HTMLSwirlIconManageAccountsElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconManageAccounts extends Components.SwirlIconManageAccounts {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-mark-chat-read',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconMarkChatRead {
  protected el: HTMLSwirlIconMarkChatReadElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconMarkChatRead extends Components.SwirlIconMarkChatRead {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-mark-chat-unread',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconMarkChatUnread {
  protected el: HTMLSwirlIconMarkChatUnreadElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconMarkChatUnread extends Components.SwirlIconMarkChatUnread {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-mention',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconMention {
  protected el: HTMLSwirlIconMentionElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconMention extends Components.SwirlIconMention {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-menu',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconMenu {
  protected el: HTMLSwirlIconMenuElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconMenu extends Components.SwirlIconMenu {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-menu-book',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconMenuBook {
  protected el: HTMLSwirlIconMenuBookElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconMenuBook extends Components.SwirlIconMenuBook {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-menu-book-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconMenuBookFilled {
  protected el: HTMLSwirlIconMenuBookFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconMenuBookFilled extends Components.SwirlIconMenuBookFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-menu-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconMenuFilled {
  protected el: HTMLSwirlIconMenuFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconMenuFilled extends Components.SwirlIconMenuFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-message',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconMessage {
  protected el: HTMLSwirlIconMessageElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconMessage extends Components.SwirlIconMessage {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-mic',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconMic {
  protected el: HTMLSwirlIconMicElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconMic extends Components.SwirlIconMic {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-mic-off',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconMicOff {
  protected el: HTMLSwirlIconMicOffElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconMicOff extends Components.SwirlIconMicOff {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-mobile-theft',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconMobileTheft {
  protected el: HTMLSwirlIconMobileTheftElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconMobileTheft extends Components.SwirlIconMobileTheft {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-more-horizontal',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconMoreHorizontal {
  protected el: HTMLSwirlIconMoreHorizontalElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconMoreHorizontal extends Components.SwirlIconMoreHorizontal {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-more-vertikal',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconMoreVertikal {
  protected el: HTMLSwirlIconMoreVertikalElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconMoreVertikal extends Components.SwirlIconMoreVertikal {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-news',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconNews {
  protected el: HTMLSwirlIconNewsElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconNews extends Components.SwirlIconNews {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-news-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconNewsFilled {
  protected el: HTMLSwirlIconNewsFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconNewsFilled extends Components.SwirlIconNewsFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-news-off',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconNewsOff {
  protected el: HTMLSwirlIconNewsOffElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconNewsOff extends Components.SwirlIconNewsOff {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-next-plan',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconNextPlan {
  protected el: HTMLSwirlIconNextPlanElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconNextPlan extends Components.SwirlIconNextPlan {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-note-stack',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconNoteStack {
  protected el: HTMLSwirlIconNoteStackElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconNoteStack extends Components.SwirlIconNoteStack {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-note-stack-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconNoteStackFilled {
  protected el: HTMLSwirlIconNoteStackFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconNoteStackFilled extends Components.SwirlIconNoteStackFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-notifications',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconNotifications {
  protected el: HTMLSwirlIconNotificationsElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconNotifications extends Components.SwirlIconNotifications {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-notifications-active',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconNotificationsActive {
  protected el: HTMLSwirlIconNotificationsActiveElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconNotificationsActive extends Components.SwirlIconNotificationsActive {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-notifications-off',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconNotificationsOff {
  protected el: HTMLSwirlIconNotificationsOffElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconNotificationsOff extends Components.SwirlIconNotificationsOff {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-open-in-full',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconOpenInFull {
  protected el: HTMLSwirlIconOpenInFullElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconOpenInFull extends Components.SwirlIconOpenInFull {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-open-in-new',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconOpenInNew {
  protected el: HTMLSwirlIconOpenInNewElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconOpenInNew extends Components.SwirlIconOpenInNew {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-passkey',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPasskey {
  protected el: HTMLSwirlIconPasskeyElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPasskey extends Components.SwirlIconPasskey {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-patient-list',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPatientList {
  protected el: HTMLSwirlIconPatientListElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPatientList extends Components.SwirlIconPatientList {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-pause',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPause {
  protected el: HTMLSwirlIconPauseElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPause extends Components.SwirlIconPause {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-pause-circle',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPauseCircle {
  protected el: HTMLSwirlIconPauseCircleElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPauseCircle extends Components.SwirlIconPauseCircle {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-people-alt',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPeopleAlt {
  protected el: HTMLSwirlIconPeopleAltElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPeopleAlt extends Components.SwirlIconPeopleAlt {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-person',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPerson {
  protected el: HTMLSwirlIconPersonElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPerson extends Components.SwirlIconPerson {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-person-check',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPersonCheck {
  protected el: HTMLSwirlIconPersonCheckElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPersonCheck extends Components.SwirlIconPersonCheck {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-person-off',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPersonOff {
  protected el: HTMLSwirlIconPersonOffElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPersonOff extends Components.SwirlIconPersonOff {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-person-raised-hand',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPersonRaisedHand {
  protected el: HTMLSwirlIconPersonRaisedHandElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPersonRaisedHand extends Components.SwirlIconPersonRaisedHand {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-phone',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPhone {
  protected el: HTMLSwirlIconPhoneElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPhone extends Components.SwirlIconPhone {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-photo-camera',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPhotoCamera {
  protected el: HTMLSwirlIconPhotoCameraElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPhotoCamera extends Components.SwirlIconPhotoCamera {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-picture-as-pdf',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPictureAsPdf {
  protected el: HTMLSwirlIconPictureAsPdfElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPictureAsPdf extends Components.SwirlIconPictureAsPdf {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-picture-in-picture',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPictureInPicture {
  protected el: HTMLSwirlIconPictureInPictureElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPictureInPicture extends Components.SwirlIconPictureInPicture {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-pin',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPin {
  protected el: HTMLSwirlIconPinElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPin extends Components.SwirlIconPin {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-pin-off',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPinOff {
  protected el: HTMLSwirlIconPinOffElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPinOff extends Components.SwirlIconPinOff {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-place',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPlace {
  protected el: HTMLSwirlIconPlaceElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPlace extends Components.SwirlIconPlace {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-play-arrow',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPlayArrow {
  protected el: HTMLSwirlIconPlayArrowElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPlayArrow extends Components.SwirlIconPlayArrow {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-poll',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPoll {
  protected el: HTMLSwirlIconPollElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPoll extends Components.SwirlIconPoll {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-post-approval',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPostApproval {
  protected el: HTMLSwirlIconPostApprovalElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPostApproval extends Components.SwirlIconPostApproval {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-present',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPresent {
  protected el: HTMLSwirlIconPresentElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPresent extends Components.SwirlIconPresent {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-preview',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPreview {
  protected el: HTMLSwirlIconPreviewElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPreview extends Components.SwirlIconPreview {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-print',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPrint {
  protected el: HTMLSwirlIconPrintElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPrint extends Components.SwirlIconPrint {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-public',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPublic {
  protected el: HTMLSwirlIconPublicElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPublic extends Components.SwirlIconPublic {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-public-off',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPublicOff {
  protected el: HTMLSwirlIconPublicOffElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPublicOff extends Components.SwirlIconPublicOff {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-published-with-changes',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconPublishedWithChanges {
  protected el: HTMLSwirlIconPublishedWithChangesElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconPublishedWithChanges extends Components.SwirlIconPublishedWithChanges {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-qr-code-scanner',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconQrCodeScanner {
  protected el: HTMLSwirlIconQrCodeScannerElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconQrCodeScanner extends Components.SwirlIconQrCodeScanner {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-ratio-four-to-three',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconRatioFourToThree {
  protected el: HTMLSwirlIconRatioFourToThreeElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconRatioFourToThree extends Components.SwirlIconRatioFourToThree {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-ratio-freeform',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconRatioFreeform {
  protected el: HTMLSwirlIconRatioFreeformElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconRatioFreeform extends Components.SwirlIconRatioFreeform {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-ratio-sixteen-to-nine',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconRatioSixteenToNine {
  protected el: HTMLSwirlIconRatioSixteenToNineElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconRatioSixteenToNine extends Components.SwirlIconRatioSixteenToNine {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-ratio-square',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconRatioSquare {
  protected el: HTMLSwirlIconRatioSquareElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconRatioSquare extends Components.SwirlIconRatioSquare {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-ratio-three-to-four',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconRatioThreeToFour {
  protected el: HTMLSwirlIconRatioThreeToFourElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconRatioThreeToFour extends Components.SwirlIconRatioThreeToFour {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-ratio-three-to-two',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconRatioThreeToTwo {
  protected el: HTMLSwirlIconRatioThreeToTwoElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconRatioThreeToTwo extends Components.SwirlIconRatioThreeToTwo {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-recieved',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconRecieved {
  protected el: HTMLSwirlIconRecievedElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconRecieved extends Components.SwirlIconRecieved {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-redo',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconRedo {
  protected el: HTMLSwirlIconRedoElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconRedo extends Components.SwirlIconRedo {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-refresh',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconRefresh {
  protected el: HTMLSwirlIconRefreshElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconRefresh extends Components.SwirlIconRefresh {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-remove',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconRemove {
  protected el: HTMLSwirlIconRemoveElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconRemove extends Components.SwirlIconRemove {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-remove-circle',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconRemoveCircle {
  protected el: HTMLSwirlIconRemoveCircleElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconRemoveCircle extends Components.SwirlIconRemoveCircle {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-remove-moderator',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconRemoveModerator {
  protected el: HTMLSwirlIconRemoveModeratorElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconRemoveModerator extends Components.SwirlIconRemoveModerator {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-repeat',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconRepeat {
  protected el: HTMLSwirlIconRepeatElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconRepeat extends Components.SwirlIconRepeat {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-reply',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconReply {
  protected el: HTMLSwirlIconReplyElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconReply extends Components.SwirlIconReply {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-report',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconReport {
  protected el: HTMLSwirlIconReportElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconReport extends Components.SwirlIconReport {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-roadmap',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconRoadmap {
  protected el: HTMLSwirlIconRoadmapElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconRoadmap extends Components.SwirlIconRoadmap {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-rotate-left',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconRotateLeft {
  protected el: HTMLSwirlIconRotateLeftElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconRotateLeft extends Components.SwirlIconRotateLeft {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-rotate-right',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconRotateRight {
  protected el: HTMLSwirlIconRotateRightElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconRotateRight extends Components.SwirlIconRotateRight {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-school',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconSchool {
  protected el: HTMLSwirlIconSchoolElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconSchool extends Components.SwirlIconSchool {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-screenshare',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconScreenshare {
  protected el: HTMLSwirlIconScreenshareElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconScreenshare extends Components.SwirlIconScreenshare {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-screenshare-off',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconScreenshareOff {
  protected el: HTMLSwirlIconScreenshareOffElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconScreenshareOff extends Components.SwirlIconScreenshareOff {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-search',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconSearch {
  protected el: HTMLSwirlIconSearchElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconSearch extends Components.SwirlIconSearch {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-search-strong',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconSearchStrong {
  protected el: HTMLSwirlIconSearchStrongElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconSearchStrong extends Components.SwirlIconSearchStrong {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-section',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconSection {
  protected el: HTMLSwirlIconSectionElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconSection extends Components.SwirlIconSection {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-secure',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconSecure {
  protected el: HTMLSwirlIconSecureElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconSecure extends Components.SwirlIconSecure {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-sell',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconSell {
  protected el: HTMLSwirlIconSellElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconSell extends Components.SwirlIconSell {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-send',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconSend {
  protected el: HTMLSwirlIconSendElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconSend extends Components.SwirlIconSend {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-settings',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconSettings {
  protected el: HTMLSwirlIconSettingsElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconSettings extends Components.SwirlIconSettings {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-short-text',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconShortText {
  protected el: HTMLSwirlIconShortTextElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconShortText extends Components.SwirlIconShortText {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-simplify',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconSimplify {
  protected el: HTMLSwirlIconSimplifyElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconSimplify extends Components.SwirlIconSimplify {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-spellcheck',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconSpellcheck {
  protected el: HTMLSwirlIconSpellcheckElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconSpellcheck extends Components.SwirlIconSpellcheck {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-stars',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconStars {
  protected el: HTMLSwirlIconStarsElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconStars extends Components.SwirlIconStars {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-sticky-note',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconStickyNote {
  protected el: HTMLSwirlIconStickyNoteElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconStickyNote extends Components.SwirlIconStickyNote {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-stop',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconStop {
  protected el: HTMLSwirlIconStopElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconStop extends Components.SwirlIconStop {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-stop-circle',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconStopCircle {
  protected el: HTMLSwirlIconStopCircleElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconStopCircle extends Components.SwirlIconStopCircle {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-strikethrough',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconStrikethrough {
  protected el: HTMLSwirlIconStrikethroughElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconStrikethrough extends Components.SwirlIconStrikethrough {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-sunny',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconSunny {
  protected el: HTMLSwirlIconSunnyElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconSunny extends Components.SwirlIconSunny {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-swap-vert',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconSwapVert {
  protected el: HTMLSwirlIconSwapVertElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconSwapVert extends Components.SwirlIconSwapVert {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-sync',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconSync {
  protected el: HTMLSwirlIconSyncElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconSync extends Components.SwirlIconSync {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-tasks',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconTasks {
  protected el: HTMLSwirlIconTasksElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconTasks extends Components.SwirlIconTasks {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-tasks-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconTasksFilled {
  protected el: HTMLSwirlIconTasksFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconTasksFilled extends Components.SwirlIconTasksFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-terminal',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconTerminal {
  protected el: HTMLSwirlIconTerminalElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconTerminal extends Components.SwirlIconTerminal {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-time',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconTime {
  protected el: HTMLSwirlIconTimeElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconTime extends Components.SwirlIconTime {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-time-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconTimeFilled {
  protected el: HTMLSwirlIconTimeFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconTimeFilled extends Components.SwirlIconTimeFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-today',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconToday {
  protected el: HTMLSwirlIconTodayElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconToday extends Components.SwirlIconToday {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-today-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconTodayFilled {
  protected el: HTMLSwirlIconTodayFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconTodayFilled extends Components.SwirlIconTodayFilled {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-translate',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconTranslate {
  protected el: HTMLSwirlIconTranslateElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconTranslate extends Components.SwirlIconTranslate {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-tree-structure',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconTreeStructure {
  protected el: HTMLSwirlIconTreeStructureElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconTreeStructure extends Components.SwirlIconTreeStructure {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-underlined',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconUnderlined {
  protected el: HTMLSwirlIconUnderlinedElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconUnderlined extends Components.SwirlIconUnderlined {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-undo',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconUndo {
  protected el: HTMLSwirlIconUndoElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconUndo extends Components.SwirlIconUndo {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-unlock-person',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconUnlockPerson {
  protected el: HTMLSwirlIconUnlockPersonElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconUnlockPerson extends Components.SwirlIconUnlockPerson {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-upload',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconUpload {
  protected el: HTMLSwirlIconUploadElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconUpload extends Components.SwirlIconUpload {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-user-add',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconUserAdd {
  protected el: HTMLSwirlIconUserAddElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconUserAdd extends Components.SwirlIconUserAdd {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-user-assign',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconUserAssign {
  protected el: HTMLSwirlIconUserAssignElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconUserAssign extends Components.SwirlIconUserAssign {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-verified-user',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconVerifiedUser {
  protected el: HTMLSwirlIconVerifiedUserElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconVerifiedUser extends Components.SwirlIconVerifiedUser {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-video-camera',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconVideoCamera {
  protected el: HTMLSwirlIconVideoCameraElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconVideoCamera extends Components.SwirlIconVideoCamera {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-video-camera-off',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconVideoCameraOff {
  protected el: HTMLSwirlIconVideoCameraOffElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconVideoCameraOff extends Components.SwirlIconVideoCameraOff {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-video-library',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconVideoLibrary {
  protected el: HTMLSwirlIconVideoLibraryElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconVideoLibrary extends Components.SwirlIconVideoLibrary {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-video-player',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconVideoPlayer {
  protected el: HTMLSwirlIconVideoPlayerElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconVideoPlayer extends Components.SwirlIconVideoPlayer {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-view-agenda',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconViewAgenda {
  protected el: HTMLSwirlIconViewAgendaElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconViewAgenda extends Components.SwirlIconViewAgenda {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-visibility',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconVisibility {
  protected el: HTMLSwirlIconVisibilityElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconVisibility extends Components.SwirlIconVisibility {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-visibility-off',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconVisibilityOff {
  protected el: HTMLSwirlIconVisibilityOffElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconVisibilityOff extends Components.SwirlIconVisibilityOff {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-voice',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconVoice {
  protected el: HTMLSwirlIconVoiceElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconVoice extends Components.SwirlIconVoice {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-volume-up',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconVolumeUp {
  protected el: HTMLSwirlIconVolumeUpElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconVolumeUp extends Components.SwirlIconVolumeUp {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-warning',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconWarning {
  protected el: HTMLSwirlIconWarningElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconWarning extends Components.SwirlIconWarning {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-waving-hand',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconWavingHand {
  protected el: HTMLSwirlIconWavingHandElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconWavingHand extends Components.SwirlIconWavingHand {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-web-asset',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconWebAsset {
  protected el: HTMLSwirlIconWebAssetElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconWebAsset extends Components.SwirlIconWebAsset {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-web-asset-off',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconWebAssetOff {
  protected el: HTMLSwirlIconWebAssetOffElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconWebAssetOff extends Components.SwirlIconWebAssetOff {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-work',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconWork {
  protected el: HTMLSwirlIconWorkElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconWork extends Components.SwirlIconWork {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-workspace-premium',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconWorkspacePremium {
  protected el: HTMLSwirlIconWorkspacePremiumElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconWorkspacePremium extends Components.SwirlIconWorkspacePremium {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-zoom-in',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconZoomIn {
  protected el: HTMLSwirlIconZoomInElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconZoomIn extends Components.SwirlIconZoomIn {}


@ProxyCmp({
  inputs: ['color', 'label', 'size']
})
@Component({
  selector: 'swirl-icon-zoom-out',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', 'label', 'size'],
  standalone: false
})
export class SwirlIconZoomOut {
  protected el: HTMLSwirlIconZoomOutElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlIconZoomOut extends Components.SwirlIconZoomOut {}


@ProxyCmp({
  inputs: ['aspectRatio', 'borderRadius', 'label']
})
@Component({
  selector: 'swirl-image-grid',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['aspectRatio', 'borderRadius', 'label'],
  standalone: false
})
export class SwirlImageGrid {
  protected el: HTMLSwirlImageGridElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlImageGrid extends Components.SwirlImageGrid {}


@ProxyCmp({
  inputs: ['alt', 'gifPauseLabel', 'gifPlayLabel', 'icon', 'interactive', 'loading', 'overlay', 'showGifControls', 'src'],
  methods: ['play', 'pause']
})
@Component({
  selector: 'swirl-image-grid-item',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: [{ name: 'alt', required: true }, 'gifPauseLabel', 'gifPlayLabel', 'icon', 'interactive', 'loading', 'overlay', 'showGifControls', { name: 'src', required: true }],
  standalone: false
})
export class SwirlImageGridItem {
  protected el: HTMLSwirlImageGridItemElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['gifStarted', 'gifStopped', 'imageError', 'imageLoad']);
  }
}


export declare interface SwirlImageGridItem extends Components.SwirlImageGridItem {

  gifStarted: EventEmitter<CustomEvent<void>>;

  gifStopped: EventEmitter<CustomEvent<void>>;

  imageError: EventEmitter<CustomEvent<void>>;

  imageLoad: EventEmitter<CustomEvent<void>>;
}


@ProxyCmp({
  inputs: ['message', 'size']
})
@Component({
  selector: 'swirl-inline-error',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: [{ name: 'message', required: true }, 'size'],
  standalone: false
})
export class SwirlInlineError {
  protected el: HTMLSwirlInlineErrorElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlInlineError extends Components.SwirlInlineError {}


@ProxyCmp({
  inputs: ['borderRadius', 'heading', 'hideHeading', 'importance', 'intent']
})
@Component({
  selector: 'swirl-inline-notification',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['borderRadius', { name: 'heading', required: true }, 'hideHeading', 'importance', 'intent'],
  standalone: false
})
export class SwirlInlineNotification {
  protected el: HTMLSwirlInlineNotificationElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlInlineNotification extends Components.SwirlInlineNotification {}


@ProxyCmp({
  inputs: ['icon', 'intent', 'message', 'size']
})
@Component({
  selector: 'swirl-inline-status',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['icon', { name: 'intent', required: true }, { name: 'message', required: true }, 'size'],
  standalone: false
})
export class SwirlInlineStatus {
  protected el: HTMLSwirlInlineStatusElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlInlineStatus extends Components.SwirlInlineStatus {}


@ProxyCmp({
  inputs: ['closeButtonLabel', 'downloadButtonEnabled', 'downloadButtonLabel', 'label', 'nextSlideButtonLabel', 'previousSlideButtonLabel'],
  methods: ['open', 'close', 'activateSlide']
})
@Component({
  selector: 'swirl-lightbox',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['closeButtonLabel', 'downloadButtonEnabled', 'downloadButtonLabel', { name: 'label', required: true }, 'nextSlideButtonLabel', 'previousSlideButtonLabel'],
  standalone: false
})
export class SwirlLightbox {
  protected el: HTMLSwirlLightboxElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['activeSlideChange', 'lightboxClose']);
  }
}


export declare interface SwirlLightbox extends Components.SwirlLightbox {

  activeSlideChange: EventEmitter<CustomEvent<number>>;

  lightboxClose: EventEmitter<CustomEvent<void>>;
}


@ProxyCmp({
  inputs: ['color', 'href', 'label', 'target']
})
@Component({
  selector: 'swirl-link',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['color', { name: 'href', required: true }, { name: 'label', required: true }, 'target'],
  standalone: false
})
export class SwirlLink {
  protected el: HTMLSwirlLinkElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlLink extends Components.SwirlLink {}


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


export declare interface SwirlList extends Components.SwirlList {}


@ProxyCmp({
  inputs: ['active', 'label', 'level', 'mobileBackButtonLabel', 'mobileCloseMenuButtonLabel', 'mobileDoneButtonLabel', 'placement', 'value', 'variant'],
  methods: ['activateMenuItem', 'close', 'goBack', 'focusFirstItem', 'focusItemAtIndex', 'updateSelection', 'updateActiveItem']
})
@Component({
  selector: 'swirl-menu',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['active', { name: 'label', required: true }, 'level', 'mobileBackButtonLabel', 'mobileCloseMenuButtonLabel', 'mobileDoneButtonLabel', 'placement', 'value', 'variant'],
  standalone: false
})
export class SwirlMenu {
  protected el: HTMLSwirlMenuElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['done', 'valueChange']);
  }
}


export declare interface SwirlMenu extends Components.SwirlMenu {

  done: EventEmitter<CustomEvent<void>>;

  valueChange: EventEmitter<CustomEvent<string>>;
}


@ProxyCmp({
  inputs: ['description', 'disabled', 'expanded', 'icon', 'iconBadge', 'intent', 'label', 'suffix', 'truncateLabel', 'value'],
  methods: ['getSubMenu', 'updateValue', 'getParentMenu']
})
@Component({
  selector: 'swirl-menu-item',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['description', 'disabled', 'expanded', 'icon', 'iconBadge', 'intent', { name: 'label', required: true }, 'suffix', 'truncateLabel', 'value'],
  standalone: false
})
export class SwirlMenuItem {
  protected el: HTMLSwirlMenuItemElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlMenuItem extends Components.SwirlMenuItem {}


@ProxyCmp({
  inputs: ['closable', 'closeButtonLabel', 'contentGap', 'fullscreenDisableButtonLabel', 'fullscreenEnableButtonLabel', 'hasSidebarCloseButton', 'height', 'hideCloseButton', 'hideLabel', 'hideScrolledHeaderBorder', 'hideSecondaryContent', 'hideSecondaryContentBorders', 'hideSidebarContent', 'label', 'maxHeight', 'maxWidth', 'minHeight', 'padded', 'primaryActionLabel', 'primaryContentFlex', 'primaryContentMaxWidth', 'returnFocusTo', 'secondaryActionLabel', 'secondaryContentFlex', 'secondaryContentMaxWidth', 'secondaryContentPadding', 'secondaryContentPaddingBlockEnd', 'secondaryContentPaddingBlockStart', 'secondaryContentPaddingInlineEnd', 'secondaryContentPaddingInlineStart', 'showFullscreenButton', 'sidebarCloseButtonLabel', 'sidebarFooterPadded', 'sidebarLabel', 'sidebarPadded', 'variant'],
  methods: ['open', 'close', 'setFullscreen', 'getScrollContainer']
})
@Component({
  selector: 'swirl-modal',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['closable', 'closeButtonLabel', 'contentGap', 'fullscreenDisableButtonLabel', 'fullscreenEnableButtonLabel', 'hasSidebarCloseButton', 'height', 'hideCloseButton', 'hideLabel', 'hideScrolledHeaderBorder', 'hideSecondaryContent', 'hideSecondaryContentBorders', 'hideSidebarContent', { name: 'label', required: true }, 'maxHeight', 'maxWidth', 'minHeight', 'padded', 'primaryActionLabel', 'primaryContentFlex', 'primaryContentMaxWidth', 'returnFocusTo', 'secondaryActionLabel', 'secondaryContentFlex', 'secondaryContentMaxWidth', 'secondaryContentPadding', 'secondaryContentPaddingBlockEnd', 'secondaryContentPaddingBlockStart', 'secondaryContentPaddingInlineEnd', 'secondaryContentPaddingInlineStart', 'showFullscreenButton', 'sidebarCloseButtonLabel', 'sidebarFooterPadded', 'sidebarLabel', 'sidebarPadded', 'variant'],
  standalone: false
})
export class SwirlModal {
  protected el: HTMLSwirlModalElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['toggleFullscreen', 'modalClose', 'modalOpen', 'primaryAction', 'requestModalClose', 'secondaryAction', 'sidebarClose', 'toggleDialog']);
  }
}


import type { SwirlDialogToggleEvent as ISwirlModalSwirlDialogToggleEvent } from '@getflip/swirl-components';

export declare interface SwirlModal extends Components.SwirlModal {

  toggleFullscreen: EventEmitter<CustomEvent<boolean>>;

  modalClose: EventEmitter<CustomEvent<void>>;

  modalOpen: EventEmitter<CustomEvent<void>>;

  primaryAction: EventEmitter<CustomEvent<MouseEvent>>;

  requestModalClose: EventEmitter<CustomEvent<void>>;

  secondaryAction: EventEmitter<CustomEvent<MouseEvent>>;

  sidebarClose: EventEmitter<CustomEvent<void>>;

  toggleDialog: EventEmitter<CustomEvent<ISwirlModalSwirlDialogToggleEvent>>;
}


@ProxyCmp({
  inputs: ['closeButtonLabel', 'label'],
  methods: ['close']
})
@Component({
  selector: 'swirl-modal-shell',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: [{ name: 'closeButtonLabel', required: true }, { name: 'label', required: true }],
  standalone: false
})
export class SwirlModalShell {
  protected el: HTMLSwirlModalShellElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['closeModal']);
  }
}


export declare interface SwirlModalShell extends Components.SwirlModalShell {

  closeModal: EventEmitter<CustomEvent<void>>;
}


@ProxyCmp({
  inputs: ['allowDeselect', 'allowDrag', 'assistiveTextItemGrabbed', 'assistiveTextItemMoved', 'assistiveTextItemMoving', 'disabled', 'label', 'multiSelect', 'optionListId', 'selectAllLabel', 'showSelectAll', 'value'],
  methods: ['focusItemWithValue']
})
@Component({
  selector: 'swirl-option-list',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['allowDeselect', 'allowDrag', 'assistiveTextItemGrabbed', 'assistiveTextItemMoved', 'assistiveTextItemMoving', 'disabled', 'label', 'multiSelect', 'optionListId', 'selectAllLabel', 'showSelectAll', 'value'],
  standalone: false
})
export class SwirlOptionList {
  protected el: HTMLSwirlOptionListElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['itemDrop', 'valueChange']);
  }
}


export declare interface SwirlOptionList extends Components.SwirlOptionList {

  itemDrop: EventEmitter<CustomEvent<{ item: HTMLSwirlOptionListItemElement; oldIndex: number; newIndex: number; }>>;

  valueChange: EventEmitter<CustomEvent<string[]>>;
}


@ProxyCmp({
  inputs: ['allowDrag', 'context', 'description', 'disabled', 'dragHandleDescription', 'dragHandleLabel', 'dragging', 'icon', 'iconBadge', 'indeterminate', 'label', 'minWidth', 'selected', 'swirlAriaRole', 'truncateLabel', 'value']
})
@Component({
  selector: 'swirl-option-list-item',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['allowDrag', 'context', 'description', 'disabled', 'dragHandleDescription', 'dragHandleLabel', 'dragging', 'icon', 'iconBadge', 'indeterminate', { name: 'label', required: true }, 'minWidth', 'selected', 'swirlAriaRole', 'truncateLabel', { name: 'value', required: true }],
  standalone: false
})
export class SwirlOptionListItem {
  protected el: HTMLSwirlOptionListItemElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['toggleDrag']);
  }
}


export declare interface SwirlOptionListItem extends Components.SwirlOptionListItem {

  toggleDrag: EventEmitter<CustomEvent<HTMLSwirlOptionListItemElement>>;
}


@ProxyCmp({
  inputs: ['hasSeparator', 'label', 'separatorSpacing', 'spacing']
})
@Component({
  selector: 'swirl-option-list-section',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['hasSeparator', { name: 'label', required: true }, 'separatorSpacing', 'spacing'],
  standalone: false
})
export class SwirlOptionListSection {
  protected el: HTMLSwirlOptionListSectionElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlOptionListSection extends Components.SwirlOptionListSection {}


@ProxyCmp({
  inputs: ['firstPageButtonLabel', 'label', 'lastPageButtonLabel', 'nextButtonLabel', 'page', 'pageLabel', 'pageSelectLabel', 'pageSize', 'pageSizeOptions', 'pageSizeSelectLabel', 'pages', 'prevButtonLabel', 'showPageSizeSelect', 'variant']
})
@Component({
  selector: 'swirl-pagination',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['firstPageButtonLabel', { name: 'label', required: true }, 'lastPageButtonLabel', 'nextButtonLabel', { name: 'page', required: true }, 'pageLabel', 'pageSelectLabel', 'pageSize', 'pageSizeOptions', 'pageSizeSelectLabel', { name: 'pages', required: true }, 'prevButtonLabel', 'showPageSizeSelect', 'variant'],
  standalone: false
})
export class SwirlPagination {
  protected el: HTMLSwirlPaginationElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['setPage', 'setPageSize']);
  }
}


export declare interface SwirlPagination extends Components.SwirlPagination {

  setPage: EventEmitter<CustomEvent<number>>;

  setPageSize: EventEmitter<CustomEvent<number>>;
}


@ProxyCmp({
  inputs: ['autoZoomLabel', 'closeButtonLabel', 'downloadButtonEnabled', 'downloadButtonLabel', 'file', 'fileName', 'fileTypeLabel', 'label', 'menuLabel', 'menuTriggerLabel', 'pdfWorkerSrc', 'printButtonEnabled', 'printButtonLabel', 'sideBySideButtonLabel', 'skipNativeDownload', 'thumbnailButtonLabel', 'thumbnailsButtonLabel', 'thumbnailsLabel', 'zoomInButtonLabel', 'zoomOutButtonLabel', 'zoomSelectLabel'],
  methods: ['open', 'close']
})
@Component({
  selector: 'swirl-pdf-reader',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['autoZoomLabel', 'closeButtonLabel', 'downloadButtonEnabled', 'downloadButtonLabel', { name: 'file', required: true }, 'fileName', 'fileTypeLabel', { name: 'label', required: true }, 'menuLabel', 'menuTriggerLabel', 'pdfWorkerSrc', 'printButtonEnabled', 'printButtonLabel', 'sideBySideButtonLabel', 'skipNativeDownload', 'thumbnailButtonLabel', 'thumbnailsButtonLabel', 'thumbnailsLabel', 'zoomInButtonLabel', 'zoomOutButtonLabel', 'zoomSelectLabel'],
  standalone: false
})
export class SwirlPdfReader {
  protected el: HTMLSwirlPdfReaderElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['modalClose', 'modalOpen']);
  }
}


export declare interface SwirlPdfReader extends Components.SwirlPdfReader {

  modalClose: EventEmitter<CustomEvent<void>>;

  modalOpen: EventEmitter<CustomEvent<void>>;
}


@ProxyCmp({
  inputs: ['animation', 'borderRadius', 'disableScrollLock', 'enableFlip', 'fallbackAxisSideDirection', 'fullscreenBottomSheet', 'label', 'maxHeight', 'offset', 'padded', 'placement', 'popoverId', 'returnFocusToTrigger', 'translucent', 'transparent', 'trigger', 'triggerContainer', 'useContainerWidth'],
  methods: ['close', 'open', 'isOpen', 'toggle']
})
@Component({
  selector: 'swirl-popover',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animation', 'borderRadius', 'disableScrollLock', 'enableFlip', 'fallbackAxisSideDirection', 'fullscreenBottomSheet', { name: 'label', required: true }, 'maxHeight', 'offset', 'padded', 'placement', 'popoverId', 'returnFocusToTrigger', 'translucent', 'transparent', 'trigger', 'triggerContainer', 'useContainerWidth'],
  standalone: false
})
export class SwirlPopover {
  protected el: HTMLSwirlPopoverElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['popoverClose', 'popoverOpen']);
  }
}


import type { ComputePositionReturn as ISwirlPopoverComputePositionReturn } from '@getflip/swirl-components';

export declare interface SwirlPopover extends Components.SwirlPopover {

  popoverClose: EventEmitter<CustomEvent<void>>;

  popoverOpen: EventEmitter<CustomEvent<{ position: ISwirlPopoverComputePositionReturn }>>;
}


@ProxyCmp({
  inputs: ['hidePopoverWhenInvisible', 'hoverDelay', 'hoverLingerDuration', 'parentScrollContainer', 'setAriaAttributes', 'swirlPopover', 'triggerOnClick', 'triggerOnHover']
})
@Component({
  selector: 'swirl-popover-trigger',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['hidePopoverWhenInvisible', 'hoverDelay', 'hoverLingerDuration', 'parentScrollContainer', 'setAriaAttributes', { name: 'swirlPopover', required: true }, 'triggerOnClick', 'triggerOnHover'],
  standalone: false
})
export class SwirlPopoverTrigger {
  protected el: HTMLSwirlPopoverTriggerElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlPopoverTrigger extends Components.SwirlPopoverTrigger {}


@ProxyCmp({
  inputs: ['label', 'size', 'value', 'variant']
})
@Component({
  selector: 'swirl-progress-indicator',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: [{ name: 'label', required: true }, 'size', 'value', 'variant'],
  standalone: false
})
export class SwirlProgressIndicator {
  protected el: HTMLSwirlProgressIndicatorElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlProgressIndicator extends Components.SwirlProgressIndicator {}


@ProxyCmp({
  inputs: ['checked', 'description', 'disabled', 'inputId', 'inputName', 'invalid', 'label', 'tooltip', 'value', 'variant']
})
@Component({
  selector: 'swirl-radio',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['checked', 'description', 'disabled', { name: 'inputId', required: true }, { name: 'inputName', required: true }, 'invalid', 'label', 'tooltip', { name: 'value', required: true }, 'variant'],
  standalone: false
})
export class SwirlRadio {
  protected el: HTMLSwirlRadioElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['valueChange']);
  }
}


export declare interface SwirlRadio extends Components.SwirlRadio {

  valueChange: EventEmitter<CustomEvent<string>>;
}


@ProxyCmp({
  inputs: ['swirlAriaDescribedby', 'value']
})
@Component({
  selector: 'swirl-radio-group',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['swirlAriaDescribedby', 'value'],
  standalone: false
})
export class SwirlRadioGroup {
  protected el: HTMLSwirlRadioGroupElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['valueChange']);
  }
}


export declare interface SwirlRadioGroup extends Components.SwirlRadioGroup {

  valueChange: EventEmitter<CustomEvent<string>>;
}


@ProxyCmp({
  inputs: ['allowDrag', 'assistiveTextItemGrabbed', 'assistiveTextItemMoved', 'assistiveTextItemMoving', 'controllingElement', 'label', 'padding', 'paddingBlockEnd', 'paddingBlockStart', 'paddingInlineEnd', 'paddingInlineStart', 'semantics', 'spacing'],
  methods: ['resetFocus']
})
@Component({
  selector: 'swirl-resource-list',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['allowDrag', 'assistiveTextItemGrabbed', 'assistiveTextItemMoved', 'assistiveTextItemMoving', 'controllingElement', 'label', 'padding', 'paddingBlockEnd', 'paddingBlockStart', 'paddingInlineEnd', 'paddingInlineStart', 'semantics', 'spacing'],
  standalone: false
})
export class SwirlResourceList {
  protected el: HTMLSwirlResourceListElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['itemDrop']);
  }
}


export declare interface SwirlResourceList extends Components.SwirlResourceList {

  itemDrop: EventEmitter<CustomEvent<{ item: HTMLSwirlResourceListItemElement; oldIndex: number; newIndex: number; }>>;
}


@ProxyCmp({
  inputs: ['description', 'errorMessage', 'icon', 'label', 'loading', 'removable', 'removeButtonLabel']
})
@Component({
  selector: 'swirl-resource-list-file-item',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['description', 'errorMessage', 'icon', { name: 'label', required: true }, 'loading', 'removable', 'removeButtonLabel'],
  standalone: false
})
export class SwirlResourceListFileItem {
  protected el: HTMLSwirlResourceListFileItemElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['remove']);
  }
}


export declare interface SwirlResourceListFileItem extends Components.SwirlResourceListFileItem {

  remove: EventEmitter<CustomEvent<MouseEvent>>;
}


@ProxyCmp({
  inputs: ['active', 'alignItems', 'allowDrag', 'allowHtml', 'checked', 'compact', 'description', 'descriptionWrap', 'disabled', 'dragHandleDescription', 'dragHandleLabel', 'dragging', 'hideDivider', 'href', 'interactive', 'label', 'labelMinHeight', 'labelTooltip', 'labelTooltipPosition', 'labelWeight', 'labelWrap', 'labelWrapMaxLines', 'menuTriggerId', 'menuTriggerLabel', 'meta', 'selectable', 'swirlAriaCurrent', 'swirlAriaLabel', 'value']
})
@Component({
  selector: 'swirl-resource-list-item',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['active', 'alignItems', 'allowDrag', 'allowHtml', 'checked', 'compact', 'description', 'descriptionWrap', 'disabled', 'dragHandleDescription', 'dragHandleLabel', 'dragging', 'hideDivider', 'href', 'interactive', { name: 'label', required: true }, 'labelMinHeight', 'labelTooltip', 'labelTooltipPosition', 'labelWeight', 'labelWrap', 'labelWrapMaxLines', 'menuTriggerId', 'menuTriggerLabel', 'meta', 'selectable', 'swirlAriaCurrent', 'swirlAriaLabel', 'value'],
  standalone: false
})
export class SwirlResourceListItem {
  protected el: HTMLSwirlResourceListItemElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['toggleDrag', 'valueChange']);
  }
}


export declare interface SwirlResourceListItem extends Components.SwirlResourceListItem {

  toggleDrag: EventEmitter<CustomEvent<HTMLSwirlResourceListItemElement>>;

  valueChange: EventEmitter<CustomEvent<boolean>>;
}


@ProxyCmp({
  inputs: ['hasSeparator', 'label', 'separatorSpacing', 'spacing']
})
@Component({
  selector: 'swirl-resource-list-section',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['hasSeparator', { name: 'label', required: true }, 'separatorSpacing', 'spacing'],
  standalone: false
})
export class SwirlResourceListSection {
  protected el: HTMLSwirlResourceListSectionElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlResourceListSection extends Components.SwirlResourceListSection {}


@ProxyCmp({
  inputs: ['autoFocus', 'clearButtonLabel', 'clearable', 'disabled', 'inputId', 'inputName', 'label', 'placeholder', 'value', 'variant']
})
@Component({
  selector: 'swirl-search',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['autoFocus', 'clearButtonLabel', 'clearable', 'disabled', 'inputId', 'inputName', 'label', 'placeholder', 'value', 'variant'],
  standalone: false
})
export class SwirlSearch {
  protected el: HTMLSwirlSearchElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['clear', 'inputBlur', 'inputFocus', 'inputInput', 'valueChange']);
  }
}


export declare interface SwirlSearch extends Components.SwirlSearch {

  clear: EventEmitter<CustomEvent<void>>;

  inputBlur: EventEmitter<CustomEvent<FocusEvent>>;

  inputFocus: EventEmitter<CustomEvent<FocusEvent>>;

  inputInput: EventEmitter<CustomEvent<string>>;

  valueChange: EventEmitter<CustomEvent<string>>;
}


@ProxyCmp({
  inputs: ['allowDeselect', 'disabled', 'emptyListLabel', 'inline', 'invalid', 'label', 'multiSelect', 'required', 'searchInputLabel', 'searchLoading', 'searchPlaceholder', 'selectId', 'standalone', 'swirlAriaDescribedby', 'value', 'withSearch']
})
@Component({
  selector: 'swirl-select',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['allowDeselect', 'disabled', 'emptyListLabel', 'inline', 'invalid', { name: 'label', required: true }, 'multiSelect', 'required', 'searchInputLabel', 'searchLoading', 'searchPlaceholder', 'selectId', 'standalone', 'swirlAriaDescribedby', 'value', 'withSearch'],
  standalone: false
})
export class SwirlSelect {
  protected el: HTMLSwirlSelectElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['searchChange', 'valueChange']);
  }
}


export declare interface SwirlSelect extends Components.SwirlSelect {

  searchChange: EventEmitter<CustomEvent<string>>;

  valueChange: EventEmitter<CustomEvent<string[]>>;
}


@ProxyCmp({
  inputs: ['borderColor', 'color', 'label', 'orientation', 'semantics', 'spacing']
})
@Component({
  selector: 'swirl-separator',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['borderColor', 'color', 'label', 'orientation', 'semantics', 'spacing'],
  standalone: false
})
export class SwirlSeparator {
  protected el: HTMLSwirlSeparatorElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSeparator extends Components.SwirlSeparator {}


@ProxyCmp({
  inputs: ['brandedHeader', 'browserBackButtonLabel', 'browserForwardButtonLabel', 'collapseNavigationButtonLabel', 'enableSecondaryNavGridLayout', 'expandNavigationButtonLabel', 'gridNavLayoutToggleLabel', 'hideMobileNavigationButtonLabel', 'listNavLayoutToggleLabel', 'navigationLabel', 'secondaryNavCollapseLabel', 'secondaryNavExpandLabel', 'secondaryNavGridLayoutVariant', 'skipLinkLabel'],
  methods: ['showMobileNavigation', 'hideMobileNavigation']
})
@Component({
  selector: 'swirl-shell-layout',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['brandedHeader', 'browserBackButtonLabel', 'browserForwardButtonLabel', 'collapseNavigationButtonLabel', 'enableSecondaryNavGridLayout', 'expandNavigationButtonLabel', 'gridNavLayoutToggleLabel', 'hideMobileNavigationButtonLabel', 'listNavLayoutToggleLabel', 'navigationLabel', 'secondaryNavCollapseLabel', 'secondaryNavExpandLabel', 'secondaryNavGridLayoutVariant', 'skipLinkLabel'],
  standalone: false
})
export class SwirlShellLayout {
  protected el: HTMLSwirlShellLayoutElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['historyBackClick', 'historyForwardClick', 'skipLinkClick']);
  }
}


export declare interface SwirlShellLayout extends Components.SwirlShellLayout {

  historyBackClick: EventEmitter<CustomEvent<MouseEvent>>;

  historyForwardClick: EventEmitter<CustomEvent<MouseEvent>>;

  skipLinkClick: EventEmitter<CustomEvent<MouseEvent>>;
}


@ProxyCmp({
  inputs: ['active', 'badgeLabel', 'boxed', 'description', 'filled', 'hideLabel', 'href', 'inlineLabel', 'inlineLabelColor', 'label', 'markAsNew', 'markAsNewLabel', 'swirlAriaCurrent', 'target', 'useCustomIconSize', 'variant', 'withGradient']
})
@Component({
  selector: 'swirl-shell-navigation-item',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['active', 'badgeLabel', 'boxed', 'description', 'filled', 'hideLabel', 'href', 'inlineLabel', 'inlineLabelColor', { name: 'label', required: true }, 'markAsNew', 'markAsNewLabel', 'swirlAriaCurrent', 'target', 'useCustomIconSize', 'variant', 'withGradient'],
  standalone: false
})
export class SwirlShellNavigationItem {
  protected el: HTMLSwirlShellNavigationItemElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlShellNavigationItem extends Components.SwirlShellNavigationItem {}


@ProxyCmp({
  inputs: ['animated', 'aspectRatio', 'borderRadius', 'height', 'width']
})
@Component({
  selector: 'swirl-skeleton-box',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animated', 'aspectRatio', 'borderRadius', 'height', 'width'],
  standalone: false
})
export class SwirlSkeletonBox {
  protected el: HTMLSwirlSkeletonBoxElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSkeletonBox extends Components.SwirlSkeletonBox {}


@ProxyCmp({
  inputs: ['animated', 'lines', 'size']
})
@Component({
  selector: 'swirl-skeleton-text',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['animated', 'lines', 'size'],
  standalone: false
})
export class SwirlSkeletonText {
  protected el: HTMLSwirlSkeletonTextElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSkeletonText extends Components.SwirlSkeletonText {}


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


export declare interface SwirlSpinner extends Components.SwirlSpinner {}


@ProxyCmp({
  inputs: ['align', 'as', 'columnSpacing', 'height', 'justify', 'orientation', 'rowSpacing', 'spacing', 'swirlAriaRole', 'wrap']
})
@Component({
  selector: 'swirl-stack',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['align', 'as', 'columnSpacing', 'height', 'justify', 'orientation', 'rowSpacing', 'spacing', 'swirlAriaRole', 'wrap'],
  standalone: false
})
export class SwirlStack {
  protected el: HTMLSwirlStackElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlStack extends Components.SwirlStack {}


@ProxyCmp({
  inputs: ['intent', 'label']
})
@Component({
  selector: 'swirl-status-indicator',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: [{ name: 'intent', required: true }, { name: 'label', required: true }],
  standalone: false
})
export class SwirlStatusIndicator {
  protected el: HTMLSwirlStatusIndicatorElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlStatusIndicator extends Components.SwirlStatusIndicator {}


@ProxyCmp({
  inputs: ['checked', 'description', 'disabled', 'hideDescription', 'hideLabel', 'inputId', 'inputName', 'label', 'labelPosition', 'swirlAriaLabel', 'value'],
  methods: ['toggle']
})
@Component({
  selector: 'swirl-switch',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['checked', 'description', 'disabled', 'hideDescription', 'hideLabel', { name: 'inputId', required: true }, { name: 'inputName', required: true }, 'label', 'labelPosition', 'swirlAriaLabel', 'value'],
  standalone: false
})
export class SwirlSwitch {
  protected el: HTMLSwirlSwitchElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['valueChange']);
  }
}


export declare interface SwirlSwitch extends Components.SwirlSwitch {

  valueChange: EventEmitter<CustomEvent<boolean>>;
}


@ProxyCmp({
  inputs: ['glyph', 'size']
})
@Component({
  selector: 'swirl-symbol',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: [{ name: 'glyph', required: true }, 'size'],
  standalone: false
})
export class SwirlSymbol {
  protected el: HTMLSwirlSymbolElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbol extends Components.SwirlSymbol {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-ac-unit',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolAcUnit {
  protected el: HTMLSwirlSymbolAcUnitElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolAcUnit extends Components.SwirlSymbolAcUnit {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-account-circle',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolAccountCircle {
  protected el: HTMLSwirlSymbolAccountCircleElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolAccountCircle extends Components.SwirlSymbolAccountCircle {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-alternate-email',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolAlternateEmail {
  protected el: HTMLSwirlSymbolAlternateEmailElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolAlternateEmail extends Components.SwirlSymbolAlternateEmail {}


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


export declare interface SwirlSymbolAndroid extends Components.SwirlSymbolAndroid {}


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


export declare interface SwirlSymbolAnnouncement extends Components.SwirlSymbolAnnouncement {}


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


export declare interface SwirlSymbolAutorenew extends Components.SwirlSymbolAutorenew {}


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


export declare interface SwirlSymbolBackup extends Components.SwirlSymbolBackup {}


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


export declare interface SwirlSymbolBadge extends Components.SwirlSymbolBadge {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-barcode-reader',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolBarcodeReader {
  protected el: HTMLSwirlSymbolBarcodeReaderElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolBarcodeReader extends Components.SwirlSymbolBarcodeReader {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-barcode-scanner',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolBarcodeScanner {
  protected el: HTMLSwirlSymbolBarcodeScannerElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolBarcodeScanner extends Components.SwirlSymbolBarcodeScanner {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-battery-horiz',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolBatteryHoriz {
  protected el: HTMLSwirlSymbolBatteryHorizElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolBatteryHoriz extends Components.SwirlSymbolBatteryHoriz {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-beach-access',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolBeachAccess {
  protected el: HTMLSwirlSymbolBeachAccessElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolBeachAccess extends Components.SwirlSymbolBeachAccess {}


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


export declare interface SwirlSymbolBolt extends Components.SwirlSymbolBolt {}


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


export declare interface SwirlSymbolBookmark extends Components.SwirlSymbolBookmark {}


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


export declare interface SwirlSymbolCalendar extends Components.SwirlSymbolCalendar {}


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


export declare interface SwirlSymbolCampaign extends Components.SwirlSymbolCampaign {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-cards-star',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolCardsStar {
  protected el: HTMLSwirlSymbolCardsStarElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolCardsStar extends Components.SwirlSymbolCardsStar {}


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


export declare interface SwirlSymbolCloud extends Components.SwirlSymbolCloud {}


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


export declare interface SwirlSymbolConstruction extends Components.SwirlSymbolConstruction {}


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


export declare interface SwirlSymbolContacts extends Components.SwirlSymbolContacts {}


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


export declare interface SwirlSymbolCoronavirus extends Components.SwirlSymbolCoronavirus {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-design-services',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolDesignServices {
  protected el: HTMLSwirlSymbolDesignServicesElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolDesignServices extends Components.SwirlSymbolDesignServices {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-desktop-windows',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolDesktopWindows {
  protected el: HTMLSwirlSymbolDesktopWindowsElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolDesktopWindows extends Components.SwirlSymbolDesktopWindows {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-directions-car-filled',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolDirectionsCarFilled {
  protected el: HTMLSwirlSymbolDirectionsCarFilledElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolDirectionsCarFilled extends Components.SwirlSymbolDirectionsCarFilled {}


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


export declare interface SwirlSymbolDiversity extends Components.SwirlSymbolDiversity {}


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


export declare interface SwirlSymbolDraw extends Components.SwirlSymbolDraw {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-edit-calendar',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolEditCalendar {
  protected el: HTMLSwirlSymbolEditCalendarElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolEditCalendar extends Components.SwirlSymbolEditCalendar {}


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


export declare interface SwirlSymbolEmail extends Components.SwirlSymbolEmail {}


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


export declare interface SwirlSymbolEmergency extends Components.SwirlSymbolEmergency {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-emoji-food-beverage',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolEmojiFoodBeverage {
  protected el: HTMLSwirlSymbolEmojiFoodBeverageElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolEmojiFoodBeverage extends Components.SwirlSymbolEmojiFoodBeverage {}


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


export declare interface SwirlSymbolEngineering extends Components.SwirlSymbolEngineering {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-event-menu',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolEventMenu {
  protected el: HTMLSwirlSymbolEventMenuElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolEventMenu extends Components.SwirlSymbolEventMenu {}


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


export declare interface SwirlSymbolExplore extends Components.SwirlSymbolExplore {}


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


export declare interface SwirlSymbolExtension extends Components.SwirlSymbolExtension {}


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


export declare interface SwirlSymbolFacebook extends Components.SwirlSymbolFacebook {}


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


export declare interface SwirlSymbolFavorite extends Components.SwirlSymbolFavorite {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-fitness-center',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolFitnessCenter {
  protected el: HTMLSwirlSymbolFitnessCenterElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolFitnessCenter extends Components.SwirlSymbolFitnessCenter {}


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


export declare interface SwirlSymbolFlag extends Components.SwirlSymbolFlag {}


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


export declare interface SwirlSymbolFlight extends Components.SwirlSymbolFlight {}


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


export declare interface SwirlSymbolFolder extends Components.SwirlSymbolFolder {}


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


export declare interface SwirlSymbolGlobe extends Components.SwirlSymbolGlobe {}


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


export declare interface SwirlSymbolGroups extends Components.SwirlSymbolGroups {}


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


export declare interface SwirlSymbolHealing extends Components.SwirlSymbolHealing {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-health-and-safety',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolHealthAndSafety {
  protected el: HTMLSwirlSymbolHealthAndSafetyElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolHealthAndSafety extends Components.SwirlSymbolHealthAndSafety {}


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


export declare interface SwirlSymbolHelp extends Components.SwirlSymbolHelp {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-home-repair-service',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolHomeRepairService {
  protected el: HTMLSwirlSymbolHomeRepairServiceElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolHomeRepairService extends Components.SwirlSymbolHomeRepairService {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-home-storage',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolHomeStorage {
  protected el: HTMLSwirlSymbolHomeStorageElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolHomeStorage extends Components.SwirlSymbolHomeStorage {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-id-card',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolIdCard {
  protected el: HTMLSwirlSymbolIdCardElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolIdCard extends Components.SwirlSymbolIdCard {}


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


export declare interface SwirlSymbolImage extends Components.SwirlSymbolImage {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-info-menu',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolInfoMenu {
  protected el: HTMLSwirlSymbolInfoMenuElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolInfoMenu extends Components.SwirlSymbolInfoMenu {}


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


export declare interface SwirlSymbolInstagram extends Components.SwirlSymbolInstagram {}


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


export declare interface SwirlSymbolInventory extends Components.SwirlSymbolInventory {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-inventory-2',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolInventory2 {
  protected el: HTMLSwirlSymbolInventory2Element;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolInventory2 extends Components.SwirlSymbolInventory2 {}


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


export declare interface SwirlSymbolIos extends Components.SwirlSymbolIos {}


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


export declare interface SwirlSymbolKey extends Components.SwirlSymbolKey {}


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


export declare interface SwirlSymbolLanguage extends Components.SwirlSymbolLanguage {}


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


export declare interface SwirlSymbolLeaderboard extends Components.SwirlSymbolLeaderboard {}


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


export declare interface SwirlSymbolLightbulb extends Components.SwirlSymbolLightbulb {}


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


export declare interface SwirlSymbolLinkedin extends Components.SwirlSymbolLinkedin {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-local-shipping',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolLocalShipping {
  protected el: HTMLSwirlSymbolLocalShippingElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolLocalShipping extends Components.SwirlSymbolLocalShipping {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-location-on',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolLocationOn {
  protected el: HTMLSwirlSymbolLocationOnElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolLocationOn extends Components.SwirlSymbolLocationOn {}


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


export declare interface SwirlSymbolLoyalty extends Components.SwirlSymbolLoyalty {}


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


export declare interface SwirlSymbolMap extends Components.SwirlSymbolMap {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-maps-home-work',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolMapsHomeWork {
  protected el: HTMLSwirlSymbolMapsHomeWorkElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolMapsHomeWork extends Components.SwirlSymbolMapsHomeWork {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-menu-book',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolMenuBook {
  protected el: HTMLSwirlSymbolMenuBookElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolMenuBook extends Components.SwirlSymbolMenuBook {}


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


export declare interface SwirlSymbolMop extends Components.SwirlSymbolMop {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-nest-eco-leaf',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolNestEcoLeaf {
  protected el: HTMLSwirlSymbolNestEcoLeafElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolNestEcoLeaf extends Components.SwirlSymbolNestEcoLeaf {}


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


export declare interface SwirlSymbolNotifications extends Components.SwirlSymbolNotifications {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-open-in-new',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolOpenInNew {
  protected el: HTMLSwirlSymbolOpenInNewElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolOpenInNew extends Components.SwirlSymbolOpenInNew {}


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


export declare interface SwirlSymbolOrders extends Components.SwirlSymbolOrders {}


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


export declare interface SwirlSymbolPackage extends Components.SwirlSymbolPackage {}


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


export declare interface SwirlSymbolPalette extends Components.SwirlSymbolPalette {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-partly-cloudy-day',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolPartlyCloudyDay {
  protected el: HTMLSwirlSymbolPartlyCloudyDayElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolPartlyCloudyDay extends Components.SwirlSymbolPartlyCloudyDay {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-pedal-bike',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolPedalBike {
  protected el: HTMLSwirlSymbolPedalBikeElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolPedalBike extends Components.SwirlSymbolPedalBike {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-percent-discount',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolPercentDiscount {
  protected el: HTMLSwirlSymbolPercentDiscountElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolPercentDiscount extends Components.SwirlSymbolPercentDiscount {}


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


export declare interface SwirlSymbolPets extends Components.SwirlSymbolPets {}


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


export declare interface SwirlSymbolPinterest extends Components.SwirlSymbolPinterest {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-point-of-sale',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolPointOfSale {
  protected el: HTMLSwirlSymbolPointOfSaleElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolPointOfSale extends Components.SwirlSymbolPointOfSale {}


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


export declare interface SwirlSymbolPolicy extends Components.SwirlSymbolPolicy {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-precision-manufacturing',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolPrecisionManufacturing {
  protected el: HTMLSwirlSymbolPrecisionManufacturingElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolPrecisionManufacturing extends Components.SwirlSymbolPrecisionManufacturing {}


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


export declare interface SwirlSymbolPrint extends Components.SwirlSymbolPrint {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-push-pin',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolPushPin {
  protected el: HTMLSwirlSymbolPushPinElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolPushPin extends Components.SwirlSymbolPushPin {}


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


export declare interface SwirlSymbolRecycling extends Components.SwirlSymbolRecycling {}


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


export declare interface SwirlSymbolRedeem extends Components.SwirlSymbolRedeem {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-report-problem',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolReportProblem {
  protected el: HTMLSwirlSymbolReportProblemElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolReportProblem extends Components.SwirlSymbolReportProblem {}


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


export declare interface SwirlSymbolRestaurant extends Components.SwirlSymbolRestaurant {}


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


export declare interface SwirlSymbolRoadmap extends Components.SwirlSymbolRoadmap {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-rocket-launch',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolRocketLaunch {
  protected el: HTMLSwirlSymbolRocketLaunchElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolRocketLaunch extends Components.SwirlSymbolRocketLaunch {}


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


export declare interface SwirlSymbolRoom extends Components.SwirlSymbolRoom {}


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


export declare interface SwirlSymbolSavings extends Components.SwirlSymbolSavings {}


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


export declare interface SwirlSymbolSchool extends Components.SwirlSymbolSchool {}


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


export declare interface SwirlSymbolSell extends Components.SwirlSymbolSell {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-settings-voice',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolSettingsVoice {
  protected el: HTMLSwirlSymbolSettingsVoiceElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolSettingsVoice extends Components.SwirlSymbolSettingsVoice {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-shopping-bag',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolShoppingBag {
  protected el: HTMLSwirlSymbolShoppingBagElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolShoppingBag extends Components.SwirlSymbolShoppingBag {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-shopping-cart',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolShoppingCart {
  protected el: HTMLSwirlSymbolShoppingCartElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolShoppingCart extends Components.SwirlSymbolShoppingCart {}


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


export declare interface SwirlSymbolSmartphone extends Components.SwirlSymbolSmartphone {}


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


export declare interface SwirlSymbolSpa extends Components.SwirlSymbolSpa {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-sports-soccer',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolSportsSoccer {
  protected el: HTMLSwirlSymbolSportsSoccerElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolSportsSoccer extends Components.SwirlSymbolSportsSoccer {}


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


export declare interface SwirlSymbolStar extends Components.SwirlSymbolStar {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-supervisor-account',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolSupervisorAccount {
  protected el: HTMLSwirlSymbolSupervisorAccountElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolSupervisorAccount extends Components.SwirlSymbolSupervisorAccount {}


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


export declare interface SwirlSymbolTask extends Components.SwirlSymbolTask {}


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


export declare interface SwirlSymbolTasks extends Components.SwirlSymbolTasks {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-thumbs-up-down',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolThumbsUpDown {
  protected el: HTMLSwirlSymbolThumbsUpDownElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolThumbsUpDown extends Components.SwirlSymbolThumbsUpDown {}


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


export declare interface SwirlSymbolTimer extends Components.SwirlSymbolTimer {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-tools-power-drill',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolToolsPowerDrill {
  protected el: HTMLSwirlSymbolToolsPowerDrillElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolToolsPowerDrill extends Components.SwirlSymbolToolsPowerDrill {}


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


export declare interface SwirlSymbolTrain extends Components.SwirlSymbolTrain {}


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


export declare interface SwirlSymbolTrophy extends Components.SwirlSymbolTrophy {}


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


export declare interface SwirlSymbolTwitter extends Components.SwirlSymbolTwitter {}


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


export declare interface SwirlSymbolVideo extends Components.SwirlSymbolVideo {}


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


export declare interface SwirlSymbolWarehouse extends Components.SwirlSymbolWarehouse {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-water-drop',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolWaterDrop {
  protected el: HTMLSwirlSymbolWaterDropElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolWaterDrop extends Components.SwirlSymbolWaterDrop {}


@ProxyCmp({
  inputs: ['size']
})
@Component({
  selector: 'swirl-symbol-wb-sunny',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['size'],
  standalone: false
})
export class SwirlSymbolWbSunny {
  protected el: HTMLSwirlSymbolWbSunnyElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlSymbolWbSunny extends Components.SwirlSymbolWbSunny {}


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


export declare interface SwirlSymbolWechat extends Components.SwirlSymbolWechat {}


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


export declare interface SwirlSymbolWeibo extends Components.SwirlSymbolWeibo {}


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


export declare interface SwirlSymbolWifi extends Components.SwirlSymbolWifi {}


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


export declare interface SwirlSymbolWork extends Components.SwirlSymbolWork {}


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


export declare interface SwirlSymbolXing extends Components.SwirlSymbolXing {}


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


export declare interface SwirlSymbolYoutube extends Components.SwirlSymbolYoutube {}


@ProxyCmp({
  inputs: ['active', 'icon', 'label', 'padding', 'tabId']
})
@Component({
  selector: 'swirl-tab',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['active', 'icon', { name: 'label', required: true }, 'padding', { name: 'tabId', required: true }],
  standalone: false
})
export class SwirlTab {
  protected el: HTMLSwirlTabElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlTab extends Components.SwirlTab {}


@ProxyCmp({
  inputs: ['disableTabSemantics', 'justify', 'label', 'paddingBlockEnd', 'paddingBlockStart', 'paddingInlineEnd', 'paddingInlineStart', 'tabs', 'variant']
})
@Component({
  selector: 'swirl-tab-bar',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['disableTabSemantics', 'justify', { name: 'label', required: true }, 'paddingBlockEnd', 'paddingBlockStart', 'paddingInlineEnd', 'paddingInlineStart', 'tabs', 'variant'],
  standalone: false
})
export class SwirlTabBar {
  protected el: HTMLSwirlTabBarElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['activateNextTab', 'activatePreviousTab', 'activateTab']);
  }
}


export declare interface SwirlTabBar extends Components.SwirlTabBar {

  activateNextTab: EventEmitter<CustomEvent<void>>;

  activatePreviousTab: EventEmitter<CustomEvent<void>>;

  activateTab: EventEmitter<CustomEvent<string>>;
}


@ProxyCmp({
  inputs: ['caption', 'dragDropHandle', 'dragDropInstructions', 'emptyStateLabel', 'enableDragDrop', 'label', 'loading'],
  methods: ['rerender']
})
@Component({
  selector: 'swirl-table',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['caption', 'dragDropHandle', 'dragDropInstructions', 'emptyStateLabel', 'enableDragDrop', { name: 'label', required: true }, 'loading'],
  standalone: false
})
export class SwirlTable {
  protected el: HTMLSwirlTableElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['dropRow']);
  }
}


import type { SwirlTableDropRowEvent as ISwirlTableSwirlTableDropRowEvent } from '@getflip/swirl-components';

export declare interface SwirlTable extends Components.SwirlTable {

  dropRow: EventEmitter<CustomEvent<ISwirlTableSwirlTableDropRowEvent>>;
}


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


export declare interface SwirlTableCell extends Components.SwirlTableCell {}


@ProxyCmp({
  inputs: ['maxWidth', 'minWidth', 'sort', 'sortable', 'sticky', 'variant', 'width']
})
@Component({
  selector: 'swirl-table-column',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['maxWidth', 'minWidth', 'sort', 'sortable', 'sticky', 'variant', 'width'],
  standalone: false
})
export class SwirlTableColumn {
  protected el: HTMLSwirlTableColumnElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlTableColumn extends Components.SwirlTableColumn {}


@ProxyCmp({
  inputs: ['highlighted', 'index']
})
@Component({
  selector: 'swirl-table-row',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['highlighted', 'index'],
  standalone: false
})
export class SwirlTableRow {
  protected el: HTMLSwirlTableRowElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlTableRow extends Components.SwirlTableRow {}


@ProxyCmp({
  inputs: ['collapseButtonLabel', 'collapsible', 'label', 'tooltip']
})
@Component({
  selector: 'swirl-table-row-group',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['collapseButtonLabel', 'collapsible', { name: 'label', required: true }, 'tooltip'],
  standalone: false
})
export class SwirlTableRowGroup {
  protected el: HTMLSwirlTableRowGroupElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlTableRowGroup extends Components.SwirlTableRowGroup {}


@ProxyCmp({
  inputs: ['initialTab', 'justifyTabBar', 'label', 'tabBarPaddingBlockEnd', 'tabBarPaddingBlockStart', 'tabBarPaddingInlineEnd', 'tabBarPaddingInlineStart', 'tabBarVariant'],
  methods: ['activateTab']
})
@Component({
  selector: 'swirl-tabs',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['initialTab', 'justifyTabBar', { name: 'label', required: true }, 'tabBarPaddingBlockEnd', 'tabBarPaddingBlockStart', 'tabBarPaddingInlineEnd', 'tabBarPaddingInlineStart', 'tabBarVariant'],
  standalone: false
})
export class SwirlTabs {
  protected el: HTMLSwirlTabsElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['tabActivated']);
  }
}


export declare interface SwirlTabs extends Components.SwirlTabs {

  tabActivated: EventEmitter<CustomEvent<HTMLSwirlTabElement>>;
}


@ProxyCmp({
  inputs: ['bordered', 'hideLabel', 'icon', 'iconPosition', 'intent', 'label', 'removable', 'removalButtonLabel', 'size', 'variant']
})
@Component({
  selector: 'swirl-tag',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['bordered', 'hideLabel', 'icon', 'iconPosition', 'intent', { name: 'label', required: true }, 'removable', 'removalButtonLabel', 'size', 'variant'],
  standalone: false
})
export class SwirlTag {
  protected el: HTMLSwirlTagElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['remove']);
  }
}


export declare interface SwirlTag extends Components.SwirlTag {

  remove: EventEmitter<CustomEvent<MouseEvent>>;
}


@ProxyCmp({
  inputs: ['align', 'as', 'balance', 'color', 'fontFamily', 'fontStyle', 'lines', 'responsive', 'size', 'truncate', 'truncateDirection', 'weight', 'whiteSpace']
})
@Component({
  selector: 'swirl-text',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['align', 'as', 'balance', 'color', 'fontFamily', 'fontStyle', 'lines', 'responsive', 'size', 'truncate', 'truncateDirection', 'weight', 'whiteSpace'],
  standalone: false
})
export class SwirlText {
  protected el: HTMLSwirlTextElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlText extends Components.SwirlText {}


@ProxyCmp({
  inputs: ['autoComplete', 'autoFocus', 'autoGrow', 'autoSelect', 'characterCounterLabel', 'clearButtonLabel', 'clearable', 'disableDynamicWidth', 'disabled', 'fontSize', 'inline', 'inputName', 'invalid', 'max', 'maxLength', 'min', 'mode', 'passwordToggleLabel', 'placeholder', 'prefixLabel', 'readonly', 'required', 'rows', 'showCharacterCounter', 'showCharacterCounterNearLimit', 'spellCheck', 'step', 'suffixLabel', 'swirlAriaAutocomplete', 'swirlAriaControls', 'swirlAriaDescribedby', 'swirlAriaExpanded', 'swirlRole', 'type', 'value'],
  methods: ['blurInput', 'focusInput']
})
@Component({
  selector: 'swirl-text-input',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['autoComplete', 'autoFocus', 'autoGrow', 'autoSelect', 'characterCounterLabel', 'clearButtonLabel', 'clearable', 'disableDynamicWidth', 'disabled', 'fontSize', 'inline', 'inputName', 'invalid', 'max', 'maxLength', 'min', 'mode', 'passwordToggleLabel', 'placeholder', 'prefixLabel', 'readonly', 'required', 'rows', 'showCharacterCounter', 'showCharacterCounterNearLimit', 'spellCheck', 'step', 'suffixLabel', 'swirlAriaAutocomplete', 'swirlAriaControls', 'swirlAriaDescribedby', 'swirlAriaExpanded', 'swirlRole', 'type', 'value'],
  standalone: false
})
export class SwirlTextInput {
  protected el: HTMLSwirlTextInputElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['clear', 'inputBlur', 'inputFocus', 'valueChange']);
  }
}


export declare interface SwirlTextInput extends Components.SwirlTextInput {

  clear: EventEmitter<CustomEvent<void>>;

  inputBlur: EventEmitter<CustomEvent<FocusEvent>>;

  inputFocus: EventEmitter<CustomEvent<FocusEvent>>;

  valueChange: EventEmitter<CustomEvent<string>>;
}


@ProxyCmp({
  inputs: ['config'],
  methods: ['getActiveOSTheme', 'getPreferredOSTheme', 'setPreferredOSTheme', 'resetPreferredOSTheme']
})
@Component({
  selector: 'swirl-theme-provider',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['config'],
  standalone: false
})
export class SwirlThemeProvider {
  protected el: HTMLSwirlThemeProviderElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['appThemeUpdated', 'themeChange']);
  }
}


import type { SwirlOSThemeChangeEventData as ISwirlThemeProviderSwirlOSThemeChangeEventData } from '@getflip/swirl-components';

export declare interface SwirlThemeProvider extends Components.SwirlThemeProvider {

  appThemeUpdated: EventEmitter<CustomEvent<void>>;

  themeChange: EventEmitter<CustomEvent<ISwirlThemeProviderSwirlOSThemeChangeEventData>>;
}


@ProxyCmp({
  inputs: ['alt', 'cursor', 'editButtonIcon', 'editButtonLabel', 'error', 'format', 'interactive', 'menuButtonLabel', 'openButtonIcon', 'openButtonLabel', 'progress', 'progressLabel', 'removeButtonIcon', 'removeButtonLabel', 'showEditButton', 'showRemoveButton', 'size', 'src', 'timestamp']
})
@Component({
  selector: 'swirl-thumbnail',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: [{ name: 'alt', required: true }, 'cursor', 'editButtonIcon', 'editButtonLabel', 'error', 'format', 'interactive', 'menuButtonLabel', 'openButtonIcon', 'openButtonLabel', 'progress', 'progressLabel', 'removeButtonIcon', 'removeButtonLabel', 'showEditButton', 'showRemoveButton', 'size', { name: 'src', required: true }, 'timestamp'],
  standalone: false
})
export class SwirlThumbnail {
  protected el: HTMLSwirlThumbnailElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['edit', 'remove', 'thumbnailClick']);
  }
}


export declare interface SwirlThumbnail extends Components.SwirlThumbnail {

  edit: EventEmitter<CustomEvent<MouseEvent>>;

  remove: EventEmitter<CustomEvent<MouseEvent>>;

  thumbnailClick: EventEmitter<CustomEvent<MouseEvent>>;
}


@ProxyCmp({
  inputs: ['autoFocus', 'autoSelect', 'disabled', 'format', 'inline', 'invalid', 'placeholder', 'readonly', 'required', 'swirlAriaDescribedby', 'value']
})
@Component({
  selector: 'swirl-time-input',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['autoFocus', 'autoSelect', 'disabled', 'format', 'inline', 'invalid', 'placeholder', 'readonly', 'required', 'swirlAriaDescribedby', 'value'],
  standalone: false
})
export class SwirlTimeInput {
  protected el: HTMLSwirlTimeInputElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['inputBlur', 'inputFocus', 'valueChange']);
  }
}


export declare interface SwirlTimeInput extends Components.SwirlTimeInput {

  inputBlur: EventEmitter<CustomEvent<FocusEvent>>;

  inputFocus: EventEmitter<CustomEvent<FocusEvent>>;

  valueChange: EventEmitter<CustomEvent<string>>;
}


@ProxyCmp({
  inputs: ['accessibleDismissLabel', 'actionLabel', 'content', 'dismissLabel', 'duration', 'icon', 'intent', 'toastId']
})
@Component({
  selector: 'swirl-toast',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['accessibleDismissLabel', 'actionLabel', 'content', 'dismissLabel', 'duration', 'icon', 'intent', { name: 'toastId', required: true }],
  standalone: false
})
export class SwirlToast {
  protected el: HTMLSwirlToastElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['action', 'dismiss']);
  }
}


export declare interface SwirlToast extends Components.SwirlToast {

  action: EventEmitter<CustomEvent<string>>;

  dismiss: EventEmitter<CustomEvent<string>>;
}


@ProxyCmp({
  inputs: ['globalDuration'],
  methods: ['clearAll', 'dismiss', 'toast']
})
@Component({
  selector: 'swirl-toast-provider',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['globalDuration'],
  standalone: false
})
export class SwirlToastProvider {
  protected el: HTMLSwirlToastProviderElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlToastProvider extends Components.SwirlToastProvider {}


@ProxyCmp({
  inputs: ['hideLabel', 'icon', 'identifier', 'isPressed', 'label']
})
@Component({
  selector: 'swirl-toggle-button',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['hideLabel', 'icon', { name: 'identifier', required: true }, 'isPressed', { name: 'label', required: true }],
  standalone: false
})
export class SwirlToggleButton {
  protected el: HTMLSwirlToggleButtonElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlToggleButton extends Components.SwirlToggleButton {}


@ProxyCmp({
  inputs: ['elevated', 'selectedToggleId', 'swirlAriaLabel', 'variant']
})
@Component({
  selector: 'swirl-toggle-group',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['elevated', { name: 'selectedToggleId', required: true }, 'swirlAriaLabel', 'variant'],
  standalone: false
})
export class SwirlToggleGroup {
  protected el: HTMLSwirlToggleGroupElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['selectedToggleChange']);
  }
}


export declare interface SwirlToggleGroup extends Components.SwirlToggleGroup {

  selectedToggleChange: EventEmitter<CustomEvent<string>>;
}


@ProxyCmp({
  inputs: ['label', 'orientation', 'spacing']
})
@Component({
  selector: 'swirl-toolbar',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['label', 'orientation', 'spacing'],
  standalone: false
})
export class SwirlToolbar {
  protected el: HTMLSwirlToolbarElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlToolbar extends Components.SwirlToolbar {}


@ProxyCmp({
  inputs: ['active', 'content', 'delay', 'enableFlip', 'intent', 'maxWidth', 'position', 'positioning', 'trigger'],
  methods: ['show', 'hide']
})
@Component({
  selector: 'swirl-tooltip',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['active', { name: 'content', required: true }, 'delay', 'enableFlip', 'intent', 'maxWidth', 'position', 'positioning', 'trigger'],
  standalone: false
})
export class SwirlTooltip {
  protected el: HTMLSwirlTooltipElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlTooltip extends Components.SwirlTooltip {}


@ProxyCmp({
  inputs: ['label']
})
@Component({
  selector: 'swirl-tree-navigation',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: [{ name: 'label', required: true }],
  standalone: false
})
export class SwirlTreeNavigation {
  protected el: HTMLSwirlTreeNavigationElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlTreeNavigation extends Components.SwirlTreeNavigation {}


@ProxyCmp({
  inputs: ['active', 'expandable', 'external', 'href', 'icon', 'label', 'level', 'markAsNew', 'markAsNewLabel', 'navigationItemId', 'target'],
  methods: ['expand', 'collapse']
})
@Component({
  selector: 'swirl-tree-navigation-item',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['active', 'expandable', 'external', 'href', 'icon', { name: 'label', required: true }, 'level', 'markAsNew', 'markAsNewLabel', { name: 'navigationItemId', required: true }, 'target'],
  standalone: false
})
export class SwirlTreeNavigationItem {
  protected el: HTMLSwirlTreeNavigationItemElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['expansionChange']);
  }
}


export declare interface SwirlTreeNavigationItem extends Components.SwirlTreeNavigationItem {

  expansionChange: EventEmitter<CustomEvent<boolean>>;
}


@ProxyCmp({
  inputs: ['canDrop', 'dragDropInstructions', 'dragDropItemSelector', 'enableDragDrop', 'initiallyExpandedItemIds', 'label', 'semantics'],
  methods: ['expandItems']
})
@Component({
  selector: 'swirl-tree-view',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['canDrop', 'dragDropInstructions', 'dragDropItemSelector', 'enableDragDrop', 'initiallyExpandedItemIds', { name: 'label', required: true }, 'semantics'],
  standalone: false
})
export class SwirlTreeView {
  protected el: HTMLSwirlTreeViewElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['dropItem', 'itemExpansionChanged']);
  }
}


import type { SwirlTreeViewDropItemEvent as ISwirlTreeViewSwirlTreeViewDropItemEvent } from '@getflip/swirl-components';

export declare interface SwirlTreeView extends Components.SwirlTreeView {

  dropItem: EventEmitter<CustomEvent<ISwirlTreeViewSwirlTreeViewDropItemEvent>>;

  itemExpansionChanged: EventEmitter<CustomEvent<{ itemId: string; expanded: boolean; }>>;
}


@ProxyCmp({
  inputs: ['active', 'disableDrag', 'expandable', 'href', 'icon', 'iconColor', 'itemId', 'label'],
  methods: ['expand', 'collapse', 'select', 'unselect']
})
@Component({
  selector: 'swirl-tree-view-item',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['active', 'disableDrag', 'expandable', 'href', 'icon', 'iconColor', { name: 'itemId', required: true }, { name: 'label', required: true }],
  standalone: false
})
export class SwirlTreeViewItem {
  protected el: HTMLSwirlTreeViewItemElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
    proxyOutputs(this, this.el, ['dropTreeViewItem', 'expandedChange', 'itemSelected', 'startKeyboardMove', 'endKeyboardMove', 'keyboardMove']);
  }
}


import type { SwirlTreeViewDropItemEvent as ISwirlTreeViewItemSwirlTreeViewDropItemEvent } from '@getflip/swirl-components';
import type { SwirlTreeViewItemKeyboardMoveEvent as ISwirlTreeViewItemSwirlTreeViewItemKeyboardMoveEvent } from '@getflip/swirl-components';

export declare interface SwirlTreeViewItem extends Components.SwirlTreeViewItem {

  dropTreeViewItem: EventEmitter<CustomEvent<ISwirlTreeViewItemSwirlTreeViewDropItemEvent>>;

  expandedChange: EventEmitter<CustomEvent<boolean>>;

  itemSelected: EventEmitter<CustomEvent<HTMLSwirlTreeViewItemElement>>;

  startKeyboardMove: EventEmitter<CustomEvent<ISwirlTreeViewItemSwirlTreeViewItemKeyboardMoveEvent>>;

  endKeyboardMove: EventEmitter<CustomEvent<ISwirlTreeViewItemSwirlTreeViewItemKeyboardMoveEvent>>;

  keyboardMove: EventEmitter<CustomEvent<ISwirlTreeViewItemSwirlTreeViewItemKeyboardMoveEvent>>;
}


@ProxyCmp({
  inputs: ['duration', 'durationLabel', 'label', 'src']
})
@Component({
  selector: 'swirl-video-thumbnail',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: '<ng-content></ng-content>',
  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
  inputs: ['duration', 'durationLabel', { name: 'label', required: true }, { name: 'src', required: true }],
  standalone: false
})
export class SwirlVideoThumbnail {
  protected el: HTMLSwirlVideoThumbnailElement;
  constructor(c: ChangeDetectorRef, r: ElementRef, protected z: NgZone) {
    c.detach();
    this.el = r.nativeElement;
  }
}


export declare interface SwirlVideoThumbnail extends Components.SwirlVideoThumbnail {}


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


export declare interface SwirlVisuallyHidden extends Components.SwirlVisuallyHidden {}