@zonos/amino 5.5.29 → 5.5.31

package/types/BaseProps.d.ts

@@ -0,0 +1,7 @@
+/**
+ * All components props should extend this.
+ */
+export type BaseProps = {
+    className?: string;
+    style?: React.CSSProperties;
+};

package/types/Color.d.ts

@@ -0,0 +1,5 @@
+export declare const colorPrefixes: readonly ["blue", "cyan", "green", "orange", "purple", "red", "gray", "glass"];
+export declare const colorContrasts: readonly ["50", "100", "200", "300", "400", "500", "600", "700", "800", "900", "950"];
+export type ColorContrast = (typeof colorContrasts)[number];
+export type ColorPrefix = (typeof colorPrefixes)[number];
+export type Color = 'gray0' | 'gray50' | 'glass0' | 'glass50' | `${ColorPrefix}${ColorContrast}` | 'gray950' | 'gray1000' | 'glass950' | 'glass1000';

package/types/Depth.d.ts

@@ -0,0 +1 @@
+export type Depth = 'depth4' | 'depth8' | 'depth16' | 'depth64';

package/types/GeoJsonWorld.d.ts

@@ -0,0 +1,21 @@
+import type { BBox } from 'geojson';
+import type { Arc, MultiPolygon, Polygon, Transform } from 'topojson-specification';
+type Properties = {
+    name: string;
+};
+type Geometry = (Polygon | MultiPolygon) & {
+    properties: Properties;
+};
+export type GeoJsonWorld = {
+    arcs: Arc[];
+    bbox: BBox;
+    objects: {
+        countries: {
+            geometries: Geometry[];
+            type: 'GeometryCollection';
+        };
+    };
+    transform: Transform;
+    type: 'Topology';
+};
+export {};

package/types/GridSpacing.d.ts

@@ -0,0 +1,2 @@
+export type GridAlignment = 'start' | 'end';
+export type GridSpacing = 0 | 4 | 8 | 12 | 16 | 20 | 24 | 28 | 32 | 36 | 40 | 44 | 48 | 52 | 56;

package/types/IconProps.d.ts

@@ -0,0 +1,10 @@
+import type { Color } from "./Color";
+export type IconProps = {
+    className?: string;
+    color?: Color;
+    inlineBlock?: boolean;
+    /**
+     * @default 24
+     */
+    size?: number;
+};

package/types/Intent.d.ts

@@ -0,0 +1 @@
+export type Intent = 'default' | 'primary' | 'secondary' | 'info' | 'success' | 'warning' | 'danger' | 'error';

package/types/ReactComponent.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentType, ExoticComponent } from 'react';
+export type ReactComponent<T> = ComponentType<T> | ExoticComponent<T>;

package/types/SectionLayout.d.ts

@@ -0,0 +1 @@
+export type SectionLayout = 'vertical' | 'horizontal';

package/types/SelectOption.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+export type SelectValue = string | number | null;
+export type SelectOption<V extends SelectValue = SelectValue> = {
+    icon?: ReactNode;
+    isDisabled?: boolean;
+    label: string;
+    /**
+     * For checkboxes
+     */
+    labelDescription?: string;
+    value: V;
+};

package/types/Size.d.ts

@@ -0,0 +1 @@
+export type Size = 'sm' | 'md' | 'lg' | 'xl';

package/types/Theme.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const themeSchema: z.ZodEnum<["day", "night"]>;
+export type Theme = z.infer<typeof themeSchema>;

