@monkvision/common 4.0.0

package/README/UTILITIES.md

@@ -0,0 +1,254 @@
+# Utilities
+This README page is aimed at providing documentation on a specific part of the `@monkvision/common` package : the
+utility functions. You can refer to [this page](README.md) for more general information on the package.
+
+This package exports various utility functions used throughout the MonkJs SDK.
+
+# Array Utils
+### permutations
+```typescript
+import { permutations } from '@monkvision/common';
+
+console.log(permutations([1, 2, 3]));
+// Output : [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
+```
+Returns an array containing all the possible permutations of the given array.
+
+### uniq
+```typescript
+import { uniq } from '@monkvision/common';
+
+console.log(uniq([1, 1, 1, 2, 3, 3]));
+// Output : [1, 2, 3]
+```
+Return a copy of the given array in which all duplicates have been removed.
+
+### flatten
+```typescript
+import { flatten } from '@monkvision/common';
+
+console.log(flatten([ 1, [2, 3], [[4], [5, 6]]]));
+// Output : [1, 2, 3, 4, 5, 6]
+```
+Flatten the given array.
+
+### flatten
+```typescript
+import { flatMap } from '@monkvision/common';
+
+console.log(flatMap([1, 2, 3], (item: number) => [item, item + 1]));
+// Output : [1, 2, 2, 3, 3, 4]
+```
+JS implementation of the
+[Array.prototype.flatMap](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flatMap)
+method, available on all versions of JavaScript.
+
+---
+
+# Color Utils
+### getRGBAFromString
+```typescript
+import { getRGBAFromString } from '@monkvision/common';
+
+console.log(JSON.stringify(getRGBAFromString('#AF270CCC')));
+// Output : {"r":175,"g":39,"b":12,"a":0.8}
+```
+Returns the RGBA values of the given color. The accepted formats are :
+- RGB : `rgb(167, 224, 146)`
+- RGBA : `rgb(167, 224, 146, 0.03)`
+- HEX : `#A7E092`
+- HEX (alpha) : `#A7E09208`
+- HEX (short) : `#AE9`
+- HEX (short + alpha) : `#AE98`
+
+This function is case-insensitive and ignores white spaces.
+
+### getHexFromRGBA
+```typescript
+import { getHexFromRGBA } from '@monkvision/common';
+
+console.log(getHexFromRGBA({ r: 111, g: 222, b: 0, a: 0.67 }));
+// Output : #6FDE00AB
+```
+Converts RGBA values to their hexadecimal representation.
+
+### shadeColor
+```typescript
+import { shadeColor } from '@monkvision/common';
+
+console.log(shadeColor('#FC72A7', 0.7));
+// Output : #FFC2FFFF
+```
+Apply a shade of black or white over the given color. The amount of shade to apply works as a ratio :
+- use positive values like 0.08 to lighten the color by 8%
+- use negative values like -0.08 to darken the color by 8%
+
+### changeAlpha
+```typescript
+import { changeAlpha } from '@monkvision/common';
+
+console.log(changeAlpha('#FF1234FF', 0.5));
+// Output : #FF123480
+```
+Returns a new color equal to the given color but with a different alpha value.
+
+### getInteractiveVariants
+```typescript
+import { getInteractiveVariants } from '@monkvision/common';
+
+const variants = getInteractiveVariants('#FC72A7');
+/*
+ * variants = {
+ *   [InteractiveStatus.DEFAULT]: '#FC72A7',
+ *   [InteractiveStatus.HOVERED]: '#FF7BB4',
+ *   [InteractiveStatus.ACTIVE]: '#FF80BB',
+ *   [InteractiveStatus.DISABLED]: '#FC72A7',
+ * }
+ */
+```
+Create interactive variants (hovered, active...) for the given color. You can specify as an additional parameter the
+type of variation to use for the interactive colors (lighten or darken the color, default = lighten).
+
+---
+
+# Environment Utils
+### getEnvOrThrow
+```typescript
+import { getEnvOrThrow } from '@monkvision/common';
+
+try {
+  const example = getEnvOrThrow('REACT_APP_EXAMPLE');
+  console.log('Env var is defined :', example);
+} catch (err) {
+  console.log('Env var is not defined');
+}
+```
+Returns the value of a given environment variable. If the value does not exist, it throws an error.
+
+---
+
+# Mimetype Utils
+### MIMETYPE_FILE_EXTENSIONS
+```typescript
+import { MIMETYPE_FILE_EXTENSIONS } from '@monkvision/common';
+
+console.log(MIMETYPE_FILE_EXTENSIONS['text/plain']);
+// Output : ['txt']
+```
+Datamap that associates mimetypes to known file extensions corresponding to this mimetype.
+
+### getFileExtensions
+```typescript
+import { getFileExtensions } from '@monkvision/common';
+
+console.log(getFileExtensions('image/jpeg'));
+// Output : ['jpeg', 'jpg']
+```
+Returns a list of file extensions known to be corresponding to the given mimetype. If no file extension is known for
+this mimetype, this function will throw an error.
+
+### getMimetype
+```typescript
+import { getMimetype } from '@monkvision/common';
+
+console.log(getMimetype('jpg'));
+// Output : 'image/jpeg'
+```
+Returns the mimetype associated with the given file extension. If the file extension is unknown, this function will
+throw an error.
+
+---
+
+# Promise Utils
+### timeoutPromise
+```typescript
+import { timeoutPromise } from '@monkvision/common';
+
+timeoutPromise(5000).then(() => console.log('Hello!'));
+// Output after 5 seconds : 'Hello!'
+```
+This function creates and returns a new Promise that will resolve to void after the given amount of milliseconds.
+
+---
+
+# State Utils
+### getInspectionImages
+```typescript
+import { getInspectionImages } from '@monkvision/common';
+
+console.log(getInspectionImages(inspectionId, images, filterRetakes));
+// Returns an array of all the images having the given inspectionId.
+```
+Utility function that extracts the images of the given inspection. Set `filterRetakes` to `false` to filter retaken
+pictures.
+
+---
+
+# String Utils
+### suffix
+```typescript
+import { suffix } from '@monkvision/common';
+
+console.log(suffix('my-str', { suffix1: true, suffix2: false }));
+// Output : 'my-str suffix1'
+```
+This function suffixes a string with the given suffixes, only if their value is `true` in the suffixes object param.
+
+*Note : The order of the suffixes is not guaranteed.*
+
+### words
+```typescript
+import { words } from '@monkvision/common';
+
+console.log(words('my-str-test'));
+// Output : 'my str test'
+```
+Split the given string into its composing words.
+
+### capitalize
+```typescript
+import { capitalize } from '@monkvision/common';
+
+console.log(capitalize('my-str-test'));
+// Output : 'My-str-test'
+```
+Capitalizes (transforms the first character to upper case) the given string.
+
+### uncapitalize
+```typescript
+import { uncapitalize } from '@monkvision/common';
+
+console.log(uncapitalize('My-str-test'));
+// Output : 'my-str-test'
+```
+Uncapitalizes (transforms the first character to lower case) the given string.
+
+### toCamelCase
+```typescript
+import { toCamelCase } from '@monkvision/common';
+
+console.log(toCamelCase('My-str-test'));
+// Output : 'myStrTest'
+```
+Converts a string to camel case.
+
+---
+
+# Zlib Utils
+### zlibCompress
+```typescript
+import { zlibCompress } from '@monkvision/common';
+
+console.log(zlibCompress('Hello World!'))
+// Output : 'eJzzSM3JyVcIzy/KSVEEABxJBD4='
+```
+Compresses and encodes a string in base64 using the ZLib algorithm.
+
+### zlibDecompress
+```typescript
+import { zlibDecompress } from '@monkvision/common';
+
+console.log(zlibDecompress('eJzzSM3JyVcIzy/KSVEEABxJBD4='))
+// Output : 'Hello World!'
+```
+Decompresses a string that has been encoded in base64 and compressed using the Zlib algorithm.

