bt-core-app 1.4.2 → 1.4.4

package/dist/index.d.ts

@@ -1,41 +1,1273 @@
-export { useActionsTracker } from './composables/actions-tracker';
-export type { BTActions, GetOptions, DeleteOptions, RestoreOptions, SaveOptions, ApiActionOptions, UseActionsOptions } from './composables/actions';
-export { useActions } from './composables/actions';
-export type { BTApi, UseApiOptions, PathOptions, QueryParams } from './composables/api';
-export { createApi, useApi } from './composables/api';
-export type { BTAuth, AuthItem, AuthSubscription, BaseAuthCredentials, CreateAuthOptions } from './composables/auth';
-export { createAuth, useAuth } from './composables/auth';
-export type { BTCosmetics, BaseCosmeticTheme, UseCosmeticsOptions } from './composables/cosmetics';
-export { createCosmetics, useCosmetics } from './composables/cosmetics';
-export * from './composables/csv';
-export type { BTDates, CreateDatesOptions } from './composables/dates';
-export { createDates, useDates } from './composables/dates';
-export type { BTDemo } from './composables/demo';
-export { createDemo, useDemo } from './composables/demo';
-export type { BTDocumentMeta, UseDocumentMetaOptions } from './composables/document-meta';
-export { useDocumentMeta } from './composables/document-meta';
-export * from './composables/draggable';
-export type { BTFilters, UseFiltersOptions } from './composables/filters';
-export { createFilters, useFilters } from './composables/filters';
-export { useLocalDb, useLocalCache } from './composables/forage';
-export * from './composables/helpers';
-export { useId } from './composables/id';
-export type { TableColumn, CustomFilterParam, ListEvents, ListProps, GroupedHeaderOption, UseListOptions } from './composables/list';
-export { useList } from './composables/list';
-export type { BTNavigation, ExternalParty, ExternalNavigation, NavigationItem, UseNavigationOptions } from './composables/navigation';
-export { createNavigation, useNavigation } from './composables/navigation';
-export type { BTPresets, CreatePresetsOptions } from './composables/presets';
-export { createPresets, usePresets } from './composables/presets';
-export type { BTPWA, SWEvent } from './composables/pwa';
-export { createPWA, usePWA } from './composables/pwa';
-export * from './composables/resizable';
-export type { UseRulesOptions } from './composables/rules';
-export { useRules } from './composables/rules';
-export type { BTStoreDefinition, BTStore, StoreMode, StorageMode, LocalMeta, LocallyStoredItem, StoreGetAllReturn, StoreGetReturn, UseStoreOptions, CreateStoreBuilderOptions, CreateStoreOptions } from './composables/stores';
-export { createStoreBuilder, createStoreDefinition, useStore, useStoreDefinition, createWholeLastUpdateStoreDefinition, createSessionStoreDefinition } from './composables/stores';
-export type { UseTrackerOptions } from './composables/track';
-export { useTracker } from './composables/track';
-export { createUrl, useUrls, useAuthUrl, useDbName, useDataUrl } from './composables/urls';
-export * from './types';
-export type { CoreApp, CreateCoreOptions } from './core';
-export { createCore } from './core';
+import { App } from 'vue';
+import { ComponentPublicInstance } from 'vue';
+import { ComputedRef } from 'vue';
+import { DateTime } from 'luxon';
+import { MaybeRefOrGetter } from 'vue';
+import { MaybeRefOrGetter as MaybeRefOrGetter_2 } from '@vueuse/core';
+import { Position } from '@vueuse/core';
+import { Ref } from 'vue';
+import { RemovableRef } from '@vueuse/core';
+import { RouteLocationNormalized } from 'vue-router';
+import { ShallowRef } from 'vue';
+import { Store } from 'pinia';
+import { StoreDefinition } from 'pinia';
+
+/**adds and sorts the weekday string */
+export declare function addWeekday(weekdays?: string, day?: string): string | undefined;
+
+export declare interface ApiActionOptions extends PathOptions, DoActionOptions {
+    api: BTApi;
+}
+
+export declare function appendUrl(originalVal?: string, additionalVal?: string): string;
+
+export declare interface AuthItem {
+    children?: AuthItem[];
+    ignoreSuspension?: boolean;
+    permissions?: string[];
+    requiresAuth?: boolean;
+    subscriptions?: string[];
+}
+
+export declare interface AuthSubscription {
+    code: string;
+    value: number;
+}
+
+export declare interface BaseAuthCredentials {
+    expiresOn?: string;
+    isGlobalAdmin?: boolean;
+    isLoggedIn?: boolean;
+    isSuspended?: boolean;
+    permissions?: string;
+    subscriptionCode?: string;
+    timeZone?: string;
+    token?: string;
+    userID?: string;
+    userPermissions?: string[];
+}
+
+export declare interface BaseCosmeticTheme {
+    primary: string;
+    secondary: string;
+    accent: string;
+    error: string;
+    info: string;
+    success: string;
+    warning: string;
+}
+
+export declare interface BaseModel {
+    id?: string;
+}
+
+export declare type BladeDensity = 'default' | 'comfortable' | 'compact';
+
+export declare type BladeMode = 'new' | 'view' | 'edit';
+
+/**
+ Inline: merges toolbars | much more compact | hides navigation
+ Page: shows navigation and page settings
+ Blade: shows blade minimize, maximize, close, and pins as a column
+ Free-moving: show blade as draggable and resizable with minimize, maximize, and close and pinning
+ */
+export declare type BladeVariant = 'page' | 'blade' | 'freestyle' | 'inline' | 'pane';
+
+export declare interface BTActions {
+    apiGet: (doOptions: ApiActionOptions) => Promise<any>;
+    apiPost: (doOptions: ApiActionOptions) => Promise<any>;
+    actionLoadingMsg: ShallowRef<string | undefined>;
+    actionErrorMsg: ShallowRef<string | undefined>;
+    clearErrors: () => void;
+    deleteItem: (doOptions: DeleteOptions) => Promise<any>;
+    doAction: (action: any, options?: DoActionOptions) => Promise<any>;
+    getAllItems: (doOptions: GetOptions) => Promise<any>;
+    getItem: (doOptions: GetOptions) => Promise<any>;
+    isLoading: ComputedRef<boolean>;
+    logError: (err?: string | Error) => void;
+    restoreItem: (doOptions: RestoreOptions) => Promise<any>;
+    saveItem: (doOptions: SaveOptions) => Promise<any>;
+}
+
+export declare interface BTApi {
+    buildHeaders: (options: PathOptions) => HeadersInit;
+    buildQuery: (params: any) => string;
+    buildUrl: (path: PathOptions) => string;
+    deleteItem: (pathOptions: PathOptions) => Promise<string | undefined>;
+    get: <T>(pathOptions: PathOptions) => Promise<T>;
+    getAll: <T>(pathOptions: PathOptions) => Promise<T>;
+    post: <T>(pathOptions: PathOptions) => Promise<T | undefined>;
+    patch: <T>(pathOptions: PathOptions) => Promise<T | undefined>;
+}
+
+export declare interface BTAuth {
+    authState: string;
+    canEdit: (navName?: string) => boolean;
+    canEditPermit: (permit: string) => boolean;
+    canView: (navName?: string) => boolean;
+    canViewPermit: (permit: string) => boolean;
+    credentials: RemovableRef<any>;
+    doShow: (subcodes?: string[], permissions?: string[], action?: 'view' | 'edit') => boolean;
+    doShowByNav: (navName?: string | AuthItem, includeChildren?: boolean) => boolean;
+    getAuthorizeUrl: (redirectPath?: string) => string;
+    getTimeZone: () => string;
+    getToken: (code?: string, state?: string) => Promise<void>;
+    isLoggedIn: ComputedRef<boolean>;
+    login: (redirectPath?: string) => void;
+    logout: (navNameRedirect?: string) => void;
+    setAuth: (jwtToken?: string) => void;
+    timeZone: ComputedRef<string>;
+    tryLogin: () => boolean | undefined;
+}
+
+export declare interface BTCosmetics {
+    state: RemovableRef<CosmeticData>;
+    initiate: () => void;
+    resetCosmetics: (toDefault: boolean) => void;
+    setTemporaryColor: (color: string) => void;
+    toggleDrawer: () => void;
+    toggleDrawerStick: () => void;
+    toggleLightDark: () => void;
+    undoTemporaryColor: () => void;
+}
+
+export declare interface BTDates {
+    getToday: () => string;
+    getTomorrow: () => string;
+    tzDate: (val?: string, fromFormat?: string) => DateTime;
+    tzString: (val?: string, format?: string, fromFormat?: string) => string;
+    utcDate: (val?: string, fromFormat?: string) => DateTime;
+    utcString: (val?: string, format?: string, fromFormat?: string) => string;
+}
+
+export declare interface BTDemo {
+    endDemo: () => void;
+    isDemoing: Ref<boolean>;
+    startDemo: () => void;
+}
+
+export declare interface BTDocumentMeta {
+    updateMeta: (to: RouteLocationNormalized) => void;
+}
+
+export declare interface BTFilters {
+    findFilter: (mFilter: string | undefined) => Function;
+}
+
+export declare interface BTNavigation {
+    showAppBar: Ref<boolean>;
+    showAppNavigation: Ref<boolean>;
+    backgroundName: Ref<string | undefined>;
+    hesitate: Ref<boolean>;
+    navigationItems: NavigationItem[];
+    findArchiveName: (navName?: string) => string | undefined;
+    findCacheHours: (navName?: string) => number;
+    findDisplay: (navName?: string) => string | undefined;
+    findIcon: (navName?: string) => string | undefined;
+    findItem: (navName?: string | NavigationItem) => NavigationItem | null;
+    findStoreName: (navName?: string) => string;
+    findPath: (navName?: string) => string | undefined;
+    findSingleDisplay: (navName?: string) => string | undefined;
+    updateNavigationProperties: (navName?: string | NavigationItem) => void;
+}
+
+export declare interface BTPresets {
+    usePresets(preset?: string): any;
+}
+
+export declare interface BTPWA {
+    canInstallApp: Ref<boolean>;
+    canUpdateApp: Ref<boolean>;
+    installApp: () => void;
+    isInstalled: () => boolean;
+    updateApp: () => void;
+}
+
+export declare interface BTStore extends Store<any, {}, {}, {
+    deleteItem: (dOptions: PathOptions) => Promise<string | undefined>;
+    get: <T extends BaseModel>(dOptions: PathOptions) => Promise<StoreGetReturn<T>>;
+    getAll: <T extends BaseModel>(dOptions: PathOptions) => Promise<StoreGetAllReturn<T>>;
+    patch: <T extends BaseModel>(dOptions: PathOptions) => Promise<T | undefined>;
+    post: <T extends BaseModel>(dOptions: PathOptions) => Promise<T | undefined>;
+    restore: <T extends BaseModel>(dOptions: PathOptions) => Promise<T | undefined>;
+}> {
+}
+
+export declare interface BTStoreDefinition extends StoreDefinition<any, {}, {}, {
+    deleteItem: (dOptions: PathOptions) => Promise<string | undefined>;
+    get: <T extends BaseModel>(dOptions: PathOptions) => Promise<StoreGetReturn<T>>;
+    getAll: <T extends BaseModel>(dOptions: PathOptions) => Promise<StoreGetAllReturn<T>>;
+    patch: <T extends BaseModel>(dOptions: PathOptions) => Promise<T | undefined>;
+    post: <T extends BaseModel>(dOptions: PathOptions) => Promise<T | undefined>;
+    restore: <T extends BaseModel>(dOptions: PathOptions) => Promise<T | undefined>;
+}> {
+}
+
+export declare function capitalizeWords(val?: string): string | undefined;
+
+export declare function checkImage(url?: string, goodCallback?: any, badCallback?: any): void;
+
+/**whether string is contained somewhere in this value */
+export declare function containsSearch(value?: string, str?: string): boolean;
+
+/**whether the csv string contains the weekday
+ * returns true if either prop is undefined
+ */
+export declare function containsWeekday(weekdays?: string, wkDay?: string): boolean;
+
+/**copies object and all descendant properties */
+export declare function copyDeep(aObject: any): any;
+
+/**copies object and returns copied object with descendant properties placed in alphabetical order */
+export declare function copyItemByAlphabet(aObject: any): any;
+
+export declare interface CoreApp {
+    install(app: App): void;
+}
+
+declare interface CosmeticData {
+    dark?: BaseCosmeticTheme;
+    drawer?: boolean;
+    drawerStick?: boolean;
+    light?: BaseCosmeticTheme;
+    theme?: string;
+}
+
+export declare function createApi(options?: UseApiOptions): BTApi;
+
+export declare function createAuth(options: CreateAuthOptions): BTAuth;
+
+export declare interface CreateAuthOptions {
+    defaultTimeZone?: string;
+    demo?: BTDemo;
+    /**expiry token date format.  Defaults to 'd/MM/yyyy h:mm:ss a' */
+    expiryTokenFormat?: string;
+    /**OVERRIDES CORE DEFAULT. retrieve the auth item */
+    getAuthItem?: (navName?: string | AuthItem) => AuthItem | null;
+    /**OVERRIDES DEFAULT. the url to start the OAuth 2.0 process */
+    getAuthorizeUrl?: (redirectPath?: string, state?: string) => string;
+    /**OVERRIDES DEFAULT. use the given code and generate the url to convert to an access token */
+    getTokenUrl?: (code: string, redirect_uri: string, grant_type: string, client_id: string) => string;
+    /**OVERRIDES DEFAULT.  */
+    getToken?: (code?: string, state?: string) => Promise<void>;
+    oauthGrantType?: string;
+    oauthClientID?: string;
+    /**sets current credentials on top of default function
+     * for processing the token payload and applying to state
+     */
+    processTokenPayload?: (state: RemovableRef<any>, payload: any) => void;
+    /**suboptions */
+    subscriptionOptions?: AuthSubscription[];
+}
+
+export declare function createCore(options: CreateCoreOptions): CoreApp;
+
+export declare interface CreateCoreOptions extends UseCosmeticsOptions<BaseCosmeticTheme> {
+    auth: CreateAuthOptions;
+    defaultCacheExpiryHours?: number;
+    navItems?: NavigationItem[];
+    presets: any;
+    /**suboptions */
+    subscriptionOptions?: AuthSubscription[];
+    urls: CreateUrlOptions;
+}
+
+export declare function createCosmetics<T extends BaseCosmeticTheme>(options: UseCosmeticsOptions<T>): void;
+
+export declare function createDates(options: CreateDatesOptions): BTDates;
+
+export declare interface CreateDatesOptions {
+    getTimeZone: () => string;
+}
+
+export declare function createDemo(): BTDemo;
+
+export declare function createFilters(options: UseFiltersOptions): BTFilters;
+
+export declare function createNavigation(options: UseNavigationOptions): BTNavigation;
+
+export declare function createPresets(options: CreatePresetsOptions): BTPresets;
+
+export declare interface CreatePresetsOptions {
+    presets: any;
+}
+
+export declare function createPWA(): BTPWA;
+
+export declare function createSessionStoreDefinition(options: UseSessionStoreOptions): BTStoreDefinition;
+
+export declare function createStoreBuilder(options: CreateStoreBuilderOptions): (opt: CreateStoreOptions) => BTStoreDefinition;
+
+export declare interface CreateStoreBuilderOptions {
+    /**ideally required. Otherwise will struggle to find url path */
+    api?: BTApi;
+    /**ideally required. For setting unique local storage keys */
+    auth?: BTAuth;
+    /**build a query.  Overrides the default */
+    builderQuery?: (params: any) => string;
+    /**overrides the default */
+    buildUrl?: (path: PathOptions) => string;
+}
+
+export declare function createStoreDefinition(options: UseStoreOptions): BTStoreDefinition;
+
+export declare interface CreateStoreOptions {
+    /**particularly what store syle to use */
+    storeMode: StoreMode;
+    /**whether to store data locally or only for the duration of the session */
+    storageMode: StorageMode;
+    /**the name of this store */
+    storeName: string;
+}
+
+export declare function createUrl(options: CreateUrlOptions): CreateUrlOptions;
+
+declare interface CreateUrlOptions {
+    production: UrlSet;
+    staging: UrlSet;
+    development: UrlSet;
+}
+
+export declare function createWholeLastUpdateStoreDefinition(options: UseWholeLastUpdateStoreOptions): BTStoreDefinition;
+
+export declare function csvContains(value?: string, tag?: string): boolean;
+
+export declare const csvDefaults: {
+    canExportCSV: boolean;
+};
+
+export declare interface CSVItem {
+    header: string;
+    itemText?: string;
+    value: any;
+}
+
+export declare interface CSVProps {
+    canExportCSV?: boolean;
+}
+
+export declare interface CustomFilterParam {
+    name: string;
+    filterFunction: () => string;
+    onFilterResult: Function | null;
+}
+
+export declare function DataURIToBlob(dataURI: any): Blob;
+
+/**must be an object.  Returns a flat map of all items in the prop selector */
+export declare function deepSelect(obj: any, propSelector?: Function): any[];
+
+export declare interface DeleteOptions extends PathOptions, DoActionOptions {
+    /**Returns a string if cannot */
+    onCanDeleteAsync?: OnCanDoAsync;
+    /**Will override the default store delete action */
+    onDeleteAsync?: OnDoAsync;
+    /**Will open a dialog box requesting user confirmation for delete action */
+    onDeleteSuccessAsync?: OnDoAsync;
+    store?: BTStoreDefinition;
+}
+
+declare interface DoActionOptions {
+    completionMsg?: string;
+    confirmationMsg?: string;
+    errorMsg?: string;
+    loadingMsg?: string;
+    requireConfirmation?: boolean;
+    throwError?: boolean;
+}
+
+export declare function extensionExists(elementId?: string): boolean;
+
+export declare interface ExternalNavigation {
+    canPull?: boolean;
+    canPush?: boolean;
+    convertFunc?: Function;
+    name?: string;
+    localNavigation?: string;
+    localDisplayPath?: string;
+    localComparePath?: string;
+    syncComparePath?: string;
+    syncDisplayPath?: string;
+    syncIDPath?: string;
+}
+
+export declare interface ExternalParty {
+    party?: string;
+    property?: string;
+}
+
+export declare function extractErrorDescription(error: any): string;
+
+export declare type FieldVariant = 'underlined' | 'outlined' | 'filled' | 'solo' | 'solo-inverted' | 'solo-filled' | 'plain';
+
+declare type FindPath = (navName?: string) => string | undefined;
+
+/**
+ *
+ * @param val Converts string from camel case to every word being capitalized and spaces between
+ * @returns
+ */
+export declare function fromCamelCase(val?: string): string | undefined;
+
+declare interface GeoCoordinate {
+    lat: number;
+    lng: number;
+}
+
+/**
+ * get area around a certain location with a space of the given size
+ * @param location
+ * @param radius
+ * @returns
+ */
+export declare function getAreaAround(location: GeoCoordinate, radius: number): {
+    lat: number;
+    lng: number;
+}[];
+
+/**get square area using the location as the far right line */
+export declare function getAreaToLeft(location: GeoCoordinate, radius: number): {
+    lat: number;
+    lng: number;
+}[];
+
+/**get square area using the location as the far left line */
+export declare function getAreaToRight(location: GeoCoordinate, radius: number): {
+    lat: number;
+    lng: number;
+}[];
+
+/**
+ *
+ * @param value converts location to a single string and standardizes state and road names, etc.
+ * @returns
+ */
+export declare function getGoogleMapsLocationLine(value: any): any;
+
+export declare function getImageData(url?: string, throwErrorOnFail?: boolean): Promise<unknown>;
+
+export declare function getLocationLine(value: any, forGoogle?: boolean): any;
+
+export declare function getMinDate(): number;
+
+export declare function getMinDateString(): string;
+
+export declare interface GetOptions extends PathOptions, DoActionOptions {
+    /**returns an error msg if failed */
+    onGetAsync?: OnGetAsync;
+    /**called after get occurs successfully */
+    onGetSuccessAsync?: OnGetSuccessAsync;
+    store?: BTStoreDefinition;
+}
+
+export declare function getRandomColor(): string;
+
+export declare interface GroupedHeaderOption {
+    position: number;
+    values: TableColumn[];
+}
+
+/**tests for whether string is contains in any of the given props of the given value */
+export declare function hasSearch(value: any, str?: string, props?: string[]): boolean;
+
+export declare function isArrayOfLength(val: any, l: number): boolean;
+
+export declare function isLengthyArray(val: any, greaterThan?: number): boolean;
+
+export declare function isMinDate(d?: string): boolean;
+
+export declare interface ListEvents {
+    (e: 'change', item: any): void;
+    (e: 'deleted', item: any): void;
+    (e: 'input', item: any): void;
+    (e: 'select', item: any): void;
+    (e: 'mouse-over-item', item: any): void;
+}
+
+export declare interface ListProps {
+    additionalUrl?: string;
+    bladeName?: string;
+    canAdd?: boolean;
+    canDelete?: boolean;
+    canEdit?: boolean;
+    canRestore?: boolean;
+    canShowInactive?: boolean;
+    canSelect?: boolean;
+    canUnselect?: boolean;
+    confirmOnDelete?: boolean;
+    customFilters?: CustomFilterParam[];
+    defaultFilters?: string[];
+    dividers?: boolean;
+    eager?: boolean;
+    errorMsg?: string;
+    headers?: TableColumn[];
+    hideActions?: boolean;
+    hideColumns?: boolean;
+    hideFilters?: boolean;
+    hideRefresh?: boolean;
+    hideSubtoolbarSettings?: boolean;
+    includeDetails?: boolean;
+    isSingle?: boolean;
+    itemBladeName?: string;
+    itemID?: string;
+    items?: any[];
+    itemsPerPage?: number;
+    itemText?: string;
+    lines?: 'one' | 'two' | 'three';
+    loadingMsg?: string;
+    localOnly?: boolean;
+    nav?: string;
+    /**for defining if deletable (show button or not) */
+    onCanDelete?: (item: any) => boolean;
+    /**when trying to delete in api */
+    onCanDeleteAsync?: OnCanDoAsync;
+    onGetSaveAsync?: OnDoSuccessAsync;
+    onCanRestore?: (item: any) => boolean;
+    onCanRestoreAsync?: OnCanDoAsync;
+    onCanSaveAsync?: OnCanDoAsync;
+    onCanSelectItem?: (item: any) => boolean;
+    onDeleteAsync?: OnDoAsync;
+    onDeleteSuccessAsync?: OnDoAsync;
+    onFilter?: Function;
+    onGetAsync?: OnGetAsync;
+    onGetSuccessAsync?: OnGetSuccessAsync;
+    onRestoreAsync?: OnDoSuccessAsync;
+    onRestoreSuccessAsync?: OnDoSuccessAsync;
+    onSaveAsync?: OnDoSuccessAsync;
+    onSaveSuccessAsync?: OnDoSuccessAsync;
+    onSelectItem?: (item: any) => void;
+    params?: any;
+    proxyID?: string;
+    proxyQueryKey?: string;
+    refreshToggle?: boolean;
+    searchProps?: string[];
+    searchQueryKey?: string;
+    selectProps?: string[];
+    sortBy?: string;
+    sortOrder?: 'Ascending' | 'Descending';
+    showListOnly?: boolean;
+    showTableOnly?: boolean;
+    showSearch?: boolean;
+    startShowingInactive?: boolean;
+    storeMode?: StoreMode;
+    storageMode?: StorageMode;
+    useInterEvents?: boolean;
+    useServerPagination?: boolean;
+    useBladeSrc?: boolean;
+    useRouteSrc?: boolean;
+    variant?: BladeVariant;
+}
+
+declare interface LocalForage extends LocalForageDbMethods {
+    LOCALSTORAGE: string;
+    WEBSQL: string;
+    INDEXEDDB: string;
+    /**
+     * Set and persist localForage options. This must be called before any other calls to localForage are made, but can be called after localForage is loaded.
+     * If you set any config values with this method they will persist after driver changes, so you can call config() then setDriver()
+     * @param {LocalForageOptions} options?
+     */
+    config(options: LocalForageOptions): boolean;
+    config(options: string): any;
+    config(): LocalForageOptions;
+    /**
+     * Create a new instance of localForage to point to a different store.
+     * All the configuration options used by config are supported.
+     * @param {LocalForageOptions} options
+     */
+    createInstance(options: LocalForageOptions): LocalForage;
+    driver(): string;
+    /**
+     * Force usage of a particular driver or drivers, if available.
+     * @param {string} driver
+     */
+    setDriver(driver: string | string[], callback?: () => void, errorCallback?: (error: any) => void): Promise<void>;
+    defineDriver(driver: LocalForageDriver, callback?: () => void, errorCallback?: (error: any) => void): Promise<void>;
+    /**
+     * Return a particular driver
+     * @param {string} driver
+     */
+    getDriver(driver: string): Promise<LocalForageDriver>;
+    getSerializer(callback?: (serializer: LocalForageSerializer) => void): Promise<LocalForageSerializer>;
+    supports(driverName: string): boolean;
+    ready(callback?: (error: any) => void): Promise<void>;
+}
+
+declare interface LocalForageDbInstanceOptions {
+    name?: string;
+    storeName?: string;
+}
+
+declare interface LocalForageDbMethods extends LocalForageDbMethodsCore, LocalForageDbMethodsOptional {
+}
+
+declare interface LocalForageDbMethodsCore {
+    getItem<T>(key: string, callback?: (err: any, value: T | null) => void): Promise<T | null>;
+    setItem<T>(key: string, value: T, callback?: (err: any, value: T) => void): Promise<T>;
+    removeItem(key: string, callback?: (err: any) => void): Promise<void>;
+    clear(callback?: (err: any) => void): Promise<void>;
+    length(callback?: (err: any, numberOfKeys: number) => void): Promise<number>;
+    key(keyIndex: number, callback?: (err: any, key: string) => void): Promise<string>;
+    keys(callback?: (err: any, keys: string[]) => void): Promise<string[]>;
+    iterate<T, U>(iteratee: (value: T, key: string, iterationNumber: number) => U, callback?: (err: any, result: U) => void): Promise<U>;
+}
+
+declare interface LocalForageDbMethodsOptional {
+    dropInstance: LocalForageDropInstanceFn;
+}
+
+declare interface LocalForageDriver extends LocalForageDriverDbMethods {
+    _driver: string;
+    _initStorage(options: LocalForageOptions): void;
+    _support?: boolean | LocalForageDriverSupportFunc;
+}
+
+declare interface LocalForageDriverDbMethods extends LocalForageDbMethodsCore, LocalForageDriverMethodsOptional {
+}
+
+declare interface LocalForageDriverMethodsOptional {
+    dropInstance?: LocalForageDropInstanceFn;
+}
+
+declare interface LocalForageDriverSupportFunc {
+    (): Promise<boolean>;
+}
+
+declare interface LocalForageDropInstanceFn {
+    (dbInstanceOptions?: LocalForageDbInstanceOptions, callback?: (err: any) => void): Promise<void>;
+}
+
+declare interface LocalForageOptions extends LocalForageDbInstanceOptions {
+    driver?: string | string[];
+    size?: number;
+    version?: number;
+    description?: string;
+}
+
+declare interface LocalForageSerializer {
+    serialize<T>(value: T | ArrayBuffer | Blob, callback: (value: string, error: any) => void): void;
+    deserialize<T>(value: string): T | ArrayBuffer | Blob;
+    stringToBuffer(serializedString: string): ArrayBuffer;
+    bufferToString(buffer: ArrayBuffer): string;
+}
+
+export declare interface LocallyStoredItem<T> {
+    meta: LocalMeta;
+    data: T;
+    count?: number;
+    filters?: string[];
+}
+
+export declare interface LocalMeta {
+    storedOn: string;
+    isDetailed?: boolean;
+    earliestData?: string;
+    lastUpdate?: string;
+}
+
+export declare interface NavigationItem extends AuthItem {
+    /**aliases are other names that could use this navigation item's set of permissions, etc.*/
+    aliases?: string[];
+    /**potentially the nav that leads to the archive */
+    archiveName?: string;
+    /**the name of the background img to show when the route opens this nav */
+    background?: string;
+    /**how long until locally cached data is refreshed */
+    cacheExpiryHours?: number;
+    /**any children of this nav item */
+    children?: NavigationItem[];
+    /**the name that will be displayed in the navigation menu */
+    displayName?: string;
+    /**where credentials can be found for external parties*/
+    externalPartyCredentialNavigation?: string;
+    /**possible external parties to connect to and sync with */
+    externalParties?: ExternalParty[];
+    /**possible external party navigation items and how to connect/sync */
+    externalNavigations?: ExternalNavigation[];
+    /**will hide app bar if set to true when the route opens this nav */
+    hideAppBar?: boolean;
+    /**will hide the nav sidebar if set to true when the route opens this nav */
+    hideNavigation?: boolean;
+    /**will open a dialog box to confirm navigating away from this route */
+    hesitate?: boolean;
+    /**the mdi icon that goes with this nav item.  Will show in places like the nav menu */
+    icon?: string;
+    /**default to false. True will mean that even is account is suspended, this will still allow navigation */
+    ignoreSuspension?: boolean;
+    /**default to true.  When false will hide from nav menu */
+    isInNavMenu?: boolean;
+    /**the microservice the leads to the default url to obtain data from.  Defaults to 'default'. */
+    microservice?: string;
+    /**the name of this nav item. */
+    name?: string;
+    /**the url path on top of the base microservice url */
+    path?: string;
+    /**permissions that are required for this navItem.  All these permissions must be met. */
+    permissions?: string[];
+    /**default to true.  When false will allow universal access regardless of permission */
+    requiresAuth?: boolean;
+    /**the name of the route to access individual items */
+    singleName?: string;
+    /**this nav item is restricted to these subscriptions.  So the user needs to have at least one of these subscription codes. */
+    subscriptions?: string[];
+    /**this nav item is preferred in this subscription codes. */
+    subFilters?: string[];
+}
+
+export declare function nestedValue(obj: any, path?: string): any;
+
+declare type OnCanDoAsync = (item: any) => Promise<string | undefined>;
+
+declare type OnDoAsync = (item: any) => Promise<string | undefined>;
+
+declare type OnDoSuccessAsync = (item: any) => Promise<any>;
+
+declare type OnGetAsync = (opt?: GetOptions) => Promise<any>;
+
+declare type OnGetSuccessAsync = (item: any, opt?: GetOptions) => Promise<any>;
+
+export declare interface PathOptions {
+    /**always added to end before query {url}/{additionalUrl}?{query} */
+    additionalUrl?: string;
+    /**application/json or other options */
+    contentType?: string;
+    /**that data to send in the body for POST, PATCH, and DELETE requests */
+    data?: any;
+    /** resulting url after building {nav | url}/{additionalUrl}?{params} */
+    finalUrl?: string;
+    /**override default headers */
+    headers?: HeadersInit;
+    /**id will be added as a url paramter (/{id}?) rather than as a query parameter */
+    id?: string;
+    /**where to find the url */
+    nav?: string;
+    /**headers will not be calculated.  Only the given headers in these options will be used */
+    overrideHeaders?: boolean;
+    /**query parameters */
+    params?: QueryParams;
+    /**attaches a proxyID to the request */
+    proxyID?: string;
+    /**whether to refresh the store data and go straight to the server */
+    refresh?: boolean;
+    /**returns result as a json object.  Defaults to true. */
+    returnJson?: boolean;
+    /**returns result as a string */
+    returnText?: boolean;
+    /**If false, returns response no matter the status code */
+    throwError?: boolean;
+    /**if exists then overrides default nav */
+    url?: string;
+    /**whether to preference using the local cache */
+    useLocalCache?: boolean;
+}
+
+export declare interface PointerOrTouchEvent extends PointerEvent, TouchEvent {
+}
+
+export declare interface QueryParams {
+    filterBy?: string;
+    includeCount?: boolean;
+    includeDetails?: boolean;
+    includeInactive?: boolean;
+    lastUpdate?: string;
+    other?: any;
+    properties?: string[] | string;
+    query?: string;
+    searchString?: string;
+    sortOrder?: string;
+    sortBy?: string;
+    takeFrom?: number;
+    takeAmount?: number;
+}
+
+declare interface RefreshOptions {
+    deepRefresh?: boolean;
+    resetSearch?: boolean;
+}
+
+export declare function removeWeekday(weekdays?: string, day?: string): string | undefined;
+
+export declare type ResizeHandle = 't' | 'r' | 'b' | 'l' | 'tr' | 'br' | 'bl' | 'tl';
+
+export declare interface RestoreOptions extends PathOptions, DoActionOptions {
+    /**Returns a string if cannot */
+    onCanRestoreAsync?: OnCanDoAsync;
+    /**Will override the default store delete action */
+    onRestoreAsync?: OnDoSuccessAsync;
+    /**Called after restore succeeds */
+    onRestoreSuccessAsync?: OnDoSuccessAsync;
+    store?: BTStoreDefinition;
+}
+
+/**
+ * rounds the given value to a certain number of decimal places
+ * @param v
+ * @param dPlaces
+ * @returns
+ */
+export declare function roundTo(val: number, dPlaces: number): number;
+
+export declare interface SaveOptions extends PathOptions, DoActionOptions {
+    /**will seek to post if 'new' otherwise will patch */
+    mode?: BladeMode;
+    /**called to check whether to proceed with save */
+    onCanSaveAsync?: OnCanDoAsync;
+    /**
+     * retrieves item to save
+     * called before seeing whether it can save
+     */
+    onGetSaveAsync?: OnDoSuccessAsync;
+    /**Will override the default store post/patch action */
+    onSaveAsync?: OnDoSuccessAsync;
+    /**Called after save succeeds */
+    onSaveSuccessAsync?: OnDoSuccessAsync;
+    store?: BTStoreDefinition;
+}
+
+export declare type StorageMode = 'session' | 'local-cache';
+
+export declare interface StoreGetAllReturn<T> {
+    data: T[];
+    count?: number;
+    filters?: string[];
+}
+
+export declare interface StoreGetReturn<T> {
+    data: T;
+}
+
+export declare type StoreMode = 'whole-last-updated' | 'partial-last-updated' | 'session';
+
+export declare interface SWEvent extends Event {
+    detail: any;
+}
+
+export declare interface TableColumn {
+    align?: 'start' | 'end' | 'center';
+    bool?: number;
+    csv?: boolean;
+    csvArray?: boolean;
+    csvFilter?: string;
+    csvText?: string;
+    hide?: boolean;
+    itemText?: string;
+    level?: number;
+    maxWidth?: string;
+    minWidth?: string;
+    nav?: string;
+    prefix?: string;
+    searchable?: boolean;
+    single?: boolean;
+    sublevel?: number;
+    suffix?: string;
+    textFilter?: string;
+    textFunction?: Function;
+    title?: string;
+    value?: string;
+}
+
+/**
+ * Converts props to camel casing
+ * @param value
+ * @returns
+ */
+export declare function toCamelCase(value: any): any;
+
+export declare function toCompareString(str?: string): string | null;
+
+export declare function toggleCSV(value?: string, tag?: string): string | null;
+
+export declare function twiddleThumbs(mSec?: number): Promise<void>;
+
+declare interface UrlSet {
+    auth?: string;
+    data?: string;
+    localDbName?: string;
+    other?: any;
+}
+
+export declare function useActions(options?: UseActionsOptions): BTActions;
+
+export declare interface UseActionsOptions extends DoActionOptions {
+    nav?: string;
+    proxyID?: string;
+    refresh?: boolean;
+    store?: BTStoreDefinition;
+    throwError?: boolean;
+    url?: string;
+}
+
+export declare function useActionsTracker(useOptions?: DoActionOptions): {
+    actionErrorMsg: ShallowRef<string | undefined>;
+    actionLoadingMsg: ShallowRef<string | undefined>;
+    actionCompleteMsg: ShallowRef<string | undefined>;
+    clearErrors: () => void;
+    doAction: (action: any, options?: DoActionOptions) => Promise<any>;
+    isLoading: ComputedRef<boolean>;
+    logError: (err?: string | Error) => void;
+};
+
+export declare function useApi(): BTApi;
+
+export declare interface UseApiOptions {
+    auth?: BTAuth;
+    /**overrides the default */
+    buildHeaders?: (path: PathOptions) => HeadersInit;
+    /**build a query.  Overrides the default */
+    buildQuery?: (params: any) => string;
+    /**overrides the default */
+    buildUrl?: (path: PathOptions) => string;
+    /**defaults to 'application/json' */
+    defaultContentType?: string;
+    /**returns result as a json object.  Defaults to true. */
+    defaultReturnJson?: boolean;
+    /**returns result as a string */
+    defaultReturnText?: boolean;
+    /**defaults to true.  Will throw an error on fail */
+    defaultThrowError?: boolean;
+    /**defaults to a function that returns '' */
+    findPath?: FindPath;
+    /**if true and logged in then will set an authorization header with 'bearer [token]' */
+    useBearerToken?: boolean;
+}
+
+export declare function useAuth(): BTAuth;
+
+export declare function useAuthUrl(): string;
+
+export declare function useCosmetics(): BTCosmetics;
+
+export declare interface UseCosmeticsOptions<T extends BaseCosmeticTheme> {
+    defaultDarkTheme?: T;
+    defaultLightTheme?: T;
+    defaultDrawer?: boolean;
+    defaultDrawerStick?: boolean;
+    defaultTheme?: string;
+}
+
+export declare function useCSV(): UseCSVPropsReturn;
+
+export declare interface UseCSVPropsReturn {
+    exportToCSV: Function;
+}
+
+/**
+ *
+ * @param microservice
+ * @returns
+ */
+export declare function useDataUrl(microservice?: string): string;
+
+export declare function useDates(): BTDates;
+
+export declare function useDbName(): string;
+
+export declare function useDemo(): BTDemo;
+
+/**routes with meta object */
+export declare function useDocumentMeta(options?: UseDocumentMetaOptions): BTDocumentMeta;
+
+export declare interface UseDocumentMetaOptions {
+    demo?: BTDemo;
+}
+
+export declare function useDraggable(target: MaybeRefOrGetter<ComponentPublicInstance | null>, //HTMLElement | SVGElement | null | undefined>,
+handle: MaybeRefOrGetter<ComponentPublicInstance | null>, options?: UseDraggableOptions): {
+    draggingIsOn: Ref<boolean>;
+    turnDraggableOff: () => void;
+    turnDraggableOn: () => void;
+};
+
+export declare interface UseDraggableOptions {
+    /**
+     * Only start the dragging when click on the element directly
+     *
+     * @default false
+     */
+    preventDefault?: MaybeRefOrGetter<boolean>;
+    stopPropagation?: MaybeRefOrGetter<boolean>;
+    /**
+     * Whether dispatch events in capturing phase
+     *
+     * @default true
+     */
+    capture?: boolean;
+    /**
+     * Element to attach `pointermove` and `pointerup` events to.
+     *
+     * @default window
+     */
+    draggingElement?: MaybeRefOrGetter<HTMLElement | SVGElement | Window | Document | null | undefined>;
+    /**
+     * Element for calculating bounds (If not set, it will use the event's target).
+     *
+     * @default undefined
+     */
+    /**
+     * Handle that triggers the drag event
+     *
+     * @default target
+     */
+    handle?: MaybeRefOrGetter<HTMLElement | SVGElement | null | undefined>;
+    /**
+     * Initial position of the element.
+     *
+     * @default { x: 0, y: 0 }
+     */
+    initialValue?: MaybeRefOrGetter<Position>;
+    onStart?: (position: Position, event: PointerEvent) => void | false;
+    onMove?: (position: Position, event: PointerEvent) => void;
+    onEnd?: (position: Position, event: PointerEvent) => void;
+    /**
+     * Axis to drag on.
+     *
+     * @default 'both'
+     */
+    axis?: 'x' | 'y' | 'both';
+}
+
+export declare function useFilters(): BTFilters;
+
+export declare interface UseFiltersOptions {
+    dates: BTDates;
+}
+
+export declare function useId(pattern?: string): string;
+
+/**
+ * PROPS first
+ * ROUTE second
+ * BLADE third
+ * @param props
+ * @param emit
+ * @param options
+ */
+export declare function useList(props: ListProps, emit?: ListEvents, options?: UseListOptions): {
+    add: (variant: BladeVariant) => void;
+    asyncItems: Ref<any[]>;
+    currentPage: Ref<number>;
+    deleteItem: (dItem: MaybeRefOrGetter<any>) => void;
+    displayHeaders: ComputedRef<never[]>;
+    errorMsg: ComputedRef<string | undefined>;
+    exportToCSV: () => void;
+    filteredItems: ShallowRef<any[]>;
+    filters: ComputedRef<string[]>;
+    filtersChanged: ComputedRef<boolean>;
+    headerOptions: Ref<    {
+    align?: "start" | "end" | "center" | undefined;
+    bool?: number | undefined;
+    csv?: boolean | undefined;
+    csvArray?: boolean | undefined;
+    csvFilter?: string | undefined;
+    csvText?: string | undefined;
+    hide?: boolean | undefined;
+    itemText?: string | undefined;
+    level?: number | undefined;
+    maxWidth?: string | undefined;
+    minWidth?: string | undefined;
+    nav?: string | undefined;
+    prefix?: string | undefined;
+    searchable?: boolean | undefined;
+    single?: boolean | undefined;
+    sublevel?: number | undefined;
+    suffix?: string | undefined;
+    textFilter?: string | undefined;
+    textFunction?: Function | undefined;
+    title?: string | undefined;
+    value?: string | undefined;
+    }[]>;
+    isDeletable: ComputedRef<(item: any) => boolean>;
+    isLoading: ComputedRef<boolean>;
+    isRestorable: ComputedRef<(item: any) => boolean>;
+    loadingMsg: ComputedRef<string | undefined>;
+    refresh: (options?: RefreshOptions) => Promise<void>;
+    restoreItem: (dItem: MaybeRefOrGetter<any>) => void;
+    searchString: Ref<string | undefined>;
+    selectedFilters: Ref<number[]>;
+    selectItem: (rItem: any, variant: BladeVariant) => void;
+    serverFilters: Ref<string[]>;
+    showError: ShallowRef<boolean>;
+    showInactive: Ref<boolean>;
+    showSearch: ShallowRef<boolean>;
+    sortOrder: Ref<"Ascending" | "Descending" | undefined>;
+    subtitleOptions: ComputedRef<GroupedHeaderOption[]>;
+    tableHeaders: ComputedRef<    {
+    align?: "start" | "end" | "center" | undefined;
+    bool?: number | undefined;
+    csv?: boolean | undefined;
+    csvArray?: boolean | undefined;
+    csvFilter?: string | undefined;
+    csvText?: string | undefined;
+    hide?: boolean | undefined;
+    itemText?: string | undefined;
+    level?: number | undefined;
+    maxWidth?: string | undefined;
+    minWidth?: string | undefined;
+    nav?: string | undefined;
+    prefix?: string | undefined;
+    searchable?: boolean | undefined;
+    single?: boolean | undefined;
+    sublevel?: number | undefined;
+    suffix?: string | undefined;
+    textFilter?: string | undefined;
+    textFunction?: Function | undefined;
+    title?: string | undefined;
+    value?: string | undefined;
+    }[]>;
+    titleOptions: ComputedRef<GroupedHeaderOption[]>;
+    toggleSearch: () => void;
+    totalPages: Ref<number>;
+};
+
+export declare interface UseListOptions {
+    storeMode?: StoreMode;
+    storageMode?: StorageMode;
+    useBladeSrc?: boolean;
+    useRouteSrc?: boolean;
+}
+
+export declare function useLocalCache(): {
+    clearAsync: (storeName: string) => Promise<void>;
+    getAsync: <T>(key: string) => Promise<T | null>;
+    removeAsync: (key: string) => Promise<void>;
+    saveAsync: <T_1>(data: T_1, key: string) => Promise<void>;
+};
+
+export declare function useLocalDb(): LocalForage;
+
+export declare function useNavigation(): BTNavigation;
+
+export declare interface UseNavigationOptions {
+    defaultCacheExpiryHours?: number;
+    navItems?: NavigationItem[];
+}
+
+export declare function usePresets(preset?: string): any;
+
+export declare function usePWA(): BTPWA;
+
+export declare function useResizable(target: MaybeRefOrGetter_2<ComponentPublicInstance | null>, options?: UseResizeOptions): {
+    resizingIsOn: Ref<boolean>;
+    turnResizingOn: (handles?: ResizeHandle[], variant?: BladeVariant) => void;
+    turnResizingOff: (variant?: BladeVariant | undefined) => void;
+};
+
+export declare interface UseResizeOptions {
+    preventDefault?: MaybeRefOrGetter_2<boolean>;
+    stopPropagation?: MaybeRefOrGetter_2<boolean>;
+    handles?: ResizeHandle[];
+    /**
+     * Callback when the dragging starts. Return `false` to prevent dragging.
+     */
+    onStart?: (position: Position, event: PointerEvent) => void | false;
+    /**
+     * Callback during dragging.
+     */
+    onMove?: (position: Position, event: PointerEvent) => void;
+    /**
+     * Callback when dragging end.
+     */
+    onEnd?: (position: Position, event: PointerEvent) => void;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    handleWidth?: number;
+    handleZIndex?: number;
+}
+
+export declare function useRules(options?: UseRulesOptions): any[];
+
+export declare interface UseRulesOptions {
+    forEmail?: boolean;
+    forPassword?: boolean;
+    otherRules?: any;
+    required?: boolean;
+}
+
+declare interface UseSessionStoreOptions {
+    /**ideally required. Otherwise will struggle to find url path */
+    api?: BTApi;
+    /**ideally required. For setting unique local storage keys */
+    auth?: BTAuth;
+    /**whether to store data locally or only for the duration of the session */
+    storageMode: 'session' | 'local-cache';
+    /**build a query.  Overrides the default */
+    buildQuery?: (params: any) => string;
+    /**overrides the default */
+    buildUrl?: (path: PathOptions) => string;
+    /**the name of this store */
+    storeName: string;
+}
+
+export declare function useStore(options: CreateStoreOptions): BTStore;
+
+export declare function useStoreDefinition(options: CreateStoreOptions): BTStoreDefinition;
+
+export declare interface UseStoreOptions {
+    /**ideally required. Otherwise will struggle to find url path */
+    api?: BTApi;
+    /**ideally required. For setting unique local storage keys */
+    auth?: BTAuth;
+    /**build a query.  Overrides the default */
+    builderQuery?: (params: any) => string;
+    /**overrides the default */
+    buildUrl?: (path: PathOptions) => string;
+    /**particularly what store syle to use */
+    storeMode: StoreMode;
+    /**whether to store data locally or only for the duration of the session */
+    storageMode: StorageMode;
+    /**the name of this store */
+    storeName: string;
+}
+
+export declare function useTracker(data: MaybeRefOrGetter<any>, options?: UseTrackerOptions): {
+    asyncItem: Ref<any>;
+    isChanged: Ref<boolean>;
+    restartTracker: () => void;
+};
+
+export declare interface UseTrackerOptions {
+    propsToIgnore?: string[];
+    propsToTrack?: string[];
+    useTracker?: boolean;
+}
+
+export declare function useUrls(): CreateUrlOptions;
+
+declare interface UseWholeLastUpdateStoreOptions {
+    /**ideally required. Otherwise will struggle to find url path */
+    api?: BTApi;
+    /**ideally required. For setting unique local storage keys */
+    auth?: BTAuth;
+    storageMode: 'session' | 'local-cache';
+    storeName: string;
+}
+
+export declare function validEmail(email?: string): boolean;
+
+export declare const weekdayPairs: {
+    value: number;
+    short: string;
+    values: (string | null | undefined)[];
+}[];
+
+/**returns the sort value of the weekday csv string
+ * returns minimum if csv list
+ */
+export declare function weekdayShortName(wkDay?: string): string | undefined;
+
+/**returns the sort value of the weekday csv string
+ * returns minimum if csv list
+ */
+export declare function weekdayValue(wkDay?: string): number;
+
+export { }
+
+
+declare global {
+    interface Navigator {
+        msSaveOrOpenBlob: (blob: Blob, fileName: string) => boolean;
+    }
+}
+