package/types/UnitedStates.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+export type UnitedStatesCode = 'AL' | 'AK' | 'AZ' | 'AR' | 'CA' | 'CO' | 'CT' | 'DE' | 'FL' | 'GA' | 'HI' | 'ID' | 'IL' | 'IN' | 'IA' | 'KS' | 'KY' | 'LA' | 'ME' | 'MD' | 'MA' | 'MI' | 'MN' | 'MS' | 'MO' | 'MT' | 'NE' | 'NV' | 'NH' | 'NJ' | 'NM' | 'NY' | 'NC' | 'ND' | 'OH' | 'OK' | 'OR' | 'PA' | 'PR' | 'RI' | 'SC' | 'SD' | 'TN' | 'TX' | 'UT' | 'VT' | 'VA' | 'WA' | 'WV' | 'WI' | 'WY';
+type UnitedStatesName = 'Alabama' | 'Alaska' | 'Arizona' | 'Arkansas' | 'California' | 'Colorado' | 'Connecticut' | 'Delaware' | 'Florida' | 'Georgia' | 'Hawaii' | 'Idaho' | 'Illinois' | 'Indiana' | 'Iowa' | 'Kansas' | 'Kentucky' | 'Louisiana' | 'Maine' | 'Maryland' | 'Massachusetts' | 'Michigan' | 'Minnesota' | 'Mississippi' | 'Missouri' | 'Montana' | 'Nebraska' | 'Nevada' | 'New Hampshire' | 'New Jersey' | 'New Mexico' | 'New York' | 'North Carolina' | 'North Dakota' | 'Ohio' | 'Oklahoma' | 'Oregon' | 'Pennsylvania' | 'Puerto Rico' | 'Rhode Island' | 'South Carolina' | 'South Dakota' | 'Tennessee' | 'Texas' | 'Utah' | 'Vermont' | 'Virginia' | 'Washington' | 'West Virginia' | 'Wisconsin' | 'Wyoming';
+type UnitedStatesRegions = 'Midwest' | 'Northeast' | 'South' | 'Territories' | 'West';
+export type UnitedState = {
+    code: UnitedStatesCode;
+    highlighted?: boolean;
+    icon: ReactNode;
+    name: UnitedStatesName;
+    region: UnitedStatesRegions;
+};
+export {};

package/types/UploadedFile.d.ts

@@ -0,0 +1,5 @@
+export type UploadedFile = {
+    imageUrl?: string;
+    name: string;
+    size?: string;
+};

package/types/Variant.d.ts

@@ -0,0 +1 @@
+export type Variant = 'danger' | 'inlineLink' | 'inverted' | 'link' | 'plain' | 'primary' | 'standard' | 'subtle' | 'success' | 'text' | 'warning' | 'purple' | 'cyan';

package/types/deep/Deep.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/types/deep/DeepKeyof.d.ts

@@ -0,0 +1,18 @@
+import type { DeepPrev, DeepRecursionLimited, DeepRecursiveDepth } from "./deep";
+type Delimiter = '.';
+/**
+ * Constructs a union of all possible keys with primitive values, with nested properties separated with a delimiter.
+ *
+ * Default recursion depth limit is 4.
+ *
+ * @example 'person.age'
+ *
+ */
+export type DeepKeyof<T extends object, Depth extends DeepRecursiveDepth = 4> = DeepRecursionLimited<Depth, {
+    [K in Extract<keyof T, string>]: T[K] extends Array<unknown> ? K : T[K] extends object ? `${K}${Delimiter}${DeepKeyof<T[K], DeepPrev[Depth]>}` : K;
+}[Extract<keyof T, string>]>;
+/**
+ * Extracts a type for a field given a property path string.
+ */
+export type DeepPropertyType<T extends object, KeyPath extends DeepKeyof<T, Depth>, Depth extends DeepRecursiveDepth = 4> = DeepRecursionLimited<Depth, KeyPath extends `${infer Top}${Delimiter}${infer Rest}` ? Top extends keyof T ? T[Top] extends object ? Rest extends DeepKeyof<T[Top], DeepPrev[Depth]> ? DeepPropertyType<T[Top], Rest, DeepPrev[Depth]> : never : never : never : KeyPath extends keyof T ? T[KeyPath] : never>;
+export {};

package/types/deep/DeepKeyofAtIndex.d.ts

