@elderbyte/ngx-starter 19.19.0 → 20.0.0-beta.1

package/lib/common/templates/template-slot-manager.d.ts

@@ -1,70 +0,0 @@
-import { TemplateRef } from '@angular/core';
-import { Observable } from 'rxjs';
-/**
- * Manages templates for different slots.
- * Supports global fallback templates for slots (default templates)
- */
-export declare class TemplateSlotManager<TSlot> {
-    /***************************************************************************
-     *                                                                         *
-     * Fields                                                                  *
-     *                                                                         *
-     **************************************************************************/
-    private readonly logger;
-    /** Default templates (App Level) */
-    private readonly _defaultSlotTemplates;
-    /** Custom templates (Component Level) */
-    private readonly _slotTemplates;
-    private readonly _activeSlotTemplates;
-    /**
-     * Key: A synonym slot name
-     * Value: The primary slot the synonym is resolving to
-     */
-    private readonly _slotSynonyms;
-    /***************************************************************************
-     *                                                                         *
-     * Constructors                                                            *
-     *                                                                         *
-     **************************************************************************/
-    /**
-     * Create a new Template Slot Manager.
-     * @param slotDefinitions Slot definitions, supporting synonyms
-     */
-    constructor(slotDefinitions: Array<TSlot | TSlot[]>);
-    /***************************************************************************
-     *                                                                         *
-     * Public API                                                              *
-     *                                                                         *
-     **************************************************************************/
-    /**
-     * Returns an observable which emits the current active template for the given slot
-     * over time.
-     */
-    activeSlotTemplate(slot: TSlot): Observable<TemplateRef<any>>;
-    /**
-     * Registers the given template for the given slot.
-     *
-     * @param slot at which template should be placed
-     * @param template to set at slot
-     * @param isDefault if the given template should be used as global default
-     */
-    registerSlotTemplate(slot: TSlot, template: TemplateRef<any>, isDefault?: boolean): void;
-    /**
-     * Deregister the given template from the toolbar.
-     *
-     * @param template to deregister
-     * @param slot if set, the template will only be deregistered if it was registered at this slot (optional)
-     */
-    deregisterSlotTemplate(template: TemplateRef<any>, slot?: TSlot): void;
-    /***************************************************************************
-     *                                                                         *
-     * Private methods                                                         *
-     *                                                                         *
-     **************************************************************************/
-    private initSlot;
-    private registerSlotSynonyms;
-    private resolveSlot;
-    private removeSlotTemplate;
-    private updateActiveSlotTemplate;
-    private findActiveTemplate;
-}

package/lib/common/theme-sizes.d.ts

@@ -1,4 +0,0 @@
-/**
- * Defined in _elder-scss-variables.scss
- */
-export type ElderSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';

package/lib/common/time/date-util.d.ts

@@ -1,54 +0,0 @@
-/**
- * Represents an ISO-8601 date string.
- * https://en.wikipedia.org/wiki/ISO_8601#Dates
- */
-import { Instant } from '@js-joda/core';
-export type IsoDateStr = string;
-export declare class DateUtil {
-    static readonly IsoDateDelimiter = "-";
-    static readonly IsoTimeDelimiter = ":";
-    static readonly DateTimeSeparator = "T";
-    /***************************************************************************
-     *                                                                         *
-     * Public API                                                              *
-     *                                                                         *
-     **************************************************************************/
-    static instantToDate(instant: Instant): Date;
-    /**
-     * Returns the given Date as ISO formatted local date string.
-     *
-     * YYYY-MM-DD
-     *
-     * @param date
-     */
-    static toLocalDateIso(date: Date): string;
-    /**
-     * Returns the given Date as ISO formatted local date-time string.
-     *
-     * YYYY-MM-DDTHH:mm:ss.sss
-     *
-     * @param date
-     */
-    static toLocalDateTimeIso(date: Date): string;
-    /**
-     * Checks if the given DateTime is represents the start of the day.
-     *
-     * @param dateTime DateTime to check
-     */
-    static isStartOfDay(date: Date): boolean;
-    /**
-     * Sets the given Date to the start of its day by setting its time to 0.
-     *
-     * @param localDate Date to set to start of day
-     */
-    static startOfDay(localDate: Date): Date;
-    static plusDays(date: Date, days: number): Date;
-    /***************************************************************************
-     *                                                                         *
-     * private Methods                                                         *
-     *                                                                         *
-     **************************************************************************/
-    private static dateString;
-    private static timeString;
-    private static format;
-}

