@envive-ai/react-hooks 0.1.5 → 0.1.6

package/dist/index-OEifcBsm.d.cts

@@ -0,0 +1,191 @@
+import { CamelCasedPropertiesDeep } from "./index-CESxqFso.cjs";
+import { BasicOrgInfoType, ColorMapping, EnviveConfig, FeatureGates, FrontendConfig, GenerationParams, IdExtractor, OrgConfigFeatureGate, SearchParams, SearchResult } from "./index-DTu2X-YS.cjs";
+import * as react2 from "react";
+import React, { Dispatch, ReactNode, SetStateAction } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/contexts/featureFlagServiceContext.d.ts
+declare class FeatureFlagService {
+  private featureGates;
+  constructor(featureGates: OrgConfigFeatureGate[]);
+  isFeatureGateEnabled: (featureGate: FeatureGates) => boolean;
+  isClientSessionEnabled: () => boolean;
+  getFeatureFlags: () => Record<string, boolean>;
+}
+interface FeatureFlagContextType {
+  featureFlagService: FeatureFlagService | undefined;
+}
+interface FeatureFlagServiceProviderProps {
+  featureGates: OrgConfigFeatureGate[];
+  children: ReactNode;
+}
+declare const FeatureFlagServiceProvider: React.FC<FeatureFlagServiceProviderProps>;
+declare const useFeatureFlagService: () => FeatureFlagContextType;
+//#endregion
+//#region src/contexts/cdnContext.d.ts
+interface CdnContextType {
+  cdnUrl: string;
+  getCdnBasePath: () => string;
+  getAssetURL: (assetName: string, orgShortName: string) => string;
+}
+declare const CdnProvider: React.FC<{
+  children: React.ReactNode;
+}>;
+declare const useCdn: () => CdnContextType;
+//#endregion
+//#region src/contexts/chatContext.d.ts
+interface ChatContextParams {}
+declare const ChatContext: react2.Context<ChatContextParams | undefined>;
+declare const ChatContextProvider: ({
+  children
+}: {
+  children: ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/contexts/enviveConfigContext.d.ts
+interface EnviveConfigProviderProps {
+  children: ReactNode;
+  amplitudeApiKey?: string;
+  dataResidency?: string;
+  env?: string;
+  baseUrl?: string;
+  reactAppName?: string;
+  cdnUrl?: string;
+  contextSource?: string;
+  orgLevelApiKey?: string;
+  orgShortName?: string;
+  identifyingPrefix: string;
+  featureOverrides?: Record<string, boolean>;
+  variantUrlOverride?: string;
+  variantInfoOverride?: any;
+  show?: boolean;
+  publicKey?: string;
+  featureGates?: OrgConfigFeatureGate[];
+}
+declare const EnviveConfigProvider: React.FC<EnviveConfigProviderProps>;
+declare const useEnviveConfig: () => EnviveConfig;
+//#endregion
+//#region src/contexts/enviveCssContext.d.ts
+interface EnviveCssProviderProps {
+  children: ReactNode;
+}
+declare const EnviveCssProvider: React.FC<EnviveCssProviderProps>;
+//#endregion
+//#region src/contexts/graphqlContext.d.ts
+type ColorsConfigResponse = CamelCasedPropertiesDeep<ColorMapping>;
+type FrontendConfigResponse = CamelCasedPropertiesDeep<FrontendConfig>;
+type GraphQlConfigValues = {
+  colorsConfig?: ColorsConfigResponse;
+  frontendConfig?: CamelCasedPropertiesDeep<FrontendConfig>;
+};
+interface GraphQLContextValue {
+  executeQuery: <T>(query: string, variables?: Record<string, unknown>) => Promise<T>;
+  getOrgId: () => Promise<string | undefined>;
+  getColorsAndFrontendConfig: () => Promise<GraphQlConfigValues>;
+  isReady: boolean;
+}
+type GraphQLProviderProps = {
+  children: ReactNode;
+};
+declare const GraphQLProvider: ({
+  children
+}: GraphQLProviderProps) => react_jsx_runtime0.JSX.Element;
+declare const useGraphQLClient: () => GraphQLContextValue;
+//#endregion
+//#region src/application/models/localStorageEventListener.d.ts
+type LocalStorageEventListener = {
+  storageKey: string;
+  listener: (event: StorageEvent) => void;
+};
+//#endregion
+//#region src/contexts/localStorageContext.d.ts
+declare enum LocalStorageKeys {
+  ChatId = "v1-spiffy-chat-session-id",
+  SpiffyOnOverride = "spiffy_on",
+  EnviveOnOverride = "envive_on",
+}
+interface LocalStorageContextType {
+  setItem: (key: string, value: string) => void;
+  getItem: (key: string) => string | null;
+  setSpiffyOnFeatureFlag: (value: boolean | null) => void;
+  getSpiffyOnFeatureFlag: () => string | null;
+  attachListener: (listener: LocalStorageEventListener) => void;
+  detachListener: (listener: LocalStorageEventListener) => void;
+  isAvailable: boolean;
+}
+declare const LocalStorageProvider: React.FC<{
+  children: React.ReactNode;
+}>;
+declare const useLocalStorage: () => LocalStorageContextType;
+//#endregion
+//#region src/contexts/searchContext.d.ts
+interface SearchContextValue {
+  searchProducts: (params: SearchParams) => Promise<SearchResult>;
+  isReady: boolean;
+}
+declare const SearchProvider: React.FC<{
+  children: React.ReactNode;
+}>;
+declare const useSearchService: () => SearchContextValue;
+//#endregion
+//#region src/contexts/sessionStorageContext.d.ts
+interface SessionStorageContextType {
+  setItem: (key: string, value: string) => void;
+  getItem: (key: string) => string | null;
+  isAvailable: boolean;
+}
+declare const SessionStorageProvider: React.FC<{
+  children: React.ReactNode;
+}>;
+declare const useSessionStorage: () => SessionStorageContextType;
+//#endregion
+//#region src/contexts/shopifyUrlContext.d.ts
+interface ShopifyUrlContextType {
+  getTrimmedPathName: () => string | null;
+  getPlpOrPdpId: (extractor: IdExtractor) => string | null;
+  isOnPdpPage: () => boolean;
+  isOnPlpPage: () => boolean;
+  isReady: boolean;
+}
+declare const ShopifyUrlProvider: React.FC<{
+  children: React.ReactNode;
+}>;
+declare const useShopifyUrl: () => ShopifyUrlContextType;
+//#endregion
+//#region src/contexts/systemSettingsContext.d.ts
+declare const defaultGenerationParams: GenerationParams;
+interface SystemSettingsContextParams {
+  generationParams?: GenerationParams;
+  showDebugBar?: boolean;
+  endpointURL?: string;
+  setGenerationParams: Dispatch<SetStateAction<GenerationParams | undefined>>;
+}
+interface SystemSettingsContextProviderProps {
+  children: ReactNode;
+  generationParams?: GenerationParams;
+  showDebugBar?: boolean;
+}
+declare const SystemSettingsContext: react2.Context<SystemSettingsContextParams | undefined>;
+declare const SystemSettingsContextProvider: ({
+  children,
+  generationParams,
+  showDebugBar
+}: SystemSettingsContextProviderProps) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/contexts/newOrgConfigContext.d.ts
+interface NewOrgConfigContextType {
+  combinedConfig?: (BasicOrgInfoType & {
+    colorsConfig?: ColorsConfigResponse;
+    frontendConfig?: FrontendConfigResponse;
+  }) | null;
+  loading: boolean;
+  error: Error | null;
+}
+interface NewOrgConfigProviderProps {
+  children: ReactNode;
+}
+declare const NewOrgConfigProvider: React.FC<NewOrgConfigProviderProps>;
+declare const useNewOrgConfigContext: () => NewOrgConfigContextType;
+//#endregion
+export { CdnProvider, ChatContext, type ChatContextParams, ChatContextProvider, ColorsConfigResponse, EnviveConfigProvider, EnviveCssProvider, FeatureFlagContextType, FeatureFlagServiceProvider, FrontendConfigResponse, GraphQLProvider, GraphQlConfigValues, LocalStorageKeys, LocalStorageProvider, NewOrgConfigContextType, NewOrgConfigProvider, SearchProvider, SessionStorageProvider, ShopifyUrlProvider, SystemSettingsContext, SystemSettingsContextProvider, defaultGenerationParams, useCdn, useEnviveConfig, useFeatureFlagService, useGraphQLClient, useLocalStorage, useNewOrgConfigContext, useSearchService, useSessionStorage, useShopifyUrl };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-OEifcBsm.d.cts","names":[],"sources":["../src/contexts/featureFlagServiceContext.d.ts","../src/contexts/cdnContext.d.ts","../src/contexts/chatContext.d.ts","../src/contexts/enviveConfigContext.d.ts","../src/contexts/enviveCssContext.d.ts","../src/contexts/graphqlContext.d.ts","../src/application/models/localStorageEventListener.d.ts","../src/contexts/localStorageContext.d.ts","../src/contexts/searchContext.d.ts","../src/contexts/sessionStorageContext.d.ts","../src/contexts/shopifyUrlContext.d.ts","../src/contexts/systemSettingsContext.d.ts","../src/contexts/newOrgConfigContext.d.ts"],"sourcesContent":["import React, { ReactNode } from \"react\";\nimport { OrgConfigFeatureGate } from \"src/application/models/api/orgConfigResults\";\nimport { FeatureGates } from \"src/application/models/featureGates\";\ndeclare class FeatureFlagService {\n    private featureGates;\n    constructor(featureGates: OrgConfigFeatureGate[]);\n    isFeatureGateEnabled: (featureGate: FeatureGates) => boolean;\n    isClientSessionEnabled: () => boolean;\n    getFeatureFlags: () => Record<string, boolean>;\n}\nexport interface FeatureFlagContextType {\n    featureFlagService: FeatureFlagService | undefined;\n}\ninterface FeatureFlagServiceProviderProps {\n    featureGates: OrgConfigFeatureGate[];\n    children: ReactNode;\n}\nexport declare const FeatureFlagServiceProvider: React.FC<FeatureFlagServiceProviderProps>;\nexport declare const useFeatureFlagService: () => FeatureFlagContextType;\nexport {};\n","import React from \"react\";\ninterface CdnContextType {\n    cdnUrl: string;\n    getCdnBasePath: () => string;\n    getAssetURL: (assetName: string, orgShortName: string) => string;\n}\nexport declare const CdnProvider: React.FC<{\n    children: React.ReactNode;\n}>;\nexport declare const useCdn: () => CdnContextType;\nexport {};\n","import { ReactNode } from \"react\";\ninterface ChatContextParams {\n}\ndeclare const ChatContext: import(\"react\").Context<ChatContextParams | undefined>;\ndeclare const ChatContextProvider: ({ children }: {\n    children: ReactNode;\n}) => import(\"react/jsx-runtime\").JSX.Element;\nexport { ChatContext, ChatContextProvider };\nexport type { ChatContextParams };\n","import React, { ReactNode } from \"react\";\nimport type { EnviveConfig } from \"./types\";\nimport { OrgConfigFeatureGate } from \"src/application/models/api/orgConfigResults\";\ninterface EnviveConfigProviderProps {\n    children: ReactNode;\n    amplitudeApiKey?: string;\n    dataResidency?: string;\n    env?: string;\n    baseUrl?: string;\n    reactAppName?: string;\n    cdnUrl?: string;\n    contextSource?: string;\n    orgLevelApiKey?: string;\n    orgShortName?: string;\n    identifyingPrefix: string;\n    featureOverrides?: Record<string, boolean>;\n    variantUrlOverride?: string;\n    variantInfoOverride?: any;\n    show?: boolean;\n    publicKey?: string;\n    featureGates?: OrgConfigFeatureGate[];\n}\nexport declare const EnviveConfigProvider: React.FC<EnviveConfigProviderProps>;\nexport declare const useEnviveConfig: () => EnviveConfig;\nexport {};\n","import React, { ReactNode } from \"react\";\ninterface EnviveCssProviderProps {\n    children: ReactNode;\n}\nexport declare const EnviveCssProvider: React.FC<EnviveCssProviderProps>;\nexport {};\n","import { ReactNode } from \"react\";\nimport { ColorMapping } from \"src/application/models/colorsConfig\";\nimport { FrontendConfig } from \"src/application/models/frontendConfig\";\nimport { CamelCasedPropertiesDeep } from \"src/application/models\";\nexport type ColorsConfigResponse = CamelCasedPropertiesDeep<ColorMapping>;\nexport type FrontendConfigResponse = CamelCasedPropertiesDeep<FrontendConfig>;\nexport type GraphQlConfigValues = {\n    colorsConfig?: ColorsConfigResponse;\n    frontendConfig?: CamelCasedPropertiesDeep<FrontendConfig>;\n};\ninterface GraphQLContextValue {\n    executeQuery: <T>(query: string, variables?: Record<string, unknown>) => Promise<T>;\n    getOrgId: () => Promise<string | undefined>;\n    getColorsAndFrontendConfig: () => Promise<GraphQlConfigValues>;\n    isReady: boolean;\n}\ntype GraphQLProviderProps = {\n    children: ReactNode;\n};\nexport declare const GraphQLProvider: ({ children }: GraphQLProviderProps) => import(\"react/jsx-runtime\").JSX.Element;\nexport declare const useGraphQLClient: () => GraphQLContextValue;\nexport {};\n","export type LocalStorageEventListener = {\n    storageKey: string;\n    listener: (event: StorageEvent) => void;\n};\n","import React from \"react\";\nimport { LocalStorageEventListener } from \"../application/models/localStorageEventListener\";\nexport declare enum LocalStorageKeys {\n    ChatId = \"v1-spiffy-chat-session-id\",\n    SpiffyOnOverride = \"spiffy_on\",\n    EnviveOnOverride = \"envive_on\"\n}\ninterface LocalStorageContextType {\n    setItem: (key: string, value: string) => void;\n    getItem: (key: string) => string | null;\n    setSpiffyOnFeatureFlag: (value: boolean | null) => void;\n    getSpiffyOnFeatureFlag: () => string | null;\n    attachListener: (listener: LocalStorageEventListener) => void;\n    detachListener: (listener: LocalStorageEventListener) => void;\n    isAvailable: boolean;\n}\nexport declare const LocalStorageProvider: React.FC<{\n    children: React.ReactNode;\n}>;\nexport declare const useLocalStorage: () => LocalStorageContextType;\nexport {};\n","import React from \"react\";\nimport { SearchResult, SearchParams } from \"../application/models/api/search\";\ninterface SearchContextValue {\n    searchProducts: (params: SearchParams) => Promise<SearchResult>;\n    isReady: boolean;\n}\nexport declare const SearchProvider: React.FC<{\n    children: React.ReactNode;\n}>;\nexport declare const useSearchService: () => SearchContextValue;\nexport {};\n","import React from \"react\";\ninterface SessionStorageContextType {\n    setItem: (key: string, value: string) => void;\n    getItem: (key: string) => string | null;\n    isAvailable: boolean;\n}\nexport declare const SessionStorageProvider: React.FC<{\n    children: React.ReactNode;\n}>;\nexport declare const useSessionStorage: () => SessionStorageContextType;\nexport {};\n","import React from \"react\";\nimport { IdExtractor } from \"src/contexts/types\";\ninterface ShopifyUrlContextType {\n    getTrimmedPathName: () => string | null;\n    getPlpOrPdpId: (extractor: IdExtractor) => string | null;\n    isOnPdpPage: () => boolean;\n    isOnPlpPage: () => boolean;\n    isReady: boolean;\n}\nexport declare const ShopifyUrlProvider: React.FC<{\n    children: React.ReactNode;\n}>;\nexport declare const useShopifyUrl: () => ShopifyUrlContextType;\nexport {};\n","import { Dispatch, ReactNode, SetStateAction } from \"react\";\nimport { GenerationParams } from \"src/application/models\";\ndeclare const defaultGenerationParams: GenerationParams;\ninterface SystemSettingsContextParams {\n    generationParams?: GenerationParams;\n    showDebugBar?: boolean;\n    endpointURL?: string;\n    setGenerationParams: Dispatch<SetStateAction<GenerationParams | undefined>>;\n}\ninterface SystemSettingsContextProviderProps {\n    children: ReactNode;\n    generationParams?: GenerationParams;\n    showDebugBar?: boolean;\n}\ndeclare const SystemSettingsContext: import(\"react\").Context<SystemSettingsContextParams | undefined>;\ndeclare const SystemSettingsContextProvider: ({ children, generationParams, showDebugBar, }: SystemSettingsContextProviderProps) => import(\"react/jsx-runtime\").JSX.Element;\nexport { SystemSettingsContextProvider, SystemSettingsContext, defaultGenerationParams, };\n","import React, { ReactNode } from \"react\";\nimport { BasicOrgInfoType } from \"src/application/models/supportedOrgs\";\nimport { ColorsConfigResponse, FrontendConfigResponse } from \"./graphqlContext\";\nexport interface NewOrgConfigContextType {\n    combinedConfig?: (BasicOrgInfoType & {\n        colorsConfig?: ColorsConfigResponse;\n        frontendConfig?: FrontendConfigResponse;\n    }) | null;\n    loading: boolean;\n    error: Error | null;\n}\ninterface NewOrgConfigProviderProps {\n    children: ReactNode;\n}\nexport declare const NewOrgConfigProvider: React.FC<NewOrgConfigProviderProps>;\nexport declare const useNewOrgConfigContext: () => NewOrgConfigContextType;\nexport {};\n"],"mappings":";;;;;;;AAGA,IAAI,qBAAqB;CAAC;OAAO;OAAA;OAAA;CAAA;AACjC,IAAW,yBAAa,CAAA,WAAA,mBAAA;AACxB,IAAI,kCAAkC;CAAC;OAAW;OAAG;CAAA;AACrD,IAAW,6BAA6B;CAAC;OAAW;OAAY,MAAA;CAAA;AAChE,IAAW,wBAAwB,CAAC,WAAK,uBAAA;;;;ACNzC,IAAI,iBAAiB,CAAC,IAAG;AACzB,IAAW,cAAO;CAAA;OAAA,MAAA;OAAA,MAAA;CAAA;AAClB,IAAW,SAAS,CAAC,WAAW,eAAA;;;;ACAhC,IAAI,oBAAoB,CAAC,IAAI;AAC7B,IAAI,cAAc;CAAC;OAAW;OAAoB,OAAA;CAAA;AAClD,IAAI,sBAAmB;CAAA;OAAA;OAAA;OAAA,mBAAA,IAAA;CAAA;;;;ACFvB,IAAI,4BAA4B;CAAC;OAAG;OAAA;OAAA;CAAA;AACpC,IAAW,uBAAY;CAAA;OAAA;OAAA,MAAA;CAAA;AACvB,IAAW,kBAAiB,CAAA,WAAA,aAAA;;;;ACJ5B,IAAI,yBAAyB,CAAC,WAAG,UAAA;AACjC,IAAW,oBAAY;CAAA;OAAA;OAAA,MAAA;CAAA;;;;ACGvB,IAAW,uBAAuB;CAAC;OAAW;OAAoB;CAAW;AAC7E,IAAW,yBAAuB;CAAA;OAAA;OAAA;CAAA;AAClC,IAAW,sBAAsB;CAAC;OAAK;OAAA;OAAA;CAAA;AACvC,IAAI,sBAAsB;CAAC;OAAW;OAAc;OAAS;OAAA;OAAA;OAAA;CAAA;AAC7D,IAAC,uBAAA,CAAA,WAAA,UAAA;AACD,IAAW,kBAAkB;CAAC;OAAA;OAAA;OAAA,mBAAA,IAAA;CAAA;AAC9B,IAAW,mBAAmB,CAAC,WAAW,oBAAoB;;;;ACX9D,IAAW,4BAA4B,CAAC,WAAA,aAAA;;;;ACExC,IAAW,mBAAmB,CAAC,IAAI;AACnC,IAAI,0BAA0B;CAAC;OAAS;OAAA;CAAA;AACxC,IAAW,uBAAuB;CAAA;OAAA,MAAA;OAAA,MAAA;CAAA;AAClC,IAAW,kBAAkB,CAAC,WAAG,wBAAA;;;;ACHjC,IAAI,qBAAqB;CAAC;OAAG;OAAA;OAAA;CAAA;AAC7B,IAAW,iBAAiB;CAAC;OAAW,MAAM;OAAiB,MAAI;CAAA;AACnE,IAAW,mBAAS,CAAA,WAAA,mBAAA;;;;ACHpB,IAAI,4BAA4B,CAAC,IAAG;AACpC,IAAW,yBAAyB;CAAC;OAAW,MAAC;OAAA,MAAA;CAAA;AACjD,IAAW,oBAAoB,CAAC,WAAW,0BAAA;;;;ACD3C,IAAI,wBAAwB,CAAC,WAAG,YAAA;AAChC,IAAW,qBAAqB;CAAC;OAAU,MAAA;OAAA,MAAA;CAAA;AAC3C,IAAW,gBAAgB,CAAC,WAAW,sBAAqB;;;;ACA5D,IAAI,0BAA0B,CAAC,WAAQ,iBAAA;AACvC,IAAI,8BAAsB;CAAA;OAAA;OAAA;OAAA;OAAA;CAAA;AAC1B,IAAI,qCAAoB;CAAA;OAAA;OAAA;CAAA;AACxB,IAAI,wBAAwB;CAAC;OAAW;OAAmC,OAAI;CAAA;AAC/E,IAAA,gCAAA;CAAA;OAAA;OAAA;OAAA;OAAA;OAAA,mBAAA,IAAA;CAAA;;;;ACLA,IAAW,0BAA0B;CAAC;OAAG;OAAA;OAAA;OAAA;CAAA;AACzC,IAAI,4BAA4B,CAAC,WAAQ,UAAA;AACzC,IAAW,uBAAuB;CAAC;OAAQ;OAAA,MAAA;CAAA;AAC3C,IAAW,yBAAyB,CAAC,WAAU,wBAAA"}