@@ -0,0 +1,12 @@
+import type { DeepPrev, DeepRecursionLimited, DeepRecursiveDepth } from "./deep";
+type DeepKeyofObjAndArray<T extends object, Depth extends DeepRecursiveDepth = 4> = DeepRecursionLimited<Depth, {
+    [K in Extract<keyof T, string>]: T[K] extends unknown[] ? T[K][number] extends object ? `${K}[number].${DeepKeyofObjAndArray<T[K][number], DeepPrev[Depth]>}` : `${K}[number]` : T[K] extends object ? `${K}.${DeepKeyofObjAndArray<T[K], DeepPrev[Depth]>}` : K;
+}[Extract<keyof T, string>]>;
+export type DeepKeyofAtIndex<T extends object, Depth extends DeepRecursiveDepth = 4> = {
+    [Path in DeepKeyofObjAndArray<T, Depth>]: Path extends `${string}[number]${string}` ? Path : Path extends `${string}[number]` ? Path : never;
+}[DeepKeyofObjAndArray<T, Depth>];
+/**
+ * Extracts a type for a field given a property path string.
+ */
+export type DeepPropertyTypeAtIndex<T extends object, KeyPath extends DeepKeyofObjAndArray<T, Depth>, Depth extends DeepRecursiveDepth = 4> = DeepRecursionLimited<Depth, KeyPath extends `${infer Top}.${infer Rest}` ? Top extends `${infer ArrayField}[number]` ? ArrayField extends keyof T ? T[ArrayField] extends unknown[] ? T[ArrayField][number] extends object ? Rest extends DeepKeyofObjAndArray<T[ArrayField][number], DeepPrev[Depth]> ? DeepPropertyTypeAtIndex<T[ArrayField][number], Rest, DeepPrev[Depth]> : never : never : never : never : Top extends keyof T ? T[Top] extends object ? Rest extends DeepKeyofObjAndArray<T[Top], DeepPrev[Depth]> ? DeepPropertyTypeAtIndex<T[Top], Rest, DeepPrev[Depth]> : never : never : never : KeyPath extends `${infer ArrayField}[number]` ? ArrayField extends keyof T ? T[ArrayField] extends unknown[] ? T[ArrayField][number] : never : never : KeyPath extends keyof T ? T[KeyPath] : never>;
+export {};

package/types/deep/DeepKeyofAtIndex.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/types/deep/DeepReducerActions.d.ts

@@ -0,0 +1,25 @@
+import type { DeepRecursiveDepth } from "./deep";
+import type { DeepKeyof, DeepPropertyType } from "./DeepKeyof";
+import type { DeepKeyofAtIndex, DeepPropertyTypeAtIndex } from "./DeepKeyofAtIndex";
+/**
+ * Default depth of 4
+ */
+export type DeepReducerActions<T extends object, Depth extends DeepRecursiveDepth = 4> = DeepReducerWithoutArrayActions<T, Depth> | DeepReducerWithArrayActions<T, Depth>;
+/**
+ * Default depth of 4
+ */
+export type DeepReducerWithArrayActions<T extends object, Depth extends DeepRecursiveDepth = 4> = {
+    [Name in DeepKeyofAtIndex<T, Depth>]: {
+        index: number;
+        name: Name;
+        type: 'changeAtIndex';
+        value: DeepPropertyTypeAtIndex<T, Name, Depth>;
+    };
+}[DeepKeyofAtIndex<T, Depth>];
+export type DeepReducerWithoutArrayActions<T extends object, Depth extends DeepRecursiveDepth = 4> = {
+    [Name in DeepKeyof<T, Depth>]: {
+        name: Name;
+        type: 'change';
+        value: DeepPropertyType<T, Name, Depth>;
+    };
+}[DeepKeyof<T, Depth>];

package/types/deep/deep.d.ts

@@ -0,0 +1,4 @@
+/** For depth limiting recursive types */
+export type DeepPrev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+export type DeepRecursiveDepth = DeepPrev[number];
+export type DeepRecursionLimited<Depth extends DeepRecursiveDepth, T> = Depth extends never ? never : T;

package/utils/_extractQueryParams.d.ts

