@deenruv/admin-ui 1.0.0

package/core/extension/register-bulk-action.d.ts

@@ -0,0 +1,49 @@
+import { FactoryProvider } from '@angular/core';
+import { BulkAction } from '../providers/bulk-action-registry/bulk-action-types';
+/**
+ * @description
+ * Registers a custom {@link BulkAction} which can be invoked from the bulk action menu
+ * of any supported list view.
+ *
+ * This allows you to provide custom functionality that can operate on any of the selected
+ * items in the list view.
+ *
+ * In this example, imagine we have an integration with a 3rd-party text translation service. This
+ * bulk action allows us to select multiple products from the product list view, and send them for
+ * translation via a custom service which integrates with the translation service's API.
+ *
+ * @example
+ * ```ts title="providers.ts"
+ * import { ModalService, registerBulkAction, SharedModule } from '\@deenruv/admin-ui/core';
+ * import { ProductDataTranslationService } from './product-data-translation.service';
+ *
+ * export default [
+ *     ProductDataTranslationService,
+ *     registerBulkAction({
+ *         location: 'product-list',
+ *         label: 'Send to translation service',
+ *         icon: 'language',
+ *         onClick: ({ injector, selection }) => {
+ *             const modalService = injector.get(ModalService);
+ *             const translationService = injector.get(ProductDataTranslationService);
+ *             modalService
+ *                 .dialog({
+ *                     title: `Send ${selection.length} products for translation?`,
+ *                     buttons: [
+ *                         { type: 'secondary', label: 'cancel' },
+ *                         { type: 'primary', label: 'send', returnValue: true },
+ *                     ],
+ *                 })
+ *                 .subscribe(response => {
+ *                     if (response) {
+ *                         translationService.sendForTranslation(selection.map(item => item.productId));
+ *                     }
+ *                 });
+ *         },
+ *     }),
+ * ];
+ * ```
+ * @since 1.8.0
+ * @docsCategory bulk-actions
+ */
+export declare function registerBulkAction(bulkAction: BulkAction): FactoryProvider;

package/core/extension/register-custom-detail-component.d.ts

@@ -0,0 +1,55 @@
+import { Provider } from '@angular/core';
+import { CustomDetailComponentConfig } from '../providers/custom-detail-component/custom-detail-component-types';
+/**
+ * @description
+ * Registers a {@link CustomDetailComponent} to be placed in a given location. This allows you
+ * to embed any type of custom Angular component in the entity detail pages of the Admin UI.
+ *
+ * @example
+ * ```ts
+ * import { Component, OnInit } from '\@angular/core';
+ * import { switchMap } from 'rxjs';
+ * import { FormGroup } from '\@angular/forms';
+ * import { CustomFieldConfig } from '\@deenruv/common/lib/generated-types';
+ * import {
+ *     DataService,
+ *     SharedModule,
+ *     CustomDetailComponent,
+ *     registerCustomDetailComponent,
+ *     GetProductWithVariants
+ * } from '\@deenruv/admin-ui/core';
+ *
+ * \@Component({
+ *     template: `{{ extraInfo$ | async | json }}`,
+ *     standalone: true,
+ *     imports: [SharedModule],
+ * })
+ * export class ProductInfoComponent implements CustomDetailComponent, OnInit {
+ *     // These two properties are provided by Deenruv and will vary
+ *     // depending on the particular detail page you are embedding this
+ *     // component into.
+ *     entity$: Observable<GetProductWithVariants.Product>
+ *     detailForm: FormGroup;
+ *
+ *     extraInfo$: Observable<any>;
+ *
+ *     constructor(private cmsDataService: CmsDataService) {}
+ *
+ *     ngOnInit() {
+ *         this.extraInfo$ = this.entity$.pipe(
+ *             switchMap(entity => this.cmsDataService.getDataFor(entity.id))
+ *         );
+ *     }
+ * }
+ *
+ * export default [
+ *     registerCustomDetailComponent({
+ *         locationId: 'product-detail',
+ *         component: ProductInfoComponent,
+ *     }),
+ * ];
+ * ```
+ *
+ * @docsCategory custom-detail-components
+ */
+export declare function registerCustomDetailComponent(config: CustomDetailComponentConfig): Provider;

package/core/extension/register-dashboard-widget.d.ts

