@firestitch/form 18.0.29 → 18.0.30

package/app/components/form-dialog-actions/form-dialog-actions.component.d.ts

@@ -1,16 +1,28 @@
 import { OnDestroy, OnInit } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class FsFormDialogActionsComponent implements OnInit, OnDestroy {
-    private _form;
-    private _cdRef;
+    /** Leave unset inside an `fsFormContainer` to follow whether it has anything to save. */
     save: boolean;
     create: boolean;
     close: boolean;
+    /** Leave unset inside an `fsFormContainer` to fill in whenever Save does not apply. */
     done: boolean;
     closeData: any;
     name: string;
     dirty: boolean;
     private _destroy$;
+    private _container;
+    private _form;
+    private _cdRef;
+    /**
+     * Inside a container these default to whether anything mounted can actually
+     * save, so a footer left as a bare `<fs-form-dialog-actions>` swaps Save for
+     * Done as tabs change without the dialog listing which tabs are savable. An
+     * explicit binding always wins, and outside a container Save stays on as it
+     * always did.
+     */
+    get showSave(): boolean;
+    get showDone(): boolean;
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FsFormDialogActionsComponent, never>;

package/app/directives/button.directive.d.ts

@@ -11,7 +11,7 @@ export declare class FsButtonDirective implements OnInit, OnDestroy {
     private _formDisabled;
     private _previousDisabled;
     private _destroy$;
-    private _formGroup;
+    private _container;
     private _form;
     private _matButton;
     private _elementRef;

package/app/directives/form/form.directive.d.ts

@@ -3,34 +3,37 @@ import { NgForm } from '@angular/forms';
 import { Observable } from 'rxjs';
 import { FsFormBaseDirective } from '../form-base';
 import { ConfirmResult } from './../../enums/confirm-result';
-import { ConfirmConfig, SubmittedEvent } from './../../interfaces';
+import { FormStatus } from './../../enums/form-status';
+import { SubmittedEvent } from './../../interfaces';
 import { SubmitEvent } from './../../interfaces/submit-event';
 import * as i0 from "@angular/core";
 export declare class FsFormDirective extends FsFormBaseDirective implements OnInit, OnDestroy, AfterContentInit, OnChanges {
     ngForm: NgForm;
-    private _form;
-    private _element;
-    private _message;
-    private _formGroup;
-    private _dialogRef;
-    private _drawerRef;
-    private _route;
     wrapperSelector: string;
     messageSelector: string;
     hintSelector: string;
     labelSelector: string;
     autocomplete: boolean;
-    shortcuts: boolean;
-    confirm: ConfirmConfig | boolean;
-    confirmDialog: boolean;
-    confirmDrawer: boolean;
-    confirmBrowser: boolean;
     dirtySubmitButton: boolean;
     set submit(submit$: (event: SubmitEvent) => Observable<any>);
     get submit(): (event: SubmitEvent) => Observable<any>;
     successDelay: number;
     errorDelay: number;
-    deactivationGuard: boolean;
+    /**
+     * Whether this form joins the set around it - the `fsForm` it is nested inside,
+     * or the `fsFormContainer` enclosing it.
+     *
+     * Forms in a set behave as one submittable unit: the outermost form is what the
+     * submit buttons drive, and validation, dirty state, the unsaved-changes
+     * confirm and the pristine reset all span the set. That is what lets a form
+     * wrap only one tab's fields while the dialog footer stays outside it.
+     *
+     * Set `[link]="false"` for a panel that owns its own saving - an instant-save
+     * side panel, say. It keeps every fsForm feature for itself, but its dirty
+     * state never enables the outer Save button, its validation never blocks the
+     * outer submit, and the outer submit never touches it.
+     */
+    link: boolean;
     submitEvent: EventEmitter<SubmitEvent>;
     invalid: EventEmitter<SubmitEvent>;
     valid: EventEmitter<SubmitEvent>;
@@ -39,19 +42,73 @@ export declare class FsFormDirective extends FsFormBaseDirective implements OnIn
     cleared: EventEmitter<SubmitEvent>;
     fsFormClass: boolean;
     private _registerControl;
-    private _dialogBackdropEscape;
     private _snapshot;
-    private _activatedRouteConfig;
     private _status$;
     private _submit$;
+    private _linkedForms;
+    private _containerParent;
+    private _dirtyChange$;
+    private _message;
+    private _container;
+    private _ancestorForm;
+    /**
+     * Emits whenever the set's dirty state may have moved. Anything outside the
+     * form that renders off it - the dialog actions, say - can't watch
+     * `ngForm.valueChanges` on its own, because the edits happen in a nested form's
+     * NgForm, not this one's.
+     */
+    get dirtyChange$(): Observable<void>;
+    get submitted$(): Observable<SubmittedEvent>;
+    get status$(): Observable<FormStatus>;
+    get element(): HTMLElement;
+    /** True when a Save button driving this form would have something to run. */
+    get hasSubmit(): boolean;
+    /**
+     * The form this one is linked into, or null when it is a root - either because
+     * nothing encloses it or because `[link]="false"` cut it loose. A container
+     * supplies the parent when the forms are siblings rather than nested.
+     */
+    get parentForm(): FsFormDirective;
+    /** The outermost form of this set. Submit buttons drive this one. */
+    get rootForm(): FsFormDirective;
+    /** This form plus every form linked into it, at any depth. */
+    get linkedForms(): FsFormDirective[];
+    /** True when this form or anything linked into it has unsaved changes. */
+    get dirtyLinked(): boolean;
+    /**
+     * True when this form or anything linked into it has a submit handler - i.e.
+     * there is something for a Save button to do. A dialog footer can bind to this
+     * to swap Save for Done as the mounted tab changes, instead of hard-coding
+     * which tab names happen to be savable.
+     */
+    get submits(): boolean;
     get submitting(): boolean;
     get validating(): boolean;
     get completing(): boolean;
+    /**
+     * True when nothing above this form speaks for the set it belongs to. Reads the
+     * raw injections rather than `parentForm`, so an unlinked panel inside a dialog
+     * still defers to whatever encloses it instead of registering a second backdrop
+     * confirm on the same dialog.
+     */
+    private get _owns();
     private get _submitEvent();
     private get _formValidState$();
     private get _formInvalidState$();
     private get _submitter();
     ngOnInit(): void;
+    /**
+     * Take a nested form into this one's set. Called by the child on init, or by a
+     * container linking its siblings - consumers never call it directly.
+     */
+    linkForm(form: FsFormDirective): void;
+    unlinkForm(form: FsFormDirective): void;
+    /**
+     * Adopt a parent that DI could not supply. Only a container calls this, to link
+     * forms that are siblings in the template into one set.
+     */
+    linkTo(form: FsFormDirective): void;
+    unlinkFrom(): void;
     ngOnChanges(changes: SimpleChanges): void;
     clearSubmit(submit?: (event: SubmitEvent) => Observable<any>): void;
     registerSubmit(submit$: () => Observable<any>): void;
@@ -72,22 +129,25 @@ export declare class FsFormDirective extends FsFormBaseDirective implements OnIn
     enable(): void;
     disable(): void;
     validate(): void;
-    submit$(submitEvent: SubmitEvent): Observable<SubmittedEvent>;
+    submit$(submitEvent?: SubmitEvent): Observable<SubmittedEvent>;
     private _listenSubmit;
     private _listenFormStatus;
-    private _listenWindowClose;
-    private _activeDialog;
-    private _listenHotKeys;
-    private _formClose;
     private _getActiveSubmitButton;
-    private _elementInForm;
     private _completeSubmit;
-    private _getFormGroup;
+    /**
+     * Whoever holds the submit buttons for this form. A container when one encloses
+     * it, otherwise the root of its linked set - the button that saves a tab's form
+     * typically sits outside it, down in the dialog footer.
+     *
+     * Only a form that actually joined the container may drive its buttons. DI
+     * hands `_container` to every form inside, including one cut loose with
+     * `[link]="false"`, and an instant-save panel is usually `[confirm]="false"`
+     * too - so without this it would take the `!confirm` branch below and
+     * re-enable the footer's Save button that the linked set had just disabled.
+     */
+    private _getOwner;
     private _resetButtons;
     private _registerConfirm;
-    private _registerDrawerClose;
-    private _registerConfirmDrawerClose;
-    private _registerConfirmDialogBackdropEscape;
     private _registerAutocomplete;
     private _registerDirtySubmitButton;
     private _updateDirtySubmitButtons;
@@ -97,8 +157,6 @@ export declare class FsFormDirective extends FsFormBaseDirective implements OnIn
     private _disableButtons;
     private _waitUntilStatusPending;
     private _handleError;
-    private _registerCanDeactivateGuard;
-    private _cleanupCanDeactivate;
     static ɵfac: i0.ɵɵFactoryDeclaration<FsFormDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FsFormDirective, "[fsForm]", ["fsForm"], { "wrapperSelector": { "alias": "wrapperSelector"; "required": false; }; "messageSelector": { "alias": "messageSelector"; "required": false; }; "hintSelector": { "alias": "hintSelector"; "required": false; }; "labelSelector": { "alias": "labelSelector"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "shortcuts": { "alias": "shortcuts"; "required": false; }; "confirm": { "alias": "confirm"; "required": false; }; "confirmDialog": { "alias": "confirmDialog"; "required": false; }; "confirmDrawer": { "alias": "confirmDrawer"; "required": false; }; "confirmBrowser": { "alias": "confirmBrowser"; "required": false; }; "dirtySubmitButton": { "alias": "dirtySubmitButton"; "required": false; }; "submit": { "alias": "submit"; "required": false; }; "successDelay": { "alias": "successDelay"; "required": false; }; "errorDelay": { "alias": "errorDelay"; "required": false; }; "deactivationGuard": { "alias": "deactivationGuard"; "required": false; }; }, { "submitEvent": "fsForm"; "invalid": "invalid"; "valid": "valid"; "submitted": "submitted"; "reseted": "reseted"; "cleared": "cleared"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FsFormDirective, "[fsForm]", ["fsForm"], { "wrapperSelector": { "alias": "wrapperSelector"; "required": false; }; "messageSelector": { "alias": "messageSelector"; "required": false; }; "hintSelector": { "alias": "hintSelector"; "required": false; }; "labelSelector": { "alias": "labelSelector"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "dirtySubmitButton": { "alias": "dirtySubmitButton"; "required": false; }; "submit": { "alias": "submit"; "required": false; }; "successDelay": { "alias": "successDelay"; "required": false; }; "errorDelay": { "alias": "errorDelay"; "required": false; }; "link": { "alias": "link"; "required": false; }; }, { "submitEvent": "fsForm"; "invalid": "invalid"; "valid": "valid"; "submitted": "submitted"; "reseted": "reseted"; "cleared": "cleared"; }, never, never, true, never>;
 }

package/app/directives/form-base/form-base.directive.d.ts

@@ -1,21 +1,62 @@
-import { AfterContentInit, ChangeDetectorRef, NgZone, OnDestroy, QueryList } from '@angular/core';
+import { AfterContentInit, ChangeDetectorRef, ElementRef, NgZone, OnDestroy, OnInit, QueryList } from '@angular/core';
+import { ActivatedRoute, Route } from '@angular/router';
+import { MatDialogRef } from '@angular/material/dialog';
 import { MatTabGroup } from '@angular/material/tabs';
+import { DrawerRef } from '@firestitch/drawer';
 import { Observable } from 'rxjs';
 import { ConfirmResult } from '../../enums';
-import { ConfirmConfig } from '../../interfaces';
+import { FormStatus } from '../../enums/form-status';
+import { ConfirmConfig, SubmitEvent, SubmittedEvent } from '../../interfaces';
+import { FsForm } from '../../services/fsform.service';
 import { FsButtonDirective } from '../button.directive';
+import type { FsFormDirective } from '../form/form.directive';
 import * as i0 from "@angular/core";
-export declare abstract class FsFormBaseDirective implements AfterContentInit, OnDestroy {
+/**
+ * Shared by the two things that can own a set of forms: an `fsForm` sitting at
+ * the root of its linked set, and an `fsFormContainer` holding forms that are
+ * siblings rather than nested.
+ *
+ * It holds the submit-button registry both of them expose to buttons, and the
+ * lifecycle that belongs to the set as a whole rather than to any one form -
+ * the dialog backdrop and Escape, Ctrl+S, the browser close prompt, the drawer
+ * and tab-switch confirms. Exactly one owner registers that lifecycle; see
+ * `_registerOwnerLifecycle`.
+ */
+export declare abstract class FsFormBaseDirective implements OnInit, AfterContentInit, OnDestroy {
     confirmTabs: boolean;
     tabGroup: MatTabGroup;
+    confirm: ConfirmConfig | boolean;
+    confirmDialog: boolean;
+    confirmDrawer: boolean;
+    confirmBrowser: boolean;
+    shortcuts: boolean;
+    deactivationGuard: boolean;
     protected _ngZone: NgZone;
     protected _cdRef: ChangeDetectorRef;
+    protected _element: ElementRef<any>;
+    protected _form: FsForm;
+    protected _route: ActivatedRoute;
+    protected _dialogRef: MatDialogRef<any, any>;
+    protected _drawerRef: DrawerRef<any, any>;
+    protected _dialogBackdropEscape: boolean;
+    protected _activatedRouteConfig: Route | null;
     private _tabGroups;
     private _buttons;
     private _activeSubmitButton;
+    private _confirmTabGroups;
     private _destroy$;
     abstract submitting: boolean;
-    abstract confirm: ConfirmConfig | boolean;
+    /** True when anything in the owned set has unsaved changes. */
+    abstract dirtyLinked: boolean;
+    /** Every form in the owned set, at any depth. */
+    abstract linkedForms: FsFormDirective[];
+    /** Emits whenever the owned set's dirty state may have moved. */
+    abstract dirtyChange$: Observable<void>;
+    /** Emits once a submit over the owned set has completed successfully. */
+    abstract submitted$: Observable<SubmittedEvent>;
+    /** Tracks the owned set's submit lifecycle, so the drawer can wait one out. */
+    abstract status$: Observable<FormStatus>;
+    ngOnInit(): void;
     ngAfterContentInit(): void;
     get destroy$(): Observable<void>;
     ngOnDestroy(): void;
@@ -24,11 +65,38 @@ export declare abstract class FsFormBaseDirective implements AfterContentInit, O
     set activeSubmitButton(button: FsButtonDirective);
     addButton(button: FsButtonDirective): void;
     removeButton(button: FsButtonDirective): void;
+    /**
+     * Everything here acts on the form set as a whole, so exactly one thing may
+     * register it. A form linked into a parent defers to that parent; every form
+     * inside a container defers to the container. Registering twice would put two
+     * confirms on the same backdrop click and two handlers on the same Ctrl+S.
+     */
+    protected _registerOwnerLifecycle(): void;
+    /** The half of the same ownership that needs projected content resolved. */
+    protected _registerOwnerContentLifecycle(): void;
+    /**
+     * Whether the element is inside what this owner covers. Overridden by the
+     * container, whose own element is a poor proxy: it may be an `<ng-container>`,
+     * which is a comment node and contains nothing.
+     */
+    protected _containsElement(el: Element): boolean;
+    protected _nodeContains(root: Node, el: Element): boolean;
+    protected _formClose(): void;
+    private _listenWindowClose;
+    private _activeDialog;
+    private _listenHotKeys;
+    private _registerConfirmDialogBackdropEscape;
+    private _registerDrawerClose;
+    private _registerConfirmDrawerClose;
     private _registerConfirmTabs;
     private _registerConfirmTabGroups;
     private _registerConfirmTabGroup;
+    private _registerCanDeactivateGuard;
+    private _cleanupCanDeactivate;
     abstract triggerSubmit(): void;
     abstract triggerConfirm(): Observable<ConfirmResult>;
+    abstract reset(): void;
+    abstract submit$(event?: SubmitEvent): Observable<SubmittedEvent>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FsFormBaseDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FsFormBaseDirective, never, never, { "confirmTabs": { "alias": "confirmTabs"; "required": false; }; "tabGroup": { "alias": "tabGroup"; "required": false; }; }, {}, ["_tabGroups"], never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FsFormBaseDirective, never, never, { "confirmTabs": { "alias": "confirmTabs"; "required": false; }; "tabGroup": { "alias": "tabGroup"; "required": false; }; "confirm": { "alias": "confirm"; "required": false; }; "confirmDialog": { "alias": "confirmDialog"; "required": false; }; "confirmDrawer": { "alias": "confirmDrawer"; "required": false; }; "confirmBrowser": { "alias": "confirmBrowser"; "required": false; }; "shortcuts": { "alias": "shortcuts"; "required": false; }; "deactivationGuard": { "alias": "deactivationGuard"; "required": false; }; }, {}, ["_tabGroups"], never, false, never>;
 }

package/app/directives/form-container/form-container.directive.d.ts

@@ -0,0 +1,80 @@
+import { Observable } from 'rxjs';
+import { ConfirmResult } from '../../enums';
+import { FormStatus } from '../../enums/form-status';
+import { FsFormOwner, SubmitEvent, SubmittedEvent } from '../../interfaces';
+import { FsFormBaseDirective } from '../form-base';
+import type { FsFormDirective } from '../form/form.directive';
+import * as i0 from "@angular/core";
+/**
+ * Bounds a set of forms without being one.
+ *
+ * An `fsForm` can only reach the forms nested inside it through DI, which forces
+ * a wrapper carrying `ngForm` around anything that needs to see them - and that
+ * wrapper then owns a real, empty `NgForm` whose control namespace every field
+ * below it falls into. A container has no `ngForm` and no controls. It only
+ * watches: forms register themselves as they mount, buttons resolve to it, and
+ * `fs-form-dialog-actions` reads Save-vs-Done off it. Put it on whatever element
+ * already frames the layout - or on an `<ng-container>` for no element at all.
+ *
+ * Forms in a container are siblings rather than nested, so on registration each
+ * one is linked into the first. That reproduces exactly the structure DI nesting
+ * builds, which is why validation, dirty state, the unsaved-changes confirm and
+ * the submit chain all span a container without any of that machinery knowing
+ * containers exist.
+ *
+ * A form marked `[link]="false"` never registers, so an instant-save panel stays
+ * out of the set the same way it does when nested.
+ */
+export declare class FsFormContainerDirective extends FsFormBaseDirective implements FsFormOwner {
+    private _forms;
+    private _formsChange$;
+    /** The forms registered into this container, in registration order. */
+    get forms(): FsFormDirective[];
+    /**
+     * The form the rest of the set is linked into, or null while the container
+     * holds none - an open tab that has nothing to save, say.
+     */
+    get rootForm(): FsFormDirective;
+    /** Emits whenever a form registers or deregisters. */
+    get formsChange$(): Observable<void>;
+    get linkedForms(): FsFormDirective[];
+    /**
+     * True when anything in the container has a submit handler - i.e. there is
+     * something for a Save button to do. `fs-form-dialog-actions` reads this to
+     * swap Save for Done as the mounted tab changes, so a dialog never has to keep
+     * a list of which tabs happen to be savable.
+     */
+    get submits(): boolean;
+    get dirtyLinked(): boolean;
+    get submitting(): boolean;
+    /**
+     * Emits whenever the set's dirty state may have moved, including when the set
+     * itself changes. Anything rendering off it - the dialog actions - subscribes
+     * once and outlives any particular form, so this has to follow the root across
+     * tab switches rather than bind to whichever form happened to be first.
+     */
+    get dirtyChange$(): Observable<void>;
+    get submitted$(): Observable<SubmittedEvent>;
+    get status$(): Observable<FormStatus>;
+    /**
+     * Take a form into the container. Called by the form on init - consumers never
+     * call it directly.
+     */
+    registerForm(form: FsFormDirective): void;
+    /**
+     * Material attaches an incoming tab body before it detaches the outgoing one,
+     * so losing the root is a routine reshuffle rather than teardown. Re-elect and
+     * re-link the survivors instead of leaving them pointing at a dead root, and
+     * only let go of forms actually registered - clearing unconditionally would
+     * drop the form that just arrived.
+     */
+    deregisterForm(form?: FsFormDirective): void;
+    triggerSubmit(): void;
+    triggerConfirm(): Observable<ConfirmResult>;
+    submit$(event?: SubmitEvent): Observable<SubmittedEvent>;
+    reset(): void;
+    validate(): void;
+    protected _containsElement(el: Element): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FsFormContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FsFormContainerDirective, "fs-form-container,[fsFormContainer]", ["fsFormContainer"], {}, {}, never, never, true, never>;
+}

package/app/directives/form-container/index.d.ts

@@ -0,0 +1 @@
+export * from './form-container.directive';

package/app/directives/index.d.ts

@@ -1,5 +1,5 @@
 export * from './form';
-export * from './form-group';
+export * from './form-container';
 export * from './validators';
 export * from './button.directive';
 export * from './form-dialog-close.directive';

package/app/fs-form.module.d.ts

@@ -34,10 +34,10 @@ import * as i31 from "./directives/button.directive";
 import * as i32 from "./directives/submit-button.directive";
 import * as i33 from "./directives/form-template.directive";
 import * as i34 from "./directives/form-template-outlet.directive";
-import * as i35 from "./directives/form-group/form-group.directive";
+import * as i35 from "./directives/form-container/form-container.directive";
 export declare class FsFormModule {
     static forRoot(): ModuleWithProviders<FsFormModule>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FsFormModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<FsFormModule, never, [typeof i1.CommonModule, typeof i2.FormsModule, typeof i3.MatButtonModule, typeof i4.MatDialogModule, typeof i4.MatDialogModule, typeof i5.FsDialogModule, typeof i6.FsFormDirective, typeof i7.FsControlDirective, typeof i8.FsFormRequiredDirective, typeof i9.FsFormMinDirective, typeof i10.FsFormMaxDirective, typeof i11.FsFormMinLengthDirective, typeof i12.FsFormMaxLengthDirective, typeof i13.FsFormEmailDirective, typeof i14.FsFormEmailsDirective, typeof i15.FsFormPhoneDirective, typeof i16.FsFormCompareDirective, typeof i17.FsFormIntegerDirective, typeof i18.FsFormNumericDirective, typeof i19.FsFormPatternDirective, typeof i20.FsFormFunctionDirective, typeof i21.FsFormDateRangeDirective, typeof i22.FsFormGreaterDirective, typeof i23.FsFormGreaterEqualDirective, typeof i24.FsFormLesserDirective, typeof i25.FsFormLesserEqualDirective, typeof i26.FsFormUrlDirective, typeof i27.FsFormDialogCloseDirective, typeof i28.FsFormValidateDirective, typeof i29.FsFormDialogActionsComponent, typeof i30.FsFormNoFsValidatorsDirective, typeof i31.FsButtonDirective, typeof i32.FsSubmitButtonDirective, typeof i33.FsFormTemplateDirective, typeof i33.FsFormTemplateDirective, typeof i34.FsFormTemplateOutletDirective, typeof i35.FsFormGroupDirective], [typeof i6.FsFormDirective, typeof i7.FsControlDirective, typeof i8.FsFormRequiredDirective, typeof i9.FsFormMinDirective, typeof i10.FsFormMaxDirective, typeof i11.FsFormMinLengthDirective, typeof i12.FsFormMaxLengthDirective, typeof i13.FsFormEmailDirective, typeof i14.FsFormEmailsDirective, typeof i15.FsFormPhoneDirective, typeof i16.FsFormCompareDirective, typeof i17.FsFormIntegerDirective, typeof i18.FsFormNumericDirective, typeof i19.FsFormPatternDirective, typeof i20.FsFormFunctionDirective, typeof i21.FsFormDateRangeDirective, typeof i22.FsFormGreaterDirective, typeof i23.FsFormGreaterEqualDirective, typeof i24.FsFormLesserDirective, typeof i25.FsFormLesserEqualDirective, typeof i26.FsFormUrlDirective, typeof i27.FsFormDialogCloseDirective, typeof i28.FsFormValidateDirective, typeof i29.FsFormDialogActionsComponent, typeof i30.FsFormNoFsValidatorsDirective, typeof i31.FsButtonDirective, typeof i32.FsSubmitButtonDirective, typeof i33.FsFormTemplateDirective, typeof i33.FsFormTemplateDirective, typeof i34.FsFormTemplateOutletDirective, typeof i35.FsFormGroupDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FsFormModule, never, [typeof i1.CommonModule, typeof i2.FormsModule, typeof i3.MatButtonModule, typeof i4.MatDialogModule, typeof i4.MatDialogModule, typeof i5.FsDialogModule, typeof i6.FsFormDirective, typeof i7.FsControlDirective, typeof i8.FsFormRequiredDirective, typeof i9.FsFormMinDirective, typeof i10.FsFormMaxDirective, typeof i11.FsFormMinLengthDirective, typeof i12.FsFormMaxLengthDirective, typeof i13.FsFormEmailDirective, typeof i14.FsFormEmailsDirective, typeof i15.FsFormPhoneDirective, typeof i16.FsFormCompareDirective, typeof i17.FsFormIntegerDirective, typeof i18.FsFormNumericDirective, typeof i19.FsFormPatternDirective, typeof i20.FsFormFunctionDirective, typeof i21.FsFormDateRangeDirective, typeof i22.FsFormGreaterDirective, typeof i23.FsFormGreaterEqualDirective, typeof i24.FsFormLesserDirective, typeof i25.FsFormLesserEqualDirective, typeof i26.FsFormUrlDirective, typeof i27.FsFormDialogCloseDirective, typeof i28.FsFormValidateDirective, typeof i29.FsFormDialogActionsComponent, typeof i30.FsFormNoFsValidatorsDirective, typeof i31.FsButtonDirective, typeof i32.FsSubmitButtonDirective, typeof i33.FsFormTemplateDirective, typeof i33.FsFormTemplateDirective, typeof i34.FsFormTemplateOutletDirective, typeof i35.FsFormContainerDirective], [typeof i6.FsFormDirective, typeof i7.FsControlDirective, typeof i8.FsFormRequiredDirective, typeof i9.FsFormMinDirective, typeof i10.FsFormMaxDirective, typeof i11.FsFormMinLengthDirective, typeof i12.FsFormMaxLengthDirective, typeof i13.FsFormEmailDirective, typeof i14.FsFormEmailsDirective, typeof i15.FsFormPhoneDirective, typeof i16.FsFormCompareDirective, typeof i17.FsFormIntegerDirective, typeof i18.FsFormNumericDirective, typeof i19.FsFormPatternDirective, typeof i20.FsFormFunctionDirective, typeof i21.FsFormDateRangeDirective, typeof i22.FsFormGreaterDirective, typeof i23.FsFormGreaterEqualDirective, typeof i24.FsFormLesserDirective, typeof i25.FsFormLesserEqualDirective, typeof i26.FsFormUrlDirective, typeof i27.FsFormDialogCloseDirective, typeof i28.FsFormValidateDirective, typeof i29.FsFormDialogActionsComponent, typeof i30.FsFormNoFsValidatorsDirective, typeof i31.FsButtonDirective, typeof i32.FsSubmitButtonDirective, typeof i33.FsFormTemplateDirective, typeof i33.FsFormTemplateDirective, typeof i34.FsFormTemplateOutletDirective, typeof i35.FsFormContainerDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<FsFormModule>;
 }

package/app/interfaces/form-owner.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+import type { FsFormDirective } from '../directives/form/form.directive';
+import { ConfirmConfig } from './confirm-config';
+import { SubmitEvent } from './submit-event';
+import { SubmittedEvent } from './submitted-event';
+/**
+ * What the unsaved-changes confirm and the route guard need from whatever owns a
+ * set of forms. Both an `fsForm` at the root of its linked set and an
+ * `fsFormContainer` holding several satisfy it, so neither caller has to know
+ * which of the two it was handed.
+ */
+export interface FsFormOwner {
+    confirm: ConfirmConfig | boolean;
+    linkedForms: FsFormDirective[];
+    reset(): void;
+    submit$(event?: SubmitEvent): Observable<SubmittedEvent>;
+}

package/app/interfaces/index.d.ts

@@ -2,3 +2,4 @@ export * from './submit-event';
 export * from './submitted-event';
 export * from './confirm-config';
 export * from './confirm-tab-group';
+export * from './form-owner';

package/app/services/fsform.service.d.ts

@@ -1,16 +1,16 @@
 import { Type } from '@angular/core';
 import { Observable } from 'rxjs';
-import type { FsFormDirective } from '../directives/form/form.directive';
 import { ConfirmResult } from '../enums';
+import { FsFormOwner } from '../interfaces';
 import * as i0 from "@angular/core";
 export declare class FsForm {
     private _formDirectiveStore;
     private _dialog;
-    registerFormDirective(routeComponent: Type<any>, directive: FsFormDirective): void;
-    getFormDirectives(routeComponent: any): FsFormDirective[];
+    registerFormDirective(routeComponent: Type<any>, directive: FsFormOwner): void;
+    getFormDirectives(routeComponent: any): FsFormOwner[];
     removeFormDirective(routeComponent: any): void;
-    hasChanges(form: FsFormDirective): boolean;
-    confirmUnsaved(form: FsFormDirective): Observable<ConfirmResult>;
+    hasChanges(form: FsFormOwner): boolean;
+    confirmUnsaved(form: FsFormOwner): Observable<ConfirmResult>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FsForm, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FsForm>;
 }