@envive-ai/react-hooks 0.1.3 → 0.1.4

package/dist/index-Dxpscrvz.d.ts

@@ -0,0 +1,228 @@
+//#region src/application/models/utilityTypes/primitive.d.ts
+/**
+ * Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+ *
+ * @category Type
+ */
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+//#endregion
+//#region src/application/models/utilityTypes/trim.d.ts
+/**
+ * Remove spaces from the left side.
+ */
+type TrimLeft<V extends string> = V extends `${Whitespace}${infer R}` ? TrimLeft<R> : V;
+/**
+ * Remove spaces from the right side.
+ */
+type TrimRight<V extends string> = V extends `${infer R}${Whitespace}` ? TrimRight<R> : V;
+/**
+ * Remove leading and trailing spaces from a string.
+ * @example
+ * ```
+ * import type {Trim} from 'type-fest';
+ *
+ * Trim<' foo '>
+ * //=> 'foo'
+ * ```
+ *
+ * @category String
+ * @category Template literal
+ */
+type Trim<V extends string> = TrimLeft<TrimRight<V>>;
+//#endregion
+//#region src/application/models/utilityTypes/internal.d.ts
+/**
+ * Matches any primitive, `void`, `Date`, or `RegExp` value.
+ */
+type BuiltIns = Primitive | void | Date | RegExp;
+/**
+ * Matches non-recursive types.
+ */
+type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
+/**
+ * Returns a boolean for whether the string is numeric.
+ *
+ * This type is a workaround for [Microsoft/TypeScript#46109](https://github.com/microsoft/TypeScript/issues/46109#issuecomment-930307987).
+ */
+type IsNumeric<T extends string> = T extends `${number}` ? Trim<T> extends T ? true : false : false;
+/**
+ * Returns a boolean for whether the string is lowercased.
+ */
+type IsLowerCase<T extends string> = T extends Lowercase<T> ? true : false;
+/**
+ * Returns a boolean for whether the string is upper-cased.
+ */
+type IsUpperCase<T extends string> = T extends Uppercase<T> ? true : false;
+type WordSeparators = '-' | '_' | Whitespace;
+type Whitespace = '\u{9}' | '\u{A}' | '\u{B}' | '\u{C}' | '\u{D}' | '\u{20}' | '\u{85}' | '\u{A0}' | '\u{1680}' | '\u{2000}' | '\u{2001}' | '\u{2002}' | '\u{2003}' | '\u{2004}' | '\u{2005}' | '\u{2006}' | '\u{2007}' | '\u{2008}' | '\u{2009}' | '\u{200A}' | '\u{2028}' | '\u{2029}' | '\u{202F}' | '\u{205F}' | '\u{3000}' | '\u{FEFF}';
+type UpperCaseCharacters = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
+//#endregion
+//#region src/application/models/utilityTypes/splitWords.d.ts
+type SkipEmptyWord<Word extends string> = Word extends '' ? [] : [Word];
+type RemoveLastCharacter<Sentence extends string, Character extends string> = Sentence extends `${infer LeftSide}${Character}` ? SkipEmptyWord<LeftSide> : never;
+/**
+ * Split a string (almost) like Lodash's `_.words()` function.
+ *
+ * - Split on each word that begins with a capital letter.
+ * - Split on each {@link WordSeparators}.
+ * - Split on numeric sequence.
+ *
+ * @example
+ * ```
+ * type Words0 = SplitWords<'helloWorld'>; // ['hello', 'World']
+ * type Words1 = SplitWords<'helloWORLD'>; // ['hello', 'WORLD']
+ * type Words2 = SplitWords<'hello-world'>; // ['hello', 'world']
+ * type Words3 = SplitWords<'--hello the_world'>; // ['hello', 'the', 'world']
+ * type Words4 = SplitWords<'lifeIs42'>; // ['life', 'Is', '42']
+ * ```
+ *
+ * @internal
+ * @category Change case
+ * @category Template literal
+ */
+type SplitWords<Sentence extends string, LastCharacter extends string = '', CurrentWord extends string = ''> = Sentence extends `${infer FirstCharacter}${infer RemainingCharacters}` ? FirstCharacter extends WordSeparators ? [...SkipEmptyWord<CurrentWord>, ...SplitWords<RemainingCharacters>] : LastCharacter extends '' ? SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter> : [false, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? [...SkipEmptyWord<CurrentWord>, ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>] : [true, false] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? [...SkipEmptyWord<CurrentWord>, ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>] : [true, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? SplitWords<RemainingCharacters, FirstCharacter, `${CurrentWord}${FirstCharacter}`> : [true, true] extends [IsLowerCase<LastCharacter>, IsUpperCase<FirstCharacter>] ? [...SkipEmptyWord<CurrentWord>, ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>] : [true, true] extends [IsUpperCase<LastCharacter>, IsLowerCase<FirstCharacter>] ? [...RemoveLastCharacter<CurrentWord, LastCharacter>, ...SplitWords<RemainingCharacters, FirstCharacter, `${LastCharacter}${FirstCharacter}`>] : SplitWords<RemainingCharacters, FirstCharacter, `${CurrentWord}${FirstCharacter}`> : [...SkipEmptyWord<CurrentWord>];
+//#endregion
+//#region src/application/models/utilityTypes/camelCase.d.ts
+/**
+ * CamelCase options.
+ *
+ * @see {@link CamelCase}
+ */
+type CamelCaseOptions = {
+  /**
+   * Whether to preserved consecutive uppercase letter.
+   *
+   * @default true
+   */
+  preserveConsecutiveUppercase?: boolean;
+};
+/**
+ * Convert an array of words to camel-case.
+ */
+type CamelCaseFromArray<Words extends string[], Options extends CamelCaseOptions, OutputString extends string = ''> = Words extends [infer FirstWord extends string, ...infer RemainingWords extends string[]] ? Options['preserveConsecutiveUppercase'] extends true ? `${Capitalize<FirstWord>}${CamelCaseFromArray<RemainingWords, Options>}` : `${Capitalize<Lowercase<FirstWord>>}${CamelCaseFromArray<RemainingWords, Options>}` : OutputString;
+/**
+ * Convert a string literal to camel-case.
+ *
+ * This can be useful when, for example, converting some kebab-cased command-line flags or a snake-cased database result.
+ *
+ * By default, consecutive uppercase letter are preserved. See {@link CamelCaseOptions.preserveConsecutiveUppercase preserveConsecutiveUppercase} option to change this behaviour.
+ *
+ * @example
+ * ```
+ * import type {CamelCase} from 'type-fest';
+ *
+ * // Simple
+ *
+ * const someVariable: CamelCase<'foo-bar'> = 'fooBar';
+ *
+ * // Advanced
+ *
+ * type CamelCasedProperties<T> = {
+ * 	[K in keyof T as CamelCase<K>]: T[K]
+ * };
+ *
+ * interface RawOptions {
+ * 	'dry-run': boolean;
+ * 	'full_family_name': string;
+ * 	foo: number;
+ * 	BAR: string;
+ * 	QUZ_QUX: number;
+ * 	'OTHER-FIELD': boolean;
+ * }
+ *
+ * const dbResult: CamelCasedProperties<RawOptions> = {
+ * 	dryRun: true,
+ * 	fullFamilyName: 'bar.js',
+ * 	foo: 123,
+ * 	bar: 'foo',
+ * 	quzQux: 6,
+ * 	otherField: false
+ * };
+ * ```
+ *
+ * @category Change case
+ * @category Template literal
+ */
+type CamelCase<Type, Options extends CamelCaseOptions = {
+  preserveConsecutiveUppercase: true;
+}> = Type extends string ? string extends Type ? Type : Uncapitalize<CamelCaseFromArray<SplitWords<Type extends Uppercase<Type> ? Lowercase<Type> : Type>, Options>> : Type;
+//#endregion
+//#region src/application/models/utilityTypes/unknownArray.d.ts
+/**
+ * Represents an array with `unknown` value.
+ *
+ * Use case: You want a type that all arrays can be assigned to, but you don't care about the value.
+ *
+ * @example
+ * ```
+ * import type {UnknownArray} from 'type-fest';
+ *
+ * type IsArray<T> = T extends UnknownArray ? true : false;
+ *
+ * type A = IsArray<['foo']>;
+ * //=> true
+ *
+ * type B = IsArray<readonly number[]>;
+ * //=> true
+ *
+ * type C = IsArray<string>;
+ * //=> false
+ * ```
+ *
+ * @category Type
+ * @category Array
+ */
+type UnknownArray = readonly unknown[];
+//#endregion
+//#region src/application/models/utilityTypes/camelCasedPropertiesDeep.d.ts
+/**
+ * Convert object properties to camel case recursively.
+ *
+ * This can be useful when, for example, converting some API types from a different style.
+ *
+ * @see CamelCasedProperties
+ * @see CamelCase
+ *
+ * @example
+ * ```
+ * import type {CamelCasedPropertiesDeep} from 'type-fest';
+ *
+ * interface User {
+ * 	UserId: number;
+ * 	UserName: string;
+ * }
+ *
+ * interface UserWithFriends {
+ * 	UserInfo: User;
+ * 	UserFriends: User[];
+ * }
+ *
+ * const result: CamelCasedPropertiesDeep<UserWithFriends> = {
+ * 	userInfo: {
+ * 		userId: 1,
+ * 		userName: 'Tom',
+ * 	},
+ * 	userFriends: [
+ * 		{
+ * 			userId: 2,
+ * 			userName: 'Jerry',
+ * 		},
+ * 		{
+ * 			userId: 3,
+ * 			userName: 'Spike',
+ * 		},
+ * 	],
+ * };
+ * ```
+ *
+ * @category Change case
+ * @category Template literal
+ * @category Object
+ */
+type CamelCasedPropertiesDeep<Value, Options extends CamelCaseOptions = {
+  preserveConsecutiveUppercase: true;
+}> = Value extends Function ? Value : Value extends UnknownArray ? CamelCasedPropertiesArrayDeep<Value> : Value extends Set<infer U> ? Set<CamelCasedPropertiesDeep<U, Options>> : { [K in keyof Value as CamelCase<K, Options>]: CamelCasedPropertiesDeep<Value[K], Options> };
+type CamelCasedPropertiesArrayDeep<Value extends UnknownArray> = Value extends [] ? [] : Value extends [infer U, ...infer V] ? [CamelCasedPropertiesDeep<U>, ...CamelCasedPropertiesDeep<V>] : Value extends readonly [infer U, ...infer V] ? readonly [CamelCasedPropertiesDeep<U>, ...CamelCasedPropertiesDeep<V>] : Value extends readonly [...infer U, infer V] ? [...CamelCasedPropertiesDeep<U>, CamelCasedPropertiesDeep<V>] : Value extends readonly [...infer U, infer V] ? readonly [...CamelCasedPropertiesDeep<U>, CamelCasedPropertiesDeep<V>] : Value extends Array<infer U> ? Array<CamelCasedPropertiesDeep<U>> : Value extends ReadonlyArray<infer U> ? ReadonlyArray<CamelCasedPropertiesDeep<U>> : never;
+//#endregion
+export { BuiltIns, CamelCase, CamelCaseOptions, CamelCasedPropertiesDeep, IsLowerCase, IsNumeric, IsUpperCase, NonRecursiveType, Primitive, SplitWords, Trim, UnknownArray, UpperCaseCharacters, Whitespace, WordSeparators };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-Dxpscrvz.d.ts","names":[],"sources":["../src/application/models/utilityTypes/primitive.d.ts","../src/application/models/utilityTypes/trim.d.ts","../src/application/models/utilityTypes/internal.d.ts","../src/application/models/utilityTypes/splitWords.d.ts","../src/application/models/utilityTypes/camelCase.d.ts","../src/application/models/utilityTypes/unknownArray.d.ts","../src/application/models/utilityTypes/camelCasedPropertiesDeep.d.ts"],"sourcesContent":["/**\n * Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).\n *\n * @category Type\n */\nexport type Primitive = null | undefined | string | number | boolean | symbol | bigint;\n","import type { Whitespace } from './internal';\n/**\n * Remove spaces from the left side.\n */\ntype TrimLeft<V extends string> = V extends `${Whitespace}${infer R}` ? TrimLeft<R> : V;\n/**\n * Remove spaces from the right side.\n */\ntype TrimRight<V extends string> = V extends `${infer R}${Whitespace}` ? TrimRight<R> : V;\n/**\n * Remove leading and trailing spaces from a string.\n * @example\n * ```\n * import type {Trim} from 'type-fest';\n *\n * Trim<' foo '>\n * //=> 'foo'\n * ```\n *\n * @category String\n * @category Template literal\n */\nexport type Trim<V extends string> = TrimLeft<TrimRight<V>>;\nexport {};\n","import { Primitive } from './primitive';\nimport { Trim } from './trim';\n/**\n * Matches any primitive, `void`, `Date`, or `RegExp` value.\n */\nexport type BuiltIns = Primitive | void | Date | RegExp;\n/**\n * Matches non-recursive types.\n */\nexport type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);\n/**\n * Returns a boolean for whether the string is numeric.\n *\n * This type is a workaround for [Microsoft/TypeScript#46109](https://github.com/microsoft/TypeScript/issues/46109#issuecomment-930307987).\n */\nexport type IsNumeric<T extends string> = T extends `${number}` ? Trim<T> extends T ? true : false : false;\n/**\n * Returns a boolean for whether the string is lowercased.\n */\nexport type IsLowerCase<T extends string> = T extends Lowercase<T> ? true : false;\n/**\n * Returns a boolean for whether the string is upper-cased.\n */\nexport type IsUpperCase<T extends string> = T extends Uppercase<T> ? true : false;\nexport type WordSeparators = '-' | '_' | Whitespace;\nexport type Whitespace = '\\u{9}' | '\\u{A}' | '\\u{B}' | '\\u{C}' | '\\u{D}' | '\\u{20}' | '\\u{85}' | '\\u{A0}' | '\\u{1680}' | '\\u{2000}' | '\\u{2001}' | '\\u{2002}' | '\\u{2003}' | '\\u{2004}' | '\\u{2005}' | '\\u{2006}' | '\\u{2007}' | '\\u{2008}' | '\\u{2009}' | '\\u{200A}' | '\\u{2028}' | '\\u{2029}' | '\\u{202F}' | '\\u{205F}' | '\\u{3000}' | '\\u{FEFF}';\nexport type UpperCaseCharacters = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';\n","import type { IsLowerCase, IsNumeric, IsUpperCase, WordSeparators } from './internal';\ntype SkipEmptyWord<Word extends string> = Word extends '' ? [] : [Word];\ntype RemoveLastCharacter<Sentence extends string, Character extends string> = Sentence extends `${infer LeftSide}${Character}` ? SkipEmptyWord<LeftSide> : never;\n/**\n * Split a string (almost) like Lodash's `_.words()` function.\n *\n * - Split on each word that begins with a capital letter.\n * - Split on each {@link WordSeparators}.\n * - Split on numeric sequence.\n *\n * @example\n * ```\n * type Words0 = SplitWords<'helloWorld'>; // ['hello', 'World']\n * type Words1 = SplitWords<'helloWORLD'>; // ['hello', 'WORLD']\n * type Words2 = SplitWords<'hello-world'>; // ['hello', 'world']\n * type Words3 = SplitWords<'--hello the_world'>; // ['hello', 'the', 'world']\n * type Words4 = SplitWords<'lifeIs42'>; // ['life', 'Is', '42']\n * ```\n *\n * @internal\n * @category Change case\n * @category Template literal\n */\nexport type SplitWords<Sentence extends string, LastCharacter extends string = '', CurrentWord extends string = ''> = Sentence extends `${infer FirstCharacter}${infer RemainingCharacters}` ? FirstCharacter extends WordSeparators ? [\n    ...SkipEmptyWord<CurrentWord>,\n    ...SplitWords<RemainingCharacters>\n] : LastCharacter extends '' ? SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter> : [\n    false,\n    true\n] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? [\n    ...SkipEmptyWord<CurrentWord>,\n    ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>\n] : [\n    true,\n    false\n] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? [\n    ...SkipEmptyWord<CurrentWord>,\n    ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>\n] : [\n    true,\n    true\n] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? SplitWords<RemainingCharacters, FirstCharacter, `${CurrentWord}${FirstCharacter}`> : [\n    true,\n    true\n] extends [IsLowerCase<LastCharacter>, IsUpperCase<FirstCharacter>] ? [\n    ...SkipEmptyWord<CurrentWord>,\n    ...SplitWords<RemainingCharacters, FirstCharacter, FirstCharacter>\n] : [\n    true,\n    true\n] extends [IsUpperCase<LastCharacter>, IsLowerCase<FirstCharacter>] ? [\n    ...RemoveLastCharacter<CurrentWord, LastCharacter>,\n    ...SplitWords<RemainingCharacters, FirstCharacter, `${LastCharacter}${FirstCharacter}`>\n] : SplitWords<RemainingCharacters, FirstCharacter, `${CurrentWord}${FirstCharacter}`> : [...SkipEmptyWord<CurrentWord>];\nexport {};\n","import { SplitWords } from './splitWords';\n/**\n * CamelCase options.\n *\n * @see {@link CamelCase}\n */\nexport type CamelCaseOptions = {\n    /**\n     * Whether to preserved consecutive uppercase letter.\n     *\n     * @default true\n     */\n    preserveConsecutiveUppercase?: boolean;\n};\n/**\n * Convert an array of words to camel-case.\n */\ntype CamelCaseFromArray<Words extends string[], Options extends CamelCaseOptions, OutputString extends string = ''> = Words extends [infer FirstWord extends string, ...infer RemainingWords extends string[]] ? Options['preserveConsecutiveUppercase'] extends true ? `${Capitalize<FirstWord>}${CamelCaseFromArray<RemainingWords, Options>}` : `${Capitalize<Lowercase<FirstWord>>}${CamelCaseFromArray<RemainingWords, Options>}` : OutputString;\n/**\n * Convert a string literal to camel-case.\n *\n * This can be useful when, for example, converting some kebab-cased command-line flags or a snake-cased database result.\n *\n * By default, consecutive uppercase letter are preserved. See {@link CamelCaseOptions.preserveConsecutiveUppercase preserveConsecutiveUppercase} option to change this behaviour.\n *\n * @example\n * ```\n * import type {CamelCase} from 'type-fest';\n *\n * // Simple\n *\n * const someVariable: CamelCase<'foo-bar'> = 'fooBar';\n *\n * // Advanced\n *\n * type CamelCasedProperties<T> = {\n * \t[K in keyof T as CamelCase<K>]: T[K]\n * };\n *\n * interface RawOptions {\n * \t'dry-run': boolean;\n * \t'full_family_name': string;\n * \tfoo: number;\n * \tBAR: string;\n * \tQUZ_QUX: number;\n * \t'OTHER-FIELD': boolean;\n * }\n *\n * const dbResult: CamelCasedProperties<RawOptions> = {\n * \tdryRun: true,\n * \tfullFamilyName: 'bar.js',\n * \tfoo: 123,\n * \tbar: 'foo',\n * \tquzQux: 6,\n * \totherField: false\n * };\n * ```\n *\n * @category Change case\n * @category Template literal\n */\nexport type CamelCase<Type, Options extends CamelCaseOptions = {\n    preserveConsecutiveUppercase: true;\n}> = Type extends string ? string extends Type ? Type : Uncapitalize<CamelCaseFromArray<SplitWords<Type extends Uppercase<Type> ? Lowercase<Type> : Type>, Options>> : Type;\nexport {};\n","/**\n * Represents an array with `unknown` value.\n *\n * Use case: You want a type that all arrays can be assigned to, but you don't care about the value.\n *\n * @example\n * ```\n * import type {UnknownArray} from 'type-fest';\n *\n * type IsArray<T> = T extends UnknownArray ? true : false;\n *\n * type A = IsArray<['foo']>;\n * //=> true\n *\n * type B = IsArray<readonly number[]>;\n * //=> true\n *\n * type C = IsArray<string>;\n * //=> false\n * ```\n *\n * @category Type\n * @category Array\n */\nexport type UnknownArray = readonly unknown[];\n","import { CamelCase, CamelCaseOptions } from './camelCase';\nimport { UnknownArray } from './unknownArray';\n/**\n * Convert object properties to camel case recursively.\n *\n * This can be useful when, for example, converting some API types from a different style.\n *\n * @see CamelCasedProperties\n * @see CamelCase\n *\n * @example\n * ```\n * import type {CamelCasedPropertiesDeep} from 'type-fest';\n *\n * interface User {\n * \tUserId: number;\n * \tUserName: string;\n * }\n *\n * interface UserWithFriends {\n * \tUserInfo: User;\n * \tUserFriends: User[];\n * }\n *\n * const result: CamelCasedPropertiesDeep<UserWithFriends> = {\n * \tuserInfo: {\n * \t\tuserId: 1,\n * \t\tuserName: 'Tom',\n * \t},\n * \tuserFriends: [\n * \t\t{\n * \t\t\tuserId: 2,\n * \t\t\tuserName: 'Jerry',\n * \t\t},\n * \t\t{\n * \t\t\tuserId: 3,\n * \t\t\tuserName: 'Spike',\n * \t\t},\n * \t],\n * };\n * ```\n *\n * @category Change case\n * @category Template literal\n * @category Object\n */\nexport type CamelCasedPropertiesDeep<Value, Options extends CamelCaseOptions = {\n    preserveConsecutiveUppercase: true;\n}> = Value extends Function ? Value : Value extends UnknownArray ? CamelCasedPropertiesArrayDeep<Value> : Value extends Set<infer U> ? Set<CamelCasedPropertiesDeep<U, Options>> : {\n    [K in keyof Value as CamelCase<K, Options>]: CamelCasedPropertiesDeep<Value[K], Options>;\n};\ntype CamelCasedPropertiesArrayDeep<Value extends UnknownArray> = Value extends [] ? [] : Value extends [infer U, ...infer V] ? [CamelCasedPropertiesDeep<U>, ...CamelCasedPropertiesDeep<V>] : Value extends readonly [infer U, ...infer V] ? readonly [CamelCasedPropertiesDeep<U>, ...CamelCasedPropertiesDeep<V>] : Value extends readonly [...infer U, infer V] ? [...CamelCasedPropertiesDeep<U>, CamelCasedPropertiesDeep<V>] : Value extends readonly [...infer U, infer V] ? readonly [...CamelCasedPropertiesDeep<U>, CamelCasedPropertiesDeep<V>] : Value extends Array<infer U> ? Array<CamelCasedPropertiesDeep<U>> : Value extends ReadonlyArray<infer U> ? ReadonlyArray<CamelCasedPropertiesDeep<U>> : never;\nexport {};\n"],"mappings":";AAAA,IAAE,YAAA,CAAA,IAAA;;;;ACCF,IAAE,WAAA;CAAA;OAAA;OAAA;OAAA;OAAA;OAAA;CAAA;AACF,IAAI,YAAY;CAAC;OAAW;OAAO;OAAA;OAAA;OAAA;CAAA;AACnC,IAAE,OAAA;CAAA;OAAA;OAAA;OAAA;CAAA;;;;ACDF,IAAE,WAAA;CAAA;OAAA;OAAA;OAAA;CAAA;AACF,IAAW,mBAAmB;CAAC;OAAW;OAAgB;CAAC;AAC3D,IAAE,YAAA;CAAA;OAAA;OAAA;OAAA;OAAA;CAAA;AACF,IAAW,cAAc;CAAC;OAAW;OAAS;OAAS;CAAA;AACvD,IAAE,cAAA;CAAA;OAAA;OAAA;OAAA;CAAA;AACF,IAAW,iBAAiB,CAAC,WAAC,WAAA;AAC9B,IAAE,aAAA,CAAA,IAAA;AACF,IAAW,sBAAsB,CAAC,IAAI;;;;ACRtC,IAAI,gBAAgB;CAAC;OAAW;OAAY;CAAK;AACjD,IAAI,sBAAsB;CAAC;OAAW;OAAgB;OAAiB;OAAgB;CAAc;AACrG,IAAE,aAAA;CAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;CAAA;;;;ACFF,IAAE,mBAAA,CAAA,IAAA;AACF,IAAI,qBAAgB;CAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;CAAA;AACpB,IAAC,YAAA;CAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;CAAA;;;;ACHD,IAAE,eAAA,CAAA,IAAA;;;;ACEF,IAAE,2BAAA;CAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;CAAA;AACF,IAAI,gCAAgC;CAAC;OAAW;OAAM;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;OAAA;CAAA"}

package/dist/index-MFbPQ8Ji.d.ts

@@ -0,0 +1,95 @@
+import { OrgAnalyticsGoogleAnalyticsConfig, OrgConfig } from "./orgConfigResults--dAwtw3W.js";
+import { FeatureFlagService } from "./featureFlagService-5wdmW02z.js";
+import { BrowserClient, EnrichmentPlugin } from "@amplitude/analytics-types";
+
+//#region src/adapters/amplitude/amplitudeAdapter.d.ts
+declare enum SpiffyMetricsEventName {
+  BundleLoaded = "Bundle Loaded",
+  ChatLiveAgentBtnClick = "Chat Live Agent Btn Click",
+  ChatFloatingButtonVisible = "Chat Floating Button Visible",
+  ChatComponentVisible = "Chat Component Visible",
+  ChatComponentExpanded = "Chat Component Expanded",
+  ChatComponentCollapsed = "Chat Component Collapsed",
+  ChatUserMessageInput = "Chat User Message Input",
+  ChatSuggestionClicked = "Chat Suggestion Clicked",
+  ChatAssistantResponse = "Chat Assistant Response",
+  ProductCardClicked = "Product Card Clicked",
+  ProductReviewCardClicked = "Product Review Card Clicked",
+  AddToCartClicked = "Add to Cart Clicked",
+  PromptCardClicked = "Prompt Card Clicked",
+  SupportedEvent = "Supported Event",
+  SearchBackToResponseClicked = "Search Back to Response Clicked",
+  PerformanceMetrics = "Performance Metrics",
+  SearchBarClicked = "Search Bar Clicked",
+  OrderLookupStarted = "Order Lookup Started",
+  OrderLookupFormSubmitted = "Order Lookup Form Submitted",
+  SearchComponentVisible = "Search Component Visible",
+  GlobalSearchPromptClicked = "Global Search Prompt Clicked",
+  // This is the scrolling list of suggestion buttons in global search
+  SearchInputStarted = "Search Input Started",
+  SearchQuerySubmitted = "Search Query Submitted",
+  SearchResultsViewed = "Search Results Viewed",
+  SearchTimeToFirstClick = "Search Time to First Click",
+  SearchZeroResultsRate = "Search Zero Results Rate",
+  SearchFilterClicked = "Search Filter Clicked",
+  SearchSortClicked = "Search Sort Clicked",
+}
+declare class AmplitudeAdapter {
+  private readonly userId;
+  private readonly orgConfig;
+  private readonly featureFlagService;
+  private readonly orgGaConfig?;
+  private underlyingAmplitudeClient;
+  private internalEventTrackingEnrichment;
+  private supplementalDefaultProps;
+  constructor(userId: string, orgConfig: OrgConfig, featureFlagService: FeatureFlagService, orgGaConfig?: OrgAnalyticsGoogleAnalyticsConfig | undefined);
+  init(): void;
+  getUnderlyingAmplitudeClient(): BrowserClient | undefined;
+  getSupplementalDefaultProps(): Record<string, unknown>;
+  setSupplementalDefaultProps(supplementalDefaultProps: Record<string, unknown>): void;
+  getEventTrackingEnrichment(): EnrichmentPlugin;
+  amplitudeSessionReplayInit(): boolean;
+  createUnderlyingClient(): BrowserClient;
+  getDefaultTrackingProps(): Record<string, unknown>;
+  /**
+   * Prefixes the event properties sent to Amplitude with the event name to prevent event-level
+   * property names from clashing with app-level property names. Event properties will be in the
+   * format of `event_name.property_name`.
+   *
+   * @param eventName - The name of the event to prefix the properties for.
+   * @param eventProps - The event properties to prefix.
+   *
+   * @returns The prefixed properties.
+   */
+  private eventPropsToPrefixedEventProps;
+  static trackEvent: ({
+    eventName,
+    eventProps,
+    eventGroups,
+    alsoSendToGoogleAnalytics
+  }: {
+    eventName: SpiffyMetricsEventName;
+    eventProps?: Record<string, unknown>;
+    eventGroups?: Record<string, unknown>;
+    alsoSendToGoogleAnalytics?: boolean;
+  }) => Promise<void>;
+  static amplitudeSafeString(input: string | undefined): string | null;
+  static getSingletonInstanceOf(): AmplitudeAdapter;
+}
+//#endregion
+//#region src/adapters/amplitude/stubAmplitudeAdapter.d.ts
+declare class StubAmplitudeAdapter extends AmplitudeAdapter {
+  constructor();
+  init: () => void;
+  getUnderlyingAmplitudeClient: () => BrowserClient | undefined;
+  getSupplementalDefaultProps: () => Record<string, unknown>;
+  setSupplementalDefaultProps: () => void;
+  getEventTrackingEnrichment: () => EnrichmentPlugin;
+  amplitudeSessionReplayInit: () => boolean;
+  createUnderlyingClient: () => BrowserClient;
+  getDefaultTrackingProps: () => Record<string, unknown>;
+  trackEvent: () => Promise<void>;
+}
+//#endregion
+export { AmplitudeAdapter, SpiffyMetricsEventName, StubAmplitudeAdapter };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/index-VSFakgAI.d.cts

@@ -0,0 +1,95 @@
+import { OrgAnalyticsGoogleAnalyticsConfig, OrgConfig } from "./orgConfigResults-BL0XBA6x.cjs";
+import { FeatureFlagService } from "./featureFlagService-DaelrXEk.cjs";
+import { BrowserClient, EnrichmentPlugin } from "@amplitude/analytics-types";
+
+//#region src/adapters/amplitude/amplitudeAdapter.d.ts
+declare enum SpiffyMetricsEventName {
+  BundleLoaded = "Bundle Loaded",
+  ChatLiveAgentBtnClick = "Chat Live Agent Btn Click",
+  ChatFloatingButtonVisible = "Chat Floating Button Visible",
+  ChatComponentVisible = "Chat Component Visible",
+  ChatComponentExpanded = "Chat Component Expanded",
+  ChatComponentCollapsed = "Chat Component Collapsed",
+  ChatUserMessageInput = "Chat User Message Input",
+  ChatSuggestionClicked = "Chat Suggestion Clicked",
+  ChatAssistantResponse = "Chat Assistant Response",
+  ProductCardClicked = "Product Card Clicked",
+  ProductReviewCardClicked = "Product Review Card Clicked",
+  AddToCartClicked = "Add to Cart Clicked",
+  PromptCardClicked = "Prompt Card Clicked",
+  SupportedEvent = "Supported Event",
+  SearchBackToResponseClicked = "Search Back to Response Clicked",
+  PerformanceMetrics = "Performance Metrics",
+  SearchBarClicked = "Search Bar Clicked",
+  OrderLookupStarted = "Order Lookup Started",
+  OrderLookupFormSubmitted = "Order Lookup Form Submitted",
+  SearchComponentVisible = "Search Component Visible",
+  GlobalSearchPromptClicked = "Global Search Prompt Clicked",
+  // This is the scrolling list of suggestion buttons in global search
+  SearchInputStarted = "Search Input Started",
+  SearchQuerySubmitted = "Search Query Submitted",
+  SearchResultsViewed = "Search Results Viewed",
+  SearchTimeToFirstClick = "Search Time to First Click",
+  SearchZeroResultsRate = "Search Zero Results Rate",
+  SearchFilterClicked = "Search Filter Clicked",
+  SearchSortClicked = "Search Sort Clicked",
+}
+declare class AmplitudeAdapter {
+  private readonly userId;
+  private readonly orgConfig;
+  private readonly featureFlagService;
+  private readonly orgGaConfig?;
+  private underlyingAmplitudeClient;
+  private internalEventTrackingEnrichment;
+  private supplementalDefaultProps;
+  constructor(userId: string, orgConfig: OrgConfig, featureFlagService: FeatureFlagService, orgGaConfig?: OrgAnalyticsGoogleAnalyticsConfig | undefined);
+  init(): void;
+  getUnderlyingAmplitudeClient(): BrowserClient | undefined;
+  getSupplementalDefaultProps(): Record<string, unknown>;
+  setSupplementalDefaultProps(supplementalDefaultProps: Record<string, unknown>): void;
+  getEventTrackingEnrichment(): EnrichmentPlugin;
+  amplitudeSessionReplayInit(): boolean;
+  createUnderlyingClient(): BrowserClient;
+  getDefaultTrackingProps(): Record<string, unknown>;
+  /**
+   * Prefixes the event properties sent to Amplitude with the event name to prevent event-level
+   * property names from clashing with app-level property names. Event properties will be in the
+   * format of `event_name.property_name`.
+   *
+   * @param eventName - The name of the event to prefix the properties for.
+   * @param eventProps - The event properties to prefix.
+   *
+   * @returns The prefixed properties.
+   */
+  private eventPropsToPrefixedEventProps;
+  static trackEvent: ({
+    eventName,
+    eventProps,
+    eventGroups,
+    alsoSendToGoogleAnalytics
+  }: {
+    eventName: SpiffyMetricsEventName;
+    eventProps?: Record<string, unknown>;
+    eventGroups?: Record<string, unknown>;
+    alsoSendToGoogleAnalytics?: boolean;
+  }) => Promise<void>;
+  static amplitudeSafeString(input: string | undefined): string | null;
+  static getSingletonInstanceOf(): AmplitudeAdapter;
+}
+//#endregion
+//#region src/adapters/amplitude/stubAmplitudeAdapter.d.ts
+declare class StubAmplitudeAdapter extends AmplitudeAdapter {
+  constructor();
+  init: () => void;
+  getUnderlyingAmplitudeClient: () => BrowserClient | undefined;
+  getSupplementalDefaultProps: () => Record<string, unknown>;
+  setSupplementalDefaultProps: () => void;
+  getEventTrackingEnrichment: () => EnrichmentPlugin;
+  amplitudeSessionReplayInit: () => boolean;
+  createUnderlyingClient: () => BrowserClient;
+  getDefaultTrackingProps: () => Record<string, unknown>;
+  trackEvent: () => Promise<void>;
+}
+//#endregion
+export { AmplitudeAdapter, SpiffyMetricsEventName, StubAmplitudeAdapter };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/index-jBATkcc_.d.cts

@@ -0,0 +1,9 @@
+//#region src/config/locators/components/floating-button.d.ts
+declare const FLOATING_BUTTON_ICON_TESTID = "floating-button-icon";
+declare const FLOATING_BUTTON_TEXT_TESTID = "floating-button-text";
+//#endregion
+//#region src/config/locators/components/shadow-dom.d.ts
+declare const SHADOW_DOM_CONTAINER_TESTID = "shadow-dom-container";
+//#endregion
+export { FLOATING_BUTTON_ICON_TESTID, FLOATING_BUTTON_TEXT_TESTID, SHADOW_DOM_CONTAINER_TESTID };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXgtakJBVGtjY18uZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vc3JjL2NvbmZpZy9sb2NhdG9ycy9jb21wb25lbnRzL2Zsb2F0aW5nLWJ1dHRvbi5kLnRzIiwiLi4vc3JjL2NvbmZpZy9sb2NhdG9ycy9jb21wb25lbnRzL3NoYWRvdy1kb20uZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZGVjbGFyZSBjb25zdCBGTE9BVElOR19CVVRUT05fSUNPTl9URVNUSUQgPSBcImZsb2F0aW5nLWJ1dHRvbi1pY29uXCI7XG5leHBvcnQgZGVjbGFyZSBjb25zdCBGTE9BVElOR19CVVRUT05fVEVYVF9URVNUSUQgPSBcImZsb2F0aW5nLWJ1dHRvbi10ZXh0XCI7XG4iLCJleHBvcnQgZGVjbGFyZSBjb25zdCBTSEFET1dfRE9NX0NPTlRBSU5FUl9URVNUSUQgPSBcInNoYWRvdy1kb20tY29udGFpbmVyXCI7XG4iXSwibWFwcGluZ3MiOiI7QUFBQSxJQUFXLDhCQUE4QixDQUFDLElBQUk7QUFDOUMsSUFBVyw4QkFBOEIsQ0FBQyxJQUFJOzs7O0FDRDlDLElBQVcsOEJBQThCLENBQUMsSUFBSSJ9

package/dist/index-zZjcds15.d.cts

@@ -0,0 +1,7 @@
+import { CustomerServiceIntegration, CustomerServiceType } from "./types-CD4LFta-.cjs";
+
+//#region src/application/service/customerService/index.d.ts
+declare const findCustomerServiceImpl: (_provider: CustomerServiceType | undefined) => CustomerServiceIntegration;
+//#endregion
+export { findCustomerServiceImpl };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXgtelpqY2RzMTUuZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vc3JjL2FwcGxpY2F0aW9uL3NlcnZpY2UvY3VzdG9tZXJTZXJ2aWNlL2luZGV4LmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ3VzdG9tZXJTZXJ2aWNlSW50ZWdyYXRpb24sIEN1c3RvbWVyU2VydmljZVR5cGUgfSBmcm9tIFwiLi90eXBlc1wiO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgZmluZEN1c3RvbWVyU2VydmljZUltcGw6IChfcHJvdmlkZXI6IEN1c3RvbWVyU2VydmljZVR5cGUgfCB1bmRlZmluZWQpID0+IEN1c3RvbWVyU2VydmljZUludGVncmF0aW9uO1xuIl0sIm1hcHBpbmdzIjoiOzs7QUFDQSxJQUFXLDBCQUEwQjtDQUFDO09BQVU7T0FBMkI7Q0FBMkIifQ==

package/dist/interceptors/index.cjs

@@ -1,14 +1,13 @@
-require('../events-bH-24eRW.cjs');
-require('../logger-Be0NyKaY.cjs');
-require('../chat-CCQMmhc1.cjs');
-require('../types-lcjuhDBt.cjs');
-require('../enviveConfigContext-Bs8kepnO.cjs');
-require('../atomStore-BNQyGmU_.cjs');
-require('../api-BtzLHcfU.cjs');
-require('../customerService-zsDlp7g2.cjs');
-require('../utilityTypes-DMdsI0DG.cjs');
-require('../variantInfo-Cz2YXraO.cjs');
-const require_useMessageInterceptor = require('../useMessageInterceptor-BnUG2Pzt.cjs');
+require('../logger-Dln20ans.cjs');
+require('../api-B2euFL-5.cjs');
+const require_contexts = require('../contexts-CQDwe3rK.cjs');
+require('../types-CNH4sfF-.cjs');
+require('../atomStore-JwGb7pcy.cjs');
+require('../customerService-BG1uNZZ1.cjs');
+require('../globalSearch-BTeZxvk1.cjs');
+require('../utilityTypes-C4h2wgAK.cjs');
+require('../variantInfo-CNRTY0gH.cjs');
+require('../events-Da7gpmGv.cjs');
 
-exports.useFormEscalation = require_useMessageInterceptor.useFormEscalation;
-exports.useMessageInterceptor = require_useMessageInterceptor.useMessageInterceptor;
+exports.useFormEscalation = require_contexts.useFormEscalation;
+exports.useMessageInterceptor = require_contexts.useMessageInterceptor;

package/dist/interceptors/index.d.cts

@@ -1,12 +1,11 @@
-import "../featureGates-N_gyHCTn.cjs";
-import "../index-DtoVXd6O.cjs";
-import { Response } from "../index-Cn1SeI5y.cjs";
-import "../index-C4zjAR1c.cjs";
-import "../index-DbWWcYax.cjs";
-import "../frontendConfig-KeNqU1wa.cjs";
-import "../types-BE4faOO_.cjs";
-import "../test-types-CpKCxk8U.cjs";
-import "../index-hdbCEjYy.cjs";
+import "../orgConfigResults-BL0XBA6x.cjs";
+import "../types-CD4LFta-.cjs";
+import "../test-types-CuOq25VT.cjs";
+import "../index-BTK5uzs6.cjs";
+import { Response } from "../index-ClJ0nMsR.cjs";
+import "../index-BzgkfbNO.cjs";
+import "../index-CNsGWfS6.cjs";
+import "../index-D46Rd0io.cjs";
 
 //#region src/interceptors/types.d.ts
 interface MessageInterceptor {
@@ -22,4 +21,5 @@ declare const useMessageInterceptor: () => {
   intercept: (response?: Response) => boolean | undefined;
 };
 //#endregion
-export { MessageInterceptor, useFormEscalation, useMessageInterceptor };
+export { MessageInterceptor, useFormEscalation, useMessageInterceptor };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL2ludGVyY2VwdG9ycy90eXBlcy5kLnRzIiwiLi4vLi4vc3JjL2ludGVyY2VwdG9ycy91c2VGb3JtRXNjYWxhdGlvbi5kLnRzIiwiLi4vLi4vc3JjL2ludGVyY2VwdG9ycy91c2VNZXNzYWdlSW50ZXJjZXB0b3IuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZXNwb25zZSB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMnO1xuZXhwb3J0IGludGVyZmFjZSBNZXNzYWdlSW50ZXJjZXB0b3Ige1xuICAgIGV4ZWN1dGU6IChyZXNwb25zZTogUmVzcG9uc2UpID0+IHZvaWQgfCBQcm9taXNlPHZvaWQ+O1xuICAgIGJsb2NrRXhlY3V0aW9uOiAoKSA9PiBib29sZWFuO1xufVxuIiwiaW1wb3J0IHsgTWVzc2FnZUludGVyY2VwdG9yIH0gZnJvbSBcIi4vdHlwZXNcIjtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IHVzZUZvcm1Fc2NhbGF0aW9uOiAoKSA9PiBNZXNzYWdlSW50ZXJjZXB0b3I7XG4iLCJpbXBvcnQgeyBSZXNwb25zZSB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMnO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgdXNlTWVzc2FnZUludGVyY2VwdG9yOiAoKSA9PiB7XG4gICAgaW50ZXJjZXB0OiAocmVzcG9uc2U/OiBSZXNwb25zZSkgPT4gYm9vbGVhbiB8IHVuZGVmaW5lZDtcbn07XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7QUFDQSxJQUFXLHFCQUFxQjtDQUFDO09BQUc7T0FBQTtDQUFBOzs7O0FDQXBDLElBQVcsb0JBQW9CLENBQUMsV0FBVyxtQkFBbUI7Ozs7QUNBOUQsSUFBVyx3QkFBd0IsQ0FBQyxXQUFXLFNBQUcifQ==

package/dist/interceptors/index.d.ts

@@ -1,12 +1,11 @@
-import "../featureGates-BMWXU0dS.js";
-import "../index-luJrHgPN.js";
-import { Response } from "../index-CIco0cCQ.js";
-import "../index-tfRj22E1.js";
-import "../index-COG1kOZG.js";
-import "../frontendConfig-cPvCTWm6.js";
-import "../types-TD8g7LnH.js";
-import "../test-types-C9b_OdfO.js";
-import "../index-Cqg6ltII.js";
+import "../orgConfigResults--dAwtw3W.js";
+import "../types-DBdI0j89.js";
+import "../test-types-CXVJxTeu.js";
+import "../index-D2VaMPA3.js";
+import { Response } from "../index-Cx9e-fRi.js";
+import "../index-Dxpscrvz.js";
+import "../index-BfuO9b0Q.js";
+import "../index-CKKkTsms.js";
 
 //#region src/interceptors/types.d.ts
 interface MessageInterceptor {
@@ -22,4 +21,5 @@ declare const useMessageInterceptor: () => {
   intercept: (response?: Response) => boolean | undefined;
 };
 //#endregion
-export { MessageInterceptor, useFormEscalation, useMessageInterceptor };
+export { MessageInterceptor, useFormEscalation, useMessageInterceptor };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi9zcmMvaW50ZXJjZXB0b3JzL3R5cGVzLmQudHMiLCIuLi8uLi9zcmMvaW50ZXJjZXB0b3JzL3VzZUZvcm1Fc2NhbGF0aW9uLmQudHMiLCIuLi8uLi9zcmMvaW50ZXJjZXB0b3JzL3VzZU1lc3NhZ2VJbnRlcmNlcHRvci5kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJlc3BvbnNlIH0gZnJvbSAnc3JjL2FwcGxpY2F0aW9uL21vZGVscyc7XG5leHBvcnQgaW50ZXJmYWNlIE1lc3NhZ2VJbnRlcmNlcHRvciB7XG4gICAgZXhlY3V0ZTogKHJlc3BvbnNlOiBSZXNwb25zZSkgPT4gdm9pZCB8IFByb21pc2U8dm9pZD47XG4gICAgYmxvY2tFeGVjdXRpb246ICgpID0+IGJvb2xlYW47XG59XG4iLCJpbXBvcnQgeyBNZXNzYWdlSW50ZXJjZXB0b3IgfSBmcm9tIFwiLi90eXBlc1wiO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgdXNlRm9ybUVzY2FsYXRpb246ICgpID0+IE1lc3NhZ2VJbnRlcmNlcHRvcjtcbiIsImltcG9ydCB7IFJlc3BvbnNlIH0gZnJvbSAnc3JjL2FwcGxpY2F0aW9uL21vZGVscyc7XG5leHBvcnQgZGVjbGFyZSBjb25zdCB1c2VNZXNzYWdlSW50ZXJjZXB0b3I6ICgpID0+IHtcbiAgICBpbnRlcmNlcHQ6IChyZXNwb25zZT86IFJlc3BvbnNlKSA9PiBib29sZWFuIHwgdW5kZWZpbmVkO1xufTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7OztBQUNBLElBQVcscUJBQXFCO0NBQUM7T0FBRztPQUFBO0NBQUE7Ozs7QUNBcEMsSUFBVyxvQkFBb0IsQ0FBQyxXQUFXLG1CQUFtQjs7OztBQ0E5RCxJQUFXLHdCQUF3QixDQUFDLFdBQVcsU0FBRyJ9

package/dist/interceptors/index.js

@@ -1,13 +1,12 @@
-import "../events-DgFzlVJR.js";
-import "../logger-BexDfK3W.js";
-import "../chat-H6YcCS4I.js";
-import "../types-C3S1H4hl.js";
-import "../enviveConfigContext-CWVdVWKW.js";
-import "../atomStore-TnLPtYns.js";
-import "../api-kpPTZhV9.js";
-import "../customerService-C4wc0glQ.js";
-import "../utilityTypes-UWdNHElu.js";
-import "../variantInfo-BTvC6CQh.js";
-import { useFormEscalation, useMessageInterceptor } from "../useMessageInterceptor-BP6gzo8a.js";
+import "../logger-pdEEY8T2.js";
+import "../api-XRr_lAG6.js";
+import { useFormEscalation, useMessageInterceptor } from "../contexts-e2sM-B9g.js";
+import "../types-BF_CJeck.js";
+import "../atomStore-B1cgmbP0.js";
+import "../customerService-BHQRnLhC.js";
+import "../globalSearch-b0wC7ZEO.js";
+import "../utilityTypes-BVikejDo.js";
+import "../variantInfo-CzhR5W6h.js";
+import "../events-ClCDFK7t.js";
 
 export { useFormEscalation, useMessageInterceptor };