@@ -0,0 +1,17 @@
+import { FactoryProvider } from '@angular/core';
+import { DashboardWidgetConfig, WidgetLayoutDefinition } from '../providers/dashboard-widget/dashboard-widget-types';
+/**
+ * @description
+ * Registers a dashboard widget. Once registered, the widget can be set as part of the default
+ * (using {@link setDashboardWidgetLayout}).
+ *
+ * @docsCategory dashboard-widgets
+ */
+export declare function registerDashboardWidget(id: string, config: DashboardWidgetConfig): FactoryProvider;
+/**
+ * @description
+ * Sets the default widget layout for the Admin UI dashboard.
+ *
+ * @docsCategory dashboard-widgets
+ */
+export declare function setDashboardWidgetLayout(layoutDef: WidgetLayoutDefinition): FactoryProvider;

package/core/extension/register-data-table-component.d.ts

@@ -0,0 +1,45 @@
+import { DataTableComponentConfig, DataTableCustomComponentService } from '../shared/components/data-table-2/data-table-custom-component.service';
+/**
+ * @description
+ * Allows you to override the default component used to render the data of a particular column in a DataTable.
+ * The component should implement the {@link CustomColumnComponent} interface. The tableId and columnId can
+ * be determined by pressing `ctrl + u` when running the Admin UI in dev mode.
+ *
+ * @example
+ * ```ts title="components/custom-table.component.ts"
+ * import { Component, Input } from '\@angular/core';
+ * import { CustomColumnComponent } from '\@deenruv/admin-ui/core';
+ *
+ * \@Component({
+ *     selector: 'custom-slug-component',
+ *     template: `
+ *         <a [href]="'https://example.com/products/' + rowItem.slug" target="_blank">{{ rowItem.slug }}</a>
+ *     `,
+ *     standalone: true,
+ * })
+ * export class CustomTableComponent implements CustomColumnComponent {
+ *     \@Input() rowItem: any;
+ * }
+ * ```
+ *
+ * ```ts title="providers.ts"
+ * import { registerDataTableComponent } from '\@deenruv/admin-ui/core';
+ * import { CustomTableComponent } from './components/custom-table.component';
+ *
+ * export default [
+ *     registerDataTableComponent({
+ *         component: CustomTableComponent,
+ *         tableId: 'product-list',
+ *         columnId: 'slug',
+ *     }),
+ * ];
+ * ```
+ *
+ * @docsCategory custom-table-components
+ */
+export declare function registerDataTableComponent(config: DataTableComponentConfig): {
+    provide: import("@angular/core").InjectionToken<readonly (() => void | import("rxjs").Observable<unknown> | Promise<unknown>)[]>;
+    multi: boolean;
+    useFactory: (dataTableCustomComponentService: DataTableCustomComponentService) => () => void;
+    deps: (typeof DataTableCustomComponentService)[];
+};

package/core/extension/register-form-input-component.d.ts

@@ -0,0 +1,51 @@
+import { FactoryProvider, Type } from '@angular/core';
+import { FormInputComponent } from '../common/component-registry-types';
+/**
+ * @description
+ * Registers a custom FormInputComponent which can be used to control the argument inputs
+ * of a {@link ConfigurableOperationDef} (e.g. CollectionFilter, ShippingMethod etc.) or for
+ * a custom field.
+ *
+ * @example
+ * ```ts title="providers.ts"
+ * import { registerFormInputComponent } from '\@deenruv/admin-ui/core';
+ *
+ * export default [
+ *     // highlight-next-line
+ *     registerFormInputComponent('my-custom-input', MyCustomFieldControl),
+ * ];
+ * ```
+ *
+ * This input component can then be used in a custom field:
+ *
+ * @example
+ * ```ts title="src/deenruv-config.ts"
+ * import { DeenruvConfig } from '\@deenruv/core';
+ *
+ * const config: DeenruvConfig = {
+ *   // ...
+ *   customFields: {
+ *     ProductVariant: [
+ *       {
+ *         name: 'rrp',
+ *         type: 'int',
+ *         // highlight-next-line
+ *         ui: { component: 'my-custom-input' },
+ *       },
+ *     ]
+ *   }
+ * }
+ * ```
+ *
+ * or with an argument of a {@link ConfigurableOperationDef}:
+ *
+ * @example
+ * ```ts
+ * args: {
+ *   rrp: { type: 'int', ui: { component: 'my-custom-input' } },
+ * }
+ * ```
+ *
+ * @docsCategory custom-input-components
+ */
+export declare function registerFormInputComponent(id: string, component: Type<FormInputComponent>): FactoryProvider;