@@ -0,0 +1,5 @@
+export declare const paramRegex = "\\s*\\(([\\W\\w]*)\\)";
+export declare const extractQueryParams: ({ actionName, query, }: {
+    actionName: string;
+    query: string;
+}) => Record<string, unknown>;

package/utils/addIndex.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @desc adds _itemIndex for the item in the array
+ * */
+export declare const addIndex: <T extends Record<string, unknown>>(item: T, index: number) => T & {
+    _itemIndex: number;
+};

package/utils/changeDeepProperty.d.ts

@@ -0,0 +1,45 @@
+import type { DeepRecursiveDepth } from "../types/deep/deep";
+import type { DeepKeyof, DeepPropertyType } from "../types/deep/DeepKeyof";
+/**
+ * Will change a nested property on an object, and return a copy of the object with only that property changed.
+ *
+ * If a leaf field is optional, and not specified on the initial object, it will add it.
+ *
+ * Uses lodash `set` internally. @link https://lodash.com/docs/4.17.15#set
+ *
+ * @param propertyPath The path to the property, with nested keys separated by the delimiter.
+ * @param value The value to change it to.
+ *
+ * @example
+ * const t: T = {
+    my: {
+      friend: {
+        paul: {
+          age: 32,
+        },
+      },
+    },
+  };
+
+    const out = changeDeepProperty({
+      obj: t,
+      propertyPath: 'my.friend.paul.age',
+      value: 40
+    );
+
+    // Output:
+    out === {
+      my: {
+        friend: {
+          paul: {
+            age: 40,
+          },
+        },
+      },
+    };
+ */
+export declare const changeDeepProperty: <T extends Record<string, unknown>, P extends DeepKeyof<T, Depth>, Depth extends DeepRecursiveDepth = 4>({ obj, propertyPath, value, }: {
+    obj: T;
+    propertyPath: P;
+    value: DeepPropertyType<T, P, Depth>;
+}) => T;

package/utils/changeDeepPropertyAtIndex.d.ts

@@ -0,0 +1,69 @@
+import type { DeepRecursiveDepth } from "../types/deep/deep";
+import type { DeepKeyofAtIndex, DeepPropertyTypeAtIndex } from "../types/deep/DeepKeyofAtIndex";
+/**
+ * Will change a nested property on an object (with array), and return a copy of the object with only that property changed.
+ *
+ * If a leaf field is optional, and not specified on the initial object, it will add it.
+ *
+ * **KeyPath only suggest on the field path that has array**
+ *
+ * Uses lodash `set` internally. @link https://lodash.com/docs/4.17.15#set
+ *
+ * @param propertyPath The path to the property, with nested keys separated by the delimiter.
+ * @param index Position of desired field want to set
+ * @param value The value to change it to.
+ *
+ * @example
+ * const t = {
+    my: {
+      friend: {
+        paul: {
+          age: 32,
+          childrens: [
+            {
+              name: "Janny",
+              sex: "MALE",
+            },
+            {
+              name: "Kicha",
+              sex: "FEMALE"
+            }
+          ]
+        },
+      },
+    },
+  };
+
+    const out = changeDeepPropertyAtIndex(
+      obj: t, propertyPath: 'my.friend.paul.childrens[number].name',
+      index: 1, value:
+      "Ketchup"
+    );
+
+    // Output:
+    out === {
+      my: {
+        friend: {
+          paul: {
+            age: 32,
+            childrenName: [
+              {
+                name: "Janny";
+                sex: "MALE",
+              },
+              {
+                name: "Ketchup" // <== Change here
+                sex: "FEMALE"
+              }
+            ]
+          },
+        },
+      },
+    };
+ */
+export declare const changeDeepPropertyAtIndex: <T extends object, P extends DeepKeyofAtIndex<T, Depth>, Depth extends DeepRecursiveDepth = 4>({ index, obj, propertyPath, value, }: {
+    index: number;
+    obj: T;
+    propertyPath: P;
+    value: DeepPropertyTypeAtIndex<T, P, Depth>;
+}) => T;

