glint types

components/bs-accordion.d.ts

@@ -0,0 +1,34 @@
+import BsAccordionItem from './bs-accordion/item';
+
+import Component from '@glimmer/component';
+
+export interface BsAccordionActions<T> {
+  doChange: (newValue: T) => void;
+}
+
+interface BsAccordionSignature<T> {
+  Element: HTMLDivElement;
+  Args: {
+    selected?: T;
+    onChange?: (e?: Event, value?: T) => void;
+  };
+  Blocks: {
+    default: [
+      {
+        item: typeof BsAccordionItem;
+        actions: BsAccordionActions<T>;
+      }
+    ];
+  };
+}
+
+export declare class BsAccordion<T> extends Component<BsAccordionSignature<T>> {}
+
+export default BsAccordion;
+
+declare module '@glint/environment-ember-loose/registry' {
+  export default interface Registry {
+    BsAccordion: typeof BsAccordion;
+    'bs-accordion': typeof BsAccordion;
+  }
+}

components/bs-accordion/item.d.ts

@@ -0,0 +1,34 @@
+import { BsButtonType } from '../bs-button';
+
+import Component from '@glimmer/component';
+import BsAccordionItemBody from './item/body';
+import BsAccordionItemTitle from './item/title';
+
+interface BsAccordionItemSignature<T> {
+  Element: HTMLDivElement;
+  Args: {
+    title?: string;
+    type?: 'default' | 'light' | 'dark' | BsButtonType | string;
+    value?: T;
+    onClick?: (e?: Event, value?: T) => void;
+  };
+  Blocks: {
+    default: [
+      {
+        body: typeof BsAccordionItemBody;
+        title: typeof BsAccordionItemTitle;
+      }
+    ];
+  };
+}
+
+export declare class BsAccordionItem<T> extends Component<BsAccordionItemSignature<T>> {}
+
+export default BsAccordionItem;
+
+declare module '@glint/environment-ember-loose/registry' {
+  export default interface Registry {
+    BsAccordionItem: typeof BsAccordionItem;
+    'bs-accordion/item': typeof BsAccordionItem;
+  }
+}

components/bs-accordion/item/body.d.ts

@@ -0,0 +1,22 @@
+import Component from '@glimmer/component';
+
+interface BsAccordionItemBodySignature {
+  Element: HTMLDivElement;
+  Args: {
+    collapsed?: boolean;
+  };
+  Blocks: {
+    default: [];
+  };
+}
+
+export declare class BsAccordionItemBody extends Component<BsAccordionItemBodySignature> {}
+
+export default BsAccordionItemBody;
+
+declare module '@glint/environment-ember-loose/registry' {
+  export default interface Registry {
+    BsAccordionItemBody: typeof BsAccordionItemBody;
+    'bs-accordion/item/body': typeof BsAccordionItemBody;
+  }
+}

components/bs-accordion/item/title.d.ts

@@ -0,0 +1,23 @@
+import Component from '@glimmer/component';
+
+interface BsAccordionItemTitleSignature<T> {
+  Element: HTMLDivElement;
+  Args: {
+    collapsed?: boolean;
+    onClick?: (e?: Event, value?: T) => void;
+  };
+  Blocks: {
+    default: [];
+  };
+}
+
+export declare class BsAccordionItemTitle<T> extends Component<BsAccordionItemTitleSignature<T>> {}
+
+export default BsAccordionItemTitle;
+
+declare module '@glint/environment-ember-loose/registry' {
+  export default interface Registry {
+    BsAccordionItemTitle: typeof BsAccordionItemTitle;
+    'bs-accordion/item/title': typeof BsAccordionItemTitle;
+  }
+}

components/bs-alert.d.ts

@@ -0,0 +1,32 @@
+import { BsButtonType } from './bs-button';
+
+import Component from '@glimmer/component';
+
+interface BsAlertSignature {
+  Element: HTMLDivElement;
+  Args: {
+    dismissible?: boolean;
+    fade?: boolean;
+    fadeDuration?: number;
+    type?: BsButtonType;
+    visible?: boolean;
+    onDismiss?: (e?: Event) => void;
+    onDismissed?: (e?: Event) => void;
+  };
+  Blocks: {
+    default: [];
+    header: [];
+    body: [];
+  };
+}
+
+export declare class BsAlert extends Component<BsAlertSignature> {}
+
+export default BsAlert;
+
+declare module '@glint/environment-ember-loose/registry' {
+  export default interface Registry {
+    BsAlert: typeof BsAlert;
+    'bs-alert': typeof BsAlert;
+  }
+}

components/bs-button-group.d.ts

@@ -0,0 +1,37 @@
+import Component from '@glimmer/component';
+import BsButtonGroupButton from './bs-button-group/button';
+
+interface BsButtonGroupSignature<T> {
+  Element: HTMLDivElement;
+  Args: {
+    justified?: boolean;
+    size?: 'lg' | 'sm' | 'xs';
+    type?: null | 'radio' | 'checkbox';
+    value?: Array<T>;
+    vertical?: boolean;
+    onChange?: (e?: Event, value?: T) => void;
+  };
+  Blocks: {
+    default: [
+      {
+        button: typeof BsButtonGroupButton;
+        actions: BsButtonGroupActions<T>;
+      }
+    ];
+  };
+}
+
+export interface BsButtonGroupActions<T> {
+  buttonPressed: (pressedValue: T) => void;
+}
+
+export declare class BsButtonGroup<T> extends Component<BsButtonGroupSignature<T>> {}
+
+export default BsButtonGroup;
+
+declare module '@glint/environment-ember-loose/registry' {
+  export default interface Registry {
+    BsButtonGroup: typeof BsButtonGroup;
+    'bs-button-group': typeof BsButtonGroup;
+  }
+}