package/core/extension/register-history-entry-component.d.ts

@@ -0,0 +1,66 @@
+import { Provider } from '@angular/core';
+import { HistoryEntryConfig } from '../providers/custom-history-entry-component/history-entry-component-types';
+/**
+ * @description
+ * Registers a {@link HistoryEntryComponent} for displaying history entries in the Order/Customer
+ * history timeline.
+ *
+ * @example
+ * ```ts
+ * import { Component } from '\@angular/core';
+ * import {
+ *     CustomerFragment,
+ *     CustomerHistoryEntryComponent,
+ *     registerHistoryEntryComponent,
+ *     SharedModule,
+ *     TimelineDisplayType,
+ *     TimelineHistoryEntry,
+ * } from '\@deenruv/admin-ui/core';
+ *
+ * \@Component({
+ *     selector: 'tax-id-verification-component',
+ *     template: `
+ *         <div *ngIf="entry.data.valid">
+ *           Tax ID <strong>{{ entry.data.taxId }}</strong> was verified
+ *           <vdr-history-entry-detail *ngIf="entry.data">
+ *             <vdr-object-tree [value]="entry.data"></vdr-object-tree>
+ *           </vdr-history-entry-detail>
+ *         </div>
+ *         <div *ngIf="entry.data.valid">Tax ID {{ entry.data.taxId }} could not be verified</div>
+ *     `,
+ *     standalone: true,
+ *     imports: [SharedModule],
+ * })
+ * class TaxIdHistoryEntryComponent implements CustomerHistoryEntryComponent {
+ *     entry: TimelineHistoryEntry;
+ *     customer: CustomerFragment;
+ *
+ *     getDisplayType(entry: TimelineHistoryEntry): TimelineDisplayType {
+ *         return entry.data.valid ? 'success' : 'error';
+ *     }
+ *
+ *     getName(entry: TimelineHistoryEntry): string {
+ *         return 'Tax ID Verification Plugin';
+ *     }
+ *
+ *     isFeatured(entry: TimelineHistoryEntry): boolean {
+ *         return true;
+ *     }
+ *
+ *     getIconShape(entry: TimelineHistoryEntry) {
+ *         return entry.data.valid ? 'check-circle' : 'exclamation-circle';
+ *     }
+ * }
+ *
+ * export default [
+ *     registerHistoryEntryComponent({
+ *         type: 'CUSTOMER_TAX_ID_VERIFICATION',
+ *         component: TaxIdHistoryEntryComponent,
+ *     }),
+ * ];
+ * ```
+ *
+ * @since 1.9.0
+ * @docsCategory custom-history-entry-components
+ */
+export declare function registerHistoryEntryComponent(config: HistoryEntryConfig): Provider;

package/core/extension/register-page-tab.d.ts

@@ -0,0 +1,23 @@
+import { Provider } from '@angular/core';
+import { PageTabConfig } from '../providers/page/page.service';
+/**
+ * @description
+ * Add a tab to an existing list or detail page.
+ *
+ * @example
+ * ```ts title="providers.ts"
+ * import { registerPageTab } from '@deenruv/admin-ui/core';
+ * import { DeletedProductListComponent } from './components/deleted-product-list/deleted-product-list.component';
+ *
+ * export default [
+ *     registerPageTab({
+ *         location: 'product-list',
+ *         tab: 'Deleted Products',
+ *         route: 'deleted',
+ *         component: DeletedProductListComponent,
+ *     }),
+ * ];
+ * ```
+ * @docsCategory tabs
+ */
+export declare function registerPageTab(config: PageTabConfig): Provider;

package/core/extension/register-route-component.d.ts

