@hashicorp/design-system-components 4.20.2 → 4.21.0

package/declarations/components/hds/advanced-table/index.d.ts

@@ -3,14 +3,14 @@
  * SPDX-License-Identifier: MPL-2.0
  */
 import Component from '@glimmer/component';
-import type { ComponentLike } from '@glint/template';
+import type { WithBoundArgs } from '@glint/template';
 import type Owner from '@ember/owner';
 import { HdsAdvancedTableDensityValues, HdsAdvancedTableVerticalAlignmentValues } from './types.ts';
-import type { HdsAdvancedTableColumn, HdsAdvancedTableDensities, HdsAdvancedTableHorizontalAlignment, HdsAdvancedTableOnSelectionChangeSignature, HdsAdvancedTableSortingFunction, HdsAdvancedTableThSortOrder, HdsAdvancedTableVerticalAlignment, HdsAdvancedTableModel, HdsAdvancedTableExpandState } from './types.ts';
+import type { HdsAdvancedTableColumn, HdsAdvancedTableDensities, HdsAdvancedTableHorizontalAlignment, HdsAdvancedTableOnSelectionChangeSignature, HdsAdvancedTableThSortOrder, HdsAdvancedTableVerticalAlignment, HdsAdvancedTableModel, HdsAdvancedTableExpandState } from './types.ts';
 import type { HdsFormCheckboxBaseSignature } from '../form/checkbox/base.ts';
-import type { HdsAdvancedTableTdSignature } from './td.ts';
-import type { HdsAdvancedTableThSignature } from './th.ts';
-import type { HdsAdvancedTableTrSignature } from './tr.ts';
+import type HdsAdvancedTableTd from './td.ts';
+import type HdsAdvancedTableTh from './th.ts';
+import type HdsAdvancedTableTr from './tr.ts';
 export declare const DENSITIES: HdsAdvancedTableDensities[];
 export declare const DEFAULT_DENSITY = HdsAdvancedTableDensityValues.Medium;
 export declare const VALIGNMENTS: HdsAdvancedTableVerticalAlignment[];