package/README.md

@@ -0,0 +1,23 @@
+# @monkvision/common
+This package contains logic and bits of code shared accross the MonkJs project.
+
+# Installing
+To install the package, you can run the following command :
+
+```shell
+yarn add @monkvision/common
+```
+
+If you are using TypeScript, this package comes with its type definitions integrated, so you don't need to install
+anything else!
+
+# Detailed Documentation
+This exports implements multiple functionnalities for the MonkJs SDK. If you want more details for each functionnality,
+you can refer to their own README directly :
+
+- [State Management](README/STATE_MANAGEMENT.md).
+- [Theming](README/THEMING.md).
+- [Internationalization](README/INTERNATIONALIZATION.md).
+- [Hooks](README/APP_UTILS).
+- [Utilities](README/UTILITIES.md).
+- [Application Utilities](README/HOOKS).

package/lib/PreventExit/hooks.d.ts

@@ -0,0 +1,15 @@
+import { PreventExitListenerResult } from './store';
+/**
+ * Custom hook that allows preventing the user from exiting the page or navigating away.
+ *
+ * @param preventExit - A boolean value indicating whether to prevent the user from exiting the page or not.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { allowRedirect } = usePreventExit(true);
+ *   return <div onClick={allowRedirect}>My Component</div>;
+ * }
+ * ```
+ */
+export declare function usePreventExit(preventExit: boolean): Pick<PreventExitListenerResult, 'allowRedirect'>;

