@daffodil/design 0.81.1 → 0.82.0

package/tabs/tabs.d.ts

@@ -1,6 +1,12 @@
-import { DaffPrefixSuffixModule } from '@daffodil/design';
 import { DaffTabComponent } from './tabs/tab/tab.component';
 import { DaffTabLabelComponent } from './tabs/tab-label/tab-label.component';
 import { DaffTabPanelComponent } from './tabs/tab-panel/tab-panel.component';
 import { DaffTabsComponent } from './tabs/tabs.component';
-export declare const DAFF_TABS_COMPONENTS: readonly [typeof DaffTabsComponent, typeof DaffTabLabelComponent, typeof DaffTabPanelComponent, typeof DaffPrefixSuffixModule, typeof DaffTabComponent];
+/**
+ * @docs-private
+ *
+ * ```ts
+ * import { DAFF_TABS_COMPONENTS } from '@daffodil/design/tabs';
+ * ```
+ */
+export declare const DAFF_TABS_COMPONENTS: readonly [typeof DaffTabsComponent, typeof DaffTabLabelComponent, typeof DaffTabPanelComponent, typeof DaffTabComponent];

package/text-snippet/README.md

@@ -1,2 +1,20 @@
 # Text Snippet
-The text snippet component shows a snippet of text, with the ability to show or hide content beyond one line of text.
+The text snippet component shows a snippet of text, with the ability to show or hide content beyond one line of text.
+
+## Usage
+
+### Within a standalone component
+To use a text snippet in a standalone component, import `DaffTextSnippetComponent` directly into your custom component:
+
+```ts
+import { DaffTextSnippetComponent } from '@daffodil/design/text-snippet';
+
+@Component({
+  selector: 'custom-component',
+  templateUrl: './custom-component.component.html',
+  imports: [
+    DaffTextSnippetComponent,
+  ],
+})
+export class CustomComponent {}
+```

package/toast/README.md

@@ -4,187 +4,57 @@ Toasts are small messages designed to mimic push notifications. They are used to
 ## Overview
 Toasts should be used to display temporary messages about actions or events that occured or in need of attention, with no relation to content on a page. For messaging that provide context in close promixity to a piece of content within a page, use the [Notification](/libs/design/notification/README.md) component.
 
-## Basic Toast
+## Basic toast
 <design-land-example-viewer-container example="default-toast"></design-land-example-viewer-container>
 
 ## Setting up the component
-`provideDaffToast()` should be added as a provider either in your application's root component for global use or in a specific feature component.
+`provideDaffToast()` must be added as a provider in your application's root component for global use or in a specific feature component for the toast functionality to work properly.
 
 ```ts
 import { provideDaffToast } from '@daffodil/design/toast';
 
 @NgModule({
-	providers: [
-		provideDaffToast(),
-	]
+  providers: [
+    provideDaffToast(),
+  ]
 )}
 
 export class AppModule {}
 ```
 