package/lib/common/time/interval-coerce.d.ts

@@ -1,3 +0,0 @@
-import { Interval, IsoIntervalStr } from './interval';
-export declare function coerceInterval(value: Interval | IsoIntervalStr | undefined | null): Interval;
-export declare function coerceIntervalIsoStr(value: Interval | IsoIntervalStr | undefined | null): IsoIntervalStr;

package/lib/common/time/interval.d.ts

@@ -1,288 +0,0 @@
-import { Duration, Instant, LocalDate, TemporalAmount, ZoneId } from '@js-joda/core';
-import { PeriodDuration } from './period-duration';
-/**
- * Represents an ISO-8601 interval string.
- * https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
- */
-export type IsoIntervalStr = string;
-export declare class Interval {
-    readonly start: Instant;
-    readonly end: Instant;
-    private readonly log;
-    /***************************************************************************
-     *                                                                         *
-     * Constructor                                                             *
-     *                                                                         *
-     **************************************************************************/
-    constructor(start: Instant, end: Instant);
-    /***************************************************************************
-     *                                                                         *
-     * Static Builders                                                         *
-     *                                                                         *
-     **************************************************************************/
-    /**
-     * Parses an ISO-8601 interval string.
-     * https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
-     * @param iso
-     */
-    static parse(iso: IsoIntervalStr): Interval;
-    static yesterday(zoneId: ZoneId): Interval;
-    static tomorrow(zoneId: ZoneId): Interval;
-    static today(zoneId: ZoneId): Interval;
-    /**
-     * Creates a Interval from a Date by spreading it to the begin and end of its day.
-     * @param date Date to spread
-     */
-    static ofDayDate(date: Date): Interval;
-    static ofDay(day: LocalDate, zoneId: ZoneId): Interval;
-    static betweenDays(startDayInclusive: LocalDate, endDayExclusive: LocalDate, zoneId: ZoneId): Interval;
-    /**
-     * Creates a new interval with the given start time point
-     * and a offset from the start.
-     *
-     * Note that you should use Period for days to account for zone specific
-     * things like daylight saving.
-     *
-     * @param startInclusive
-     * @param offsetExclusive A Period or Duration offset.
-     */
-    static ofStartAndOffset(startInclusive: Instant, offsetExclusive: TemporalAmount): Interval;
-    static of(startInclusive: Instant, endExclusive: Instant): Interval;
-    static ofDate(startInclusive: Date | string, endExclusive: Date | string): Interval;
-    /***************************************************************************
-     *                                                                         *
-     * Properties                                                              *
-     *                                                                         *
-     **************************************************************************/
-    /**
-     * Checks if the range is empty.
-     * <p>
-     * An empty range occurs when the start date equals the inclusive end date.
-     *
-     * @return true if the range is empty
-     */
-    isEmpty(): boolean;
-    /**
-     * Checks if the start of the interval is unbounded.
-     *
-     * @return true if start is unbounded
-     */
-    isUnboundedStart(): boolean;
-    /**
-     * Checks if the end of the interval is unbounded.
-     *
-     * @return true if end is unbounded
-     */
-    isUnboundedEnd(): boolean;
-    /***************************************************************************
-     *                                                                         *
-     * Public API                                                              *
-     *                                                                         *
-     **************************************************************************/
-    toDuration(): Duration;
-    toPeriodDuration(zone: ZoneId): PeriodDuration;
-    toString(): IsoIntervalStr;
-    toInstantString(): IsoIntervalStr;
-    toDurationString(): IsoIntervalStr;
-    /***************************************************************************
-     *                                                                         *
-     * Public Modification API                                                 *
-     *                                                                         *
-     **************************************************************************/
-    /**
-     * Returns a copy of this range with the specified start instant.
-     *
-     * @param start  the start instant for the new interval, not null
-     * @return an interval with the end from this interval and the specified start
-     * @throws DateTimeException if the resulting interval has end before start
-     */
-    withStart(start: Instant): Interval;
-    /**
-     * Returns a copy of this range with the specified end instant.
-     *
-     * @param end  the end instant for the new interval, not null
-     * @return an interval with the start from this interval and the specified end
-     * @throws DateTimeException if the resulting interval has end before start
-     */
-    withEnd(end: Instant): Interval;
-    /**
-     * Calculates the interval that is the intersection of this interval and the specified interval.
-     * <p>
-     * This finds the intersection of two intervals.
-     * This throws an exception if the two intervals are not {@linkplain #isConnected(Interval) connected}.
-     *
-     * @param other  the other interval to check for, not null
-     * @return the interval that is the intersection of the two intervals
-     * @throws DateTimeException if the intervals do not connect
-     */
-    intersection(other: Interval): Interval;
-    /**
-     * Calculates the interval that is the union of this interval and the specified interval.
-     * <p>
-     * This finds the union of two intervals.
-     * This throws an exception if the two intervals are not {@linkplain #isConnected(Interval) connected}.
-     *
-     * @param other  the other interval to check for, not null
-     * @return the interval that is the union of the two intervals
-     * @throws DateTimeException if the intervals do not connect
-     */
-    union(other: Interval): Interval;
-    /**
-     * Calculates the smallest interval that encloses this interval and the specified interval.
-     * <p>
-     * The result of this method will {@linkplain #encloses(Interval) enclose}
-     * this interval and the specified interval.
-     *
-     * @param other  the other interval to check for, not null
-     * @return the interval that spans the two intervals
-     */
-    span(other: Interval): Interval;
-    /**
-     * Shift the whole interval by the given days period.
-     * @param days
-     */
-    shiftDays(days: number): Interval;
-    /**
-     * Shift the whole interval by the given temporal amount.
-     * Note that only Period will account for zone specific things such as daylight savings.
-     * Use Duration only if you are below days.
-     * @param offset
-     */
-    shift(offset: TemporalAmount): Interval;
-    moveStart(offset: TemporalAmount): Interval;
-    moveEnd(offset: TemporalAmount): Interval;
-    /***************************************************************************
-     *                                                                         *
-     * Interval Query API                                                      *
-     *                                                                         *
-     **************************************************************************/
-    /**
-     * Checks if the given TimeFrame overlaps with this one.
-     *
-     * @param other TimeFrame to check against
-     * @return Returns {@code true} if the two candidates overlap, false otherwise
-     */
-    overlaps(other: Interval): boolean;
-    /**
-     * Checks it the given localDate overlaps with the given TimeFrame.
-     *
-     * @param timeFrame TimeFrame to check against
-     * @param localDate LocalDate to check
-     */
-    overlapsWithLocalDate(localDate: Date): boolean;
-    /**
-     * Checks if this interval contains the specified instant.
-     * <p>
-     * This checks if the specified instant is within the bounds of this interval.
-     * If this range has an unbounded start then {@code contains(Instant#MIN)} returns true.
-     * If this range has an unbounded end then {@code contains(Instant#MAX)} returns true.
-     * If this range is empty then this method always returns false.
-     *
-     * @param instant  the instant, not null
-     * @return true if this interval contains the instant
-     */
-    contains(instant: Instant): boolean;
-    /**
-     * Checks if this interval encloses the specified interval.
-     * <p>
-     * This checks if the bounds of the specified interval are within the bounds of this interval.
-     * An empty interval encloses itself.
-     *
-     * @param other  the other interval, not null
-     * @return true if this interval contains the other interval
-     */
-    encloses(other: Interval): boolean;
-    /**
-     * Checks if this interval abuts (is next to or has a common boundary with) the specified interval.
-     * <p>
-     * The result is true if the end of this interval is the start of the other, or vice versa.
-     * An empty interval does not abut itself.
-     *
-     * @param other  the other interval, not null
-     * @return true if this interval abuts the other interval
-     */
-    abuts(other: Interval): boolean;
-    /**
-     * Checks if this interval is connected to the specified interval.
-     * <p>
-     * The result is true if the two intervals have an enclosed interval in common, even if that interval is empty.
-     * An empty interval is connected to itself.
-     * <p>
-     * This is equivalent to {@code (overlaps(other) || abuts(other))}.
-     *
-     * @param other  the other interval, not null
-     * @return true if this interval is connected to the other interval
-     */
-    isConnected(other: Interval): boolean;
-    /**
-     * Checks if this interval is after the specified instant.
-     * <p>
-     * The result is true if this instant starts after the specified instant.
-     * An empty interval behaves as though it is an instant for comparison purposes.
-     *
-     * @param instant  the other instant to compare to, not null
-     * @return true if the start of this interval is after the specified instant
-     */
-    isAfterInstant(instant: Instant): boolean;
-    /**
-     * Checks if this interval is before the specified instant.
-     * <p>
-     * The result is true if this instant ends before the specified instant.
-     * Since intervals do not include their end points, this will return true if the
-     * instant equals the end of the interval.
-     * An empty interval behaves as though it is an instant for comparison purposes.
-     *
-     * @param instant  the other instant to compare to, not null
-     * @return true if the start of this interval is before the specified instant
-     */
-    isBeforeInstant(instant: Instant): boolean;
-    /**
-     * Checks if this interval is after the specified interval.
-     * <p>
-     * The result is true if this instant starts after the end of the specified interval.
-     * Since intervals do not include their end points, this will return true if the
-     * instant equals the end of the interval.
-     * An empty interval behaves as though it is an instant for comparison purposes.
-     *
-     * @param interval  the other interval to compare to, not null
-     * @return true if this instant is after the specified instant
-     */
-    isAfter(interval: Interval): boolean;
-    /**
-     * Checks if this interval is before the specified interval.
-     * <p>
-     * The result is true if this instant ends before the start of the specified interval.
-     * Since intervals do not include their end points, this will return true if the
-     * two intervals abut.
-     * An empty interval behaves as though it is an instant for comparison purposes.
-     *
-     * @param interval  the other interval to compare to, not null
-     * @return true if this instant is before the specified instant
-     */
-    isBefore(interval: Interval): boolean;
-    /***************************************************************************
-     *                                                                         *
-     * Equality & Hashcode                                                     *
-     *                                                                         *
-     **************************************************************************/
-    /**
-     * Checks if this interval is equal to another interval.
-     * <p>
-     * Compares this {@code Interval} with another ensuring that the two instants are the same.
-     * Only objects of type {@code Interval} are compared, other types return false.
-     *
-     * @param obj  the object to check, null returns false
-     * @return true if this is equal to the other interval
-     */
-    equals(obj: any): boolean;
-    /**
-     * Compares this Interval to the given Interval.
-     * <p>
-     * The comparison is based on the time-line position of the lower bound instants (Interval start).
-     *
-     * @param other the other Interval to compare to, not null
-     * @return the comparator value, negative if less, positive if greater
-     * @throws NullPointerException if other is null
-     */
-    compareTo(other: Interval): number;
-}