package/lib/PreventExit/hooks.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePreventExit = void 0;
+var react_1 = require("react");
+var store_1 = require("./store");
+var hooks_1 = require("../hooks");
+/**
+ * Custom hook that allows preventing the user from exiting the page or navigating away.
+ *
+ * @param preventExit - A boolean value indicating whether to prevent the user from exiting the page or not.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { allowRedirect } = usePreventExit(true);
+ *   return <div onClick={allowRedirect}>My Component</div>;
+ * }
+ * ```
+ */
+function usePreventExit(preventExit) {
+    var _a = (0, react_1.useMemo)(store_1.createPreventExitListener, []), cleanup = _a.cleanup, setPreventExit = _a.setPreventExit, allowRedirect = _a.allowRedirect;
+    (0, react_1.useEffect)(function () { return setPreventExit(preventExit); }, [preventExit]);
+    (0, react_1.useEffect)(function () { return cleanup; }, []);
+    return (0, hooks_1.useObjectMemo)({ allowRedirect: allowRedirect });
+}
+exports.usePreventExit = usePreventExit;
+//# sourceMappingURL=hooks.js.map

package/lib/PreventExit/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","sourceRoot":"","sources":["../../src/PreventExit/hooks.ts"],"names":[],"mappings":";;;AAAA,+BAA2C;AAC3C,iCAA+E;AAC/E,kCAAyC;AAEzC;;;;;;;;;;;;GAYG;AACH,SAAgB,cAAc,CAC5B,WAAoB;IAEd,IAAA,KAA6C,IAAA,eAAO,EAAC,iCAAyB,EAAE,EAAE,CAAC,EAAjF,OAAO,aAAA,EAAE,cAAc,oBAAA,EAAE,aAAa,mBAA2C,CAAC;IAC1F,IAAA,iBAAS,EAAC,cAAM,OAAA,cAAc,CAAC,WAAW,CAAC,EAA3B,CAA2B,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;IAC5D,IAAA,iBAAS,EAAC,cAAM,OAAA,OAAO,EAAP,CAAO,EAAE,EAAE,CAAC,CAAC;IAC7B,OAAO,IAAA,qBAAa,EAAC,EAAE,aAAa,eAAA,EAAE,CAAC,CAAC;AAC1C,CAAC;AAPD,wCAOC"}

