@impartner/design-components 1.0.0

package/lib/file-upload/file-upload.component.d.ts

@@ -0,0 +1,105 @@
+import { ChangeDetectorRef, DoCheck, ElementRef, OnDestroy } from '@angular/core';
+import { ControlValueAccessor, FormGroupDirective, NgControl, NgForm, ValidationErrors, Validator } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { BooleanInput } from '../../utilities';
+import { ErrorStateMatcher, ICanUpdateErrorState, IHasErrorState, ImpdcFormFieldControl, ImpdcFormRoot } from '../form-field';
+import * as i0 from "@angular/core";
+declare const _FileUploadComponentBase: import("../form-field").Constructor<import("../form-field").HasTabIndex> & import("../form-field").AbstractConstructor<import("../form-field").HasTabIndex> & import("../form-field").Constructor<import("../form-field").CanDisable> & import("../form-field").AbstractConstructor<import("../form-field").CanDisable> & import("../form-field").Constructor<ICanUpdateErrorState> & import("../form-field").AbstractConstructor<ICanUpdateErrorState> & {
+    new (_defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl | null): {
+        readonly stateChanges: Subject<void>;
+        _defaultErrorStateMatcher: ErrorStateMatcher;
+        _formRoot: ImpdcFormRoot;
+        _parentForm: NgForm;
+        _parentFormGroup: FormGroupDirective;
+        ngControl: NgControl | null;
+    };
+};
+/**
+ * The `FileUploadComponent` (`<impdc-file-upload` or `<any impdc-file-upload`) is a file selector that supports drag and drop.
+ * To use, import `FileUploadModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+export declare class FileUploadComponent extends _FileUploadComponentBase implements ControlValueAccessor, Validator, ImpdcFormFieldControl<File | File[]>, ICanUpdateErrorState, IHasErrorState, DoCheck, OnDestroy {
+    private readonly _changeDetector;
+    protected fileDropElementRef: ElementRef<HTMLElement>;
+    /** @ignore */
+    fileUploadInputEltRef: ElementRef<HTMLInputElement>;
+    /**
+     * Whether the control supports uploading multiple files.
+     */
+    multiple: boolean;
+    /**
+     * The instructional text to display in the file upload dropzone.
+     */
+    uploadText: string;
+    /**
+     * The comma-delimited list of file types that are accepted by the control.
+     */
+    accept: string;
+    errorStateMatcher: ErrorStateMatcher;
+    get canUpload(): boolean;
+    private get acceptTypes();
+    get empty(): boolean;
+    protected get filesForDisplay(): readonly File[];
+    private _cvaOnChange;
+    private _cvaOnTouched;
+    private _uid;
+    constructor(_changeDetector: ChangeDetectorRef, _defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl | null);
+    /** @ignore */
+    handleChange(event: Event): void;
+    /** @ignore */
+    handleDrop(event: FileList): void;
+    /** @ignore */
+    removeFile(fileIndex: number): void;
+    /** @ignore */
+    focus(options?: FocusOptions): void;
+    /** @ignore */
+    ngDoCheck(): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    /**
+     * The file(s) currently uploaded into the control. Returns `File | null` when `multiple` is `false`,
+     * and `File[]` when `multiple` is `true`.
+     */
+    get value(): File | File[] | null;
+    set value(newValue: File | File[] | null);
+    private _value;
+    /** @ignore */
+    get id(): string;
+    set id(value: string);
+    private _id;
+    /**
+     * Used to set requiredness of control in a template-based manner;
+     * not necessary when using the Angular reactive forms API and `required` validator.
+     *
+     * @default false
+     */
+    get required(): boolean;
+    set required(value: BooleanInput);
+    private _required;
+    get focused(): boolean;
+    private _focused;
+    readonly controlType: string;
+    readonly supportsAffixes: boolean;
+    /** @ignore */
+    writeValue(value: File[]): void;
+    /** @ignore */
+    registerOnChange(fn: Function): void;
+    /** @ignore */
+    registerOnTouched(fn: Function): void;
+    /** @ignore */
+    setDisabledState?(isDisabled: boolean): void;
+    /**
+     * @ignore
+     */
+    validate(): ValidationErrors | null;
+    protected _onFocus(): void;
+    protected _onBlur(): void;
+    private _updateValueFromInteraction;
+    private _mergeNewFilesWithExistingFiles;
+    private _getFileList;
+    private _getExtensions;
+    private _acceptedFileType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadComponent, [null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileUploadComponent, "impdc-file-upload, [impdc-file-upload]", never, { "disabled": "disabled"; "tabIndex": "tabIndex"; "multiple": "multiple"; "uploadText": "uploadText"; "accept": "accept"; "errorStateMatcher": "errorStateMatcher"; "value": "value"; "id": "id"; "required": "required"; }, {}, never, never, false>;
+}
+export {};