-### Configurations
-Toast can be configured by using the `DaffToastService`.
-
-The following is an example of a toast with a duration:
-
-```ts
-import {
-  ChangeDetectionStrategy,
-  Component,
-} from '@angular/core';
-
-import {
-	DaffToast
-  DaffToastService,
-} from '@daffodil/design/toast';
-
-@Component({
-  selector: 'custom-toast',
-  templateUrl: './custom-toast.component.html',
-  changeDetection: ChangeDetectionStrategy.OnPush,
-  standalone: true,
-})
-export class CustomToastComponent {
-	private toast: DaffToast;
-
-	constructor(private toastService: DaffToastService) {}
-
-	open() {
-		this.toast = this.toastService.open({
-			title: 'Update Complete',
-			message: 'This page has been updated to the newest version.',
-		},
-		{
-			duration: 5000,
-		});
-	}
-}
-```
-
-The following is an example of a toast with actions:
-
-```ts
-import {
-  ChangeDetectionStrategy,
-  Component,
-	EventEmitter,
-	OnInit,
-} from '@angular/core';
-
-import { DAFF_BUTTON_COMPONENTS } from '@daffodil/design/button';
-import {
-  DaffToast,
-  DaffToastAction,
-  DaffToastService,
-} from '@daffodil/design/toast';
-
-@Component({
-  selector: 'action-toast',
-  templateUrl: './action-toast.component.html',
-  changeDetection: ChangeDetectionStrategy.OnPush,
-  standalone: true,
-	imports: [
-		DAFF_BUTTON_COMPONENTS,
-	],
-})
-export class ActionToastComponent implements OnInit {
-	private toast: DaffToast;
-
-	constructor(private toastService: DaffToastService) {}
-
-	update = new EventEmitter<DaffToastAction>();
-
-  closeToast = new EventEmitter<DaffToastAction>();
-
-	open() {
-		this.toast = this.toastService.open({
-			title: 'Update Available',
-			message: 'A new version of this page is available.',
-			actions: [
-				{ content: 'Update', color: 'theme-contrast', size: 'sm', eventEmitter: this.update },
-				{ content: 'Remind me later', type: 'flat', size: 'sm', eventEmitter: this.closeToast },
-			]
-		});
-	}
-
-	ngOnInit() {
-    this.update.subscribe(() => {
-    });
-
-    this.closeToast.subscribe(() => {
-      this.toastService.close(this.toast);
-    });
-  }
-}
-```
-
-The following configurations are available in the `DaffToastService`:
-
-| Property | Type   | Description                     | Default |
-| -------- | ------ | ------------------------------- | ------- |
-| title    | string | A quick overview of the toast   | --      |
-| message  | string | Additional details about the message that should be limited to one or two sentences | --      |
-| actions  | `DaffToastAction` | Adds a `daff-button` that allow users to perform an action related to the message. Actions should be limited to two buttons. | --      |
-| dismissible  | boolean | Allows a toast to be dismissible via a close button | true |
-| duration  | number | The duration in milliseconds that a toast is visible before it's dismissed | 5000 |
-
-The `actions` configurations are based on the properties of the `DaffButtonComponent` (view [Button Documentation](/libs/design/button/README.md)) with the addition of `data` and `eventEmitter`.
-
 ## Dismissal
-A toast can be dismissed via a timed duration, a close button, or the `ESC` key.
+A toast can be dismissed via a timed duration or a close button.
+
+The `duration` and `dismissible` properties can be updated when you open it with the `DaffToastService`.
 
 ### Timed duration
-A toast with actions will persist until one of the actions have been interacted with, or is dismissed by the close button or the `ESC` key. Actionable toasts should be persistent, but a duration is allowed to be set. If duration must be set, make sure it's long enough for users to engage with the actions.
+A toast with actions will persist until one of the actions have been interacted with or dismissed by the close button. By default, a toast without actions will be dismissed after `5000ms`.
 
-By default, a toast without actions will be dismissed after `5000ms`. This can be updated by setting `duration` through the `DaffToastService`.
+> Actionable toasts should be persistent, but a duration is allowed to be set. If duration must be set, make sure it's long enough for users to engage with the actions.
 
-#### Toast with custom duration
 <design-land-example-viewer-container example="toast-with-custom-duration"></design-land-example-viewer-container>
 
 ### Close button
-The close button is shown by default but can be hidden by setting `dismissible: false` through the `DaffToastService`.
+The close button is hidden by default, and dismissible is ignored when there are actions in a toast. You can change the visibility of the close button via the `dismissible` property.
 
-### Escape Key
-A toast can be dismissed by using the `ESC` key if it has actions and is focus trapped.
+<design-land-example-viewer-container example="dismissible-toast"></design-land-example-viewer-container>
 
 ## Stacking
 A maximum of three toasts can be shown at a time. Toasts are stacked vertically, with the most recent toast displayed on top.
 
 ## Statuses
-The status color of a toast can be updated by using the `status` property.
-
-Supported statuses: `warn | critical | success`
+You can set the status of a toast when opening it with `DaffToastService`, using values defined by `DaffStatus`.
 
-### Toast with statuses
 <design-land-example-viewer-container example="toast-status"></design-land-example-viewer-container>
 
-## Positions
-
-| Property     | Value                    | Default |
-| ------------ | ------------------------ | ------- |
-| `vertical`   | `top | bottom`           | top     |
-| `horizontal` | `left | center | right ` | right   |
-
-To change the horizontal and vertical position of a toast, add the `provideDaffToastOptions` dependency key to the `providers` key in the module as shown below:
-
-```ts
-providers: [
-	provideDaffToastOptions({
-		position: {
-			vertical: 'bottom',
-			horizontal: 'center',
-		}
-		useParent: false,
-	})
-]
-```
-
-The position of a toast on a mobile device will always be on the bottom center.
+## Accessibility
+By default, toasts use a `role="status"` to announce messages. It's the equivalent of `aria-live="polite"`, which does not interrupt a user's current activity and waits until they are idle to make the announcement.
 