package/dist/{index-Dxpscrvz.d.ts → index-PGF8BvxQ.d.ts}

@@ -225,4 +225,4 @@ type CamelCasedPropertiesDeep<Value, Options extends CamelCaseOptions = {
 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;OAAU;OAAO;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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-PGF8BvxQ.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;OAAU;OAAO;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-D2VaMPA3.d.ts → index-ylUiJvnr.d.ts}

@@ -95,4 +95,4 @@ interface GetMerchantColorsQueryData {
 }
 //#endregion
 export { type GetMerchantColorsQueryData, type GetMerchantFrontendConfigQueryData, type MountingConfigQueryData, type PageVariantCheckQueryData, type PageVariantQueryData, type UIConfigQueryData, type WidgetConfigQueryData, type WidgetMountingQueryData, getMerchantColorsQuery, getMerchantFrontendConfigQuery };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/interceptors/index.cjs

@@ -1,13 +1,3 @@
-require('../logger-Dln20ans.cjs');
-require('../api-B2euFL-5.cjs');
-const require_contexts = require('../contexts-CtgmnYNn.cjs');
-require('../types-CGC6Oozp.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');
+const require_useMessageInterceptor = require('../useMessageInterceptor-B87e3yu3.cjs');
 
-exports.useFormEscalation = require_contexts.useFormEscalation;
-exports.useMessageInterceptor = require_contexts.useMessageInterceptor;
+exports.useMessageInterceptor = require_useMessageInterceptor.useMessageInterceptor;

