@byuhbll/components 6.0.0-rc.0 → 6.0.0-rc.2

package/index.d.ts

@@ -1,5 +1,640 @@
+import * as rxjs from 'rxjs';
+import { Subject } from 'rxjs';
+import * as i0 from '@angular/core';
+import { AfterViewInit, ElementRef, EventEmitter, PipeTransform, OnInit, OnDestroy, Signal, OnChanges, SimpleChanges, ApplicationRef, EnvironmentInjector } from '@angular/core';
+import * as _angular_forms from '@angular/forms';
+import { JwtPayload } from 'jwt-decode';
+
+interface LibraryHours {
+    date: string;
+    is_closed: boolean;
+    open_time: string;
+    close_time: string;
+    has_exception: boolean;
+    exception_title: string;
+    exception_message: string;
+    is_currently_open: boolean;
+}
+
+declare const LIBRARY_HOURS_API_URL = "https://apps.lib.byu.edu/libraryhours/api/hours";
+declare class HbllHeaderComponent implements AfterViewInit {
+    private readonly r2;
+    private readonly http;
+    private readonly bo;
+    private doc;
+    header: ElementRef;
+    navWrapper: ElementRef<HTMLElement>;
+    backdrop: ElementRef<HTMLElement>;
+    name: string;
+    mainsitebaseurl: string;
+    showImpersonateButton: i0.InputSignal<boolean>;
+    openImpersonationModal: EventEmitter<void>;
+    login: EventEmitter<void>;
+    logout: EventEmitter<void>;
+    private formatDateForHours;
+    private accountInfoEl;
+    private hoursEl;
+    protected get isLoggedIn(): boolean;
+    protected libraryHours: i0.Signal<LibraryHours | undefined>;
+    protected hoursExceptions$: rxjs.Observable<LibraryHours[]>;
+    protected showAccountDropdown: boolean;
+    protected showLibraryHours: boolean;
+    protected mobileSidebarHeight: number;
+    protected showNavBar: boolean;
+    protected isScreenSmall: i0.Signal<boolean | undefined>;
+    ngAfterViewInit(): void;
+    protected openSidebarNav: () => void;
+    protected closeSidebarNav: () => void;
+    private onResize;
+    private setMobileSidebarHeight;
+    focusMainContent(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HbllHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HbllHeaderComponent, "lib-hbll-header", never, { "name": { "alias": "name"; "required": false; }; "mainsitebaseurl": { "alias": "mainsitebaseurl"; "required": false; }; "showImpersonateButton": { "alias": "showImpersonateButton"; "required": false; "isSignal": true; }; }, { "openImpersonationModal": "openImpersonationModal"; "login": "login"; "logout": "logout"; }, never, never, true, never>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * Converts an item type to an icon type to be used with Google Material Icons
+ *
+ * Intended to be used with an imported font, such as: `<link
+            rel="stylesheet"
+            href="https://fonts.googleapis.com/css2?family=Material+Symbols+Outlined:opsz,wght,FILL,GRAD@24,400,1,0"
+        />`
+ *
+ * Reference: https://fonts.google.com/icons?selected=Material+Symbols+Outlined:inventory_2:FILL@0;wght@400;GRAD@0;opsz@24&icon.query=invent&icon.size=24&icon.color=%235f6368
  */
-/// <amd-module name="@byuhbll/components" />
-export * from './public-api';
+declare class HbllItemTypeIconPipe implements PipeTransform {
+    transform(itemType: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HbllItemTypeIconPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<HbllItemTypeIconPipe, "libByuItemTypeIcon", true>;
+}
+
+declare const USER_STATUSES: readonly ["", "Undergraduate", "Graduate", "Faculty", "Staff", "Library Employee", "Other"];
+type UserStatus = (typeof USER_STATUSES)[number];
+interface ContactPayload {
+    email?: string;
+    message: string;
+    name?: string;
+    status?: UserStatus;
+}
+declare const getUserStatusFromRoles: (roles: string[]) => UserStatus;
+
+declare class HbllFooterComponent {
+    private readonly fb;
+    private readonly http;
+    private readonly footerSkipTargetId;
+    private emailDialog;
+    mainsitebaseurl: string;
+    myaccountapibaseuri: string;
+    byuid: string;
+    set emailname(name: string);
+    set emailemail(email: string);
+    set emailmessage(message: string);
+    set emailstatus(status: ContactPayload['status']);
+    protected date: Date;
+    protected isSubmitted: boolean;
+    protected isLoading: boolean;
+    protected hasConnectionError: boolean;
+    protected isEmailSent: boolean;
+    protected emailForm: _angular_forms.FormGroup<{
+        name: _angular_forms.FormControl<string>;
+        email: _angular_forms.FormControl<string>;
+        message: _angular_forms.FormControl<string>;
+        status: _angular_forms.FormControl<"" | "Other" | "Undergraduate" | "Graduate" | "Faculty" | "Staff" | "Library Employee" | undefined>;
+    }>;
+    protected userStatuses: readonly ["", "Undergraduate", "Graduate", "Faculty", "Staff", "Library Employee", "Other"];
+    protected sendEmail: () => void;
+    protected handleClose: () => void;
+    openEmailForm: (formValues?: Partial<ContactPayload>) => void;
+    skipFooter(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HbllFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HbllFooterComponent, "lib-hbll-footer", never, { "mainsitebaseurl": { "alias": "mainsitebaseurl"; "required": false; }; "myaccountapibaseuri": { "alias": "myaccountapibaseuri"; "required": false; }; "byuid": { "alias": "byuid"; "required": false; }; "emailname": { "alias": "emailname"; "required": false; }; "emailemail": { "alias": "emailemail"; "required": false; }; "emailmessage": { "alias": "emailmessage"; "required": false; }; "emailstatus": { "alias": "emailstatus"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface TokenPayload {
+    token: string;
+}
+
+declare class HeaderWithImpersonationComponent implements OnInit, OnDestroy {
+    accessTokenPayload: i0.InputSignal<TokenPayload>;
+    oidcBaseUri: i0.InputSignal<string>;
+    oidcDefaultIdp: i0.InputSignal<string>;
+    mainSiteBaseUrl: i0.InputSignal<string>;
+    personBaseUri: i0.InputSignal<string>;
+    myAccountApiBaseUri: i0.InputSignal<string>;
+    login: EventEmitter<void>;
+    logout: EventEmitter<void>;
+    endImpersonation: EventEmitter<void>;
+    protected parsedToken: Signal<(JwtPayload & Record<string, any>) | null>;
+    protected name: Signal<any>;
+    protected showImpersonateButton: Signal<boolean>;
+    protected showImpersonationModal: boolean;
+    private isImpersonating;
+    private activityEvents;
+    private inactivityTimerId;
+    private inactivityTimeoutMs;
+    private debounceTimerId;
+    private debounceDelayMs;
+    private trackingActive;
+    private injector;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Begin listening and start countdown */
+    private startInactivityTracking;
+    /** Remove listeners and clear timers */
+    private stopInactivityTracking;
+    /** Reset the inactivity countdown (no-op if not impersonating) */
+    private resetInactivityTimer;
+    /** Debounce activity to avoid hammering resets during event storms */
+    private debouncedResetTimer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderWithImpersonationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderWithImpersonationComponent, "lib-header-with-impersonation", never, { "accessTokenPayload": { "alias": "accessTokenPayload"; "required": true; "isSignal": true; }; "oidcBaseUri": { "alias": "oidcBaseUri"; "required": false; "isSignal": true; }; "oidcDefaultIdp": { "alias": "oidcDefaultIdp"; "required": false; "isSignal": true; }; "mainSiteBaseUrl": { "alias": "mainSiteBaseUrl"; "required": false; "isSignal": true; }; "personBaseUri": { "alias": "personBaseUri"; "required": false; "isSignal": true; }; "myAccountApiBaseUri": { "alias": "myAccountApiBaseUri"; "required": false; "isSignal": true; }; }, { "login": "login"; "logout": "logout"; "endImpersonation": "endImpersonation"; }, never, never, true, never>;
+}
+
+declare const defaultOidcBaseUri = "https://keycloak.lib.byu.edu/";
+declare const defaultOidcDefaultIdp = "byu-realm";
+declare class ImpersonateUserPipe implements PipeTransform {
+    transform(user: ImpersonateSearchResult): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImpersonateUserPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ImpersonateUserPipe, "impersonateUser", true>;
+}
+interface ImpersonateSearchResult {
+    netId: string;
+    institution: string;
+    username: string;
+    name: string;
+    preferredName: string;
+    givenName: string;
+    surname: string;
+    restricted: boolean;
+}
+declare class ImpersonateModalComponent implements OnDestroy {
+    private readonly http;
+    private readonly fb;
+    private readonly eref;
+    set showModal(open: boolean);
+    oidcBaseUri: i0.InputSignal<string>;
+    oidcDefaultIdp: i0.InputSignal<string>;
+    accessTokenPayload: i0.InputSignal<TokenPayload>;
+    dismiss: EventEmitter<void>;
+    init: EventEmitter<void>;
+    protected isOpen: boolean;
+    protected hasError: boolean;
+    protected form: _angular_forms.FormGroup<{
+        search: _angular_forms.FormControl<string | null>;
+    }>;
+    protected selectedUsername?: string;
+    protected loading: boolean;
+    protected handleSearchSubject: Subject<boolean>;
+    protected results: i0.Signal<ImpersonateSearchResult[] | null | undefined>;
+    private subs;
+    outsideClick(event: MouseEvent): void;
+    handleKeyDown: (event: KeyboardEvent) => void;
+    ngOnDestroy(): void;
+    /** Redirect to Keycloak impersonate page, which will redirect back
+     * after impersonation begins.
+     */
+    protected startImpersonation: (username?: string) => void;
+    protected handleSelectUser: (event: Event) => void;
+    protected clearSearch: () => void;
+    protected close: () => void;
+    protected handleFormSubmit: (event: SubmitEvent) => void;
+    protected handleSearchKeyPress: (event: KeyboardEvent) => void;
+    protected handleResultKeyPress: (event: KeyboardEvent) => void;
+    /** Search Keycloak users using a generic search query. */
+    private searchUsers;
+    private replaceUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImpersonateModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImpersonateModalComponent, "lib-impersonate-modal", never, { "showModal": { "alias": "showModal"; "required": false; }; "oidcBaseUri": { "alias": "oidcBaseUri"; "required": false; "isSignal": true; }; "oidcDefaultIdp": { "alias": "oidcDefaultIdp"; "required": false; "isSignal": true; }; "accessTokenPayload": { "alias": "accessTokenPayload"; "required": true; "isSignal": true; }; }, { "dismiss": "dismiss"; "init": "init"; }, never, never, true, never>;
+}
+
+declare enum AccessStatus {
+    OK = "ok",
+    BLOCKED = "blocked",
+    NONE = "none"
+}
+interface ApplicationAccess {
+    label: string;
+    access: AccessStatus;
+    code?: string;
+    detail?: string;
+}
+
+declare enum EmployeePositionType {
+    STD = "std",
+    SNL = "snl",
+    FAC = "fac",
+    STF = "stf",
+    TMP = "tmp",
+    FTC = "ftc"
+}
+declare enum UndergradGraduateStatus {
+    UNDERGRAD = "undergrad",
+    GRADUATE = "graduate"
+}
+interface PersonSummary {
+    byu_id?: string;
+    email_address?: string;
+    first_name: string;
+    is_affiliate: boolean;
+    is_employee: boolean;
+    is_retired?: boolean;
+    primary_position_type?: EmployeePositionType;
+    primary_position_type_display?: string;
+    is_student: boolean;
+    undergrad_graduate_status?: UndergradGraduateStatus;
+    last_name: string;
+    library_id: string;
+    preferred_first_name: string;
+    restricted: boolean;
+    worker_id?: string;
+}
+
+/**
+ * @todo: Refactor: my recommendation would be to allow a user to be passed into this component via an input instead of the users coming from an API call based on the JWT passed in. This might look something like:
+ *  ```
+ *    ＠Input() user: {
+ *      primary_position_type_display?: string
+ *      undergrad_graduate_status?: string
+ *      restricted?: boolean
+ *      is_retired?: boolean
+ *      is_employee?: boolean
+ *      primary_position_type?: string
+ *    }
+ * ```
+ * Accepting all properties that are used in this component without needing to bring in the user type explicitly. Or the properties on this user object could be made even more general as to not be tied at all to any specific type.
+ *
+ * Something similar could be done with `accountStatuses`. I'd recommend the consuming application prepare arrays of strings to be passed into inputs of `accountsOk`, `accountsBlocked`, and `accountsNone`, that are then passed into and displayed in the template.
+ *
+ * The idea behind these revisions is that there is less business logic baked into this component, as it's role is just one of presentation. It will also avoid multiple API calls for the same data in our big Angular apps.
+ *
+ * Best of luck,
+ * Paul
+ */
+declare class ImpersonationBannerComponent {
+    private http;
+    accessTokenPayload: i0.InputSignal<TokenPayload>;
+    personBaseUri: i0.InputSignal<string>;
+    myAccountApiBaseUri: i0.InputSignal<string>;
+    endImpersonation: EventEmitter<void>;
+    protected parsedToken: Signal<JwtPayload & Record<string, any>>;
+    protected isImpersonating: Signal<boolean>;
+    protected libraryId: Signal<any>;
+    protected user: Signal<PersonSummary | null | undefined>;
+    protected userFullName: Signal<string>;
+    protected isRestricted: Signal<boolean | undefined>;
+    protected userInfoTabs: Signal<Map<string, any>>;
+    protected userPhotoUrl: Signal<string>;
+    protected activityStatus: Signal<"retired" | "active" | "inactive" | null>;
+    protected employeeStatusDescription: Signal<string | null>;
+    protected independentStudyStatus: Signal<boolean | null | undefined>;
+    protected accountStatuses: Signal<{
+        ok: ApplicationAccess[];
+        blocked: ApplicationAccess[];
+        none: ApplicationAccess[];
+    } | null | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImpersonationBannerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImpersonationBannerComponent, "lib-impersonation-banner", never, { "accessTokenPayload": { "alias": "accessTokenPayload"; "required": true; "isSignal": true; }; "personBaseUri": { "alias": "personBaseUri"; "required": false; "isSignal": true; }; "myAccountApiBaseUri": { "alias": "myAccountApiBaseUri"; "required": false; "isSignal": true; }; }, { "endImpersonation": "endImpersonation"; }, never, never, true, never>;
+}
+
+declare const searchScopeValues: readonly ["local", "external"];
+type SearchScope = (typeof searchScopeValues)[number];
+declare const isSearchScope: (scope: string) => scope is SearchScope;
+
+declare const ADVANCED_SEARCH_QUALIFIER_MAP: {
+    readonly contains: "contains";
+    readonly begins_with: "begins with";
+    readonly exact: "is (exact)";
+    readonly index: "browse value";
+    readonly subject_lc: "LC browse";
+    readonly subject_expanded: "expanded browse";
+};
+declare const ADVANCED_SEARCH_FIELD_MAP: {
+    readonly abstract: "Abstract";
+    readonly any: "Any Field";
+    readonly callNumber: "Call Number";
+    readonly contributor: "Contributor";
+    readonly creator: "Author/Creator";
+    readonly genre: "Genre";
+    readonly isbn: "ISBN";
+    readonly issn: "ISSN";
+    readonly series: "Series";
+    readonly source: "Source";
+    readonly subject: "Subject";
+    readonly title: "Title";
+};
+declare const ADVANCED_SEARCH_OPTIONS: {
+    readonly boolean: readonly ["AND", "OR", "NOT"];
+    readonly fields: readonly ["any", "title", "creator", "subject", "issn", "isbn"];
+    readonly localFields: readonly ["callNumber", "contributor", "genre", "series"];
+    readonly externalFields: readonly ["source", "abstract"];
+    readonly qualifiers: {
+        readonly any: readonly ["contains"];
+        readonly title: readonly ["contains", "exact", "begins_with", "index"];
+        readonly callNumber: readonly ["contains", "exact", "begins_with", "index"];
+        readonly creator: readonly ["contains", "exact", "begins_with", "index"];
+        readonly contributor: readonly ["contains", "exact"];
+        readonly isbn: readonly ["contains", "exact"];
+        readonly issn: readonly ["contains", "exact"];
+        readonly genre: readonly ["contains", "exact"];
+        readonly subject: readonly ["contains", "exact", "subject_lc", "subject_expanded"];
+        readonly series: readonly ["contains", "exact"];
+    };
+    readonly resultsPerPage: readonly ["10", "20", "50", "100"];
+    readonly types: {
+        readonly byu: {
+            readonly book: "Books";
+            readonly sound_recording: "Sound Recordings";
+            readonly image: "Images";
+            readonly periodical: "Periodicals";
+            readonly map: "Maps";
+            readonly score: "Music Scores";
+            readonly newspaper: "Newspapers";
+            readonly dissertation: "Theses & Dissertations";
+            readonly video: "Videos";
+        };
+        readonly law: {
+            readonly book: "Books";
+        };
+        readonly ensign: {
+            readonly book: "Books";
+            readonly sound_recording: "Sound Recordings";
+            readonly journal: "Periodicals";
+            readonly magazine: "Magazines";
+            readonly video: "Videos";
+        };
+    };
+    readonly collections: {
+        readonly byu: {
+            readonly lee: "BYU Library";
+            readonly 'lee -- asian': "Asian";
+            readonly 'lee -- general': "General Collection";
+            readonly 'lee -- govdocs': "Government Documents";
+            readonly 'lee -- humanities': "Humanities";
+            readonly 'lee -- juvenile': "Juvenile";
+            readonly 'lee -- maps': "Maps";
+            readonly 'lee -- media_center': "Media Center";
+            readonly 'lee -- music': "Music & Dance";
+            readonly 'lee -- periodicals': "Periodicals";
+            readonly 'lee -- popular': "Popular Reading";
+            readonly 'lee -- religion_famhist': "Religion & Family History";
+            readonly 'lee -- science_engineering': "Science & Engineering";
+            readonly 'lee -- social_science': "Social Science";
+            readonly 'lee -- special_collections': "Special Collections";
+        };
+        readonly law: {
+            readonly 'law -- iclrs': "Law & Religion Studies";
+            readonly 'law -- main': "Main Collection";
+            readonly 'law -- media': "Media";
+            readonly 'law -- reserve': "Reserve";
+            readonly 'law -- self_help': "Self Help";
+            readonly 'law -- study_guides': "Study Guides";
+        };
+        readonly ensign: {
+            readonly 'ldsbc -- audio_books': "Audio Books";
+            readonly 'ldsbc -- display': "Display Shelves";
+            readonly 'ldsbc -- fiction': "Fiction";
+            readonly 'ldsbc -- films': "Feature Films";
+            readonly 'ldsbc -- stacks': "General Collection";
+            readonly 'ldsbc -- news_magazines': "News Magazines";
+            readonly 'ldsbc -- non_feature_films': "Non Feature Films";
+            readonly 'ldsbc -- oversize': "Oversize";
+            readonly 'ldsbc -- paralegal': "Paralegal";
+            readonly 'ldsbc -- periodicals': "Periodicals";
+            readonly 'ldsbc -- reference': "Reference";
+            readonly 'ldsbc -- reserve': "Reserve";
+        };
+    };
+    readonly languages: {
+        readonly eng: "English";
+        readonly ara: "Arabic";
+        readonly chi: "Chinese";
+        readonly ces: "Czech";
+        readonly dan: "Danish";
+        readonly dut: "Dutch";
+        readonly fin: "Finnish";
+        readonly fre: "French";
+        readonly ger: "German";
+        readonly gre: "Greek, Modern";
+        readonly heb: "Hebrew";
+        readonly hin: "Hindi";
+        readonly hun: "Hungarian";
+        readonly ice: "Icelandic";
+        readonly ita: "Italian";
+        readonly jpn: "Japanese";
+        readonly kor: "Korean";
+        readonly lat: "Latin";
+        readonly nor: "Norwegian";
+        readonly pol: "Polish";
+        readonly por: "Portuguese";
+        readonly pan: "Punjabi";
+        readonly rum: "Romanian";
+        readonly rus: "Russian";
+        readonly spa: "Spanish";
+        readonly swe: "Swedish";
+        readonly wel: "Welsh";
+        readonly yid: "Yiddish";
+    };
+};
+
+type AdvancedSearchBooleanOption = (typeof ADVANCED_SEARCH_OPTIONS.boolean)[number];
+type AdvancedSearchFieldOption = (typeof ADVANCED_SEARCH_OPTIONS.fields)[number];
+declare const isAdvancedSearchFieldOption: (field: string) => field is AdvancedSearchLocalFieldOption;
+type AdvancedSearchLocalFieldOption = (typeof ADVANCED_SEARCH_OPTIONS.localFields)[number];
+declare const isAdvancedSearchLocalFieldOption: (field: string) => field is AdvancedSearchLocalFieldOption;
+type AdvancedSearchExternalFieldOption = (typeof ADVANCED_SEARCH_OPTIONS.externalFields)[number];
+declare const isAdvancedSearchExternalFieldOption: (field: string) => field is AdvancedSearchExternalFieldOption;
+type AdvancedSearchQualifierOption = (typeof ADVANCED_SEARCH_OPTIONS.qualifiers)[keyof typeof ADVANCED_SEARCH_OPTIONS.qualifiers][number];
+type AdvancedSearchResultsPerPageOption = (typeof ADVANCED_SEARCH_OPTIONS.resultsPerPage)[number];
+type AdvancedSearchLanguageOption = (keyof typeof ADVANCED_SEARCH_OPTIONS.languages)[number];
+type AdvancedSearchQualifier = keyof typeof ADVANCED_SEARCH_OPTIONS.qualifiers;
+interface AdvancedSearchQueryRow {
+    boolean?: AdvancedSearchBooleanOption;
+    field?: AdvancedSearchFieldOption | AdvancedSearchLocalFieldOption | AdvancedSearchExternalFieldOption;
+    qualifier?: AdvancedSearchQualifierOption;
+    query: string;
+}
+
+interface SearchConfig {
+    institution: 'byu' | 'law' | 'ensign';
+    showAdvancedSearch: boolean;
+    showAdvancedSearchAsText: boolean;
+    scope: SearchScope;
+    q: string;
+    advancedSearchQueryRows: AdvancedSearchQueryRow[];
+    localAdvancedSearch: {
+        creationDate: Date$1;
+        selectedLanguages: string[];
+        selectedResourceTypes: string[];
+        selectedCollections: string[];
+    };
+    externalAdvancedSearch: {
+        datePublished: Date$1;
+        selectedLanguages: string[];
+        limitResults: {
+            peerReviewed: boolean;
+        };
+        expandResults: {
+            applyEquivalentSubjects: boolean;
+            fullText: boolean;
+        };
+    };
+}
+interface Date$1 {
+    from: string;
+    to: string;
+}
+
+declare class SsSearchBarComponent {
+    private _config;
+    set config(config: string);
+    get config(): SearchConfig;
+    simpleSearch: EventEmitter<SearchConfig>;
+    clearSimpleSearch: EventEmitter<SearchConfig>;
+    advancedSearch: EventEmitter<SearchConfig>;
+    advancedSearchClosed: EventEmitter<SearchConfig>;
+    advancedSearchOpen: EventEmitter<SearchConfig>;
+    tabChange: EventEmitter<SearchConfig>;
+    private barWrapperRef;
+    protected heightOfContainer: number;
+    protected emitClearSimpleSearch: () => void;
+    protected emitSimpleSearch: (updatedProps: Partial<SearchConfig>) => void;
+    protected emitAdvancedSearchClosed: () => void;
+    protected emitAdvancedSearch: (config: SearchConfig) => void;
+    protected emitAdvancedSearchOpen: () => void;
+    protected emitTabChange: (newScope: SearchScope) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SsSearchBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SsSearchBarComponent, "lib-ss-search-bar", never, { "config": { "alias": "config"; "required": true; }; }, { "simpleSearch": "simpleSearch"; "clearSimpleSearch": "clearSimpleSearch"; "advancedSearch": "advancedSearch"; "advancedSearchClosed": "advancedSearchClosed"; "advancedSearchOpen": "advancedSearchOpen"; "tabChange": "tabChange"; }, never, never, true, never>;
+}
+
+type Status = 'success' | 'info' | 'warning' | 'error' | 'disabled';
+interface StatusButtonInputs {
+    label: string;
+    status?: Status;
+    leftIcon?: string;
+    rightIcon?: string;
+    hideLeftIcon?: boolean;
+    hideRightIcon?: boolean;
+    clearVariant?: boolean;
+}
+/**
+ * A button that indicates status with color and icon.
+ * Status can be one of: 'success', 'info', 'warning', 'error', or 'disabled'.
+ * Each status has a default left icon, but a custom left icon can be provided.
+ * A right icon can also be provided, defaulting to 'chevron_right'.
+ * The left and right icons can be hidden with the `hideLeftIcon` and `hideRightIcon` boolean inputs.
+ * A label input is required.
+ */
+declare class StatusButtonComponent {
+    private _status;
+    private _leftIcon;
+    private _rightIcon;
+    private _hideLeftIcon;
+    private _hideRightIcon;
+    private _clearVariant;
+    label: string;
+    set status(value: 'success' | 'info' | 'warning' | 'error' | 'disabled');
+    get status(): "success" | "info" | "warning" | "error" | "disabled";
+    set leftIcon(value: string);
+    get leftIcon(): string;
+    set rightIcon(value: string);
+    get rightIcon(): string;
+    set hideLeftIcon(value: boolean);
+    get hideLeftIcon(): boolean;
+    set hideRightIcon(value: boolean);
+    get hideRightIcon(): boolean;
+    set clearVariant(value: boolean);
+    get clearVariant(): boolean;
+    /** helper for default left icons */
+    private getDefaultLeftIcon;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StatusButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StatusButtonComponent, "lib-status-button", never, { "label": { "alias": "label"; "required": true; }; "status": { "alias": "status"; "required": false; }; "leftIcon": { "alias": "leftIcon"; "required": false; }; "rightIcon": { "alias": "rightIcon"; "required": false; }; "hideLeftIcon": { "alias": "hideLeftIcon"; "required": false; }; "hideRightIcon": { "alias": "hideRightIcon"; "required": false; }; "clearVariant": { "alias": "clearVariant"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_hideLeftIcon: unknown;
+    static ngAcceptInputType_hideRightIcon: unknown;
+    static ngAcceptInputType_clearVariant: unknown;
+}
+
+type SnackbarPurpose = 'default' | 'info' | 'success' | 'error' | 'warning';
+interface SnackbarInputs {
+    purpose?: SnackbarPurpose;
+    title?: string;
+    description?: string;
+    titleIcon?: string;
+    fieldPlaceholder?: string;
+    showTitle?: boolean;
+    showTitleIcon?: boolean;
+    titleIconFilled?: boolean;
+    showClose?: boolean;
+    showProgressBar?: boolean;
+    showField?: boolean;
+    showButton?: boolean;
+    progressMs?: number;
+    autoDismiss?: boolean;
+    y?: number;
+    right?: number;
+    zIndex?: number;
+    statusButtonInputs?: StatusButtonInputs;
+}
+declare class SnackbarComponent implements OnInit, OnChanges, OnDestroy {
+    purpose: SnackbarPurpose;
+    title: string;
+    description: string;
+    fieldPlaceholder: string;
+    titleIcon: string;
+    showTitle: boolean;
+    showTitleIcon: boolean;
+    titleIconFilled: boolean;
+    showClose: boolean;
+    showProgressBar: boolean;
+    showField: boolean;
+    showButton: boolean;
+    autoDismiss: boolean;
+    visible: boolean;
+    progressMs: number;
+    y: number;
+    statusButtonInputs?: StatusButtonInputs;
+    closed: EventEmitter<void>;
+    visibleChange: EventEmitter<boolean>;
+    buttonClicked: EventEmitter<void>;
+    isOpen: boolean;
+    private dismissTimer?;
+    private readonly EXIT_MS;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    close(emitButtonClicked?: boolean): void;
+    get status(): Status;
+    private startDismissTimer;
+    private clearDismissTimer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SnackbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SnackbarComponent, "lib-snackbar", never, { "purpose": { "alias": "purpose"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "fieldPlaceholder": { "alias": "fieldPlaceholder"; "required": false; }; "titleIcon": { "alias": "titleIcon"; "required": false; }; "showTitle": { "alias": "showTitle"; "required": false; }; "showTitleIcon": { "alias": "showTitleIcon"; "required": false; }; "titleIconFilled": { "alias": "titleIconFilled"; "required": false; }; "showClose": { "alias": "showClose"; "required": false; }; "showProgressBar": { "alias": "showProgressBar"; "required": false; }; "showField": { "alias": "showField"; "required": false; }; "showButton": { "alias": "showButton"; "required": false; }; "autoDismiss": { "alias": "autoDismiss"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "progressMs": { "alias": "progressMs"; "required": false; }; "y": { "alias": "y"; "required": false; }; "statusButtonInputs": { "alias": "statusButtonInputs"; "required": false; }; }, { "closed": "closed"; "visibleChange": "visibleChange"; "buttonClicked": "buttonClicked"; }, never, never, true, never>;
+    static ngAcceptInputType_showTitle: unknown;
+    static ngAcceptInputType_showTitleIcon: unknown;
+    static ngAcceptInputType_titleIconFilled: unknown;
+    static ngAcceptInputType_showClose: unknown;
+    static ngAcceptInputType_showProgressBar: unknown;
+    static ngAcceptInputType_showField: unknown;
+    static ngAcceptInputType_showButton: unknown;
+    static ngAcceptInputType_autoDismiss: unknown;
+    static ngAcceptInputType_visible: unknown;
+}
+
+declare class SnackbarService {
+    private appRef;
+    private env;
+    constructor(appRef: ApplicationRef, env: EnvironmentInjector);
+    /**
+     * This open method is what consuming code will use to create a snackbar
+     * @param snackbarOptions interface
+     * @param anchor HTML Element, optional. The snackbar's entrance and exit animations will happen on this element's Y axis (px)
+     * @returns void.
+     */
+    open(snackbarOptions?: SnackbarInputs, anchor?: HTMLElement): {
+        close: () => void;
+        buttonClicked: i0.EventEmitter<void>;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<SnackbarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SnackbarService>;
+}
+
+export { ADVANCED_SEARCH_FIELD_MAP, ADVANCED_SEARCH_OPTIONS, ADVANCED_SEARCH_QUALIFIER_MAP, HbllFooterComponent, HbllHeaderComponent, HbllItemTypeIconPipe, HeaderWithImpersonationComponent, ImpersonateModalComponent, ImpersonateUserPipe, ImpersonationBannerComponent, LIBRARY_HOURS_API_URL, SnackbarComponent, SnackbarService, SsSearchBarComponent, StatusButtonComponent, defaultOidcBaseUri, defaultOidcDefaultIdp, getUserStatusFromRoles, isAdvancedSearchExternalFieldOption, isAdvancedSearchFieldOption, isAdvancedSearchLocalFieldOption, isSearchScope };
+export type { AdvancedSearchBooleanOption, AdvancedSearchExternalFieldOption, AdvancedSearchFieldOption, AdvancedSearchLanguageOption, AdvancedSearchLocalFieldOption, AdvancedSearchQualifier, AdvancedSearchQualifierOption, AdvancedSearchQueryRow, AdvancedSearchResultsPerPageOption, ImpersonateSearchResult, SearchConfig, SearchScope, SnackbarInputs, SnackbarPurpose, Status, StatusButtonInputs };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@byuhbll/components",
-  "version": "6.0.0-rc.0",
+  "version": "6.0.0-rc.2",
   "peerDependencies": {
-    "@angular/common": "^19.2.17",
-    "@angular/core": "^19.2.17"
+    "@angular/common": "^20.3.15",
+    "@angular/core": "^20.3.15"
   },
   "dependencies": {
     "tslib": "^2.6.2"

package/lib/animations/animations.d.ts

@@ -1,4 +0,0 @@
-export declare const libHbllExpandCollapse: import("@angular/animations").AnimationTriggerMetadata;
-export declare const libHbllFadeInOut: import("@angular/animations").AnimationTriggerMetadata;
-export declare const libHbllFadeIn: import("@angular/animations").AnimationTriggerMetadata;
-export declare const libHbllFadeOut: import("@angular/animations").AnimationTriggerMetadata;

package/lib/checkbox/checkbox.component.d.ts

@@ -1,6 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class HbllCheckboxComponent {
-    isChecked: import("@angular/core").InputSignal<boolean>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<HbllCheckboxComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<HbllCheckboxComponent, "lib-checkbox", never, { "isChecked": { "alias": "isChecked"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}