-### Toast with configurable positions
-<design-land-example-viewer-container example="toast-positions"></design-land-example-viewer-container>
+`role="alertdialog"` is used when a toast has action. The toast will be focus trapped and focus immediately moves to the actions.
 
-## Accessibility
-By default, toasts use a `role="status"` to announce messages. It's the equivalent of `aria-live="polite"`, which does not interrupt a user's current activity and waits until they are idle to make the announcement. When a toast has actions, a `role="alertdialog"` is used. The toast will be focus trapped and focus immediately moves to the actions.
+Avoid setting a duration on toasts with actions because they will disappear automatically, making it difficult for users to interact with the actions.
 
-Avoid setting a duration on toasts with actions because they will disappear automatically, making it difficult for users to interact with the actions.
+### Keyboard Interactions
+| Key   | Action |
+| ----- | ------ |
+| `ESC` |  Dismisses a toast if it has actions and is focus trapped. |

package/toast/examples/dismissible-toast/dismissible-toast.component.d.ts

@@ -0,0 +1,11 @@
+import { DaffToastService } from '@daffodil/design/toast';
+import * as i0 from "@angular/core";
+export declare class DismissibleToastComponent {
+    private toastService;
+    private toast;
+    constructor(toastService: DaffToastService);
+    open(): void;
+    private count;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DismissibleToastComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DismissibleToastComponent, "dismissible-toast", never, {}, {}, never, never, true, never>;
+}

package/toast/examples/public_api.d.ts

@@ -1,5 +1,6 @@
 import { DefaultToastComponent } from './default-toast/default-toast.component';
+import { DismissibleToastComponent } from './dismissible-toast/dismissible-toast.component';
 import { ToastPositionsComponent } from './toast-positions/toast-positions.component';
 import { ToastStatusComponent } from './toast-status/toast-status.component';
 import { ToastWithCustomDurationComponent } from './toast-with-custom-duration/toast-with-custom-duration.component';
-export declare const TOAST_EXAMPLES: (typeof DefaultToastComponent | typeof ToastPositionsComponent | typeof ToastStatusComponent | typeof ToastWithCustomDurationComponent)[];
+export declare const TOAST_EXAMPLES: (typeof DefaultToastComponent | typeof DismissibleToastComponent | typeof ToastPositionsComponent | typeof ToastStatusComponent | typeof ToastWithCustomDurationComponent)[];

package/toast/interfaces/toast-action.d.ts

@@ -1,34 +1,45 @@
 import { EventEmitter } from '@angular/core';
 import { DaffPalette, DaffStatus } from '@daffodil/design';
+import { DaffToastActionButtonSize, DaffToastActionButtonType } from './toast-action.type';
 /**
- * An interface for properties of actions, specifically the DaffButtonComponent, placed inside of the toast.
+ * The configurations for an action button rendered inside a toast
+ * displayed using the {@link DaffButtonComponent}.
  */
 export interface DaffToastAction {
     /**
-     * The types of buttons available to be used, as defined in the {@link DaffButtonComponent}.
+     * The type of button.
+     *
+     * Matches one of the predefined types supported by {@link DaffButtonComponent}.
      */
-    type?: 'raised' | 'underline' | 'stroked' | 'flat' | undefined;
+    type?: DaffToastActionButtonType;
     /**
-     * The text for the button
+     * The text displayed on the button.
      */
     content: string;
     /**
-     * The size of the button, as defined in the {@link DaffButtonComponent}.
+     * The size of the button.
+     *
+     * Matches one of the predefined sizes supported by {@link DaffButtonComponent}.
      */
-    size?: 'sm' | 'md' | 'lg' | undefined;
+    size?: DaffToastActionButtonSize;
     /**
-     * The color of the button, as defined in the {@link DaffButtonComponent}.
-     * Color and status should not be used simultaneously.
+     * The color of the button.
+     *
+     * Do not use both `color` and `status` simultaneously.
      */
     color?: DaffPalette;
     /**
-     * The status of the button, as defined in the {@link DaffButtonComponent}.
-     * Color and status should not be used simultaneously.
+     * The button status.
+     *
+     * Do not use both `color` and `status` simultaneously.
      */
     status?: DaffStatus;
+    /**
+     * Data associated with the action.
+     */
     data?: Record<string, any>;
     /**
-     * Sets an EventEmitter on a DaffToastAction
+     * An event emitter that fires when the action is triggered.
      */
     eventEmitter?: EventEmitter<DaffToastAction>;
 }