@@ -0,0 +1,109 @@
+import { Type } from '@angular/core';
+import { ResolveFn, Route } from '@angular/router';
+import { ResultOf, TypedDocumentNode } from '@graphql-typed-document-node/core';
+import { DocumentNode } from 'graphql';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { BaseDetailComponent } from '../common/base-detail.component';
+import { BreadcrumbValue } from '../providers/breadcrumb/breadcrumb.service';
+import { AngularRouteComponent } from './components/angular-route.component';
+/**
+ * @description
+ * Configuration for a route component.
+ *
+ * @docsCategory routes
+ */
+export type RegisterRouteComponentOptions<Component extends any | BaseDetailComponent<Entity>, Entity extends {
+    id: string;
+    updatedAt?: string;
+}, T extends DocumentNode | TypedDocumentNode<any, {
+    id: string;
+}>, Field extends keyof ResultOf<T>, R extends Field> = {
+    component: Type<Component> | Component;
+    title?: string;
+    locationId?: string;
+    description?: string;
+    breadcrumb?: BreadcrumbValue;
+    path?: string;
+    query?: T;
+    getBreadcrumbs?: (entity: Exclude<ResultOf<T>[R], 'Query'>) => BreadcrumbValue;
+    entityKey?: Component extends BaseDetailComponent<any> ? R : string;
+    variables?: T extends TypedDocumentNode<any, infer V> ? Omit<V, 'id'> : never;
+    routeConfig?: Route;
+} & (Component extends BaseDetailComponent<any> ? {
+    entityKey: R;
+} : unknown);
+/**
+ * @description
+ * Registers an Angular standalone component to be rendered in a route.
+ *
+ * @example
+ * ```ts title="routes.ts"
+ * import { registerRouteComponent } from '\@deenruv/admin-ui/core';
+ * import { registerReactRouteComponent } from '\@deenruv/admin-ui/react';
+ *
+ * import { ProductReviewDetailComponent } from './components/product-review-detail/product-review-detail.component';
+ * import { AllProductReviewsList } from './components/all-product-reviews-list/all-product-reviews-list.component';
+ * import { GetReviewDetailDocument } from './generated-types';
+ *
+ * export default [
+ *     registerRouteComponent({
+ *         path: '',
+ *         component: AllProductReviewsList,
+ *         breadcrumb: 'Product reviews',
+ *     }),
+ *     registerRouteComponent({
+ *         path: ':id',
+ *         component: ProductReviewDetailComponent,
+ *         query: GetReviewDetailDocument,
+ *         entityKey: 'productReview',
+ *         getBreadcrumbs: entity => [
+ *             {
+ *                 label: 'Product reviews',
+ *                 link: ['/extensions', 'product-reviews'],
+ *             },
+ *             {
+ *                 label: `#${entity?.id} (${entity?.product.name})`,
+ *                 link: [],
+ *             },
+ *         ],
+ *     }),
+ * ];
+ * ```
+ *
+ * @docsCategory routes
+ */
+export declare function registerRouteComponent<Component extends any | BaseDetailComponent<Entity>, Entity extends {
+    id: string;
+    updatedAt?: string;
+}, T extends DocumentNode | TypedDocumentNode<any, {
+    id: string;
+}>, Field extends keyof ResultOf<T>, R extends Field>(options: RegisterRouteComponentOptions<Component, Entity, T, Field, R>): {
+    resolve: {
+        detail?: ResolveFn<{
+            entity: Observable<ResultOf<T>[Field] | null>;
+            result?: ResultOf<T> | undefined;
+        }> | undefined;
+    };
+    data: {
+        breadcrumb: BehaviorSubject<BreadcrumbValue> | ((data: any) => any);
+        locationId: string | undefined;
+        description: string | undefined;
+    };
+    component: typeof AngularRouteComponent;
+    title?: string | Type<import("@angular/router").Resolve<string>> | ResolveFn<string> | undefined;
+    path: string;
+    pathMatch?: "prefix" | "full" | undefined;
+    matcher?: import("@angular/router").UrlMatcher | undefined;
+    loadComponent?: (() => Type<unknown> | Observable<Type<unknown> | import("@angular/router").DefaultExport<Type<unknown>>> | Promise<Type<unknown> | import("@angular/router").DefaultExport<Type<unknown>>>) | undefined;
+    redirectTo?: string | undefined;
+    outlet?: string | undefined;
+    canActivate?: any[] | undefined;
+    canMatch?: any[] | undefined;
+    canActivateChild?: any[] | undefined;
+    canDeactivate?: any[] | undefined;
+    canLoad?: any[] | undefined;
+    children?: import("@angular/router").Routes | undefined;
+    loadChildren?: import("@angular/router").LoadChildrenCallback | undefined;
+    runGuardsAndResolvers?: import("@angular/router").RunGuardsAndResolvers | undefined;
+    providers: (import("@angular/core").Provider | import("@angular/core").EnvironmentProviders)[];
+};

