@crystaltech/hsms-shared-ui 0.7.29 → 0.8.0

package/dist/components/queue/QueueDisplayAdmin.d.ts

@@ -0,0 +1,16 @@
+import { QueueClient } from './queueClient';
+import { QueueLine } from './types';
+interface Props {
+    client: QueueClient;
+    module: string;
+    apiBase: string;
+    lines: QueueLine[];
+    /** Where this app's display page lives, e.g. /hsms/pharmacy/queue/display */
+    displayPath: string;
+    hospitalId?: string;
+    getToken?: () => string | null;
+    moduleApis?: Record<string, string>;
+}
+/** Named display profiles, one per monitor or group of monitors, each with its own address. */
+export default function QueueDisplayAdmin({ client, module, apiBase, lines, displayPath, hospitalId, getToken, moduleApis }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/queue/QueueDisplayScreen.d.ts

@@ -0,0 +1,21 @@
+import { QueueHttp } from './types';
+interface Props {
+    /** The owning module's API client, to read the display profile. */
+    http: QueueHttp;
+    module: string;
+    apiBase: string;
+    displayId: string;
+    hospitalId?: string;
+    hospitalName?: string;
+    hospitalLogo?: string;
+    getToken?: () => string | null;
+    moduleApis?: Record<string, string>;
+}
+/**
+ * A waiting-room screen in the usual professional layout: hospital header, a "Now serving" board
+ * (token → counter), the latest call in large type with the next tokens of every line, and a
+ * notice ticker. Tokens only: no patient names, nothing about priority. Scales from any screen
+ * size (designed at 1920×1080), turns to a stacked layout on portrait screens, and recovers by itself.
+ */
+export default function QueueDisplayScreen(props: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/queue/QueueGuide.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+/**
+ * A short "how this works" guide at the top of a section. Open the first time; once closed it stays
+ * a one-line "Show guide" link for that person on that browser.
+ */
+export declare function Guide({ id, title, steps, tips }: {
+    id: string;
+    title: string;
+    steps: ReactNode[];
+    tips?: ReactNode[];
+}): import("react/jsx-runtime").JSX.Element;
+/** A one-line explanation under a group of fields. */
+export declare function Hint({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/queue/QueueLineAdmin.d.ts

@@ -0,0 +1,14 @@
+import { QueueClient } from './queueClient';
+import { RuleOptions } from './ruleOptions';
+import { QueueLine } from './types';
+interface Props {
+    client: QueueClient;
+    module: string;
+    lines: QueueLine[];
+    onChanged: () => void;
+    /** Override or extend the pick lists in the rule editor. */
+    ruleOptions?: Partial<RuleOptions>;
+}
+/** Lines are data, not code: any number, any rules, changed while patients wait. */
+export default function QueueLineAdmin({ client, module, lines, onChanged, ruleOptions }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/queue/QueueManagement.d.ts

@@ -0,0 +1,25 @@
+import { RuleOptions } from './ruleOptions';
+import { QueueHttp } from './types';
+export interface QueueManagementProps {
+    /** The module app's API client (axios), pointed at its own backend. */
+    http: QueueHttp;
+    /** OPD, PHARMACY, LABORATORY, RADIOLOGY, BILLING, ... */
+    module: string;
+    /** The module's API root, e.g. import.meta.env.VITE_API_URL */
+    apiBase: string;
+    /** For a super admin: the hospital they chose. */
+    hospitalId?: string;
+    /** Where this app serves its display page, e.g. /hsms/pharmacy/queue/display */
+    displayPath: string;
+    title?: string;
+    getToken?: () => string | null;
+    /** Other modules' API roots when they are not on the same /hsms/<module>/ host. */
+    moduleApis?: Record<string, string>;
+    /** Extra or different choices for the line rules (patient types, categories, ...). */
+    ruleOptions?: Partial<RuleOptions>;
+}
+/**
+ * A module's Queue Management: live operations, lines, displays and reports, each shown only to
+ * those the server would allow, with a short guide on every tab.
+ */
+export default function QueueManagement(props: QueueManagementProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/queue/QueueOperatorPanel.d.ts

@@ -0,0 +1,21 @@
+import { QueueClient } from './queueClient';
+import { QueueLine, QueueMe } from './types';
+interface Props {
+    client: QueueClient;
+    me: QueueMe;
+    module: string;
+    apiBase: string;
+    lines: QueueLine[];
+    hospitalId?: string;
+    getToken?: () => string | null;
+    /** Opens the Lines tab, for an administrator with nothing set up yet. */
+    onSetUpLines?: () => void;
+    /** Reload the lines after a change made here, so every tab agrees. */
+    onLinesChanged?: () => void;
+}
+/**
+ * The counter view: pick a line and counter, call the next patient, serve, complete. Completing
+ * removes the patient at once and the next one is ready; on an automatic line they are called.
+ */
+export default function QueueOperatorPanel({ client, me, module, apiBase, lines, hospitalId, getToken, onSetUpLines, onLinesChanged }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/queue/QueueReportsPanel.d.ts

@@ -0,0 +1,6 @@
+import { QueueClient } from './queueClient';
+/** Waiting times, throughput, operators, counters and peak hours; priority history for administrators. */
+export default function QueueReportsPanel({ client, showPriority }: {
+    client: QueueClient;
+    showPriority: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/queue/RulePickers.d.ts

@@ -0,0 +1,15 @@
+import { Option } from './ruleOptions';
+/** A pick-many dropdown that still accepts a value not in its list. */
+export declare function MultiPick(props: {
+    label: string;
+    options: Option[];
+    value?: string[] | null;
+    onChange: (v: string[]) => void;
+    placeholder?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/** Government grade 1–20, or any. */
+export declare function GradePick(props: {
+    label: string;
+    value?: number | null;
+    onChange: (v: number | null) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/queue/hospitalBrand.d.ts

@@ -0,0 +1,17 @@
+/** Pure helpers for the hospital heading on queue screens (no browser or app imports, so tests can load them). */
+/** What a queue screen needs about its hospital; read from the same places as the app header. */
+export interface HospitalBrand {
+    id?: string;
+    name?: string;
+    nameBn?: string;
+    address?: string;
+    phone?: string;
+    website?: string;
+    /** Ready to put in an <img>. */
+    logoUrl?: string;
+    /** The hospital's banner picture, ready to use as a background. */
+    bannerUrl?: string;
+}
+export declare function toBrand(h: any, org?: any, resolveLogo?: (path: string) => string): HospitalBrand | null;
+/** "Phone 019… · www…" for a scrolling line along the bottom of a screen. */
+export declare const contactLine: (b: HospitalBrand | null) => string;

package/dist/components/queue/hospitalInfo.d.ts

@@ -0,0 +1,6 @@
+import { HospitalBrand } from './hospitalBrand';
+export { contactLine, type HospitalBrand } from './hospitalBrand';
+/** The hospital as already known to this browser, without a request. */
+export declare function storedHospital(hospitalId?: string): HospitalBrand | null;
+/** The hospital's name, address and logo, for headings on queue screens. */
+export declare function useHospitalBrand(hospitalId?: string): HospitalBrand | null;

package/dist/components/queue/queueClient.d.ts

@@ -0,0 +1,65 @@
+import { DisplayProfile, LineSnapshot, QueueEvent, QueueHttp, QueueLine, QueueMe, QueueTicket, ReportSummary } from './types';
+/** Calls to one module's /api/queue, scoped to the hospital when a super admin chose one. */
+export declare function createQueueClient(http: QueueHttp, hospitalId?: string, basePath?: string): {
+    me: () => Promise<QueueMe>;
+    lines: (includeArchived?: boolean) => Promise<QueueLine[]>;
+    createLine: (line: QueueLine) => Promise<QueueLine>;
+    updateLine: (id: string, line: QueueLine) => Promise<QueueLine>;
+    pause: (id: string, counterId?: string) => Promise<{
+        data: unknown;
+    }>;
+    resume: (id: string, counterId?: string) => Promise<{
+        data: unknown;
+    }>;
+    activate: (id: string) => Promise<{
+        data: unknown;
+    }>;
+    deactivate: (id: string) => Promise<{
+        data: unknown;
+    }>;
+    archive: (id: string) => Promise<{
+        data: unknown;
+    }>;
+    reorder: (ids: string[]) => Promise<{
+        data: unknown;
+    }>;
+    merge: (sourceLineIds: string[], targetLineId: string) => Promise<{
+        data: unknown;
+    }>;
+    split: (id: string, newLine: QueueLine) => Promise<{
+        data: unknown;
+    }>;
+    templates: () => Promise<{
+        id: string;
+        name: string;
+    }[]>;
+    saveTemplate: (name: string) => Promise<{
+        data: unknown;
+    }>;
+    applyTemplate: (id: string) => Promise<{
+        data: unknown;
+    }>;
+    snapshot: (lineId: string, view: "public" | "operator") => Promise<LineSnapshot>;
+    register: (body: Record<string, unknown>) => Promise<QueueTicket>;
+    callNext: (lineId: string, counterId: string) => Promise<QueueTicket | null>;
+    recall: (ticketId: string, counterId?: string) => Promise<QueueTicket>;
+    start: (ticketId: string) => Promise<QueueTicket>;
+    complete: (ticketId: string) => Promise<QueueTicket>;
+    skip: (ticketId: string, reason?: string) => Promise<QueueTicket>;
+    noShow: (ticketId: string) => Promise<QueueTicket>;
+    requeue: (ticketId: string) => Promise<QueueTicket>;
+    cancel: (ticketId: string, reason?: string) => Promise<QueueTicket>;
+    transfer: (ticketId: string, targetLineId: string, toFront: boolean, reason?: string) => Promise<QueueTicket>;
+    prioritise: (ticketId: string, position: number, kind: string, reason: string) => Promise<QueueTicket>;
+    displays: () => Promise<DisplayProfile[]>;
+    display: (id: string) => Promise<DisplayProfile>;
+    saveDisplay: (profile: DisplayProfile) => Promise<DisplayProfile>;
+    deleteDisplay: (id: string) => Promise<{
+        data: unknown;
+    }>;
+    summary: (from: string, to: string) => Promise<ReportSummary>;
+    priorityHistory: (from: string, to: string) => Promise<QueueEvent[]>;
+};
+export type QueueClient = ReturnType<typeof createQueueClient>;
+/** The message a refused request carries, for a toast or an alert. */
+export declare function queueError(error: unknown): string;

package/dist/components/queue/queueLogic.d.ts

@@ -0,0 +1,63 @@
+import { LineSnapshot } from './types';
+/** One server-sent event. */
+export interface SseEvent {
+    event?: string;
+    id?: string;
+    data?: string;
+}
+/**
+ * Reads complete events out of streamed text and returns what is left over for the next chunk.
+ * Comments (keep-alive lines) are skipped.
+ */
+export declare function parseSse(buffer: string): {
+    events: SseEvent[];
+    rest: string;
+};
+/** The key a line is known by across modules. */
+export declare const lineKey: (module: string, lineId: string) => string;
+/**
+ * Keeps the newer of two pictures of a line. Notices can arrive out of order across pods and
+ * reconnects; an older version never replaces a newer one, and a new day always wins.
+ */
+export declare function newer(current: LineSnapshot | undefined, incoming: LineSnapshot): boolean;
+/** Tokens called since the previous picture: what a display announces. */
+export declare function newlyCalled(previous: LineSnapshot | undefined, next: LineSnapshot): string[];
+/**
+ * Columns and rows for n lines on a screen of the given shape, using the space well: the most
+ * square cells that fit, more columns on a wide screen.
+ */
+export declare function gridFor(count: number, width: number, height: number, fixedColumns?: number | null): {
+    columns: number;
+    rows: number;
+};
+/** A token's font size for a cell, in px: as large as fits, never unreadably small. */
+export declare function tokenFontSize(cellWidth: number, cellHeight: number): number;
+/** Bangla digits for a token or count. */
+export declare function bnDigits(value: string | number): string;
+/**
+ * A token as it should be said: the letters one by one, then the number as a number, without its
+ * leading zeros ("M-004" → "M 4", "GM-012" → "G M 12"; in Bangla "এম ৪").
+ */
+export declare function spokenToken(tokenNo: string, language: "EN" | "BN"): string;
+/** A counter's name in Bangla: its own Bangla name, or "Counter 2" → "২ নম্বর কাউন্টার". */
+export declare function counterInBangla(name?: string | null, nameBn?: string | null): string;
+/** "…কাউন্টার" → "…কাউন্টারে", "…রুম" → "…রুমে"; anything else gets "-এ". */
+export declare const toPlace: (place: string) => string;
+/**
+ * What a screen says aloud when a token is called, in full sentences so the voice pauses naturally.
+ * The patient's name is said only by the voice that can pronounce its script: a name written in
+ * English by the English voice, a name in Bangla by the Bangla voice.
+ */
+export declare function announcement(tokenNo: string, counterName: string | null | undefined, language: "EN" | "BN", patientName?: string | null, counterNameBn?: string | null): string;
+/**
+ * The API address of another module, from this module's own: HSMS serves each module under
+ * /hsms/<path>/ on one host. An explicit map wins.
+ */
+export declare const MODULE_PATHS: Record<string, string>;
+export declare function apiBaseFor(module: string, ownBase: string, overrides?: Record<string, string>): string;
+/** A time sent as ISO text or as epoch seconds/milliseconds (depends on the backend's JSON settings). */
+export type Instant = string | number;
+/** Milliseconds since the epoch, or null when the value is missing or unreadable. */
+export declare function toMillis(value?: Instant | null): number | null;
+/** Minutes between two instants, rounded, or null. */
+export declare function minutesBetween(from?: Instant | null, to?: Instant | null): number | null;

package/dist/components/queue/queueVoice.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The spoken side of a queue screen: a soft two-note chime, then each call in the best voice the
+ * computer has, one at a time, at a calm pace. Browsers only allow sound after someone has clicked
+ * the page once; until then calls are shown but not heard.
+ */
+type Lang = "EN" | "BN";
+/** The best installed voice for a language, or null when there is none worth using. */
+export declare function pickVoice(lang: Lang): SpeechSynthesisVoice | null;
+/** Whether this computer can say a language properly; Bangla is skipped rather than mangled. */
+export declare const canSpeak: (lang: Lang) => boolean;
+/** A soft "ding-dong" made in the browser, about a second long. */
+export declare function chime(): number;
+interface Line {
+    lang: Lang;
+    text: string;
+}
+/** Plays one call: an optional chime, then the lines in order. Calls never overlap. */
+export declare function announce(lines: Line[], withChime: boolean): void;
+export {};

package/dist/components/queue/ruleOptions.d.ts

@@ -0,0 +1,18 @@
+import { EligibilityRule } from './types';
+export interface RuleOptions {
+    patientTypes: Option[];
+    categories: Option[];
+    genders: Option[];
+    privileges: Option[];
+    sourceTypes: Option[];
+}
+export interface Option {
+    value: string;
+    label: string;
+}
+/** Sources each module issues tickets from; MANUAL is a patient added at the desk. */
+export declare const SOURCES_BY_MODULE: Record<string, Option[]>;
+/** Values the registration and module data use; any other value can still be typed in. */
+export declare const defaultRuleOptions: (module: string) => RuleOptions;
+/** A rule in plain words, e.g. "Government employee, grade 1–9, female". */
+export declare function describeRule(rule: EligibilityRule, options: RuleOptions): string;

package/dist/components/queue/types.d.ts

@@ -0,0 +1,213 @@
+/** Shapes of the queue engine's API (crystal-redis-package patientqueue, /api/queue). */
+export type TicketStatus = "WAITING" | "CALLED" | "SERVING" | "COMPLETED" | "SKIPPED" | "NO_SHOW" | "CANCELLED" | "TRANSFERRED";
+export interface EligibilityRule {
+    patientTypes?: string[];
+    categories?: string[];
+    genders?: string[];
+    minAge?: number | null;
+    maxAge?: number | null;
+    minGovGrade?: number | null;
+    maxGovGrade?: number | null;
+    disabled?: boolean | null;
+    privileges?: string[];
+    sourceTypes?: string[];
+    departmentIds?: string[];
+    roomIds?: string[];
+}
+export interface CounterDesk {
+    id: string;
+    name: string;
+    nameBn?: string;
+    active: boolean;
+    paused?: boolean;
+    operatorIds?: string[];
+}
+export interface QueueLine {
+    id?: string;
+    module?: string;
+    code?: string;
+    name: string;
+    nameBn?: string;
+    prefix?: string;
+    description?: string;
+    active: boolean;
+    paused?: boolean;
+    archived?: boolean;
+    displayVisible: boolean;
+    sortOrder?: number;
+    allocationPriority?: number;
+    rules?: EligibilityRule[];
+    callPolicy?: "MANUAL" | "AUTO";
+    resetPolicy?: "DAILY" | "SHIFT";
+    shifts?: {
+        code: string;
+        start: string;
+        end: string;
+    }[];
+    capacity?: number;
+    priorityLimitPerDay?: number;
+    counters?: CounterDesk[];
+    operatorIds?: string[];
+    resourceType?: string;
+    resourceId?: string;
+    departmentId?: string;
+    effectiveFrom?: string | null;
+    effectiveTo?: string | null;
+}
+export interface SnapshotEntry {
+    tokenNo: string;
+    status: TicketStatus;
+    position?: number | null;
+    counterId?: string | null;
+    counterName?: string | null;
+    calledAt?: string | number | null;
+    recallCount?: number;
+    ticketId?: string;
+    patientId?: string;
+    patientIdentifier?: string;
+    patientName?: string;
+    patientLabel?: string;
+    priority?: boolean;
+    sourceType?: string;
+    sourceId?: string;
+    issuedAt?: string | number;
+}
+export interface LineSnapshot {
+    module: string;
+    lineId: string;
+    code: string;
+    name: string;
+    nameBn?: string;
+    active: boolean;
+    paused: boolean;
+    displayVisible: boolean;
+    callPolicy?: string;
+    version: number;
+    serviceDate: string;
+    counters: {
+        id: string;
+        name: string;
+        nameBn?: string;
+        active: boolean;
+        paused: boolean;
+    }[];
+    serving: SnapshotEntry[];
+    waiting: SnapshotEntry[];
+    waitingCount: number;
+    skipped?: SnapshotEntry[] | null;
+    generatedAt?: string;
+}
+export interface QueueTicket {
+    id: string;
+    lineId: string;
+    tokenNo: string;
+    status: TicketStatus;
+    counterId?: string;
+    patientName?: string;
+}
+export interface DisplayLineRef {
+    module: string;
+    lineId: string;
+}
+export interface DisplayProfile {
+    id?: string;
+    module?: string;
+    name: string;
+    active: boolean;
+    mode: "SINGLE" | "MULTI" | "MODULE" | "COMBINED";
+    lines: DisplayLineRef[];
+    modules?: string[];
+    layout?: string;
+    columns?: number | null;
+    upcomingCount: number;
+    language: "EN" | "BN" | "BOTH";
+    voiceEnabled: boolean;
+    chimeEnabled: boolean;
+    /** Say the patient's name in the spoken call (empty: yes). */
+    announcePatientName?: boolean | null;
+    /** Show the called patient's ID beside the token (empty: yes). */
+    showPatientIdentifier?: boolean | null;
+    title?: string;
+    bannerText?: string;
+    logoUrl?: string;
+    notices?: string[];
+    emptyMessage?: string;
+    emptyMessageBn?: string;
+    theme?: "LIGHT" | "DARK";
+}
+export interface QueueMe {
+    module: string;
+    userId: string;
+    configure: boolean;
+    supervise: boolean;
+    operate: boolean;
+    priority: boolean;
+    display: boolean;
+    serviceDate: string;
+}
+export interface ReportFigures {
+    key: string;
+    name: string;
+    issued: number;
+    served: number;
+    skipped: number;
+    noShow: number;
+    cancelled: number;
+    transferred: number;
+    waitingNow: number;
+    prioritised: number;
+    averageWaitMinutes?: number | null;
+    maxWaitMinutes?: number | null;
+    averageServiceMinutes?: number | null;
+    busyMinutes?: number | null;
+}
+export interface ReportSummary {
+    from: string;
+    to: string;
+    total: ReportFigures;
+    lines: ReportFigures[];
+    operators: ReportFigures[];
+    counters: ReportFigures[];
+    arrivalsByHour: number[];
+    byDay: Record<string, ReportFigures>;
+}
+export interface QueueEvent {
+    id: string;
+    lineId?: string;
+    ticketId?: string;
+    tokenNo?: string;
+    action: string;
+    fromStatus?: string;
+    toStatus?: string;
+    previousPosition?: number;
+    newPosition?: number;
+    reason?: string;
+    detail?: string;
+    actorId?: string;
+    actorName?: string;
+    restricted?: boolean;
+    at: string | number;
+}
+/** The part of an axios instance the queue screens use: every module already has one. */
+export interface QueueHttp {
+    get<T = unknown>(url: string, config?: {
+        params?: Record<string, unknown>;
+    }): Promise<{
+        data: T;
+    }>;
+    post<T = unknown>(url: string, body?: unknown, config?: {
+        params?: Record<string, unknown>;
+    }): Promise<{
+        data: T;
+    }>;
+    put<T = unknown>(url: string, body?: unknown, config?: {
+        params?: Record<string, unknown>;
+    }): Promise<{
+        data: T;
+    }>;
+    delete<T = unknown>(url: string, config?: {
+        params?: Record<string, unknown>;
+    }): Promise<{
+        data: T;
+    }>;
+}

package/dist/components/queue/useConfirm.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+interface ConfirmRequest {
+    title: string;
+    message: ReactNode;
+    confirmLabel?: string;
+    danger?: boolean;
+}
+/** A proper confirmation dialog in place of the browser's confirm box. */
+export declare function useConfirm(): {
+    confirm: (r: ConfirmRequest) => Promise<boolean>;
+    dialog: import("react/jsx-runtime").JSX.Element;
+};
+export {};

package/dist/components/queue/useQueueStream.d.ts

@@ -0,0 +1,24 @@
+import { LineSnapshot } from './types';
+export interface StreamSource {
+    module: string;
+    /** The module's API root, e.g. https://api.example/hsms/pharmacy/ */
+    apiBase: string;
+    /** Lines to follow; empty follows every line of the module (display-visible ones in public view). */
+    lineIds?: string[];
+}
+export type StreamStatus = "connecting" | "live" | "reconnecting";
+/**
+ * Follows lines live over each module's /api/queue/stream. Reconnects by itself with backoff; on
+ * reconnect the server sends the current state again, and older pictures never replace newer ones.
+ */
+export declare function useQueueStream(sources: StreamSource[], options: {
+    /** public: tokens only; called: plus the called patient's name and ID; operator: everything. */
+    view: "public" | "called" | "operator";
+    hospitalId?: string;
+    getToken?: () => string | null;
+    basePath?: string;
+    onLine?: (snapshot: LineSnapshot, previous: LineSnapshot | undefined) => void;
+}): {
+    lines: Record<string, LineSnapshot>;
+    status: Record<string, StreamStatus>;
+};

package/dist/index.d.ts

@@ -26,6 +26,17 @@ export { default as Loader } from './components/ui/Loader';
 export { default as NetworkStatusIndicator } from './components/ui/NetworkStatusIndicator';
 export { default as RoutesConfigLayout } from './routes/RoutesConfigLayout';
 export { default as ThemeCustomization } from './theme/ThemeCustomization';
+export { default as QueueManagement } from './components/queue/QueueManagement';
+export type { QueueManagementProps } from './components/queue/QueueManagement';
+export { defaultRuleOptions, SOURCES_BY_MODULE } from './components/queue/ruleOptions';
+export type { RuleOptions } from './components/queue/ruleOptions';
+export { default as QueueDisplayScreen } from './components/queue/QueueDisplayScreen';
+export { createQueueClient, queueError } from './components/queue/queueClient';
+export type { QueueClient } from './components/queue/queueClient';
+export { useQueueStream } from './components/queue/useQueueStream';
+export type { StreamSource, StreamStatus } from './components/queue/useQueueStream';
+export * from './components/queue/queueLogic';
+export type * from './components/queue/types';
 export { withFontFallback, FONT_FALLBACK_CHAIN } from './theme/fontFamily';
 export { configureCommonPackage, getApiBaseUrl, getCommonConfig, setApiBaseUrl, } from './config/env';
 export { configureAuthPackage, getAccountConsoleUrl, getAuthConfig, getPostLogoutRedirectUri, setAccountConsoleRoutes, setAccountConsoleUrl, setPostLogoutRedirectUri, } from './config/auth';