package/toast/interfaces/toast-action.type.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The available button styles that can be used in {@link DaffToastAction}.
+ * These correspond to the types supported by {@link DaffButtonComponent}.
+ */
+export type DaffToastActionButtonType = 'raised' | 'underline' | 'stroked' | 'flat' | undefined;
+/**
+ * The available button sizes that can be used in {@link DaffToastAction}.
+ * These correspond to the types supported by {@link DaffButtonComponent}.
+ */
+export type DaffToastActionButtonSize = 'sm' | 'md' | 'lg' | undefined;

package/toast/interfaces/toast.d.ts

@@ -3,18 +3,24 @@ import { DaffStatus } from '@daffodil/design';
 import { DaffToastAction } from './toast-action';
 /** Possible data that can be shown on a toast */
 export interface DaffToastData {
-    /** A title that provides a quick oveview of the toast */
+    /** A title that provides a quick oveview of the toast. */
     title: string;
-    /** A short message used to provide additional details about the toast */
+    /** A short message used to provide additional details about the toast. */
     message?: string;
-    /** Sets a status on the toast */
+    /** Sets a status on the toast. */
     status?: DaffStatus;
-    /** Used to display actions in the toast */
+    /** Used to display actions in the toast. */
     actions?: DaffToastAction[];
-    /** Whether or not the toast is dismissible */
+    /** Whether or not the toast is dismissible. */
     dismissible?: boolean;
 }
 export interface DaffToast extends DaffToastData {
+    /**
+     * Closes the toast.
+     */
     dismiss: () => void;
+    /**
+     * The observable that emits when the toast is closed.
+     */
     dismissalStream: Observable<void | number>;
 }

package/toast/options/daff-toast-options.d.ts

@@ -10,4 +10,5 @@ export interface DaffToastOptions {
     useParent: boolean;
 }
 export declare const daffToastDefaultOptions: DaffToastOptions;
-export declare const DAFF_TOAST_OPTIONS: import("@angular/core").InjectionToken<DaffToastOptions>, provideDaffToastOptions: <R extends DaffToastOptions = DaffToastOptions>(config: Partial<R> | import("@angular/core").InjectionToken<Partial<R>>) => import("@angular/core").FactoryProvider;
+export declare const provideDaffToastOptions: <R extends DaffToastOptions = DaffToastOptions>(config: Partial<R> | import("@angular/core").InjectionToken<Partial<R>>) => import("@angular/core").FactoryProvider;
+export declare const DAFF_TOAST_OPTIONS: import("@angular/core").InjectionToken<DaffToastOptions>;

package/toast/public_api.d.ts

@@ -1,12 +1,8 @@
 export { DaffToastPositionService } from './service/position.service';
-export { DaffToastModule } from './toast.module';
 export { DaffToastService } from './service/toast.service';
 export { DaffToastConfiguration } from './toast/toast-config';
 export { DaffToast, DaffToastData, } from './interfaces/toast';
 export { DaffToastAction } from './interfaces/toast-action';
 export { DAFF_TOAST_OPTIONS, provideDaffToastOptions, } from './options/daff-toast-options';
-export * from './toast/toast.component';
-export * from './toast-actions/toast-actions.directive';
-export * from './toast-title/toast-title.directive';
-export * from './toast-message/toast-message.directive';
-export * from './toast/toast-provider';
+export { provideDaffToast } from './toast/toast-provider';
+export { DaffToastActionButtonSize, DaffToastActionButtonType, } from './interfaces/toast-action.type';

package/toast/service/position.service.d.ts

