@deenruv/admin-ui 1.0.0

package/core/providers/bulk-action-registry/bulk-action-registry.service.d.ts

@@ -0,0 +1,9 @@
+import { BulkAction, BulkActionLocationId } from './bulk-action-types';
+import * as i0 from "@angular/core";
+export declare class BulkActionRegistryService {
+    private locationBulActionMap;
+    registerBulkAction(bulkAction: BulkAction): void;
+    getBulkActionsForLocation(id: BulkActionLocationId): BulkAction[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<BulkActionRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BulkActionRegistryService>;
+}

package/core/providers/bulk-action-registry/bulk-action-types.d.ts

@@ -0,0 +1,149 @@
+import { Injector } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+/**
+ * @description
+ * A valid location of a list view that supports the bulk actions API.
+ *
+ * @since 1.8.0
+ * @docsCategory bulk-actions
+ * @docsPage BulkAction
+ */
+export type BulkActionLocationId = 'product-list' | 'facet-list' | 'collection-list' | 'customer-list' | 'customer-group-list' | 'customer-group-members-list' | 'customer-group-members-picker-list' | 'promotion-list' | 'seller-list' | 'channel-list' | 'administrator-list' | 'role-list' | 'shipping-method-list' | 'stock-location-list' | 'payment-method-list' | 'tax-category-list' | 'tax-rate-list' | 'zone-list' | 'zone-members-list' | string;
+/**
+ * @description
+ * This is the argument which gets passed to the `getTranslationVars` and `isVisible` functions
+ * of the BulkAction definition.
+ *
+ * @since 1.8.0
+ * @docsCategory bulk-actions
+ * @docsPage BulkAction
+ */
+export interface BulkActionFunctionContext<ItemType, ComponentType> {
+    /**
+     * @description
+     * An array of the selected items from the list.
+     */
+    selection: ItemType[];
+    /**
+     * @description
+     * The component instance that is hosting the list view. For instance,
+     * `ProductListComponent`. This can be used to call methods on the instance,
+     * e.g. calling `hostComponent.refresh()` to force a list refresh after
+     * deleting the selected items.
+     */
+    hostComponent: ComponentType;
+    /**
+     * @description
+     * The Angular [Injector](https://angular.io/api/core/Injector) which can be used
+     * to get service instances which might be needed in the click handler.
+     */
+    injector: Injector;
+    route: ActivatedRoute;
+}
+/**
+ * @description
+ * This is the argument which gets passed to the `onClick` function of a BulkAction.
+ *
+ * @since 1.8.0
+ * @docsCategory bulk-actions
+ * @docsPage BulkAction
+ */
+export interface BulkActionClickContext<ItemType, ComponentType> extends BulkActionFunctionContext<ItemType, ComponentType> {
+    /**
+     * @description
+     * Clears the selection in the active list view.
+     */
+    clearSelection: () => void;
+    /**
+     * @description
+     * The click event itself.
+     */
+    event: MouseEvent;
+}
+/**
+ * @description
+ * Configures a bulk action which can be performed on all selected items in a list view.
+ *
+ * For a full example, see the {@link registerBulkAction} docs.
+ *
+ * @since 1.8.0
+ * @docsCategory bulk-actions
+ * @docsPage BulkAction
+ * @docsWeight 0
+ */
+export interface BulkAction<ItemType = any, ComponentType = any> {
+    location: BulkActionLocationId;
+    label: string;
+    /**
+     * @description
+     * An optional function that should resolve to a map of translation variables which can be
+     * used when translating the `label` string.
+     */
+    getTranslationVars?: (context: BulkActionFunctionContext<ItemType, ComponentType>) => Record<string, string | number> | Promise<Record<string, string | number>>;
+    /**
+     * @description
+     * A valid [Clarity Icons](https://core.clarity.design/foundation/icons/shapes/) icon shape, e.g.
+     * "cog", "user", "info-standard".
+     */
+    icon?: string;
+    /**
+     * @description
+     * A class to be added to the icon element. Examples:
+     *
+     * - is-success
+     * - is-danger
+     * - is-warning
+     * - is-info
+     * - is-highlight
+     */
+    iconClass?: string;
+    /**
+     * @description
+     * Defines the logic that executes when the bulk action button is clicked.
+     */
+    onClick: (context: BulkActionClickContext<ItemType, ComponentType>) => void;
+    /**
+     * @description
+     * A function that determines whether this bulk action item should be displayed in the menu.
+     * If not defined, the item will always be displayed.
+     *
+     * This function will be invoked each time the selection is changed, so try to avoid expensive code
+     * running here.
+     *
+     * @example
+     * ```ts
+     * import { registerBulkAction, DataService } from '\@deenruv/admin-ui/core';
+     *
+     * registerBulkAction({
+     *   location: 'product-list',
+     *   label: 'Assign to channel',
+     *   // Only display this action if there are multiple channels
+     *   isVisible: ({ injector }) => injector.get(DataService).client
+     *     .userStatus()
+     *     .mapSingle(({ userStatus }) => 1 < userStatus.channels.length)
+     *     .toPromise(),
+     *   // ...
+     * });
+     * ```
+     */
+    isVisible?: (context: BulkActionFunctionContext<ItemType, ComponentType>) => boolean | Promise<boolean>;
+    /**
+     * @description
+     * Control the display of this item based on the user permissions.
+     *
+     * @example
+     * ```ts
+     * registerBulkAction({
+     *   // Can be specified as a simple string
+     *   requiresPermission: Permission.UpdateProduct,
+     *
+     *   // Or as a function that returns a boolean if permissions are satisfied
+     *   requiresPermission: userPermissions =>
+     *     userPermissions.includes(Permission.UpdateCatalog) ||
+     *     userPermissions.includes(Permission.UpdateProduct),
+     *   // ...
+     * })
+     * ```
+     */
+    requiresPermission?: string | ((userPermissions: string[]) => boolean);
+}

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

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+import { UserStatusFragment } from '../../common/generated-types';
+import { DataService } from '../../data/providers/data.service';
+import { LocalStorageService } from '../local-storage/local-storage.service';
+import { PermissionsService } from '../permissions/permissions.service';
+import * as i0 from "@angular/core";
+export declare class ChannelService {
+    private dataService;
+    private localStorageService;
+    private permissionsService;
+    defaultChannelIsActive$: Observable<boolean>;
+    constructor(dataService: DataService, localStorageService: LocalStorageService, permissionsService: PermissionsService);
+    setActiveChannel(channelId: string): Observable<UserStatusFragment>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChannelService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChannelService>;
+}

package/core/providers/component-registry/component-registry.service.d.ts

@@ -0,0 +1,13 @@
+import { Provider, Type } from '@angular/core';
+import { FormInputComponent } from '../../common/component-registry-types';
+import * as i0 from "@angular/core";
+export declare class ComponentRegistryService {
+    private inputComponentMap;
+    registerInputComponent(id: string, component: Type<FormInputComponent<any>>, providers?: Provider[]): void;
+    getInputComponent(id: string): {
+        type: Type<FormInputComponent<any>>;
+        providers: Provider[];
+    } | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentRegistryService>;
+}

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

@@ -0,0 +1,10 @@
+import { ServerConfigService } from '../../data/server-config';
+import * as i0 from "@angular/core";
+export declare class CurrencyService {
+    readonly precision: number;
+    readonly precisionFactor: number;
+    constructor(serverConfigService: ServerConfigService);
+    toMajorUnits(value: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CurrencyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CurrencyService>;
+}

package/core/providers/custom-detail-component/custom-detail-component-types.d.ts

@@ -0,0 +1,26 @@
+import { Provider, Type } from '@angular/core';
+import { UntypedFormGroup } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { CustomDetailComponentLocationId } from '../../common/component-registry-types';
+/**
+ * @description
+ * CustomDetailComponents allow any arbitrary Angular components to be embedded in entity detail
+ * pages of the Admin UI.
+ *
+ * @docsCategory custom-detail-components
+ */
+export interface CustomDetailComponent {
+    entity$: Observable<any>;
+    detailForm: UntypedFormGroup;
+}
+/**
+ * @description
+ * Configures a {@link CustomDetailComponent} to be placed in the given location.
+ *
+ * @docsCategory custom-detail-components
+ */
+export interface CustomDetailComponentConfig {
+    locationId: CustomDetailComponentLocationId;
+    component: Type<CustomDetailComponent>;
+    providers?: Provider[];
+}

package/core/providers/custom-detail-component/custom-detail-component.service.d.ts

@@ -0,0 +1,9 @@
+import { CustomDetailComponentConfig } from './custom-detail-component-types';
+import * as i0 from "@angular/core";
+export declare class CustomDetailComponentService {
+    private customDetailComponents;
+    registerCustomDetailComponent(config: CustomDetailComponentConfig): void;
+    getCustomDetailComponentsFor(locationId: string): CustomDetailComponentConfig[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomDetailComponentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CustomDetailComponentService>;
+}

package/core/providers/custom-field-component/custom-field-component.service.d.ts

@@ -0,0 +1,25 @@
+import { FormInputComponent } from '../../common/component-registry-types';
+import { CustomFields, CustomFieldsFragment } from '../../common/generated-types';
+import { ComponentRegistryService } from '../component-registry/component-registry.service';
+import * as i0 from "@angular/core";
+export type CustomFieldConfigType = CustomFieldsFragment;
+export interface CustomFieldControl extends FormInputComponent<CustomFieldConfigType> {
+}
+export type CustomFieldEntityName = Exclude<keyof CustomFields, '__typename'>;
+/**
+ * This service allows the registration of custom controls for customFields.
+ *
+ * @deprecated The ComponentRegistryService now handles custom field components directly.
+ */
+export declare class CustomFieldComponentService {
+    private componentRegistryService;
+    constructor(componentRegistryService: ComponentRegistryService);
+    /**
+     * Checks whether a custom component is registered for the given entity custom field,
+     * and if so returns the ID of that component.
+     */
+    customFieldComponentExists(entity: CustomFieldEntityName, fieldName: string): string | undefined;
+    private generateId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomFieldComponentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CustomFieldComponentService>;
+}

package/core/providers/custom-history-entry-component/history-entry-component-types.d.ts

@@ -0,0 +1,81 @@
+import { Type } from '@angular/core';
+import { CustomerFragment, GetOrderHistoryQuery, OrderDetailFragment } from '../../common/generated-types';
+import { TimelineDisplayType } from '../../shared/components/timeline-entry/timeline-entry.component';
+export type TimelineHistoryEntry = NonNullable<GetOrderHistoryQuery['order']>['history']['items'][number];
+/**
+ * @description
+ * This interface should be implemented by components intended to display a history entry in the
+ * Order or Customer history timeline. If the component needs access to the Order or Customer object itself,
+ * you should implement {@link OrderHistoryEntryComponent} or {@link CustomerHistoryEntryComponent} respectively.
+ *
+ * @since 1.9.0
+ * @docsCategory custom-history-entry-components
+ */
+export interface HistoryEntryComponent {
+    /**
+     * @description
+     * The HistoryEntry data.
+     */
+    entry: TimelineHistoryEntry;
+    /**
+     * @description
+     * Defines whether this entry is highlighted with a "success", "error" etc. color.
+     */
+    getDisplayType: (entry: TimelineHistoryEntry) => TimelineDisplayType;
+    /**
+     * @description
+     * Featured entries are always expanded. Non-featured entries start of collapsed and can be clicked
+     * to expand.
+     */
+    isFeatured: (entry: TimelineHistoryEntry) => boolean;
+    /**
+     * @description
+     * Returns the name of the person who did this action. For example, it could be the Customer's name
+     * or "Administrator".
+     */
+    getName?: (entry: TimelineHistoryEntry) => string | undefined;
+    /**
+     * @description
+     * Optional Clarity icon shape to display with the entry. Examples: `'note'`, `['success-standard', 'is-solid']`
+     */
+    getIconShape?: (entry: TimelineHistoryEntry) => string | string[] | undefined;
+}
+/**
+ * @description
+ * Used to implement a {@link HistoryEntryComponent} which requires access to the Order object.
+ *
+ * @since 1.9.0
+ * @docsCategory custom-history-entry-components
+ */
+export interface OrderHistoryEntryComponent extends HistoryEntryComponent {
+    order: OrderDetailFragment;
+}
+/**
+ * @description
+ * Used to implement a {@link HistoryEntryComponent} which requires access to the Customer object.
+ *
+ * @since 1.9.0
+ * @docsCategory custom-history-entry-components
+ */
+export interface CustomerHistoryEntryComponent extends HistoryEntryComponent {
+    customer: CustomerFragment;
+}
+/**
+ * @description
+ * Configuration for registering a custom {@link HistoryEntryComponent}.
+ *
+ * @since 1.9.0
+ * @docsCategory custom-history-entry-components
+ */
+export interface HistoryEntryConfig {
+    /**
+     * @description
+     * The type should correspond to the custom HistoryEntryType string.
+     */
+    type: string;
+    /**
+     * @description
+     * The component to be rendered for this history entry type.
+     */
+    component: Type<HistoryEntryComponent>;
+}

package/core/providers/custom-history-entry-component/history-entry-component.service.d.ts

@@ -0,0 +1,10 @@
+import { Type } from '@angular/core';
+import { HistoryEntryComponent, HistoryEntryConfig } from './history-entry-component-types';
+import * as i0 from "@angular/core";
+export declare class HistoryEntryComponentService {
+    private customEntryComponents;
+    registerComponent(config: HistoryEntryConfig): void;
+    getComponent(type: string): Type<HistoryEntryComponent> | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HistoryEntryComponentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HistoryEntryComponentService>;
+}

package/core/providers/dashboard-widget/dashboard-widget-types.d.ts

@@ -0,0 +1,56 @@
+import { Type } from '@angular/core';
+export type DashboardWidgetWidth = 3 | 4 | 6 | 8 | 12;
+/**
+ * @description
+ * A configuration object for a dashboard widget.
+ *
+ * @docsCategory dashboard-widgets
+ */
+export interface DashboardWidgetConfig {
+    /**
+     * @description
+     * Used to specify the widget component. Supports both eager- and lazy-loading.
+     * @example
+     * ```ts
+     * // eager-loading
+     * loadComponent: () => MyWidgetComponent,
+     *
+     * // lazy-loading
+     * loadComponent: () => import('./path-to/widget.component').then(m => m.MyWidgetComponent),
+     * ```
+     */
+    loadComponent: () => Promise<Type<any>> | Type<any>;
+    /**
+     * @description
+     * The title of the widget. Can be a translation token as it will get passed
+     * through the `translate` pipe.
+     */
+    title?: string;
+    /**
+     * @description
+     * The supported widths of the widget, in terms of a Bootstrap-style 12-column grid.
+     * If omitted, then it is assumed the widget supports all widths.
+     */
+    supportedWidths?: DashboardWidgetWidth[];
+    /**
+     * @description
+     * If set, the widget will only be displayed if the current user has all the
+     * specified permissions.
+     */
+    requiresPermissions?: string[];
+}
+/**
+ * @description
+ * A configuration object for the default dashboard widget layout.
+ *
+ * @docsCategory dashboard-widgets
+ */
+export type WidgetLayoutDefinition = Array<{
+    id: string;
+    width: DashboardWidgetWidth;
+}>;
+export type WidgetLayout = Array<Array<{
+    id: string;
+    config: DashboardWidgetConfig;
+    width: DashboardWidgetWidth;
+}>>;

package/core/providers/dashboard-widget/dashboard-widget.service.d.ts

@@ -0,0 +1,24 @@
+import { Permission } from '../../common/generated-types';
+import { DashboardWidgetConfig, WidgetLayout, WidgetLayoutDefinition } from './dashboard-widget-types';
+import * as i0 from "@angular/core";
+/**
+ * Responsible for registering dashboard widget components and querying for layouts.
+ */
+export declare class DashboardWidgetService {
+    private registry;
+    private layoutDef;
+    registerWidget(id: string, config: DashboardWidgetConfig): void;
+    getAvailableWidgets(currentUserPermissions: Permission[]): Array<{
+        id: string;
+        config: DashboardWidgetConfig;
+    }>;
+    getWidgetById(id: string): DashboardWidgetConfig | undefined;
+    setDefaultLayout(layout: WidgetLayoutDefinition): void;
+    getDefaultLayout(): WidgetLayoutDefinition;
+    getWidgetLayout(layoutDef?: WidgetLayoutDefinition): WidgetLayout;
+    private idNotFound;
+    private getValidWidth;
+    private buildLayout;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardWidgetService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DashboardWidgetService>;
+}

package/core/providers/data-table/data-table-filter-collection.d.ts

@@ -0,0 +1,48 @@
+import { ActivatedRoute, Router } from '@angular/router';
+import { CustomFieldConfig, DateOperators, IdOperators } from '../../common/generated-types';
+import { DataTableFilter, DataTableFilterBooleanType, DataTableFilterCustomType, DataTableFilterDateRangeType, DataTableFilterIDType, DataTableFilterNumberType, DataTableFilterOptions, DataTableFilterSelectType, DataTableFilterTextType, DataTableFilterType, DataTableFilterValue } from './data-table-filter';
+export declare class FilterWithValue<Type extends DataTableFilterType = DataTableFilterType> {
+    readonly filter: DataTableFilter<any, Type>;
+    value: DataTableFilterValue<Type>;
+    private onUpdateFns;
+    constructor(filter: DataTableFilter<any, Type>, value: DataTableFilterValue<Type>, onUpdate?: (value: DataTableFilterValue<Type>) => void);
+    onUpdate(fn: (value: DataTableFilterValue<Type>) => void): void;
+    updateValue(value: DataTableFilterValue<Type>): void;
+    isId(): this is FilterWithValue<DataTableFilterIDType>;
+    isText(): this is FilterWithValue<DataTableFilterTextType>;
+    isNumber(): this is FilterWithValue<DataTableFilterNumberType>;
+    isBoolean(): this is FilterWithValue<DataTableFilterBooleanType>;
+    isSelect(): this is FilterWithValue<DataTableFilterSelectType>;
+    isDateRange(): this is FilterWithValue<DataTableFilterDateRangeType>;
+    isCustom(): this is FilterWithValue<DataTableFilterCustomType>;
+}
+export declare class DataTableFilterCollection<FilterInput extends Record<string, any> = Record<string, any>> {
+    #private;
+    private router;
+    valueChanges: import("rxjs").Observable<FilterWithValue<DataTableFilterType>[]>;
+    private readonly destroy$;
+    constructor(router: Router);
+    get length(): number;
+    get activeFilters(): FilterWithValue[];
+    destroy(): void;
+    addFilter<FilterType extends DataTableFilterType>(config: DataTableFilterOptions<FilterInput, FilterType>): DataTableFilterCollection<FilterInput>;
+    addFilters<FilterType extends DataTableFilterType>(configs: Array<DataTableFilterOptions<FilterInput, FilterType>>): DataTableFilterCollection<FilterInput>;
+    addIdFilter(): FilterInput extends {
+        id?: IdOperators | null;
+    } ? DataTableFilterCollection<FilterInput> : never;
+    addDateFilters(): FilterInput extends {
+        createdAt?: DateOperators | null;
+        updatedAt?: DateOperators | null;
+    } ? DataTableFilterCollection<FilterInput> : never;
+    addCustomFieldFilters(customFields: CustomFieldConfig[]): this;
+    getFilter(name: string): DataTableFilter<FilterInput> | undefined;
+    getFilters(): Array<DataTableFilter<FilterInput>>;
+    removeActiveFilterAtIndex(index: number): void;
+    createFilterInput(): FilterInput;
+    connectToRoute(route: ActivatedRoute): this;
+    serialize(): string;
+    private serializeValue;
+    private deserializeValue;
+    private onActivateFilter;
+    private createFilterWithValue;
+}

package/core/providers/data-table/data-table-filter.d.ts

@@ -0,0 +1,108 @@
+import { Type as ComponentType } from '@angular/core';
+import { LocalizedString } from '@deenruv/common/lib/generated-types';
+import { FormInputComponent } from '../../common/component-registry-types';
+import { BooleanOperators, DateOperators, IdOperators, NumberOperators, StringOperators } from '../../common/generated-types';
+export interface DataTableFilterIDType {
+    kind: 'id';
+}
+export interface DataTableFilterTextType {
+    kind: 'text';
+    placeholder?: string;
+}
+export interface DataTableFilterSelectType {
+    kind: 'select';
+    options: Array<{
+        value: any;
+        label: string;
+    }>;
+}
+export interface DataTableFilterBooleanType {
+    kind: 'boolean';
+}
+export interface DataTableFilterNumberType {
+    kind: 'number';
+    inputType?: 'number' | 'currency';
+}
+export interface DataTableFilterDateRangeType {
+    kind: 'dateRange';
+}
+export interface DataTableFilterCustomType {
+    kind: 'custom';
+    component: ComponentType<FormInputComponent>;
+    serializeValue: (value: any) => string;
+    deserializeValue: (serialized: string) => any;
+    getLabel(value: any): string | Promise<string>;
+}
+export type KindValueMap = {
+    id: {
+        raw: {
+            operator: keyof IdOperators;
+            term: string;
+        };
+        input: IdOperators;
+    };
+    text: {
+        raw: {
+            operator: keyof StringOperators;
+            term: string;
+        };
+        input: StringOperators;
+    };
+    select: {
+        raw: string[];
+        input: StringOperators;
+    };
+    boolean: {
+        raw: boolean;
+        input: BooleanOperators;
+    };
+    dateRange: {
+        raw: {
+            mode: 'relative' | 'range';
+            relativeValue: number;
+            relativeUnit: 'day' | 'month' | 'year';
+            start?: string;
+            end?: string;
+        };
+        input: DateOperators;
+    };
+    number: {
+        raw: {
+            operator: keyof NumberOperators;
+            amount: number;
+        };
+        input: NumberOperators;
+    };
+    custom: {
+        raw: any;
+        input: any;
+    };
+};
+export type DataTableFilterType = DataTableFilterIDType | DataTableFilterTextType | DataTableFilterSelectType | DataTableFilterBooleanType | DataTableFilterDateRangeType | DataTableFilterNumberType | DataTableFilterCustomType;
+export interface DataTableFilterOptions<FilterInput extends Record<string, any> = any, Type extends DataTableFilterType = DataTableFilterType> {
+    readonly name: string;
+    readonly type: Type;
+    readonly label: string | LocalizedString[];
+    readonly filterField?: keyof FilterInput;
+    readonly toFilterInput?: (value: DataTableFilterValue<Type>) => Partial<FilterInput>;
+}
+export type DataTableFilterValue<Type extends DataTableFilterType> = KindValueMap[Type['kind']]['raw'];
+export type DataTableFilterOperator<Type extends DataTableFilterType> = KindValueMap[Type['kind']]['input'];
+export declare class DataTableFilter<FilterInput extends Record<string, any> = any, Type extends DataTableFilterType = DataTableFilterType> {
+    private readonly options;
+    private onActivate?;
+    constructor(options: DataTableFilterOptions<FilterInput, Type>, onActivate?: ((filter: DataTableFilter<FilterInput, Type>, value: DataTableFilterValue<Type> | undefined) => void) | undefined);
+    get name(): string;
+    get type(): Type;
+    get label(): string | LocalizedString[];
+    getFilterOperator(value: any): DataTableFilterOperator<Type>;
+    toFilterInput(value: DataTableFilterValue<Type>): Partial<FilterInput>;
+    activate(value: DataTableFilterValue<Type>): void;
+    isId(): this is DataTableFilter<FilterInput, DataTableFilterIDType>;
+    isText(): this is DataTableFilter<FilterInput, DataTableFilterTextType>;
+    isNumber(): this is DataTableFilter<FilterInput, DataTableFilterNumberType>;
+    isBoolean(): this is DataTableFilter<FilterInput, DataTableFilterBooleanType>;
+    isSelect(): this is DataTableFilter<FilterInput, DataTableFilterSelectType>;
+    isDateRange(): this is DataTableFilter<FilterInput, DataTableFilterDateRangeType>;
+    isCustom(): this is DataTableFilter<FilterInput, DataTableFilterCustomType>;
+}

package/core/providers/data-table/data-table-sort-collection.d.ts

@@ -0,0 +1,24 @@
+import { ActivatedRoute, Router } from '@angular/router';
+import { CustomFieldConfig } from '../../common/generated-types';
+import { DataTableSort, DataTableSortOptions, DataTableSortOrder } from './data-table-sort';
+export declare class DataTableSortCollection<SortInput extends Record<string, 'ASC' | 'DESC'>, Names extends [...Array<keyof SortInput>] = []> {
+    #private;
+    private router;
+    valueChanges: import("rxjs").Observable<{
+        name: string;
+        sortOrder: DataTableSortOrder | undefined;
+    }[]>;
+    private readonly destroy$;
+    constructor(router: Router);
+    get length(): number;
+    destroy(): void;
+    addSort<Name extends keyof SortInput>(config: DataTableSortOptions<SortInput, Name>): DataTableSortCollection<SortInput, [...Names, Name]>;
+    addSorts<Name extends keyof SortInput>(configs: Array<DataTableSortOptions<SortInput, Name>>): DataTableSortCollection<SortInput, [...Names, Name]>;
+    addCustomFieldSorts(customFields: CustomFieldConfig[]): this;
+    defaultSort(name: keyof SortInput, sortOrder: DataTableSortOrder): this;
+    get(name: Names[number]): DataTableSort<SortInput> | undefined;
+    connectToRoute(route: ActivatedRoute): this;
+    createSortInput(): SortInput;
+    private serialize;
+    private onSetValue;
+}

package/core/providers/data-table/data-table-sort.d.ts

@@ -0,0 +1,14 @@
+export type DataTableSortOrder = 'ASC' | 'DESC';
+export interface DataTableSortOptions<SortInput extends Record<string, DataTableSortOrder>, Name extends keyof SortInput> {
+    name: Name;
+}
+export declare class DataTableSort<SortInput extends Record<string, DataTableSortOrder>> {
+    #private;
+    private readonly options;
+    private onSetValue?;
+    constructor(options: DataTableSortOptions<SortInput, any>, onSetValue?: ((name: keyof SortInput, state: DataTableSortOrder | undefined) => void) | undefined);
+    get sortOrder(): DataTableSortOrder | undefined;
+    get name(): keyof SortInput;
+    toggleSortOrder(): void;
+    setSortOrder(sortOrder: DataTableSortOrder | undefined): void;
+}

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

@@ -0,0 +1,17 @@
+import { ActivatedRouteSnapshot, Router } from '@angular/router';
+import { Observable } from 'rxjs';
+import { AuthService } from '../auth/auth.service';
+import * as i0 from "@angular/core";
+/**
+ * This guard prevents unauthorized users from accessing any routes which require
+ * authorization.
+ */
+export declare class AuthGuard {
+    private router;
+    private authService;
+    private readonly externalLoginUrl;
+    constructor(router: Router, authService: AuthService);
+    canActivate(route: ActivatedRouteSnapshot): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthGuard>;
+}