package/lib/common/time/period-duration.d.ts

@@ -1,85 +0,0 @@
-import { Duration, Period, Temporal } from '@js-joda/core';
-export declare class PeriodDuration {
-    /***************************************************************************
-     *                                                                         *
-     * Fields                                                                  *
-     *                                                                         *
-     **************************************************************************/
-    readonly period: Period;
-    readonly duration: Duration;
-    /***************************************************************************
-     *                                                                         *
-     * Constructor                                                             *
-     *                                                                         *
-     **************************************************************************/
-    private constructor();
-    /***************************************************************************
-     *                                                                         *
-     * Static Builder                                                          *
-     *                                                                         *
-     **************************************************************************/
-    /**
-     * Obtains an instance from a text string such as {@code PnYnMnDTnHnMnS}.
-     * <p>
-     * This will parse the string produced by {@code toString()} which is
-     * based on the ISO-8601 period formats {@code PnYnMnDTnHnMnS} and {@code PnW}.
-     * <p>
-     * The string starts with an optional sign, denoted by the ASCII negative
-     * or positive symbol. If negative, the whole amount is negated.
-     * The ASCII letter "P" is next in upper or lower case.
-     * There are then a number of sections, each consisting of a number and a suffix.
-     * At least one of the sections must be present.
-     * The sections have suffixes in ASCII of "Y" for years, "M" for months,
-     * "W" for weeks, "D" for days, "H" for hours, "M" for minutes, "S" for seconds,
-     * accepted in upper or lower case. Note that the ASCII letter "T" separates
-     * the date and time parts and must be present if any time part is present.
-     * The suffixes must occur in order.
-     * The number part of each section must consist of ASCII digits.
-     * The number may be prefixed by the ASCII negative or positive symbol.
-     * The number must parse to an {@code int}.
-     * Any week-based input is multiplied by 7 and treated as a number of days.
-     * <p>
-     * The leading plus/minus sign, and negative values for weeks and days are
-     * not part of the ISO-8601 standard.
-     * <p>
-     * Note that the date style format {@code PYYYY-MM-DDTHH:MM:SS} is not supported.
-     * <p>
-     * For example, the following are valid inputs:
-     * <pre>
-     *   "P2Y"             -- PeriodDuration.of(Period.ofYears(2))
-     *   "P3M"             -- PeriodDuration.of(Period.ofMonths(3))
-     *   "P4W"             -- PeriodDuration.of(Period.ofWeeks(4))
-     *   "P5D"             -- PeriodDuration.of(Period.ofDays(5))
-     *   "PT6H"            -- PeriodDuration.of(Duration.ofHours(6))
-     *   "P1Y2M3D"         -- PeriodDuration.of(Period.of(1, 2, 3))
-     *   "P1Y2M3W4DT8H"    -- PeriodDuration.of(Period.of(1, 2, 25), Duration.ofHours(8))
-     *   "P-1Y2M"          -- PeriodDuration.of(Period.of(-1, 2, 0))
-     *   "-P1Y2M"          -- PeriodDuration.of(Period.of(-1, -2, 0))
-     * </pre>
-     *
-     * @param text  the text to parse, not null
-     * @return the parsed period, not null
-     * @throws DateTimeParseException if the text cannot be parsed to a period
-     */
-    static parse(text: string): PeriodDuration;
-    /**
-     * Obtains an instance consisting of the amount of time between two temporals.
-     * <p>
-     * The start is included, but the end is not.
-     * The result of this method can be negative if the end is before the start.
-     * <p>
-     * The calculation examines the temporals and extracts {@link LocalDate} and {@link LocalTime}.
-     * If the time is missing, it will be defaulted to midnight.
-     * If one date is missing, it will be defaulted to the other date.
-     * It then finds the amount of time between the two dates and between the two times.
-     *
-     * @param startInclusive  the start, inclusive, not null
-     * @param endExclusive  the end, exclusive, not null
-     * @return the number of days between this date and the end date, not null
-     */
-    static between(startInclusive: Temporal, endExclusive: Temporal): PeriodDuration;
-    static ofPeriod(period: Period): PeriodDuration;
-    static ofDuration(duration: Duration): PeriodDuration;
-    static of(period: Period, duration: Duration): PeriodDuration;
-    static zero(): PeriodDuration;
-}