package/lib/PreventExit/index.d.ts

@@ -0,0 +1 @@
+export * from './hooks';

package/lib/PreventExit/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hooks"), exports);
+//# sourceMappingURL=index.js.map

package/lib/PreventExit/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/PreventExit/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB"}

package/lib/PreventExit/store.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Returns a listener which can used to calculate the state of prevent exit.
+ */
+export interface PreventExitListenerResult {
+    /**
+     * Callback used to set the value indicating if direct exit of the page is currently allowed or not.
+     */
+    setPreventExit: (preventExit: boolean) => void;
+    /**
+     * Allows the user to leave the page without confirmation temporarily.
+     * This should be used when the developer wants to explicitly allow navigation.
+     */
+    allowRedirect: () => void;
+    /**
+     * Performs garbage collection by removing the preventExit state associated with the component.
+     * This should be used when the component is unmounted.
+     */
+    cleanup: () => void;
+}
+/**
+ * Creates a listener function that manages the preventExit state of a component.
+ */
+export declare function createPreventExitListener(): PreventExitListenerResult;

package/lib/PreventExit/store.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPreventExitListener = void 0;
+var keys = [];
+var allPreventExitState = {};
+function arePreventExitRemaining() {
+    if (keys.map(function (key) { return allPreventExitState[key]; }).every(function (i) { return i === false; })) {
+        window.onbeforeunload = null;
+        return true;
+    }
+    return false;
+}
+function publish(id, preventExit) {
+    allPreventExitState[id] = preventExit;
+    if (!arePreventExitRemaining()) {
+        window.onbeforeunload = function (e) {
+            e.preventDefault();
+            return 'prevent-exit';
+        };
+    }
+}
+/**
+ * Creates a listener function that manages the preventExit state of a component.
+ */
+function createPreventExitListener() {
+    var key = Symbol('PreventExitListener');
+    allPreventExitState[key] = true;
+    keys.push(key);
+    return {
+        setPreventExit: function (preventExit) { return publish(key, preventExit); },
+        allowRedirect: function () {
+            window.onbeforeunload = null;
+        },
+        cleanup: function () {
+            delete allPreventExitState[key];
+            arePreventExitRemaining();
+        },
+    };
+}
+exports.createPreventExitListener = createPreventExitListener;
+//# sourceMappingURL=store.js.map

package/lib/PreventExit/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sourceRoot":"","sources":["../../src/PreventExit/store.ts"],"names":[],"mappings":";;;AAAA,IAAM,IAAI,GAAkB,EAAE,CAAC;AAC/B,IAAM,mBAAmB,GAA4B,EAAE,CAAC;AAExD,SAAS,uBAAuB;IAC9B,IAAI,IAAI,CAAC,GAAG,CAAC,UAAC,GAAG,IAAK,OAAA,mBAAmB,CAAC,GAAG,CAAC,EAAxB,CAAwB,CAAC,CAAC,KAAK,CAAC,UAAC,CAAC,IAAK,OAAA,CAAC,KAAK,KAAK,EAAX,CAAW,CAAC,EAAE;QACzE,MAAM,CAAC,cAAc,GAAG,IAAI,CAAC;QAC7B,OAAO,IAAI,CAAC;KACb;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,OAAO,CAAC,EAAU,EAAE,WAAoB;IAC/C,mBAAmB,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC;IACtC,IAAI,CAAC,uBAAuB,EAAE,EAAE;QAC9B,MAAM,CAAC,cAAc,GAAG,UAAC,CAAC;YACxB,CAAC,CAAC,cAAc,EAAE,CAAC;YACnB,OAAO,cAAc,CAAC;QACxB,CAAC,CAAC;KACH;AACH,CAAC;AAsBD;;GAEG;AACH,SAAgB,yBAAyB;IACvC,IAAM,GAAG,GAAG,MAAM,CAAC,qBAAqB,CAAC,CAAC;IAC1C,mBAAmB,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IAChC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAEf,OAAO;QACL,cAAc,EAAE,UAAC,WAAW,IAAK,OAAA,OAAO,CAAC,GAAG,EAAE,WAAW,CAAC,EAAzB,CAAyB;QAC1D,aAAa,EAAE;YACb,MAAM,CAAC,cAAc,GAAG,IAAI,CAAC;QAC/B,CAAC;QACD,OAAO,EAAE;YACP,OAAO,mBAAmB,CAAC,GAAG,CAAC,CAAC;YAChC,uBAAuB,EAAE,CAAC;QAC5B,CAAC;KACF,CAAC;AACJ,CAAC;AAfD,8DAeC"}