package/lib/file-upload/file-upload.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./directives/file-drop.directive";
+import * as i2 from "./file-upload.component";
+import * as i3 from "./pipes/human-readable-byte-size.pipe";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/forms";
+import * as i6 from "../button/button.module";
+export declare class FileUploadModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FileUploadModule, [typeof i1.FileDropDirective, typeof i2.FileUploadComponent, typeof i3.HumanReadableByteSizePipe], [typeof i4.CommonModule, typeof i5.FormsModule, typeof i6.ButtonModule], [typeof i1.FileDropDirective, typeof i2.FileUploadComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FileUploadModule>;
+}

package/lib/file-upload/index.d.ts

@@ -0,0 +1,4 @@
+export * from './directives';
+export * from './pipes';
+export { FileUploadComponent } from './file-upload.component';
+export { FileUploadModule } from './file-upload.module';

package/lib/file-upload/pipes/human-readable-byte-size.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class HumanReadableByteSizePipe implements PipeTransform {
+    transform(bytes: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HumanReadableByteSizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<HumanReadableByteSizePipe, "humanReadableByteSize", false>;
+}

package/lib/file-upload/pipes/index.d.ts

@@ -0,0 +1 @@
+export * from './human-readable-byte-size.pipe';

package/lib/form-field/controls/checkbox/checkbox.component.d.ts

@@ -0,0 +1,133 @@
+import { ChangeDetectorRef, DoCheck, ElementRef, EventEmitter, OnDestroy } from '@angular/core';
+import { ControlValueAccessor, FormGroupDirective, NgControl, NgForm, ValidationErrors, Validator } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { BooleanInput } from '../../../../utilities';
+import { ImpdcFormRoot } from '../../directives';
+import { ErrorStateMatcher } from '../../services';
+import { HasTabIndex, ICanUpdateErrorState, IHasErrorState, ImpdcFormFieldControl } from '../../shared';
+import * as i0 from "@angular/core";
+export declare class CheckboxChangeEvent {
+    /** The specific checkbox that changed. */
+    readonly source: CheckboxComponent;
+    /** Whether the changed checkbox was checked or unchecked at the time of the event. */
+    readonly checked: boolean;
+    constructor(
+    /** The specific checkbox that changed. */
+    source: CheckboxComponent, 
+    /** Whether the changed checkbox was checked or unchecked at the time of the event. */
+    checked: boolean);
+}
+declare abstract class CheckboxComponentBase {
+    _defaultErrorStateMatcher: ErrorStateMatcher;
+    _formRoot: ImpdcFormRoot;
+    _parentForm: NgForm;
+    _parentFormGroup: FormGroupDirective;
+    ngControl: NgControl | null;
+    readonly stateChanges: Subject<void>;
+    abstract disabled: boolean;
+    constructor(_defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl | null);
+}
+declare const _CheckboxComponentMixinBase: import("../../shared").Constructor<HasTabIndex> & import("../../shared").AbstractConstructor<HasTabIndex> & import("../../shared").Constructor<ICanUpdateErrorState> & import("../../shared").AbstractConstructor<ICanUpdateErrorState> & typeof CheckboxComponentBase;
+/**
+ * The `CheckboxComponent` (`<impdc-checkbox`) is an input with a simple boolean value as a checkbox or toggle switch.
+ * This component can be used within a `FormFieldComponent` (`<impdc-form-field`).
+ * To use, import `CheckboxModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+export declare class CheckboxComponent extends _CheckboxComponentMixinBase implements DoCheck, OnDestroy, ControlValueAccessor, Validator, HasTabIndex, ImpdcFormFieldControl<boolean>, ICanUpdateErrorState, IHasErrorState {
+    private readonly _changeDetector;
+    private readonly _uid;
+    private _cvaOnChange;
+    private _cvaOnTouched;
+    protected _inputElement?: ElementRef<HTMLInputElement>;
+    id: string;
+    /**
+     * The primary label text for the checkbox control.
+     */
+    label: string;
+    /**
+     * Text to provide additional description or context for the checkbox control. Does not display when `inline` is `true`.
+     */
+    description: string;
+    /**
+     * Whether or not the input displays as a toggle switch.
+     */
+    isSwitch: boolean;
+    /**
+     * When `isSwitch` is `true`, sets whether or not the toggle switch uses icons.
+     */
+    switchIcons: boolean;
+    /**
+     * Whether or not the checkbox displays inline.
+     */
+    inline: boolean;
+    /**
+     * Whether or not the checkbox input is checked.
+     */
+    get checked(): boolean;
+    set checked(value: BooleanInput);
+    /**
+     * Whether or not the checkbox input is in an `indeterminate` state.
+     */
+    get indeterminate(): boolean;
+    set indeterminate(value: BooleanInput);
+    private _indeterminate;
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    protected _disabled: boolean;
+    errorStateMatcher: ErrorStateMatcher;
+    /**
+     * Event emitted whenever the checkedness of the input changes.
+     */
+    readonly change: EventEmitter<CheckboxChangeEvent>;
+    /**
+     * Event emitted whenever the control enters or leaves an `indeterminate` state.
+     */
+    readonly indeterminateChange: EventEmitter<boolean>;
+    get inputId(): string;
+    constructor(_changeDetector: ChangeDetectorRef, tabIndex: string, defaultErrorStateMatcher: ErrorStateMatcher, formRoot: ImpdcFormRoot, parentForm: NgForm, parentFormGroup: FormGroupDirective, ngControl: NgControl | null);
+    /** @ignore */
+    ngDoCheck(): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    get value(): boolean;
+    set value(value: BooleanInput);
+    private _value;
+    get focused(): boolean;
+    private _focused;
+    /**
+     * Used to set requiredness of control in a template-based manner; not necessary when using the
+     * Angular reactive forms API and 'required' or `requiredTrue` validators.
+     */
+    get required(): boolean;
+    set required(value: BooleanInput);
+    private _required;
+    readonly controlType: string;
+    readonly supportsAffixes: boolean;
+    /** @ignore */
+    writeValue(value: any): void;
+    /** @ignore */
+    registerOnChange(fn: (value: any) => void): void;
+    /** @ignore */
+    registerOnTouched(fn: () => {}): void;
+    /** @ignore */
+    setDisabledState(isDisabled: boolean): void;
+    /** @ignore */
+    validate(): ValidationErrors | null;
+    protected _getAriaChecked(): 'true' | 'false' | 'mixed';
+    protected _onBlur(): void;
+    protected _onFocus(): void;
+    protected _handleCheckClick(): void;
+    protected _onInteractionEvent(event: Event): void;
+    private _emitChangeEvents;
+    /**
+     *  Prevent click events that come from the `<label/>` element from bubbling. This prevents the
+     *  click handler on the host from triggering twice when clicking on the `<label/>` element. After
+     *  the click event on the `<label/>` propagates, the browsers dispatches click on the associated
+     *  `<input/>`. By preventing clicks on the label by bubbling, we ensure only one click event
+     *  bubbles when the label is clicked.
+     */
+    protected _preventBubblingFromLabel(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent, [null, { attribute: "tabindex"; }, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "impdc-checkbox", ["impdcCheckControl"], { "tabIndex": "tabIndex"; "id": "id"; "label": "label"; "description": "description"; "isSwitch": "isSwitch"; "switchIcons": "switchIcons"; "inline": "inline"; "checked": "checked"; "indeterminate": "indeterminate"; "disabled": "disabled"; "errorStateMatcher": "errorStateMatcher"; "required": "required"; }, { "change": "change"; "indeterminateChange": "indeterminateChange"; }, never, never, false>;
+}
+export {};

package/lib/form-field/controls/checkbox/checkbox.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./checkbox.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../shared/toggle/toggle.module";
+export declare class CheckboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CheckboxModule, [typeof i1.CheckboxComponent], [typeof i2.CommonModule, typeof i3.ToggleModule], [typeof i1.CheckboxComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CheckboxModule>;
+}

package/lib/form-field/controls/checkbox/index.d.ts

@@ -0,0 +1,2 @@
+export { CheckboxChangeEvent, CheckboxComponent } from './checkbox.component';
+export { CheckboxModule } from './checkbox.module';

package/lib/form-field/controls/index.d.ts

@@ -0,0 +1,4 @@
+export * from './checkbox';
+export * from './input';
+export * from './radio';
+export * from './select';

package/lib/form-field/controls/input/index.d.ts

@@ -0,0 +1 @@
+export { InputDirective } from './input.directive';

package/lib/form-field/controls/input/input.directive.d.ts

@@ -0,0 +1,84 @@
+import { DoCheck, ElementRef, OnChanges, OnDestroy } from '@angular/core';
+import { FormGroupDirective, NgControl, NgForm } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { BooleanInput } from '../../../../utilities';
+import { ImpdcFormRoot } from '../../directives';
+import { ErrorStateMatcher } from '../../services';
+import { ICanUpdateErrorState, IHasErrorState } from '../../shared';
+import { ImpdcFormFieldControl } from '../../shared/form-field-control';
+import * as i0 from "@angular/core";
+/** @docs-private */
+export declare function getInputUnsupportedTypeError(type: string): Error;
+declare const _InputDirectiveBase: import("../../shared").Constructor<ICanUpdateErrorState> & import("../../shared").AbstractConstructor<ICanUpdateErrorState> & {
+    new (_defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl | null): {
+        readonly stateChanges: Subject<void>;
+        _defaultErrorStateMatcher: ErrorStateMatcher;
+        _formRoot: ImpdcFormRoot;
+        _parentForm: NgForm;
+        _parentFormGroup: FormGroupDirective;
+        ngControl: NgControl | null;
+    };
+};
+/**
+ * The `InputDirective` (`<input impdcInput`, `<textarea impdcInput` or `<select impdcInput`) is a directive for text inputs.
+ * With this directive, the input, textarea, and select can be used within a `FormFieldComponent` (`<impdc-form-field`).
+ * To use, import `ImpdcFormsModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+export declare class InputDirective extends _InputDirectiveBase implements ImpdcFormFieldControl<any>, ICanUpdateErrorState, IHasErrorState, OnChanges, OnDestroy, DoCheck {
+    protected _elementRef: ElementRef<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>;
+    private _inputValueAccessor;
+    protected _uid: string;
+    protected _isSelect: boolean;
+    protected _isTextarea: boolean;
+    focused: boolean;
+    readonly controlType?: string;
+    readonly supportsAffixes: boolean;
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    protected _disabled: boolean;
+    get id(): string;
+    set id(value: string);
+    protected _id: string;
+    /**
+     * Supports most standard `<input [type]>` attribute values. Does not support `button`, `checkbox`,
+     * `file`, `hidden`, `image`, `radio`, `range`, `reset`, or `button`, and does not apply to
+     * `<textarea>` or `<select>` elements.
+     *
+     * @default text
+     */
+    get type(): string;
+    set type(value: string);
+    protected _type: string;
+    /**
+     * Used to set requiredness of control in a template-based manner;
+     * not necessary when using the Angular reactive forms API and `required` validator.
+     */
+    get required(): boolean;
+    set required(value: BooleanInput);
+    private _required;
+    /**
+     * Used to put the control in a non-interactive readonly state; only supports `<input>` and
+     * `<textarea>` elements.
+     *
+     * To see the difference between `readonly` and `disabled`, refer to [MDN's documentation](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/readonly).
+     */
+    get readonly(): boolean;
+    set readonly(value: BooleanInput);
+    private _readonly;
+    errorStateMatcher: ErrorStateMatcher;
+    get value(): string;
+    set value(value: any);
+    constructor(_elementRef: ElementRef<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>, ngControl: NgControl, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, _defaultErrorStateMatcher: ErrorStateMatcher);
+    /** @ignore */
+    ngDoCheck(): void;
+    /** @ignore */
+    ngOnChanges(): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    protected _focusChanged(isFocused: boolean): void;
+    protected _typeIsValid(inputType: string): boolean;
+    protected _onInput(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDirective, [null, { optional: true; self: true; }, { optional: true; }, { optional: true; }, { optional: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputDirective, "input[impdcInput], textarea[impdcInput], select[impdcNativeSelect]", ["impdcInput"], { "disabled": "disabled"; "id": "id"; "type": "type"; "required": "required"; "readonly": "readonly"; "errorStateMatcher": "errorStateMatcher"; "value": "value"; }, {}, never, never, false>;
+}
+export {};

package/lib/form-field/controls/radio/index.d.ts

@@ -0,0 +1,5 @@
+export { RadioChangeEvent, IRadioButton, IRadioGroup } from './interfaces';
+export { RadioButtonComponent } from './radio-button/radio-button.component';
+export { RadioGroupDirective } from './radio-group/radio-group.directive';
+export { IMPDC_RADIO_GROUP, IMPDC_RADIO_BUTTON } from './injection-tokens';
+export { RadioModule } from './radio.module';

package/lib/form-field/controls/radio/injection-tokens.d.ts

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@angular/core';
+import { IRadioButton, IRadioGroup } from './interfaces';
+export declare const IMPDC_RADIO_GROUP: InjectionToken<IRadioGroup>;
+export declare const IMPDC_RADIO_BUTTON: InjectionToken<IRadioButton>;

package/lib/form-field/controls/radio/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from './radio-change-event.interface';
+export * from './radio-button.interface';
+export * from './radio-group.interface';

package/lib/form-field/controls/radio/interfaces/radio-button.interface.d.ts

@@ -0,0 +1,6 @@
+export interface IRadioButton {
+    checked: boolean;
+    name: string;
+    value: any;
+    markForCheck(): void;
+}

package/lib/form-field/controls/radio/interfaces/radio-change-event.interface.d.ts

@@ -0,0 +1,12 @@
+import { IRadioButton } from './radio-button.interface';
+export declare class RadioChangeEvent {
+    /** The specific radio button that changed. */
+    readonly source: IRadioButton;
+    /** The selected value. */
+    readonly value: any;
+    constructor(
+    /** The specific radio button that changed. */
+    source: IRadioButton, 
+    /** The selected value. */
+    value: any);
+}

package/lib/form-field/controls/radio/interfaces/radio-group.interface.d.ts

@@ -0,0 +1,13 @@
+import { IRadioButton } from './radio-button.interface';
+export interface IRadioGroup {
+    get disabled(): boolean;
+    get errorState(): boolean;
+    get inline(): boolean;
+    get name(): string;
+    get required(): boolean;
+    get value(): any;
+    selected: IRadioButton | null;
+    emitChangesEvent(): void;
+    onChangeFn(value: any): void;
+    touch(): void;
+}

package/lib/form-field/controls/radio/radio-button/radio-button.component.d.ts

@@ -0,0 +1,98 @@
+import { AfterViewInit, ChangeDetectorRef, DoCheck, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { BooleanInput } from '../../../../../utilities';
+import { UniqueSelectionDispatcher } from '../../../services/unique-selection-dispatcher.service';
+import { HasTabIndex } from '../../../shared/tab-index.mixin';
+import { RadioChangeEvent, IRadioButton, IRadioGroup } from '../interfaces';
+import * as i0 from "@angular/core";
+declare abstract class RadioButtonComponentBase {
+    abstract disabled: boolean;
+    constructor();
+}
+declare const _RadioButtonComponentMixinBase: import("@impartner/design-components").Constructor<HasTabIndex> & import("@impartner/design-components").AbstractConstructor<HasTabIndex> & typeof RadioButtonComponentBase;
+export declare class RadioButtonComponent extends _RadioButtonComponentMixinBase implements IRadioButton, HasTabIndex, OnInit, OnDestroy, DoCheck, AfterViewInit {
+    private readonly _changeDetector;
+    private _radioDispatcher;
+    readonly _radioGroup?: IRadioGroup | undefined;
+    private readonly _uid;
+    private _removeUniqueSelectionListener;
+    private _previousTabIndex?;
+    private _inputElement;
+    id: string;
+    /**
+     * The unique name for a group of radio options; Inherited from the parent `RadioGroupDirective` when available.
+     */
+    name: string;
+    /**
+     * Property for setting ARIA "label" attribute.
+     */
+    ariaLabel?: string;
+    /**
+     * Property for setting ARIA "labelled by" attribute.
+     */
+    ariaLabelledby?: string;
+    /**
+     * Property for setting ARIA "described by" attribute.
+     */
+    ariaDescribedby?: string;
+    /**
+     * Whether or not the radio input is checked/selected.
+     */
+    get checked(): boolean;
+    set checked(value: BooleanInput);
+    protected _checked: boolean;
+    /**
+     * The specific value represented by the radio button.
+     */
+    get value(): any;
+    set value(value: any);
+    protected _value: any;
+    /**
+     * Whether or not the radio button displays inline; Inherited from the parent `RadioGroupDirective` when available.
+     */
+    get inline(): boolean;
+    set inline(value: BooleanInput);
+    protected _inline?: boolean;
+    /**
+     * Used to enable or disable the radio button, but will always return `true` when the parent
+     * `RadioGroupDirective` is already disabled.
+     */
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    protected _disabled: boolean;
+    /** @ignore */
+    get required(): boolean;
+    set required(value: BooleanInput);
+    protected _required: boolean;
+    /**
+     * The primary label text for the radio button.
+     */
+    label: string;
+    /**
+     * Text to provide additional description or context for the radio button. Does
+     * not display if `inline` is `true`.
+     */
+    description: string;
+    /**
+     * Event emitted when the radio button becomes selected/checked.
+     */
+    readonly change: EventEmitter<RadioChangeEvent>;
+    protected get _errorState(): boolean;
+    constructor(_changeDetector: ChangeDetectorRef, _radioDispatcher: UniqueSelectionDispatcher, tabIndex?: string, _radioGroup?: IRadioGroup | undefined);
+    /** @ignore */
+    ngOnInit(): void;
+    /** @ignore */
+    ngDoCheck(): void;
+    /** @ignore */
+    ngAfterViewInit(): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    /** @ignore */
+    markForCheck(): void;
+    protected _emitChangesEvent(): void;
+    protected _onBlur(): void;
+    protected _onInputChange(event: Event): void;
+    protected _updateTabIndex(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioButtonComponent, [null, null, { attribute: "tabindex"; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioButtonComponent, "impdc-radio-button", ["impdcRadioButton"], { "tabIndex": "tabIndex"; "id": "id"; "name": "name"; "ariaLabel": "aria-label"; "ariaLabelledby": "aria-labelledby"; "ariaDescribedby": "aria-describedby"; "checked": "checked"; "value": "value"; "inline": "inline"; "disabled": "disabled"; "required": "required"; "label": "label"; "description": "description"; }, { "change": "change"; }, never, never, false>;
+}
+export {};

package/lib/form-field/controls/radio/radio-group/radio-group.directive.d.ts

@@ -0,0 +1,104 @@
+import { AfterContentInit, ChangeDetectorRef, DoCheck, EventEmitter, OnDestroy, QueryList } from '@angular/core';
+import { ControlValueAccessor, FormGroupDirective, NgControl, NgForm } from '@angular/forms';
+import { BooleanInput } from '../../../../../utilities';
+import { Subject } from 'rxjs';
+import { ImpdcFormRoot } from '../../../directives';
+import { ErrorStateMatcher } from '../../../services';
+import { IHasErrorState, ImpdcFormFieldControl } from '../../../shared';
+import { RadioChangeEvent, IRadioButton, IRadioGroup } from '../interfaces';
+import * as i0 from "@angular/core";
+declare const _RadioGroupDirectiveBase: import("../../../shared").Constructor<import("../../../shared").ICanUpdateErrorState> & import("../../../shared").AbstractConstructor<import("../../../shared").ICanUpdateErrorState> & {
+    new (_defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl | null): {
+        readonly stateChanges: Subject<void>;
+        _defaultErrorStateMatcher: ErrorStateMatcher;
+        _formRoot: ImpdcFormRoot;
+        _parentForm: NgForm;
+        _parentFormGroup: FormGroupDirective;
+        ngControl: NgControl | null;
+    };
+};
+/**
+ * The `RadioGroupDirective` (`<impdc-radio-group`) is a container for `RadioButtonComponent` (`<impdc-radio-button`).
+ * This directive/component can be used within a `FormFieldComponent` (`<impdc-form-field`).
+ * To use, import `RadioModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+export declare class RadioGroupDirective<TRadioButton extends IRadioButton = IRadioButton> extends _RadioGroupDirectiveBase implements IRadioGroup, ControlValueAccessor, ImpdcFormFieldControl<any>, AfterContentInit, DoCheck, OnDestroy, IHasErrorState {
+    private readonly _changeDetector;
+    protected _radioOptions: QueryList<TRadioButton>;
+    protected readonly _uid: string;
+    protected _initialized: boolean;
+    private _previousControl?;
+    private _cvaOnChange;
+    private _cvaOnTouched;
+    /**
+     * The unique name for the group of radio options; Autogenerated by default.
+     */
+    get name(): string;
+    set name(value: string);
+    protected _name: string;
+    /**
+     * Whether or not the nested radio options should display inline.
+     */
+    get inline(): boolean;
+    set inline(value: BooleanInput);
+    protected _inline: boolean;
+    /**
+     * A reference to the currently selected radio button component (eg. `<impdc-radio-button>`).
+     */
+    get selected(): TRadioButton | null;
+    set selected(selected: TRadioButton | null);
+    protected _selected: TRadioButton | null;
+    errorStateMatcher: ErrorStateMatcher;
+    /**
+     * Event emitted whenever a new radio option is selected.
+     */
+    readonly change: EventEmitter<RadioChangeEvent>;
+    constructor(_changeDetector: ChangeDetectorRef, _defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl | null);
+    /** @ignore */
+    ngAfterContentInit(): void;
+    /** @ignore */
+    ngDoCheck(): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    get value(): any;
+    set value(value: any);
+    protected _value: any;
+    get id(): string;
+    set id(value: string);
+    protected _id: string;
+    get focused(): boolean;
+    protected _focused: boolean;
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    protected _disabled: boolean;
+    /**
+     * Used to set requiredness of control in a template-based manner;
+     * not necessary when using the Angular reactive forms API and `required` validator.
+     */
+    get required(): boolean;
+    set required(value: BooleanInput);
+    private _required;
+    readonly controlType = "impdc-radio-group";
+    readonly supportsAffixes: boolean;
+    /** @ignore */
+    writeValue(value: any): void;
+    /** @ignore */
+    registerOnChange(fn: (value: any) => void): void;
+    /** @ignore */
+    registerOnTouched(fn: () => {}): void;
+    /** @ignore */
+    setDisabledState(isDisabled: boolean): void;
+    /** @ignore */
+    emitChangesEvent(): void;
+    /** @ignore */
+    onChangeFn(value: any): void;
+    /** @ignore */
+    touch(): void;
+    protected _checkSelectedRadioOption(): void;
+    protected _markRadioOptionsForCheck(): void;
+    protected _updateRadioOptionNames(): void;
+    protected _updateSelectedRadioOptionFromValue(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupDirective<any>, [null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RadioGroupDirective<any>, "impdc-radio-group", ["impdcRadioGroup"], { "name": "name"; "inline": "inline"; "selected": "selected"; "errorStateMatcher": "errorStateMatcher"; "value": "value"; "id": "id"; "disabled": "disabled"; "required": "required"; }, { "change": "change"; }, ["_radioOptions"], never, false>;
+}
+export {};

package/lib/form-field/controls/radio/radio.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./radio-button/radio-button.component";
+import * as i2 from "./radio-group/radio-group.directive";
+import * as i3 from "@angular/forms";
+import * as i4 from "../shared/toggle/toggle.module";
+export declare class RadioModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RadioModule, [typeof i1.RadioButtonComponent, typeof i2.RadioGroupDirective], [typeof i3.ReactiveFormsModule, typeof i4.ToggleModule], [typeof i1.RadioButtonComponent, typeof i2.RadioGroupDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RadioModule>;
+}