@@ -7,8 +7,16 @@ export declare class DaffToastPositionService {
     constructor(options: DaffToastOptions, mediaQuery: BreakpointObserver);
     private _config;
     private _position;
+    /**
+     * Reads the current position of the toast. Defaults to bottom center on mobile devices.
+     */
     get config(): DaffToastPosition;
-    set config(val: DaffToastPosition);
+    private set config(value);
+    /**
+     * Changes the position of the toast.
+     *
+     * @param position The position of the toast.
+     */
     setPosition(position: DaffToastPosition): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DaffToastPositionService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DaffToastPositionService>;

package/toast/service/toast.service.d.ts

@@ -7,6 +7,55 @@ import { DaffToast, DaffToastData } from '../interfaces/toast';
 import { DaffToastOptions } from '../options/daff-toast-options';
 import { DaffToastConfiguration } from '../toast/toast-config';
 import * as i0 from "@angular/core";
+/**
+ * Service to display toasts.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   ChangeDetectionStrategy,
+ *   Component,
+ *   EventEmitter,
+ *   OnInit,
+ * } from '@angular/core';
+ *
+ * import {
+ *   DaffToast,
+ *   DaffToastAction,
+ *   DaffToastService,
+ * } from '@daffodil/design/toast';
+ *
+ * @Component({
+ *   selector: 'default-toast',
+ *   templateUrl: './default-toast.component.html',
+ *   styles: [],
+ *   changeDetection: ChangeDetectionStrategy.OnPush,
+ * })
+ * export class DefaultToastComponent implements OnInit {
+ *   private toast: DaffToast;
+ *
+ *   constructor(private toastService: DaffToastService) {}
+ *
+ *   closeToast = new EventEmitter<DaffToastAction>();
+ *
+ *   open() {
+ *     this.toast = this.toastService.open({
+ *       title: 'Update Available',
+ *       message: 'A new version of this page is available.',
+ *       actions: [
+ *         { content: 'Remind me later', type: 'flat', size: 'sm', eventEmitter: this.closeToast },
+ *       ],
+ *     });
+ *   }
+ *
+ *   ngOnInit() {
+ *     this.closeToast.subscribe(() => {
+ *       this.toastService.close(this.toast);
+ *     });
+ *   }
+ * }
+ * ```
+ */
 export declare class DaffToastService implements OnDestroy {
     private overlay;
     private options;
@@ -20,10 +69,24 @@ export declare class DaffToastService implements OnDestroy {
     private _overlayRef?;
     private _template?;
     constructor(overlay: Overlay, options: DaffToastOptions, _parentToast: DaffToastService, mediaQuery: BreakpointObserver, toastPosition: DaffToastPositionService, focusStack: DaffFocusStackService, injector: Injector);
+    /**
+     * @docs-private
+     */
     ngOnDestroy(): void;
     private _attachToastTemplate;
     private _createOverlayRef;
+    /**
+     * Opens the toast.
+     *
+     * @param toast Data that can be shown on a toast.
+     * @param configuration Additional configuration options such as duration. The default duration is set to 5000ms.
+     */
     open(toast: DaffToastData, configuration?: Partial<DaffToastConfiguration>): DaffToast;
+    /**
+     * Closes the toast.
+     *
+     * @param toast The instance of toast that you wish to close.
+     */
     close(toast: DaffToast): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DaffToastService, [null, null, { optional: true; skipSelf: true; }, null, null, null, null]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DaffToastService>;

package/toast/toast/toast-config.d.ts

@@ -1,6 +1,29 @@
 export interface DaffToastConfiguration {
     /**
-     * The duration (in milliseconds) that a toast is visible before it's dismissed.
+     * The duration (in milliseconds) for which a toast remains visible before dismissal.
+     *
+     * While you can set a duration for toasts with actions, it's generally not recommended,
+     * as users should have ample time to interact with them.
+     *
+     * @usage
+     * ```
+     * export class CustomComponent {
+     *   private toast: DaffToast;
+     *
+     *   constructor(private toastService: DaffToastService) {}
+     *
+     *   open() {
+     *     this.toast = this.toastService.open({
+     *       title: 'Update Complete',
+     *       message: 'This page has been updated to the newest version.',
+     *       status: 'success',
+     *     },
+     *     {
+     *       duration: 7000,
+     *     });
+     *   }
+     * }
+     * ```
      */
     duration?: number;
 }

package/toast/toast/toast-provider.d.ts

@@ -1,2 +1,18 @@
 import { Provider } from '@angular/core';
+/**
+ * Registers the `DaffToastService` and `DaffToastPositionService` for displaying a toast. This provider ensures
+ * toasts function correctly within your application.
+ *
+ * ```ts
+ * import { provideDaffToast } from '@daffodil/design/toast';
+ *
+ * @NgModule({
+ * 	providers: [
+ * 		provideDaffToast(),
+ * 	]
+ * )}
+ *
+ * export class AppModule {}
+ * ```
+ */
 export declare const provideDaffToast: () => Provider[];

package/toast/toast/toast-template.component.d.ts

@@ -1,15 +1,13 @@
 import { ChangeDetectorRef, EventEmitter } from '@angular/core';
 import { DaffToast } from '../interfaces/toast';
-import { DaffToastOptions } from '../options/daff-toast-options';
 import { DaffToastPositionService } from '../service/position.service';
 import * as i0 from "@angular/core";
 export declare class DaffToastTemplateComponent {
     private cd;
-    private options;
     private toastPosition;
     faTimes: import("@fortawesome/fontawesome-common-types").IconDefinition;
     private _items;
-    constructor(cd: ChangeDetectorRef, options: DaffToastOptions, toastPosition: DaffToastPositionService);
+    constructor(cd: ChangeDetectorRef, toastPosition: DaffToastPositionService);
     closeToast: EventEmitter<void>;
     onCloseToast(event: Event): void;
     get slideAnimation(): any;

package/toast/toast/toast.component.d.ts

@@ -6,6 +6,8 @@ import { DaffToastActionsDirective } from '../toast-actions/toast-actions.direct
 import * as i0 from "@angular/core";
 import * as i1 from "@daffodil/design";
 /**
+ * @docs-private
+ *
  * DaffToastComponent provides a way to display and
  * communicate information for user actions or system updates.
  */
@@ -13,9 +15,17 @@ export declare class DaffToastComponent implements DaffPrefixable, AfterContentI
     private _elementRef;
     private _focusTrapFactory;
     private _focusStack;
-    /** @docs-private */
+    /**
+     * @docs-private
+     */
     class: boolean;
+    /**
+     * @docs-private
+     */
     _actions: DaffToastActionsDirective;
+    /**
+     * @docs-private
+     */
     _prefix: DaffPrefixDirective;
     toast: DaffToast;
     /**
@@ -24,8 +34,17 @@ export declare class DaffToastComponent implements DaffPrefixable, AfterContentI
     onEscape(): void;
     private _focusTrap;
     constructor(_elementRef: ElementRef, _focusTrapFactory: ConfigurableFocusTrapFactory, _focusStack: DaffFocusStackService);
+    /**
+     * @docs-private
+     */
     ngAfterContentInit(): void;
+    /**
+     * @docs-private
+     */
     ngAfterViewInit(): void;
+    /**
+     * @docs-private
+     */
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DaffToastComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<DaffToastComponent, "daff-toast", never, { "toast": { "alias": "toast"; "required": false; }; }, {}, ["_actions", "_prefix"], ["[daffPrefix]", "[daffToastTitle]", "[daffToastMessage]", "[daffToastActions]", "*"], true, [{ directive: typeof i1.DaffArticleEncapsulatedDirective; inputs: {}; outputs: {}; }, { directive: typeof i1.DaffStatusableDirective; inputs: { "status": "status"; }; outputs: {}; }]>;

package/toast/toast-actions/toast-actions.directive.d.ts

@@ -1,5 +1,8 @@
 import * as i0 from "@angular/core";
 export declare class DaffToastActionsDirective {
+    /**
+     * @docs-private
+     */
     class: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<DaffToastActionsDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DaffToastActionsDirective, "[daffToastActions]", never, {}, {}, never, never, true, never>;

package/toast/toast-message/toast-message.directive.d.ts

@@ -1,5 +1,8 @@
 import * as i0 from "@angular/core";
 export declare class DaffToastMessageDirective {
+    /**
+     * @docs-private
+     */
     class: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<DaffToastMessageDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DaffToastMessageDirective, "[daffToastMessage]", never, {}, {}, never, never, true, never>;

package/toast/toast-title/toast-title.directive.d.ts

@@ -1,5 +1,8 @@
 import * as i0 from "@angular/core";
 export declare class DaffToastTitleDirective {
+    /**
+     * @docs-private
+     */
     class: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<DaffToastTitleDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DaffToastTitleDirective, "[daffToastTitle]", never, {}, {}, never, never, true, never>;