package/lib/common/time/public_api.d.ts

@@ -1,7 +0,0 @@
-export * from './period-duration';
-export * from './interval';
-export * from './interval-coerce';
-export * from './time-util';
-export * from './date-util';
-export * from './temporal-util';
-export * from './temporal-plain-date-interval';

package/lib/common/time/temporal-plain-date-interval.d.ts

@@ -1,15 +0,0 @@
-import { Temporal } from '@js-temporal/polyfill';
-export declare class TemporalPlainDateInterval {
-    start: Temporal.PlainDate;
-    end: Temporal.PlainDate;
-    constructor(start: Temporal.PlainDate, end: Temporal.PlainDate);
-    shiftDays(days: number): TemporalPlainDateInterval;
-    shiftMonths(months: number): TemporalPlainDateInterval;
-    shiftYears(years: number): TemporalPlainDateInterval;
-    toString(): string;
-    getDuration(): Temporal.Duration;
-    getDurationInDays(): number;
-    getDurationInWeeks(): number;
-    getDurationInMonths(): number;
-    getDurationInYears(): number;
-}

package/lib/common/time/temporal-util.d.ts

@@ -1,38 +0,0 @@
-import { Temporal } from '@js-temporal/polyfill';
-import { TemporalPlainDateInterval } from './temporal-plain-date-interval';
-export declare class TemporalUtil {
-    static equalPlainDates(a: Temporal.PlainDate | undefined, b: Temporal.PlainDate | undefined): boolean;
-    static equalPlainTimes(a: Temporal.PlainTime | undefined, b: Temporal.PlainTime | undefined): boolean;
-    static getJSDateFromPlainDateTime(date: Temporal.PlainDate | Temporal.PlainDateTime): Date;
-    static getPlainDateTimeFromJSDate(date: Date): Temporal.PlainDateTime;
-    static getPlainDateTimeFromPlainDateAndPlainTime(date: Temporal.PlainDate, time: Temporal.PlainTime): Temporal.PlainDateTime;
-    static isFirstDayOfWeek(date: Temporal.PlainDate | Temporal.PlainDateTime): boolean;
-    static getPlainDateFromJSDate(date: Date): Temporal.PlainDate;
-    static getPlainTimeFromJSDate(date: Date): Temporal.PlainTime;
-    static getPlainDateTimeFromString(dateString: string): Temporal.PlainDateTime;
-    static getHtmlTimeStringFromPlainTime(time: Temporal.PlainTime | Temporal.PlainDateTime): string;
-    static getQuarterForDate(date?: Temporal.PlainDate): number;
-    static getCurrentDay(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getYesterday(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getLastSevenDays(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getLastSevenDaysIncludingToday(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getLastThirtyDays(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getLastThirtyDaysIncludingToday(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getCurrentWeek(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getCurrentMonth(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getCurrentQuarter(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getPreviousQuarter(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getCurrentYear(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getPreviousYear(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getNextYear(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getLast365Days(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getLast90Days(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getPreviousMonth(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getNextMonth(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getPreviousWeek(referenceDate?: Temporal.PlainDate): TemporalPlainDateInterval;
-    static getDateTodayLocalized(): Temporal.PlainDate;
-    static createTemporalLocalizedDateFromTimestamp(timestamp: number): Temporal.PlainDate;
-    static getHtmlDateString(date: Temporal.PlainDate | Temporal.PlainDateTime): string;
-    static getPlainDateFromHtmlDateString(dateString: string): Temporal.PlainDate;
-    static getPlainTimeFromHtmlTimeString(timeString: string): Temporal.PlainTime;
-}

package/lib/common/time/time-util.d.ts

@@ -1,15 +0,0 @@
-import { Duration, Instant, LocalDate, TemporalAccessor, ZonedDateTime, ZoneId } from '@js-joda/core';
-export declare class TimeUtil {
-    static readonly SECONDS_PER_DAY = 86400;
-    /**
-     * Returns an instant for a javascript date / iso date string.
-     * @param date
-     */
-    static instant(date: Date | string): Instant;
-    static dateToLocalDate(date: Date): LocalDate;
-    static temporalAccessor(date: Date): TemporalAccessor;
-    static date(instant: Instant): Date;
-    static localDateToDate(localDate: LocalDate, zone?: ZoneId): Date;
-    static isFullDays(duration: Duration): boolean;
-    static isStartOfDay(date: ZonedDateTime): boolean;
-}

package/lib/common/url/elder-router.service.d.ts

@@ -1,36 +0,0 @@
-import { Router, UrlTree } from '@angular/router';
-import { Location } from '@angular/common';
-import * as i0 from "@angular/core";
-/**
- * Provides advanced router navigation support for Angular.
- *
- * Provides the ability to build external & absolute urls which
- * can be used in iframes or external navigation, such as opening
- * new tabs.
- *
- */
-export declare class ElderRouterService {
-    private router;
-    private location;
-    /***************************************************************************
-     *                                                                         *
-     * Constructor                                                             *
-     *                                                                         *
-     **************************************************************************/
-    constructor(router: Router, location: Location);
-    /***************************************************************************
-     *                                                                         *
-     * Public API                                                              *
-     *                                                                         *
-     **************************************************************************/
-    /**
-     * Open the given url in a new window / tab.
-     * @param urlTree
-     * @param target
-     */
-    openUrl(urlTree: UrlTree, target?: string): void;
-    serializeUrlAbsolute(urlTree: UrlTree): string;
-    serializeUrlExternal(urlTree: UrlTree): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ElderRouterService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ElderRouterService>;
-}