package/core/extension/types.d.ts

@@ -0,0 +1,11 @@
+import { Type } from '@angular/core';
+import { Subject } from 'rxjs';
+import { BreadcrumbValue } from '../providers/breadcrumb/breadcrumb.service';
+export interface RouteComponentOptions {
+    component: any;
+    title$: Subject<string | undefined>;
+    breadcrumb$: Subject<BreadcrumbValue>;
+}
+export interface AngularRouteComponentOptions extends RouteComponentOptions {
+    component: Type<any>;
+}

package/core/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@deenruv/admin-ui/core" />
+export * from './public_api';

package/core/providers/alerts/alerts.service.d.ts

@@ -0,0 +1,150 @@
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Permission } from '../../common/generated-types';
+import { DataService } from '../../data/providers/data.service';
+import { ModalService } from '../modal/modal.service';
+import { NotificationService } from '../notification/notification.service';
+import { PermissionsService } from '../permissions/permissions.service';
+import * as i0 from "@angular/core";
+/**
+ * @description
+ * The context object which is passed to the `check`, `isAlert`, `label` and `action` functions of an
+ * {@link AlertConfig} object.
+ *
+ * @since 2.2.0
+ * @docsCategory alerts
+ */
+export interface AlertContext {
+    /**
+     * @description
+     * The Angular [Injector](https://angular.dev/api/core/Injector) which can be used to get instances
+     * of services and other providers available in the application.
+     */
+    injector: Injector;
+    /**
+     * @description
+     * The [DataService](/reference/admin-ui-api/services/data-service), which provides methods for querying the
+     * server-side data.
+     */
+    dataService: DataService;
+    /**
+     * @description
+     * The [NotificationService](/reference/admin-ui-api/services/notification-service), which provides methods for
+     * displaying notifications to the user.
+     */
+    notificationService: NotificationService;
+    /**
+     * @description
+     * The [ModalService](/reference/admin-ui-api/services/modal-service), which provides methods for
+     * opening modal dialogs.
+     */
+    modalService: ModalService;
+}
+/**
+ * @description
+ * A configuration object for an Admin UI alert.
+ *
+ * @since 2.2.0
+ * @docsCategory alerts
+ */
+export interface AlertConfig<T = any> {
+    /**
+     * @description
+     * A unique identifier for the alert.
+     */
+    id: string;
+    /**
+     * @description
+     * A function which is gets the data used to determine whether the alert should be shown.
+     * Typically, this function will query the server or some other remote data source.
+     *
+     * This function will be called once when the Admin UI app bootstraps, and can be also
+     * set to run at regular intervals by setting the `recheckIntervalMs` property.
+     */
+    check: (context: AlertContext) => T | Promise<T> | Observable<T>;
+    /**
+     * @description
+     * A function which returns an Observable which is used to determine when to re-run the `check`
+     * function. Whenever the observable emits, the `check` function will be called again.
+     *
+     * A basic time-interval-based recheck can be achieved by using the `interval` function from RxJS.
+     *
+     * @example
+     * ```ts
+     * import { interval } from 'rxjs';
+     *
+     * // ...
+     * recheck: () => interval(60_000)
+     * ```
+     *
+     * If this is not set, the `check` function will only be called once when the Admin UI app bootstraps.
+     *
+     * @default undefined
+     */
+    recheck?: (context: AlertContext) => Observable<any>;
+    /**
+     * @description
+     * A function which determines whether the alert should be shown based on the data returned by the `check`
+     * function.
+     */
+    isAlert: (data: T, context: AlertContext) => boolean;
+    /**
+     * @description
+     * A function which is called when the alert is clicked in the Admin UI.
+     */
+    action: (data: T, context: AlertContext) => void;
+    /**
+     * @description
+     * A function which returns the text used in the UI to describe the alert.
+     */
+    label: (data: T, context: AlertContext) => {
+        text: string;
+        translationVars?: {
+            [key: string]: string | number;
+        };
+    };
+    /**
+     * @description
+     * A list of permissions which the current Administrator must have in order. If the current
+     * Administrator does not have these permissions, none of the other alert functions will be called.
+     */
+    requiredPermissions?: Permission[];
+}
+export interface ActiveAlert {
+    id: string;
+    runAction: () => void;
+    hasRun: boolean;
+    label: {
+        text: string;
+        translationVars?: {
+            [key: string]: string | number;
+        };
+    };
+}
+export declare class Alert<T> {
+    private config;
+    private context;
+    activeAlert$: Observable<ActiveAlert | undefined>;
+    private hasRun$;
+    private data$;
+    constructor(config: AlertConfig<T>, context: AlertContext);
+    get id(): string;
+    runCheck(): void;
+}
+export declare class AlertsService {
+    private permissionsService;
+    private injector;
+    private dataService;
+    private notificationService;
+    private modalService;
+    activeAlerts$: Observable<ActiveAlert[]>;
+    private alertsMap;
+    private configUpdated;
+    constructor(permissionsService: PermissionsService, injector: Injector, dataService: DataService, notificationService: NotificationService, modalService: ModalService);
+    configureAlert<T>(config: AlertConfig<T>): void;
+    hasSufficientPermissions(permissions?: Permission[]): Observable<boolean>;
+    refresh(id?: string): void;
+    protected createContext(): AlertContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlertsService>;
+}