package/lib/apps/analytics.d.ts

@@ -0,0 +1,2 @@
+import { MonkAppState } from './appState';
+export declare function useAppStateAnalytics({ inspectionId }: Pick<MonkAppState, 'inspectionId'>): void;

package/lib/apps/analytics.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAppStateAnalytics = void 0;
+var analytics_1 = require("@monkvision/analytics");
+var react_1 = require("react");
+function useAppStateAnalytics(_a) {
+    var inspectionId = _a.inspectionId;
+    var setUserId = (0, analytics_1.useAnalytics)().setUserId;
+    (0, react_1.useEffect)(function () {
+        if (inspectionId) {
+            setUserId(inspectionId);
+        }
+    }, [inspectionId, setUserId]);
+}
+exports.useAppStateAnalytics = useAppStateAnalytics;
+//# sourceMappingURL=analytics.js.map

package/lib/apps/analytics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analytics.js","sourceRoot":"","sources":["../../src/apps/analytics.ts"],"names":[],"mappings":";;;AAAA,mDAAqD;AACrD,+BAAkC;AAGlC,SAAgB,oBAAoB,CAAC,EAAoD;QAAlD,YAAY,kBAAA;IACzC,IAAA,SAAS,GAAK,IAAA,wBAAY,GAAE,UAAnB,CAAoB;IAErC,IAAA,iBAAS,EAAC;QACR,IAAI,YAAY,EAAE;YAChB,SAAS,CAAC,YAAY,CAAC,CAAC;SACzB;IACH,CAAC,EAAE,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC,CAAC;AAChC,CAAC;AARD,oDAQC"}

package/lib/apps/appState.d.ts

@@ -0,0 +1,61 @@
+import { CaptureAppConfig, Sight, SteeringWheelPosition, VehicleType } from '@monkvision/types';
+import { LoadingState } from '../hooks';
+/**
+ * Application state usually used by Monk applications to configure and handle the current user journey.
+ */
+export interface MonkAppState {
+    /**
+     * LoadingState indicating if the application state is loading. If it is loading it usually means that the provider
+     * did not have time to fetch the parameter values.
+     */
+    loading: LoadingState;
+    /**
+     * The current configuration of the application.
+     */
+    config: CaptureAppConfig;
+    /**
+     * The authentication token representing the currently logged-in user. If this param is `null`, it means the user is
+     * not logged in.
+     */
+    authToken: string | null;
+    /**
+     * The ID of the current inspection being handled (picture taking, report viewing...) by the application. If this
+     * param is `null`, it probably means that the inspection must be created by the app.
+     */
+    inspectionId: string | null;
+    /**
+     * The current vehicle type of the app. This value usually helps to choose which sights to display to the user, or
+     * which car 360 wireframes to use for the inspection report.
+     */
+    vehicleType: VehicleType | null;
+    /**
+     * The position of the steering wheel.
+     */
+    steeringWheel: SteeringWheelPosition | null;
+    /**
+     * Getter function used to get the current Sights based on the current VehicleType, SteeringWheel position etc.
+     */
+    getCurrentSights: () => Sight[];
+    /**
+     * Setter function used to set the current auth token.
+     */
+    setAuthToken: (value: string | null) => void;
+    /**
+     * Setter function used to set the current inspection ID.
+     */
+    setInspectionId: (value: string | null) => void;
+    /**
+     * Setter function used to set the current vehicle type.
+     */
+    setVehicleType: (value: VehicleType | null) => void;
+    /**
+     * Setter function used to set the current steering wheel position.
+     */
+    setSteeringWheel: (value: SteeringWheelPosition | null) => void;
+}
+/**
+ * React context used to store the current Monk application state.
+ *
+ * @see MonkAppState
+ */
+export declare const MonkAppStateContext: import("react").Context<MonkAppState | null>;