components/bs-button-group/button.d.ts

@@ -0,0 +1,12 @@
+import BsButton from '../bs-button';
+
+export declare class BsButtonGroupButton extends BsButton {}
+
+export default BsButtonGroupButton;
+
+declare module '@glint/environment-ember-loose/registry' {
+  export default interface Registry {
+    BsButtonGroupButton: typeof BsButtonGroupButton;
+    'bs-button-group/button': typeof BsButtonGroupButton;
+  }
+}

components/bs-button.d.ts

@@ -0,0 +1,54 @@
+import Component from '@glimmer/component';
+
+export type BsButtonType = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'light' | 'dark';
+
+interface BsButtonSignature {
+  Element: HTMLButtonElement;
+  Args: {
+    active?: boolean;
+    block?: boolean;
+    bubble?: boolean;
+    buttonType?: 'button' | 'submit';
+    defaultText?: string;
+    fulfilledText?: string;
+    icon?: string;
+    iconActive?: string;
+    iconInactive?: string;
+    outline?: boolean;
+    pendingText?: string;
+    preventConcurrency?: boolean;
+    rejectedText?: string;
+    reset?: boolean;
+    size?: string;
+    type?: BsButtonType;
+    value?: unknown;
+    onClick?: (e?: Event, value?: unknown) => void;
+  };
+  Blocks: {
+    default: [
+      {
+        isFulfilled: boolean;
+        isPending: boolean;
+        isRejected: boolean;
+        isSettled: boolean;
+        actions: BsButtonActions;
+      }
+    ];
+  };
+}
+
+export interface BsButtonActions {
+  resetState: () => void;
+  handleClick: (e: Event) => void;
+}
+
+export declare class BsButton extends Component<BsButtonSignature> {}
+
+export default BsButton;
+
+declare module '@glint/environment-ember-loose/registry' {
+  export default interface Registry {
+    BsButton: typeof BsButton;
+    'bs-button': typeof BsButton;
+  }
+}

components/bs-carousel.d.ts

@@ -0,0 +1,53 @@
+import BsCarouselSlide from './bs-carousel/slide';
+
+import Component from '@glimmer/component';
+
+interface BsCarouselSignature {
+  Element: HTMLDivElement;
+  Args: {
+    autoPlay?: boolean;
+    index?: number;
+    interval?: number;
+    keyboard?: boolean;
+    ltr?: boolean;
+    nextControlIcon?: string;
+    nextControlLabel?: string;
+    pauseOnMouseEnter?: boolean;
+    prevControlIcon?: string;
+    prevControlLabel?: string;
+    showControls?: boolean;
+    showIndicators?: boolean;
+    transition?: 'fade' | 'slide';
+    transitionDuration?: number;
+    wrap?: boolean;
+    onSlideChanged?: (e?: Event, toIndex?: unknown) => void;
+  };
+  Blocks: {
+    default: [
+      {
+        slide: typeof BsCarouselSlide;
+        actions: BsCarouselActions;
+      }
+    ];
+  };
+}
+
+export interface BsCarouselActions {
+  toSlide: (toIndex: number) => void;
+  toNextSlide: () => void;
+  toPrevSlide: () => void;
+  handleMouseEnter: () => void;
+  handleMouseLeave: () => void;
+  handleKeyDown: () => void;
+}
+
+export declare class BsCarousel extends Component<BsCarouselSignature> {}
+
+export default BsCarousel;
+
+declare module '@glint/environment-ember-loose/registry' {
+  export default interface Registry {
+    BsCarousel: typeof BsCarousel;
+    'bs-carousel': typeof BsCarousel;
+  }
+}

components/bs-carousel/slide.d.ts

@@ -0,0 +1,19 @@
+import Component from '@glimmer/component';
+
+interface BsCarouselSlideSignature {
+  Element: HTMLDivElement;
+  Args: {};
+  Blocks: {
+    default: [];
+  };
+}
+
+export declare class BsCarouselSlide extends Component<BsCarouselSlideSignature> {}
+
+export default BsCarouselSlide;
+
+declare module '@glint/environment-ember-loose/registry' {
+  export default interface Registry {
+    'bs-carousel/slide': typeof BsCarouselSlide;
+  }
+}

components/bs-collapse.d.ts

@@ -0,0 +1,32 @@
+import Component from '@glimmer/component';
+
+export interface BsCollapseSignature {
+  Element: HTMLDivElement;
+  Args: {
+    collapsed?: boolean;
+    collapseDimension?: 'height' | 'width';
+    collapsedSize?: number;
+    expandedSize?: number;
+    transitionDuration?: number;
+
+    onHidden?: (e?: Event) => void;
+    onHide?: (e?: Event) => void;
+    onShow?: (e?: Event) => void;
+    onShown?: (e?: Event) => void;
+  };
+  Blocks: {
+    default: [];
+  };
+}
+
+// eslint-disable-next-line ember/no-empty-glimmer-component-classes
+export declare class BsCollapse extends Component<BsCollapseSignature> {}
+
+export default BsCollapse;
+
+declare module '@glint/environment-ember-loose/registry' {
+  export default interface Registry {
+    BsCollapse: typeof BsCollapse;
+    'bs-collapse': typeof BsCollapse;
+  }
+}