package/utils/countryPhoneCodes.d.ts

@@ -0,0 +1,4 @@
+export declare const countryPhoneCodes: {
+    code: string;
+    phoneCode: string[];
+}[];

package/utils/flattenRow.d.ts

@@ -0,0 +1,8 @@
+type Value = string | number | boolean;
+type Params = {
+    currentVal: [string, unknown];
+    prev: Record<string, unknown>;
+    previousKey?: string;
+};
+export declare const flattenRow: ({ currentVal: [key, value], prev, previousKey, }: Params) => Record<string, unknown> | Value;
+export {};

package/utils/formatCurrency.d.ts

@@ -0,0 +1,49 @@
+type FormatCurrencyParams = {
+    code: string;
+    /**
+     * Keep the currency symbol and separators. Defualt is to remove them.
+     * @default false
+     */
+    keepDecorators?: boolean;
+    /**
+     * If you don't want thousands separators, set useGrouping to false.
+     */
+    options?: Intl.NumberFormatOptions;
+    value: number;
+};
+export declare const formatCurrency: ({ code, options, value, }: FormatCurrencyParams) => string;
+type DualCurrencyParams = {
+    conversionRate?: number;
+    /**
+     * @default 'USD'
+     */
+    foreignCode?: string;
+    /**
+     * @default 'USD'
+     */
+    localCode?: string;
+    value: number;
+    /**
+     * For when the value is already in the foreign currency, and the conversion needs to be reversed.
+     * The rate can stay the same.
+     * @default false
+     */
+    valueIsForeign?: boolean;
+};
+type DualCurrency = {
+    foreign: {
+        amount: number;
+        code: string;
+        value: string;
+    } | null;
+    local: {
+        amount: number;
+        code: string;
+        value: string;
+    } | null;
+};
+/**
+ * Just returns values, presentation is up to implementation
+ */
+export declare const getDualCurrency: ({ conversionRate, foreignCode, localCode, value, valueIsForeign, }: DualCurrencyParams) => DualCurrency;
+export {};

package/utils/getAminoColor.d.ts

@@ -0,0 +1,2 @@
+import type { Color } from "../types/Color";
+export declare const getAminoColor: (color?: Color | "inherit") => "var(--amino-glass-0)" | "var(--amino-glass-50)" | "var(--amino-glass-100)" | "var(--amino-glass-200)" | "var(--amino-glass-300)" | "var(--amino-glass-400)" | "var(--amino-glass-500)" | "var(--amino-glass-600)" | "var(--amino-glass-700)" | "var(--amino-glass-800)" | "var(--amino-glass-900)" | "var(--amino-glass-950)" | "var(--amino-glass-1000)" | "var(--amino-gray-0)" | "var(--amino-gray-50)" | "var(--amino-gray-100)" | "var(--amino-gray-200)" | "var(--amino-gray-300)" | "var(--amino-gray-400)" | "var(--amino-gray-500)" | "var(--amino-gray-600)" | "var(--amino-gray-700)" | "var(--amino-gray-800)" | "var(--amino-gray-900)" | "var(--amino-gray-950)" | "var(--amino-gray-1000)" | "var(--amino-blue-50)" | "var(--amino-blue-100)" | "var(--amino-blue-200)" | "var(--amino-blue-300)" | "var(--amino-blue-400)" | "var(--amino-blue-500)" | "var(--amino-blue-600)" | "var(--amino-blue-700)" | "var(--amino-blue-800)" | "var(--amino-blue-900)" | "var(--amino-blue-950)" | "var(--amino-cyan-50)" | "var(--amino-cyan-100)" | "var(--amino-cyan-200)" | "var(--amino-cyan-300)" | "var(--amino-cyan-400)" | "var(--amino-cyan-500)" | "var(--amino-cyan-600)" | "var(--amino-cyan-700)" | "var(--amino-cyan-800)" | "var(--amino-cyan-900)" | "var(--amino-cyan-950)" | "var(--amino-red-50)" | "var(--amino-red-100)" | "var(--amino-red-200)" | "var(--amino-red-300)" | "var(--amino-red-400)" | "var(--amino-red-500)" | "var(--amino-red-600)" | "var(--amino-red-700)" | "var(--amino-red-800)" | "var(--amino-red-900)" | "var(--amino-red-950)" | "var(--amino-orange-50)" | "var(--amino-orange-100)" | "var(--amino-orange-200)" | "var(--amino-orange-300)" | "var(--amino-orange-400)" | "var(--amino-orange-500)" | "var(--amino-orange-600)" | "var(--amino-orange-700)" | "var(--amino-orange-800)" | "var(--amino-orange-900)" | "var(--amino-orange-950)" | "var(--amino-green-50)" | "var(--amino-green-100)" | "var(--amino-green-200)" | "var(--amino-green-300)" | "var(--amino-green-400)" | "var(--amino-green-500)" | "var(--amino-green-600)" | "var(--amino-green-700)" | "var(--amino-green-800)" | "var(--amino-green-900)" | "var(--amino-green-950)" | "var(--amino-purple-50)" | "var(--amino-purple-100)" | "var(--amino-purple-200)" | "var(--amino-purple-300)" | "var(--amino-purple-400)" | "var(--amino-purple-500)" | "var(--amino-purple-600)" | "var(--amino-purple-700)" | "var(--amino-purple-800)" | "var(--amino-purple-900)" | "var(--amino-purple-950)" | "inherit" | undefined;