package/core/providers/auth/auth.service.d.ts

@@ -0,0 +1,40 @@
+import { Observable } from 'rxjs';
+import { AttemptLoginMutation } from '../../common/generated-types';
+import { DataService } from '../../data/providers/data.service';
+import { ServerConfigService } from '../../data/server-config';
+import { LocalStorageService } from '../local-storage/local-storage.service';
+import { PermissionsService } from '../permissions/permissions.service';
+import * as i0 from "@angular/core";
+/**
+ * This service handles logic relating to authentication of the current user.
+ */
+export declare class AuthService {
+    private localStorageService;
+    private dataService;
+    private serverConfigService;
+    private permissionsService;
+    constructor(localStorageService: LocalStorageService, dataService: DataService, serverConfigService: ServerConfigService, permissionsService: PermissionsService);
+    /**
+     * Attempts to log in via the REST login endpoint and updates the app
+     * state on success.
+     */
+    logIn(username: string, password: string, rememberMe: boolean): Observable<AttemptLoginMutation['login']>;
+    /**
+     * Update the user status to being logged out.
+     */
+    logOut(): Observable<boolean>;
+    /**
+     * Checks the app state to see if the user is already logged in,
+     * and if not, attempts to validate any auth token found.
+     */
+    checkAuthenticatedStatus(): Observable<boolean>;
+    /**
+     * Checks for an auth token and if found, attempts to validate
+     * that token against the API.
+     */
+    validateAuthToken(): Observable<boolean>;
+    private getActiveChannel;
+    private setChannelToken;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}

package/core/providers/breadcrumb/breadcrumb.service.d.ts

@@ -0,0 +1,39 @@
+import { OnDestroy } from '@angular/core';
+import { ActivatedRoute, Data, Params, Router } from '@angular/router';
+import { Observable } from 'rxjs';
+import { DataService } from '../../data/providers/data.service';
+import * as i0 from "@angular/core";
+export type BreadcrumbString = string;
+export interface BreadcrumbLabelLinkPair {
+    label: string;
+    link: any[];
+}
+export type BreadcrumbValue = BreadcrumbString | BreadcrumbLabelLinkPair | BreadcrumbLabelLinkPair[];
+export type BreadcrumbFunction = (data: Data, params: Params, dataService: DataService) => BreadcrumbValue | Observable<BreadcrumbValue>;
+export type BreadcrumbDefinition = BreadcrumbValue | BreadcrumbFunction | Observable<BreadcrumbValue>;
+export declare class BreadcrumbService implements OnDestroy {
+    private router;
+    private route;
+    private dataService;
+    breadcrumbs$: Observable<Array<{
+        link: string | any[];
+        label: string;
+    }>>;
+    private destroy$;
+    constructor(router: Router, route: ActivatedRoute, dataService: DataService);
+    ngOnDestroy(): void;
+    private generateBreadcrumbs;
+    /**
+     * Walks the route definition tree to assemble an array from which the breadcrumbs can be derived.
+     */
+    private assembleBreadcrumbParts;
+    /**
+     * Accounts for relative routes in the link array, i.e. arrays whose first element is either:
+     * * `./`   - this appends the rest of the link segments to the current active route
+     * * `../`  - this removes the last segment of the current active route, and appends the link segments
+     *            to the parent route.
+     */
+    private normalizeRelativeLinks;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BreadcrumbService>;
+}