package/dist/interceptors/index.d.cts

@@ -1,11 +1,9 @@
-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-aNW5V9fh.cjs";
-import "../index-D46Rd0io.cjs";
+import "../index-Bmub8e38.cjs";
+import { Response } from "../index-CiWEYzXl.cjs";
+import "../index-CESxqFso.cjs";
+import "../index-DTu2X-YS.cjs";
+import "../test-types-CgVJtwUr.cjs";
+import "../index-B0NW9KTj.cjs";
 
 //#region src/interceptors/types.d.ts
 interface MessageInterceptor {
@@ -13,13 +11,10 @@ interface MessageInterceptor {
   blockExecution: () => boolean;
 }
 //#endregion
-//#region src/interceptors/useFormEscalation.d.ts
-declare const useFormEscalation: () => MessageInterceptor;
-//#endregion
 //#region src/interceptors/useMessageInterceptor.d.ts
 declare const useMessageInterceptor: () => {
   intercept: (response?: Response) => boolean | undefined;
 };
 //#endregion
-export { MessageInterceptor, useFormEscalation, useMessageInterceptor };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL2ludGVyY2VwdG9ycy90eXBlcy5kLnRzIiwiLi4vLi4vc3JjL2ludGVyY2VwdG9ycy91c2VGb3JtRXNjYWxhdGlvbi5kLnRzIiwiLi4vLi4vc3JjL2ludGVyY2VwdG9ycy91c2VNZXNzYWdlSW50ZXJjZXB0b3IuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZXNwb25zZSB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMnO1xuZXhwb3J0IGludGVyZmFjZSBNZXNzYWdlSW50ZXJjZXB0b3Ige1xuICAgIGV4ZWN1dGU6IChyZXNwb25zZTogUmVzcG9uc2UpID0+IHZvaWQgfCBQcm9taXNlPHZvaWQ+O1xuICAgIGJsb2NrRXhlY3V0aW9uOiAoKSA9PiBib29sZWFuO1xufVxuIiwiaW1wb3J0IHsgTWVzc2FnZUludGVyY2VwdG9yIH0gZnJvbSBcIi4vdHlwZXNcIjtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IHVzZUZvcm1Fc2NhbGF0aW9uOiAoKSA9PiBNZXNzYWdlSW50ZXJjZXB0b3I7XG4iLCJpbXBvcnQgeyBSZXNwb25zZSB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMnO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgdXNlTWVzc2FnZUludGVyY2VwdG9yOiAoKSA9PiB7XG4gICAgaW50ZXJjZXB0OiAocmVzcG9uc2U/OiBSZXNwb25zZSkgPT4gYm9vbGVhbiB8IHVuZGVmaW5lZDtcbn07XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7QUFDQSxJQUFXLHFCQUFxQjtDQUFDO09BQUc7T0FBQTtDQUFBOzs7O0FDQXBDLElBQVcsb0JBQW9CLENBQUMsVUFBVSxtQkFBbUI7Ozs7QUNBN0QsSUFBVyx3QkFBd0IsQ0FBQyxVQUFVLFNBQUkifQ==
+export { MessageInterceptor, useMessageInterceptor };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL2ludGVyY2VwdG9ycy90eXBlcy5kLnRzIiwiLi4vLi4vc3JjL2ludGVyY2VwdG9ycy91c2VNZXNzYWdlSW50ZXJjZXB0b3IuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZXNwb25zZSB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMnO1xuZXhwb3J0IGludGVyZmFjZSBNZXNzYWdlSW50ZXJjZXB0b3Ige1xuICAgIGV4ZWN1dGU6IChyZXNwb25zZTogUmVzcG9uc2UpID0+IHZvaWQgfCBQcm9taXNlPHZvaWQ+O1xuICAgIGJsb2NrRXhlY3V0aW9uOiAoKSA9PiBib29sZWFuO1xufVxuIiwiaW1wb3J0IHsgUmVzcG9uc2UgfSBmcm9tIFwic3JjL2FwcGxpY2F0aW9uL21vZGVsc1wiO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgdXNlTWVzc2FnZUludGVyY2VwdG9yOiAoKSA9PiB7XG4gICAgaW50ZXJjZXB0OiAocmVzcG9uc2U/OiBSZXNwb25zZSkgPT4gYm9vbGVhbiB8IHVuZGVmaW5lZDtcbn07XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7O0FBQ0EsSUFBVyxxQkFBcUI7Q0FBQztPQUFHO09BQUE7Q0FBQTs7OztBQ0FwQyxJQUFXLHdCQUF3QixDQUFDLFdBQVcsU0FBRyJ9

package/dist/interceptors/index.d.ts

@@ -1,11 +1,9 @@
-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-DXpgMVpp.js";
-import "../index-CKKkTsms.js";
+import "../index-ylUiJvnr.js";
+import { Response } from "../index-CcIG01PJ.js";
+import "../index-PGF8BvxQ.js";
+import "../index-C7pGDl1A.js";
+import "../test-types-C9b_OdfO.js";
+import "../index-Cqg6ltII.js";
 
 //#region src/interceptors/types.d.ts
 interface MessageInterceptor {
@@ -13,13 +11,10 @@ interface MessageInterceptor {
   blockExecution: () => boolean;
 }
 //#endregion
-//#region src/interceptors/useFormEscalation.d.ts
-declare const useFormEscalation: () => MessageInterceptor;
-//#endregion
 //#region src/interceptors/useMessageInterceptor.d.ts
 declare const useMessageInterceptor: () => {
   intercept: (response?: Response) => boolean | undefined;
 };
 //#endregion
-export { MessageInterceptor, useFormEscalation, useMessageInterceptor };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi9zcmMvaW50ZXJjZXB0b3JzL3R5cGVzLmQudHMiLCIuLi8uLi9zcmMvaW50ZXJjZXB0b3JzL3VzZUZvcm1Fc2NhbGF0aW9uLmQudHMiLCIuLi8uLi9zcmMvaW50ZXJjZXB0b3JzL3VzZU1lc3NhZ2VJbnRlcmNlcHRvci5kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJlc3BvbnNlIH0gZnJvbSAnc3JjL2FwcGxpY2F0aW9uL21vZGVscyc7XG5leHBvcnQgaW50ZXJmYWNlIE1lc3NhZ2VJbnRlcmNlcHRvciB7XG4gICAgZXhlY3V0ZTogKHJlc3BvbnNlOiBSZXNwb25zZSkgPT4gdm9pZCB8IFByb21pc2U8dm9pZD47XG4gICAgYmxvY2tFeGVjdXRpb246ICgpID0+IGJvb2xlYW47XG59XG4iLCJpbXBvcnQgeyBNZXNzYWdlSW50ZXJjZXB0b3IgfSBmcm9tIFwiLi90eXBlc1wiO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgdXNlRm9ybUVzY2FsYXRpb246ICgpID0+IE1lc3NhZ2VJbnRlcmNlcHRvcjtcbiIsImltcG9ydCB7IFJlc3BvbnNlIH0gZnJvbSAnc3JjL2FwcGxpY2F0aW9uL21vZGVscyc7XG5leHBvcnQgZGVjbGFyZSBjb25zdCB1c2VNZXNzYWdlSW50ZXJjZXB0b3I6ICgpID0+IHtcbiAgICBpbnRlcmNlcHQ6IChyZXNwb25zZT86IFJlc3BvbnNlKSA9PiBib29sZWFuIHwgdW5kZWZpbmVkO1xufTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7OztBQUNBLElBQVcscUJBQXFCO0NBQUM7T0FBRztPQUFBO0NBQUE7Ozs7QUNBcEMsSUFBVyxvQkFBb0IsQ0FBQyxXQUFXLG1CQUFtQjs7OztBQ0E5RCxJQUFXLHdCQUF3QixDQUFDLFdBQVcsU0FBRyJ9
+export { MessageInterceptor, useMessageInterceptor };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi9zcmMvaW50ZXJjZXB0b3JzL3R5cGVzLmQudHMiLCIuLi8uLi9zcmMvaW50ZXJjZXB0b3JzL3VzZU1lc3NhZ2VJbnRlcmNlcHRvci5kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJlc3BvbnNlIH0gZnJvbSAnc3JjL2FwcGxpY2F0aW9uL21vZGVscyc7XG5leHBvcnQgaW50ZXJmYWNlIE1lc3NhZ2VJbnRlcmNlcHRvciB7XG4gICAgZXhlY3V0ZTogKHJlc3BvbnNlOiBSZXNwb25zZSkgPT4gdm9pZCB8IFByb21pc2U8dm9pZD47XG4gICAgYmxvY2tFeGVjdXRpb246ICgpID0+IGJvb2xlYW47XG59XG4iLCJpbXBvcnQgeyBSZXNwb25zZSB9IGZyb20gXCJzcmMvYXBwbGljYXRpb24vbW9kZWxzXCI7XG5leHBvcnQgZGVjbGFyZSBjb25zdCB1c2VNZXNzYWdlSW50ZXJjZXB0b3I6ICgpID0+IHtcbiAgICBpbnRlcmNlcHQ6IChyZXNwb25zZT86IFJlc3BvbnNlKSA9PiBib29sZWFuIHwgdW5kZWZpbmVkO1xufTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7QUFDQSxJQUFXLHFCQUFxQjtDQUFDO09BQUc7T0FBQTtDQUFBOzs7O0FDQXBDLElBQVcsd0JBQXdCLENBQUMsV0FBVyxTQUFHIn0=

package/dist/interceptors/index.js

@@ -1,12 +1,3 @@
-import "../logger-pdEEY8T2.js";
-import "../api-XRr_lAG6.js";
-import { useFormEscalation, useMessageInterceptor } from "../contexts-CtRlNXaS.js";
-import "../types-CnTCkyvK.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";
+import { useMessageInterceptor } from "../useMessageInterceptor-Bb7YRaWk.js";
 
-export { useFormEscalation, useMessageInterceptor };
+export { useMessageInterceptor };