package/utils/getCountryCodeByName.d.ts

@@ -0,0 +1,2 @@
+import type { CountryOption } from "./hooks/useCountryOptions";
+export declare const getCountryCodeByName: (countryName: string, countries: CountryOption[]) => string;

package/utils/getCountryUrls.d.ts

@@ -0,0 +1 @@
+export declare const getCountryUrls: () => string;

package/utils/getFuzzySearch.d.ts

@@ -0,0 +1,8 @@
+import Fuse from 'fuse.js';
+export declare const getFuzzySearch: <T>({ array, index, options, }: {
+    array: T[];
+    index?: Fuse.FuseIndex<T>;
+    options?: Fuse.IFuseOptions<T>;
+}) => {
+    fuzzySearch: Fuse<T>;
+};

package/utils/getHashId.d.ts

@@ -0,0 +1,2 @@
+import type { ReactNode } from 'react';
+export declare const getHashId: (title: ReactNode) => string;

package/utils/getIsInternalLink.d.ts

@@ -0,0 +1,8 @@
+export declare const getIsInternalLink: ({ href, internalPaths, shouldWarn, }: {
+    href?: string;
+    internalPaths?: string[];
+    shouldWarn?: boolean;
+}) => {
+    isBrokenLink: boolean;
+    isInternalLink: boolean | undefined;
+};

package/utils/getProductDetails.d.ts

@@ -0,0 +1,19 @@
+import type { ReactNode } from 'react';
+import type { ColorPrefix } from "../types/Color";
+export type Product = 'checkout' | 'classify' | 'clear' | 'counter-companion' | 'dashboard' | 'prepay' | 'collect' | 'hello' | 'inclusive-pricing' | 'landed-cost' | 'rate' | 'restrict' | 'screen' | 'tax';
+export type ProductName = 'Checkout' | 'Classify' | 'Clear' | 'Counter Companion' | 'Dashboard' | 'Prepay' | 'Collect' | 'Hello' | 'Inclusive Pricing' | 'Landed Cost' | 'Rate' | 'Restrict' | 'Screen' | 'Tax';
+type Params = {
+    /**
+     * @default 24
+     */
+    iconSize?: number;
+    product?: Product;
+};
+type Return = {
+    color: ColorPrefix;
+    gradient: string;
+    icon: ReactNode;
+    name: ProductName;
+};
+export declare const getProductDetails: ({ iconSize, product, }: Params) => Return;
+export {};

package/utils/getTestId.d.ts