package/lib/apps/appState.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonkAppStateContext = void 0;
+var react_1 = require("react");
+/**
+ * React context used to store the current Monk application state.
+ *
+ * @see MonkAppState
+ */
+exports.MonkAppStateContext = (0, react_1.createContext)(null);
+//# sourceMappingURL=appState.js.map

package/lib/apps/appState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"appState.js","sourceRoot":"","sources":["../../src/apps/appState.ts"],"names":[],"mappings":";;;AACA,+BAAsC;AA2DtC;;;;GAIG;AACU,QAAA,mBAAmB,GAAG,IAAA,qBAAa,EAAsB,IAAI,CAAC,CAAC"}

package/lib/apps/appStateProvider.d.ts

@@ -0,0 +1,64 @@
+import { CaptureAppConfig } from '@monkvision/types';
+import { PropsWithChildren } from 'react';
+import { MonkAppState } from './appState';
+/**
+ * Local storage key used within Monk web applications to store the authentication token.
+ */
+export declare const STORAGE_KEY_AUTH_TOKEN = "@monk_authToken";
+/**
+ * Props accepted by the MonkAppStateProvider component.
+ */
+export type MonkAppStateProviderProps = {
+    /**
+     * The current configuration of the application.
+     */
+    config: CaptureAppConfig;
+    /**
+     * Callback called when an authentication token has successfully been fetched from either the local storage, or the
+     * URL search params.
+     */
+    onFetchAuthToken?: () => void;
+    /**
+     * Callback called when the language of the app must be updated because it has been specified in the URL params.
+     */
+    onFetchLanguage?: (lang: string) => void;
+};
+/**
+ * A React context provider that declares the state for the common parameters used by Monk applications. The parameters
+ * are described in the `MonkAppState` interface. Using options available in the App config (`config` prop),  this
+ * component can also fetch initial values for these params directly from the URL search params and the web local
+ * storage.
+ *
+ * @see MonkAppState
+ * @see MonkAppStateProviderProps
+ */
+export declare function MonkAppStateProvider({ config, onFetchAuthToken, onFetchLanguage, children, }: PropsWithChildren<MonkAppStateProviderProps>): JSX.Element;
+/**
+ * Options accepted by the `useMonkAppState`  hook.
+ */
+export interface UseMonkAppStateOptions {
+    /**
+     * Boolean indicating if the `authToken` and the `inspectionId` params are required. If this value is set to `true`,
+     * the hook will return non-null values (even in TypeScript typings) values for the `authToken` and the `inspectionId`
+     * params, at the cost of throwing an error if either one of these param is `null`.
+     */
+    requireInspection?: boolean;
+}
+/**
+ * Custom hook used to get the current Monk application state (described in the `MonkAppState` interface) for the
+ * current `MonkAppStateContext`. This hook must be called within a child of the `MonkAppStateProvider` component.
+ *
+ * @see MonkAppState
+ * @see MonkAppStateContext
+ * @see MonkAppStateProvider
+ */
+export declare function useMonkAppState(): MonkAppState;
+export declare function useMonkAppState(o: {
+    requireInspection: false | undefined;
+}): MonkAppState;
+export declare function useMonkAppState(o: {
+    requireInspection: true;
+}): MonkAppState & {
+    authToken: string;
+    inspectionId: string;
+};