@@ -25,25 +25,27 @@ export interface HdsAdvancedTableSignature {
         isSelectable?: boolean;
         isStriped?: boolean;
         model: HdsAdvancedTableModel;
-        onSelectionChange?: (selection: HdsAdvancedTableOnSelectionChangeSignature) => void;
-        onSort?: (sortBy: string, sortOrder: HdsAdvancedTableThSortOrder) => void;
         selectionAriaLabelSuffix?: string;
         sortBy?: string;
         selectableColumnKey?: string;
         sortedMessageText?: string;
         sortOrder?: HdsAdvancedTableThSortOrder;
         valign?: HdsAdvancedTableVerticalAlignment;
+        hasResizableColumns?: boolean;
         hasStickyHeader?: boolean;
         hasStickyFirstColumn?: boolean;
         childrenKey?: string;
         maxHeight?: string;
+        onColumnResize?: (columnKey: string, newWidth?: string) => void;
+        onSelectionChange?: (selection: HdsAdvancedTableOnSelectionChangeSignature) => void;
+        onSort?: (sortBy: string, sortOrder: HdsAdvancedTableThSortOrder) => void;
     };
     Blocks: {
         body?: [
             {
-                Td?: ComponentLike<HdsAdvancedTableTdSignature>;
-                Tr?: ComponentLike<HdsAdvancedTableTrSignature>;
-                Th?: ComponentLike<HdsAdvancedTableThSignature>;
+                Td?: WithBoundArgs<typeof HdsAdvancedTableTd, 'align'>;
+                Tr?: WithBoundArgs<typeof HdsAdvancedTableTr, 'selectionScope' | 'isLastRow' | 'isSelectable' | 'onSelectionChange' | 'didInsert' | 'willDestroy' | 'selectionAriaLabelSuffix' | 'hasStickyColumn' | 'isStickyColumnPinned' | 'isParentRow' | 'depth' | 'displayRow'>;
+                Th?: WithBoundArgs<typeof HdsAdvancedTableTh, 'depth' | 'isExpandable' | 'isExpanded' | 'newLabel' | 'parentId' | 'scope' | 'isStickyColumn' | 'isStickyColumnPinned' | 'onClickToggle'>;
                 data?: Record<string, unknown>;
                 rowIndex?: number | string;
                 isOpen?: HdsAdvancedTableExpandState;
@@ -53,10 +55,9 @@ export interface HdsAdvancedTableSignature {
     Element: HTMLDivElement;
 }
 export default class HdsAdvancedTable extends Component<HdsAdvancedTableSignature> {
-    private _sortBy;
-    private _sortOrder;
     private _selectAllCheckbox?;
     private _isSelectAllCheckboxSelected?;
+    private _tableHeight;
     private _selectableRows;
     private _captionId;
     private _tableModel;
@@ -79,8 +80,6 @@ export default class HdsAdvancedTable extends Component<HdsAdvancedTableSignatur
     showScrollIndicatorBottom: boolean;
     stickyColumnOffset: string;
     constructor(owner: Owner, args: HdsAdvancedTableSignature['Args']);
-    get getSortCriteria(): string | HdsAdvancedTableSortingFunction<unknown>;
-    get columnWidths(): string[] | undefined;
     get identityKey(): string | undefined;
     get childrenKey(): string;
     get hasScrollIndicator(): boolean;
@@ -93,11 +92,11 @@ export default class HdsAdvancedTable extends Component<HdsAdvancedTableSignatur
     get gridTemplateColumns(): string;
     get classNames(): string;
     get theadClassNames(): string;
-    private _didUpdateModel;
+    private _setColumnWidth;
     private _setUpScrollWrapper;
     private _setUpThead;
-    setSortBy(column: string): void;
     onSelectionChangeCallback(checkbox?: HdsFormCheckboxBaseSignature['Element'], selectionKey?: string): void;
+    setupTableModelData(): void;
     onSelectionAllChange(): void;
     onSelectionRowChange(checkbox?: HdsFormCheckboxBaseSignature['Element'], selectionKey?: string): void;
     didInsertSelectAllCheckbox(checkbox: HdsFormCheckboxBaseSignature['Element']): void;

package/declarations/components/hds/advanced-table/models/column.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import type HdsAdvancedTableModel from './table.ts';
+import type { HdsAdvancedTableHorizontalAlignment, HdsAdvancedTableColumn as HdsAdvancedTableColumnType } from '../types';
+export declare const DEFAULT_MIN_WIDTH = "150px";
+export declare const DEFAULT_MAX_WIDTH = "800px";
+export default class HdsAdvancedTableColumn {
+    label: string;
+    align?: HdsAdvancedTableHorizontalAlignment;
+    isExpandable?: boolean;
+    isReorderable?: boolean;
+    isSortable?: boolean;
+    isVisuallyHidden?: boolean;
+    key?: string;
+    minWidth?: `${number}px`;
+    maxWidth?: `${number}px`;
+    tooltip?: string;
+    width?: string;
+    originalWidth?: string;
+    imposedWidthDelta: number;
+    sortingFunction?: (a: unknown, b: unknown) => number;
+    table: HdsAdvancedTableModel;
+    get pxWidth(): number | undefined;
+    set pxWidth(value: number);
+    get pxMinWidth(): number | undefined;
+    get pxMaxWidth(): number | undefined;
+    constructor(args: {
+        column: HdsAdvancedTableColumnType;
+        table: HdsAdvancedTableModel;
+    });
+    private _setWidthValues;
+    setPxWidth(newPxWidth: number): void;
+    onPreviousColumnWidthRestored(): void;
+    onNextColumnWidthRestored(imposedWidthDelta: number): void;
+    restoreWidth(): void;
+}

package/declarations/components/hds/advanced-table/models/row.d.ts

@@ -2,8 +2,10 @@
  * Copyright (c) HashiCorp, Inc.
  * SPDX-License-Identifier: MPL-2.0
  */
+import type { HdsAdvancedTableColumn } from '../types';
 interface HdsAdvancedTableRowArgs {
     [key: string]: unknown;
+    columns: HdsAdvancedTableColumn[];
     id?: string;
     childrenKey?: string;
 }

package/declarations/components/hds/advanced-table/models/table.d.ts

@@ -3,22 +3,30 @@
  * SPDX-License-Identifier: MPL-2.0
  */
 import HdsAdvancedTableRow from './row.ts';
-import type { HdsAdvancedTableExpandState, HdsAdvancedTableModel } from '../types';
-interface HdsAdvancedTableTableArgs {
-    model: HdsAdvancedTableModel;
-    childrenKey?: string;
-}
+import HdsAdvancedTableColumn from './column.ts';
+import type { HdsAdvancedTableSignature } from '../index.ts';
+import type { HdsAdvancedTableExpandState, HdsAdvancedTableSortingFunction } from '../types';
+type HdsAdvancedTableTableArgs = Pick<HdsAdvancedTableSignature['Args'], 'model' | 'columns' | 'childrenKey' | 'hasResizableColumns' | 'sortBy' | 'sortOrder' | 'onSort'>;
 export default class HdsAdvancedTableTableModel {
+    columns: HdsAdvancedTableColumn[];
     rows: HdsAdvancedTableRow[];
-    childrenKey?: string;
+    sortBy: HdsAdvancedTableTableArgs['sortBy'];
+    sortOrder: HdsAdvancedTableTableArgs['sortOrder'];
+    childrenKey?: HdsAdvancedTableTableArgs['childrenKey'];
+    hasResizableColumns?: HdsAdvancedTableTableArgs['hasResizableColumns'];
+    onSort?: HdsAdvancedTableSignature['Args']['onSort'];
     constructor(args: HdsAdvancedTableTableArgs);
+    get sortCriteria(): string | HdsAdvancedTableSortingFunction<unknown>;
+    get sortedRows(): HdsAdvancedTableRow[];
     get totalRowCount(): number;
     get flattenedVisibleRows(): HdsAdvancedTableRow[];
     get lastVisibleRow(): HdsAdvancedTableRow | undefined;
     get hasRowsWithChildren(): boolean;
     get allRowsAreOpen(): boolean;
     get expandState(): HdsAdvancedTableExpandState;
-    updateModel(model: HdsAdvancedTableModel): void;
+    setupData(args: Pick<HdsAdvancedTableTableArgs, 'model' | 'columns' | 'sortBy' | 'sortOrder'>): void;
+    restoreColumnWidths(): void;
+    setSortBy(column: string): void;
     openAll(): void;
     collapseAll(): void;
     toggleAll(): void;

package/declarations/components/hds/advanced-table/th-context-menu.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import Component from '@glimmer/component';
+import type HdsAdvancedTableColumn from './models/column.ts';
+import type { HdsDropdownSignature } from '../dropdown/index.ts';
+import type { HdsDropdownToggleIconSignature } from '../dropdown/toggle/icon.ts';
+import type { HdsAdvancedTableSignature } from './index.ts';
+import type { HdsAdvancedTableThResizeHandleSignature } from './th-resize-handle.ts';
+interface HdsAdvancedTableThContextMenuOption {
+    key: string;
+    label: string;
+    icon: HdsDropdownToggleIconSignature['Args']['icon'];
+    action: (column: HdsAdvancedTableColumn, previousColumn?: HdsAdvancedTableColumn, nextColumn?: HdsAdvancedTableColumn, dropdownCloseCallback?: () => void) => void;
+}
+export interface HdsAdvancedTableThContextMenuSignature {
+    Args: {
+        column: HdsAdvancedTableColumn;
+        previousColumn?: HdsAdvancedTableColumn;
+        nextColumn?: HdsAdvancedTableColumn;
+        hasResizableColumns?: boolean;
+        resizeHandleElement?: HdsAdvancedTableThResizeHandleSignature['Element'];
+        onColumnResize?: HdsAdvancedTableSignature['Args']['onColumnResize'];
+    };
+    Element: HdsDropdownSignature['Element'];
+}
+export default class HdsAdvancedTableThContextMenu extends Component<HdsAdvancedTableThContextMenuSignature> {
+    private _element;
+    get _options(): HdsAdvancedTableThContextMenuOption[];
+    resizeColumn(): void;
+    resetColumnWidth(column: HdsAdvancedTableColumn, previousColumn?: HdsAdvancedTableColumn, nextColumn?: HdsAdvancedTableColumn, dropdownCloseCallback?: () => void): void;
+}
+export {};

package/declarations/components/hds/advanced-table/th-resize-handle.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import Component from '@glimmer/component';
+import type HdsAdvancedTableColumn from './models/column.ts';
+import type { HdsAdvancedTableSignature } from './index.ts';
+export interface HdsAdvancedTableThResizeHandleSignature {
+    Args: {
+        column: HdsAdvancedTableColumn;
+        nextColumn?: HdsAdvancedTableColumn;
+        hasResizableColumns: HdsAdvancedTableSignature['Args']['hasResizableColumns'];
+        tableHeight?: number;
+        onColumnResize?: HdsAdvancedTableSignature['Args']['onColumnResize'];
+    };
+    Blocks: {
+        default?: [];
+    };
+    Element: HTMLDivElement;
+}
+export default class HdsAdvancedTableThResizeHandle extends Component<HdsAdvancedTableThResizeHandleSignature> {
+    resizing: {
+        startX: number;
+        startColumnPxWidth: number;
+        startNextColumnPxWidth?: number;
+    } | null;
+    private _nextColumnDelta;
+    private _handleElement;
+    private _boundResize;
+    private _boundStopResize;
+    private _registerHandleElement;
+    constructor(owner: unknown, args: HdsAdvancedTableThResizeHandleSignature['Args']);
+    get height(): string | undefined;
+    get classNames(): string;
+    onColumnResize(key?: string, width?: string): void;
+    handleKeydown(event: KeyboardEvent): void;
+    startResize(event: PointerEvent): void;
+    private _applyResizeDelta;
+    private _resize;
+    private _stopResize;
+    private _setNextColumnImposedWidthDelta;
+}

package/declarations/components/hds/advanced-table/th-sort.d.ts

@@ -4,22 +4,32 @@
  */
 import Component from '@glimmer/component';
 import { type FocusableElement } from 'tabbable';
+import HdsAdvancedTableColumn from './models/column.ts';
 import type Owner from '@ember/owner';
 import { HdsAdvancedTableHorizontalAlignmentValues } from './types.ts';
 import type { HdsAdvancedTableHorizontalAlignment, HdsAdvancedTableThSortOrder, HdsAdvancedTableThSortOrderLabels } from './types.ts';
 import type { HdsAdvancedTableThButtonSortSignature } from './th-button-sort.ts';
+import type { HdsAdvancedTableThSignature } from './th.ts';
+import type { HdsAdvancedTableSignature } from './index.ts';
 export declare const ALIGNMENTS: string[];
 export declare const DEFAULT_ALIGN = HdsAdvancedTableHorizontalAlignmentValues.Left;
 export interface HdsAdvancedTableThSortSignature {
     Args: {
+        column?: HdsAdvancedTableThSignature['Args']['column'];
         align?: HdsAdvancedTableHorizontalAlignment;
+        hasResizableColumns: HdsAdvancedTableSignature['Args']['hasResizableColumns'];
         onClickSort?: HdsAdvancedTableThButtonSortSignature['Args']['onClick'];
         sortOrder?: HdsAdvancedTableThSortOrder;
         tooltip?: string;
         rowspan?: number;
         colspan?: number;
+        previousColumn?: HdsAdvancedTableColumn;
+        nextColumn?: HdsAdvancedTableColumn;
+        tableHeight?: number;
+        isLastColumn?: boolean;
         isStickyColumn?: boolean;
         isStickyColumnPinned?: boolean;
+        onColumnResize?: HdsAdvancedTableSignature['Args']['onColumnResize'];
     };
     Blocks: {
         default?: [];
@@ -30,12 +40,15 @@ export default class HdsAdvancedTableThSort extends Component<HdsAdvancedTableTh
     private _labelId;
     private _element;
     private _shouldTrapFocus;
+    private _resizeHandleElement?;
     constructor(owner: Owner, args: HdsAdvancedTableThSortSignature['Args']);
     get ariaSort(): HdsAdvancedTableThSortOrderLabels;
     get align(): HdsAdvancedTableHorizontalAlignment;
+    get showContextMenu(): boolean;
     get classNames(): string;
     onFocusTrapDeactivate(): void;
     enableFocusTrap(): void;
     getInitialFocus(): FocusableElement | undefined;
     setElement(element: HTMLDivElement): void;
+    private _registerResizeHandleElement;
 }

package/declarations/components/hds/advanced-table/th.d.ts

@@ -4,30 +4,39 @@
  */
 import Component from '@glimmer/component';
 import { type FocusableElement } from 'tabbable';
+import HdsAdvancedTableColumn from './models/column.ts';
+import { HdsAdvancedTableHorizontalAlignmentValues } from './types.ts';
 import type Owner from '@ember/owner';
 import type { HdsAdvancedTableHorizontalAlignment, HdsAdvancedTableScope, HdsAdvancedTableExpandState } from './types.ts';
-import { HdsAdvancedTableHorizontalAlignmentValues } from './types.ts';
+import type { HdsAdvancedTableSignature } from './index.ts';
 export declare const ALIGNMENTS: string[];
 export declare const DEFAULT_ALIGN = HdsAdvancedTableHorizontalAlignmentValues.Left;
 export interface HdsAdvancedTableThSignature {
     Args: {
         align?: HdsAdvancedTableHorizontalAlignment;
-        isVisuallyHidden?: boolean;
-        scope?: HdsAdvancedTableScope;
-        tooltip?: string;
-        rowspan?: number;
+        column?: HdsAdvancedTableColumn;
         colspan?: number;
-        newLabel?: string;
-        isExpandable?: boolean;
-        parentId?: string;
-        onClickToggle?: () => void;
-        isExpanded?: HdsAdvancedTableExpandState;
         depth?: number;
-        didInsertExpandButton?: (button: HTMLButtonElement) => void;
-        willDestroyExpandButton?: (button: HTMLButtonElement) => void;
         hasExpandAllButton?: boolean;
+        hasResizableColumns?: boolean;
+        isExpanded?: HdsAdvancedTableExpandState;
+        isExpandable?: boolean;
+        isLastColumn?: boolean;
         isStickyColumn?: boolean;
         isStickyColumnPinned?: boolean;
+        isVisuallyHidden?: boolean;
+        newLabel?: string;
+        previousColumn?: HdsAdvancedTableColumn;
+        nextColumn?: HdsAdvancedTableColumn;
+        parentId?: string;
+        rowspan?: number;
+        scope?: HdsAdvancedTableScope;
+        tooltip?: string;
+        tableHeight?: number;
+        didInsertExpandButton?: (button: HTMLButtonElement) => void;
+        onClickToggle?: () => void;
+        onColumnResize?: HdsAdvancedTableSignature['Args']['onColumnResize'];
+        willDestroyExpandButton?: (button: HTMLButtonElement) => void;
     };
     Blocks: {
         default?: [];
@@ -38,6 +47,7 @@ export default class HdsAdvancedTableTh extends Component<HdsAdvancedTableThSign
     private _labelId;
     private _element;
     private _shouldTrapFocus;
+    private _resizeHandleElement?;
     constructor(owner: Owner, args: HdsAdvancedTableThSignature['Args']);
     get scope(): HdsAdvancedTableScope;
     get role(): string;
@@ -46,9 +56,11 @@ export default class HdsAdvancedTableTh extends Component<HdsAdvancedTableThSign
     get colspan(): string | undefined;
     get paddingLeft(): string | undefined;
     get classNames(): string;
+    get showContextMenu(): boolean;
     onFocusTrapDeactivate(): void;
     enableFocusTrap(): void;
     getInitialFocus(): FocusableElement | undefined;
     setElement(element: HTMLDivElement): void;
+    private _registerResizeHandleElement;
     private _manageExpandButton;
 }

package/declarations/components/hds/advanced-table/types.d.ts

@@ -63,6 +63,8 @@ interface BaseHdsAdvancedTableColumn {
     sortingFunction?: HdsAdvancedTableSortingFunction<unknown>;
     tooltip?: string;
     width?: string;
+    minWidth?: `${number}px`;
+    maxWidth?: `${number}px`;
 }
 interface SortableHdsAdvancedTableColumn extends BaseHdsAdvancedTableColumn {
     isSortable: true;

package/declarations/components/hds/app-header/home-link.d.ts

@@ -8,11 +8,14 @@ import type { HdsInteractiveSignature } from '../interactive/';
 export interface HdsAppHeaderHomeLinkSignature {
     Args: HdsInteractiveSignature['Args'] & {
         icon: HdsIconSignature['Args']['name'];
+        isIconOnly?: boolean;
         color?: string;
-        ariaLabel: string;
+        text: string;
     };
     Element: HdsInteractiveSignature['Element'];
 }
 export default class HdsAppHeaderHomeLink extends Component<HdsAppHeaderHomeLinkSignature> {
-    get ariaLabel(): string;
+    get text(): string;
+    get icon(): HdsIconSignature['Args']['name'];
+    get isIconOnly(): boolean;
 }

package/declarations/components/hds/form/file-input/base.d.ts

@@ -3,6 +3,10 @@
  * SPDX-License-Identifier: MPL-2.0
  */
 export interface HdsFormFileInputBaseSignature {
+    Args: {
+        id?: string;
+        ariaDescribedBy?: string;
+    };
     Element: HTMLInputElement;
 }
 declare const HdsFormFileInputBase: import("@ember/component/template-only").TemplateOnlyComponent<HdsFormFileInputBaseSignature>;

package/declarations/components/hds/form/footer/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import Component from '@glimmer/component';
+import type { ComponentLike } from '@glint/template';
+import type { HdsButtonSetSignature } from '../../button-set/index.ts';
+export interface HdsFormFooterSignature {
+    Args: {
+        isFullWidth?: boolean;
+    };
+    Blocks: {
+        default: [
+            {
+                ButtonSet?: ComponentLike<HdsButtonSetSignature>;
+            }
+        ];
+    };
+    Element: HTMLDivElement;
+}
+export default class HdsFormFooter extends Component<HdsFormFooterSignature> {
+    get classNames(): string;
+}

package/declarations/components/hds/form/header/description.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import type { HdsTextBodySignature } from '../../text/body.ts';
+export interface HdsFormHeaderDescriptionSignature {
+    Blocks: {
+        default: [];
+    };
+    Element: HdsTextBodySignature['Element'];
+}
+declare const HdsFormHeaderDescription: import("@ember/component/template-only").TemplateOnlyComponent<HdsFormHeaderDescriptionSignature>;
+export default HdsFormHeaderDescription;

package/declarations/components/hds/form/header/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import Component from '@glimmer/component';
+import type { ComponentLike } from '@glint/template';
+import type { HdsFormHeaderTitleSignature } from './title.ts';
+import type { HdsFormHeaderDescriptionSignature } from './description.ts';
+export interface HdsFormHeaderSignature {
+    Args: {
+        isFullWidth?: boolean;
+    };
+    Blocks: {
+        default: [
+            {
+                Title?: ComponentLike<HdsFormHeaderTitleSignature>;
+                Description?: ComponentLike<HdsFormHeaderDescriptionSignature>;
+            }
+        ];
+    };
+    Element: HTMLDivElement;
+}
+export default class HdsFormHeader extends Component<HdsFormHeaderSignature> {
+    get classNames(): string;
+}

package/declarations/components/hds/form/header/title.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import Component from '@glimmer/component';
+import type { HdsFormHeaderTitleTags } from '../types.ts';
+import { HdsFormHeaderTitleTagValues } from '../types.ts';
+import { HdsTextSizeValues } from '../../text/types.ts';
+import type { HdsTextDisplaySignature } from '../../text/display.ts';
+export declare const DEFAULT_SIZE = HdsTextSizeValues.FourHundred;
+export declare const DEFAULT_TAG = HdsFormHeaderTitleTagValues.Div;
+export declare const AVAILABLE_TAGS: string[];
+export interface HdsFormHeaderTitleSignature {
+    Args: {
+        tag?: HdsFormHeaderTitleTags;
+        size?: HdsTextDisplaySignature['Args']['size'];
+    };
+    Blocks: {
+        default: [];
+    };
+    Element: HdsTextDisplaySignature['Element'];
+}
+export default class HdsFormHeaderTitle extends Component<HdsFormHeaderTitleSignature> {
+    get tag(): HdsFormHeaderTitleTags;
+    get size(): HdsTextDisplaySignature['Args']['size'];
+}

package/declarations/components/hds/form/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import Component from '@glimmer/component';
+import HdsFormHeaderTitleComponent from './header/title.ts';
+import { HdsFormTagValues } from './types.ts';
+import type { HdsFormTags } from './types.ts';
+import type Owner from '@ember/owner';
+import type { ComponentLike, WithBoundArgs } from '@glint/template';
+import type { HdsFormHeaderSignature } from './header/index.ts';
+import type { HdsFormHeaderTitleSignature } from './header/title.ts';
+import type { HdsFormHeaderDescriptionSignature } from './header/description.ts';
+import type { HdsFormSectionSignature } from './section/index.ts';
+import type { HdsFormSectionHeaderSignature } from './section/header.ts';
+import type { HdsFormSectionMultiFieldGroupSignature } from './section/multi-field-group/index.ts';
+import type { HdsFormSectionMultiFieldGroupItemSignature } from './section/multi-field-group/item.ts';
+import type { HdsFormSeparatorSignature } from './separator/index.ts';
+import type { HdsFormFooterSignature } from './footer/index.ts';
+export declare const DEFAULT_TAG = HdsFormTagValues.Form;
+export declare const AVAILABLE_TAGS: string[];
+export interface HdsFormSignature {
+    Args: {
+        tag?: HdsFormTags;
+        sectionMaxWidth?: string;
+    };
+    Blocks: {
+        default: [
+            {
+                Header?: ComponentLike<HdsFormHeaderSignature>;
+                HeaderTitle?: ComponentLike<HdsFormHeaderTitleSignature>;
+                HeaderDescription?: ComponentLike<HdsFormHeaderDescriptionSignature>;
+                Section?: ComponentLike<HdsFormSectionSignature>;
+                SectionHeader?: ComponentLike<HdsFormSectionHeaderSignature>;
+                SectionHeaderTitle?: WithBoundArgs<typeof HdsFormHeaderTitleComponent, 'size'>;
+                SectionHeaderDescription?: ComponentLike<HdsFormHeaderDescriptionSignature>;
+                SectionMultiFieldGroup?: ComponentLike<HdsFormSectionMultiFieldGroupSignature>;
+                SectionMultiFieldGroupItem?: ComponentLike<HdsFormSectionMultiFieldGroupItemSignature>;
+                Separator?: ComponentLike<HdsFormSeparatorSignature>;
+                Footer?: ComponentLike<HdsFormFooterSignature>;
+            }
+        ];
+    };
+    Element: HTMLFormElement | HTMLDivElement;
+}
+export default class HdsForm extends Component<HdsFormSignature> {
+    tag: HdsFormTags;
+    constructor(owner: Owner, args: HdsFormSignature['Args']);
+    get sectionMaxWidthStyle(): Record<string, string>;
+}

package/declarations/components/hds/form/key-value-inputs/add-row-button.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import Component from '@glimmer/component';
+import type { HdsButtonSignature } from '../../button/index.ts';
+export interface HdsFormKeyValueInputsAddRowButtonSignature {
+    Args: {
+        onClick?: () => void;
+        text?: HdsButtonSignature['Args']['text'];
+    };
+    Element: HdsButtonSignature['Element'];
+}
+export default class HdsFormKeyValueInputsAddRowButton extends Component<HdsFormKeyValueInputsAddRowButtonSignature> {
+    get text(): string;
+    onClick(): void;
+}

package/declarations/components/hds/form/key-value-inputs/delete-row-button.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import Component from '@glimmer/component';
+import type { HdsButtonSignature } from '../../button/index.ts';
+export interface HdsFormKeyValueInputsDeleteRowButtonSignature {
+    Args: {
+        onClick?: (rowData: unknown, rowIndex: number) => void;
+        onInsert?: () => void;
+        onRemove?: () => void;
+        returnFocusTo?: HTMLFieldSetElement;
+        rowData: unknown;
+        rowIndex: number;
+        text?: HdsButtonSignature['Args']['text'];
+    };
+    Element: HdsButtonSignature['Element'];
+}
+export default class HdsFormKeyValueInputsDeleteRowButton extends Component<HdsFormKeyValueInputsDeleteRowButtonSignature> {
+    private _onInsert;
+    get text(): string;
+    onClick(): void;
+}

package/declarations/components/hds/form/key-value-inputs/field.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import Component from '@glimmer/component';
+import type { WithBoundArgs } from '@glint/template';
+import HdsFormErrorComponent from '../error/index.ts';
+import HdsFormFileInputBaseComponent from '../file-input/base.ts';
+import HdsFormHelperTextComponent from '../helper-text/index.ts';
+import HdsFormLabelComponent from '../label/index.ts';
+import HdsFormMaskedInputBaseComponent from '../masked-input/base.ts';
+import HdsFormSelectBaseComponent from '../select/base.ts';
+import HdsFormSuperSelectMultipleBaseComponent from '../super-select/multiple/base.ts';
+import HdsFormSuperSelectSingleBaseComponent from '../super-select/single/base.ts';
+import HdsFormTextareaBaseComponent from '../textarea/base.ts';
+import HdsFormTextInputBaseComponent from '../text-input/base.ts';
+export interface HdsFormKeyValueInputsFieldSignature {
+    Args: {
+        extraAriaDescribedBy?: string;
+        id?: string;
+        isInvalid?: boolean;
+        isOptional?: boolean;
+        isRequired?: boolean;
+        onInsert?: () => void;
+        onRemove?: () => void;
+        rowIndex: number;
+        width?: string;
+    };
+    Blocks: {
+        default?: [
+            {
+                Label?: WithBoundArgs<typeof HdsFormLabelComponent, 'contextualClass' | 'controlId' | 'hiddenText' | 'isOptional' | 'isRequired'>;
+                HelperText?: WithBoundArgs<typeof HdsFormHelperTextComponent, 'contextualClass' | 'controlId' | 'onInsert'>;
+                FileInput?: WithBoundArgs<typeof HdsFormFileInputBaseComponent, 'ariaDescribedBy' | 'id'>;
+                MaskedInput?: WithBoundArgs<typeof HdsFormMaskedInputBaseComponent, 'ariaDescribedBy' | 'id' | 'isInvalid'>;
+                Select?: WithBoundArgs<typeof HdsFormSelectBaseComponent, 'ariaDescribedBy' | 'id' | 'isInvalid'>;
+                SuperSelectSingle?: WithBoundArgs<typeof HdsFormSuperSelectSingleBaseComponent, 'ariaDescribedBy' | 'ariaLabelledBy' | 'isInvalid' | 'triggerId'>;
+                SuperSelectMultiple?: WithBoundArgs<typeof HdsFormSuperSelectMultipleBaseComponent, 'ariaDescribedBy' | 'ariaLabelledBy' | 'isInvalid' | 'triggerId'>;
+                TextInput?: WithBoundArgs<typeof HdsFormTextInputBaseComponent, 'ariaDescribedBy' | 'id' | 'isInvalid'>;
+                Textarea?: WithBoundArgs<typeof HdsFormTextareaBaseComponent, 'ariaDescribedBy' | 'id' | 'isInvalid'>;
+                Error?: WithBoundArgs<typeof HdsFormErrorComponent, 'contextualClass' | 'controlId' | 'onInsert' | 'onRemove'>;
+            }
+        ];
+    };
+    Element: HTMLDivElement;
+}
+export default class HdsFormKeyValueInputsField extends Component<HdsFormKeyValueInputsFieldSignature> {
+    private _onInsert;
+    get id(): string;
+    get labelHiddenText(): string;
+    get labelIdPrefix(): string;
+    appendDescriptor(element: HTMLElement): void;
+    removeDescriptor(element: HTMLElement): void;
+}