@@ -0,0 +1,5 @@
+export type TestIdFormat = `amino--${string}`;
+export declare const getTestId: ({ componentName, name, }: {
+    componentName?: string;
+    name?: string;
+}) => TestIdFormat;

package/utils/handleFetch.d.ts

@@ -0,0 +1,23 @@
+export type JsonError = {
+    errorId?: number;
+    message: string;
+    type: string;
+};
+export type HandleFetchReturn<ResponseBody> = {
+    errors: JsonError[];
+    json: NoInfer<ResponseBody> | null;
+    response: Response | null;
+};
+export type FetcherReturn<ResponseBody> = {
+    json: NoInfer<ResponseBody> | null;
+    response: Response | null;
+};
+export declare const handleRequest: <ResponseBody>(url: string, options?: RequestInit) => Promise<HandleFetchReturn<ResponseBody>>;
+export type RequestOptions<ResponseBody, RequestBody> = {
+    body?: NoInfer<RequestBody>;
+    testExpectedData?: (data: ResponseBody) => boolean;
+} & Omit<RequestInit, 'body'>;
+export declare const handleFetch: <ResponseBody, RequestBody = unknown>(url: string, _opts?: RequestOptions<ResponseBody, RequestBody> & {
+    logRequestIfError?: boolean;
+}) => Promise<HandleFetchReturn<ResponseBody>>;
+export declare const fetcher: <ResponseBody, RequestBody = unknown>(url: string, options?: RequestOptions<ResponseBody, RequestBody>) => Promise<FetcherReturn<ResponseBody>>;

package/utils/hooks/action-pivot-table/useHasuraGqlPagination.d.ts

@@ -0,0 +1,13 @@
+type Props = {
+    actionName: string;
+    query: string;
+    setCachingKey: (key: string) => void;
+    setQuery: (query: string) => void;
+};
+export declare const useHasuraGqlPagination: ({ actionName, query, setCachingKey, setQuery, }: Props) => {
+    currentPage: number;
+    handlePagination: (page: number) => void;
+    limit: number;
+    offset: number;
+};
+export {};

package/utils/hooks/useAminoTheme.d.ts

@@ -0,0 +1,12 @@
+import { type Theme } from "../../types/Theme";
+type Params = {
+    /** Use with root to override a theme in localStorage */
+    override?: Theme;
+    /** Whether to modify the root HTML element */
+    root?: boolean;
+};
+export declare const useAminoTheme: (params?: Params) => {
+    aminoTheme: "day" | "night";
+    setAminoTheme: (value: "day" | "night") => void;
+};
+export {};

package/utils/hooks/useCountryOptions.d.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import type { SelectOption } from "../../types/SelectOption";
+export declare const regions: readonly ["Africa", "Americas", "Asia", "Central America", "Europe", "North America", "Oceania", "South America"];
+type Region = (typeof regions)[number];
+declare const schemaCountry: z.ZodObject<{
+    active: z.ZodBoolean;
+    code: z.ZodString;
+    code3: z.ZodNullable<z.ZodString>;
+    currencyCode: z.ZodString;
+    displayName: z.ZodString;
+    fraudRisk: z.ZodNumber;
+    label: z.ZodString;
+    languageCode: z.ZodNullable<z.ZodString>;
+    numericCode: z.ZodNullable<z.ZodString>;
+    phoneCode: z.ZodArray<z.ZodString, "many">;
+    region: z.ZodEnum<["Africa", "Americas", "Asia", "Central America", "Europe", "North America", "Oceania", "South America"]>;
+    upsCode: z.ZodNullable<z.ZodString>;
+    value: z.ZodString;
+    zipRegex: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    label: string;
+    region: "Africa" | "Americas" | "Asia" | "Central America" | "Europe" | "North America" | "Oceania" | "South America";
+    active: boolean;
+    displayName: string;
+    value: string;
+    code3: string | null;
+    currencyCode: string;
+    fraudRisk: number;
+    languageCode: string | null;
+    numericCode: string | null;
+    phoneCode: string[];
+    upsCode: string | null;
+    zipRegex: string | null;
+}, {
+    code: string;
+    label: string;
+    region: "Africa" | "Americas" | "Asia" | "Central America" | "Europe" | "North America" | "Oceania" | "South America";
+    active: boolean;
+    displayName: string;
+    value: string;
+    code3: string | null;
+    currencyCode: string;
+    fraudRisk: number;
+    languageCode: string | null;
+    numericCode: string | null;
+    phoneCode: string[];
+    upsCode: string | null;
+    zipRegex: string | null;
+}>;
+/** @desc /api/address/getCountries */
+export type Country<CountryCode extends string = string> = z.infer<typeof schemaCountry> & {
+    code: CountryCode;
+};
+export type CountryOption<CountryCode extends string = string> = {
+    phoneCode: string[];
+} & Country<CountryCode> & SelectOption<CountryCode>;
+export type RegionCountryOption = {
+    label: Region;
+    options: CountryOption[];
+};
+export type UnavailableCountry = {
+    code: string;
+    message: string;
+};
+/** @desc /api/address/getCountries */
+export type GetCountriesResponse<CountryCode extends string = string> = {
+    [key: string]: Country<CountryCode>;
+};
+export declare const useCountryOptions: <TCountryCode extends string>(dashboardUrl: string) => CountryOption<TCountryCode>[];
+export {};

package/utils/hooks/useDropdown.d.ts

@@ -0,0 +1,31 @@
+import { type ExtendedRefs, type Placement, type UseFloatingOptions } from '@floating-ui/react';
+export type UseDropdownParams = {
+    /**
+     * Passed to `useFloating`.
+     * @link https://floating-ui.com/docs/useFloating
+     */
+    floatingOptions?: Partial<UseFloatingOptions>;
+    /**
+     * @default 0
+     */
+    offsetCrossAxis?: number;
+    /**
+     * @default 0
+     */
+    offsetMainAxis?: number;
+    /**
+     * @default 'bottom-start'
+     */
+    placement?: Placement;
+    startOpen?: boolean;
+};
+type Return<WrapperRef extends HTMLElement = HTMLDivElement, TriggerRef extends HTMLElement = HTMLButtonElement> = {
+    floatingStyles: React.CSSProperties;
+    refs: ExtendedRefs<TriggerRef>;
+    setVisible: React.Dispatch<React.SetStateAction<boolean>>;
+    visibility: 'visible' | 'hidden';
+    visible: boolean;
+    wrapperRef: React.RefObject<WrapperRef>;
+};
+export declare const useDropdown: <WrapperRef extends HTMLElement = HTMLDivElement, TriggerRef extends HTMLElement = HTMLButtonElement>(params?: UseDropdownParams) => Return<WrapperRef, TriggerRef>;
+export {};

package/utils/hooks/useHeightAdjustTextarea.d.ts

@@ -0,0 +1,15 @@
+import { type MutableRefObject } from 'react';
+type TextareaParams = {
+    additionalHeight?: number;
+    initialRows?: number;
+    maxRows?: number;
+    ref: MutableRefObject<HTMLTextAreaElement | null>;
+    shouldExpand: boolean;
+    textareaValue: string;
+};
+/**
+ * This hook is used to adjust the height of textarea to the defined `maxRows`. It will
+ * expand the height of textarea up to `maxRows` and then it will add scroll bar.
+ */
+export declare const useHeightAdjustTextarea: ({ additionalHeight, initialRows, maxRows, ref, shouldExpand, textareaValue, }: TextareaParams) => void;
+export {};

package/utils/hooks/useNotify.d.ts

@@ -0,0 +1,5 @@
+export declare const useNotify: () => {
+    dismissAllToasts: () => void;
+    dismissToast: (toastId: string) => void;
+    notify: import("../../components/toast/ToastContext").ToastContextFunctionType;
+};

package/utils/hooks/usePrevious.d.ts

@@ -0,0 +1 @@
+export declare const usePrevious: <T>(value: T) => T | undefined;