@zonos/amino 5.1.38 → 5.1.39

package/components/button/RippleGroup.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import type { Color } from "../../types";
-export interface IRippleActions {
+export interface RippleActions {
     start: (event: React.SyntheticEvent) => void;
 }
 export type RippleGroupProps = {
@@ -17,4 +17,4 @@ export type RippleGroupProps = {
      */
     opacity?: number;
 };
-export declare const RippleGroup: React.ForwardRefExoticComponent<RippleGroupProps & React.RefAttributes<IRippleActions>>;
+export declare const RippleGroup: React.ForwardRefExoticComponent<RippleGroupProps & React.RefAttributes<RippleActions>>;

package/components/button/useRipple.d.ts

@@ -1,12 +1,12 @@
 import * as React from 'react';
-import type { IRippleActions } from "./RippleGroup";
+import type { RippleActions } from "./RippleGroup";
 interface IRippleEventHandlers {
     onMouseDown: React.MouseEventHandler;
 }
 type Props = {
     disabled: boolean;
     rippleEnabled: boolean;
-    rippleRef: React.RefObject<IRippleActions>;
+    rippleRef: React.RefObject<RippleActions>;
 };
 type Return = {
     /** Combines event handlers */

package/components/connection-map/ConnectionMap.d.ts

@@ -1,12 +1,12 @@
 import type { BaseProps } from "../../types/BaseProps";
-import { type ICountryOption } from "../../types/ICountry";
-import { type IGeoJsonWorld } from "../../types/IGeoJsonWorld";
+import { type CountryOption } from "../../types/Country";
+import { type GeoJsonWorld } from "../../types/GeoJsonWorld";
 type Props = BaseProps & {
-    countries: ICountryOption[];
+    countries: CountryOption[];
     from: string;
     height?: number;
     to: string;
-    worldData: IGeoJsonWorld | null;
+    worldData: GeoJsonWorld | null;
 };
 export declare const ConnectionMap: ({ className, countries, from, height, to, worldData, }: Props) => import("react/jsx-runtime").JSX.Element;
 export {};

package/components/filter/filter-date/FilterDate.d.ts

@@ -1,12 +1,12 @@
 import { type Dispatch } from 'react';
 import { type FilterDateAction, type FilterDateState } from "./filterDateReducer";
 import { type BaseFilterProps } from "../useFilterWrapper";
-type IBadgeFilterDateProps = BaseFilterProps & {
+type BadgeFilterDateProps = BaseFilterProps & {
     dispatch: Dispatch<FilterDateAction>;
     filter: FilterDateState;
 };
 /**
  * Assumes exclusive date range. Specific formats/ranges should be handled upstream.
  */
-export declare const FilterDate: ({ dispatch, dropdownTitle, filter, label, }: IBadgeFilterDateProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FilterDate: ({ dispatch, dropdownTitle, filter, label, }: BadgeFilterDateProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/components/filter/filter-multi-select/FilterMultiSelect.d.ts

@@ -1,9 +1,9 @@
 import { type BaseFilterProps } from "../useFilterWrapper";
-import type { IOption } from "../../../types/IOption";
+import type { SelectOption } from "../../../types/SelectOption";
 type FilterMultiSelectProps<T extends string = string> = BaseFilterProps & {
-    options: IOption<T>[];
-    value: IOption<T>[];
-    onChange: (value: IOption<T>[]) => void;
+    options: SelectOption<T>[];
+    value: SelectOption<T>[];
+    onChange: (value: SelectOption<T>[]) => void;
 };
 export declare const FilterMultiSelect: <T extends string = string>({ dropdownTitle, label, onChange, options, value, }: FilterMultiSelectProps<T>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/components/filter/filter-select/FilterSelect.d.ts

@@ -1,9 +1,9 @@
 import { type BaseFilterProps } from "../useFilterWrapper";
-import type { IOption } from "../../../types/IOption";
-type FilterSelectProps<T extends string = string, O extends IOption<string> = IOption<T>> = BaseFilterProps & {
+import type { SelectOption } from "../../../types/SelectOption";
+type FilterSelectProps<T extends string = string, O extends SelectOption<string> = SelectOption<T>> = BaseFilterProps & {
     options: O[];
     value: O | null;
     onChange: (value: O | null) => void;
 };
-export declare const FilterSelect: <T extends string = string, O extends IOption<T> = IOption<T>>({ onChange, options, value, ...props }: FilterSelectProps<T, O>) => import("react/jsx-runtime").JSX.Element;
+export declare const FilterSelect: <T extends string = string, O extends SelectOption<T> = SelectOption<T>>({ onChange, options, value, ...props }: FilterSelectProps<T, O>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/components/select/CountryMultiSelect.d.ts

@@ -1,17 +1,17 @@
 import type { ReactNode } from 'react';
 import { type GroupBase, type MenuListProps, type Props, type SelectComponentsConfig, type StylesConfig } from 'react-select';
 import { type HelpTextProps } from "../help-text/HelpText";
-import { type ICountryOption, type IUnavailableCountry } from "../../types/ICountry";
-import type { IOption } from "../../types/IOption";
-export declare const MenuList: <Option extends IOption<string | number>, IsMulti extends boolean, Group extends GroupBase<Option>>({ children, ...props }: MenuListProps<Option, IsMulti, Group>) => import("react/jsx-runtime").JSX.Element;
-export interface CountryMultiSelectProps<Option extends IOption<string> = IOption<string>, IsMulti extends true = true, Group extends GroupBase<Option> = GroupBase<Option>> extends Omit<Props<Option, IsMulti, Group>, 'isMulti' | 'onChange' | 'options' | 'value'>, HelpTextProps {
+import { type CountryOption, type UnavailableCountry } from "../../types/Country";
+import type { SelectOption } from "../../types/SelectOption";
+export declare const MenuList: <Option extends SelectOption, IsMulti extends boolean, Group extends GroupBase<Option>>({ children, ...props }: MenuListProps<Option, IsMulti, Group>) => import("react/jsx-runtime").JSX.Element;
+export interface CountryMultiSelectProps<Option extends SelectOption<string> = SelectOption<string>, IsMulti extends true = true, Group extends GroupBase<Option> = GroupBase<Option>> extends Omit<Props<Option, IsMulti, Group>, 'isMulti' | 'onChange' | 'options' | 'value'>, HelpTextProps {
     components?: SelectComponentsConfig<Option, IsMulti, Group>;
-    countryOptions: ICountryOption<Option['value']>[];
+    countryOptions: CountryOption<Option['value']>[];
     icon?: ReactNode;
     label?: string;
     styles?: StylesConfig<Option, IsMulti, Group>;
-    unavailableCountries: IUnavailableCountry[];
+    unavailableCountries: UnavailableCountry[];
     value: Option['value'][];
     onChange: (countryCodes: Option['value'][]) => void;
 }
-export declare const CountryMultiSelect: <T extends string>({ countryOptions, label, onChange, unavailableCountries, value, ...props }: CountryMultiSelectProps<IOption<T>, true, GroupBase<IOption<T>>>) => import("react/jsx-runtime").JSX.Element;
+export declare const CountryMultiSelect: <T extends string>({ countryOptions, label, onChange, unavailableCountries, value, ...props }: CountryMultiSelectProps<SelectOption<T>, true, GroupBase<SelectOption<T>>>) => import("react/jsx-runtime").JSX.Element;

package/components/select/CountryPhoneSelect.d.ts

@@ -1,18 +1,18 @@
 import { type ReactNode } from 'react';
 import { type GroupBase, type Props, type SelectComponentsConfig, type StylesConfig } from 'react-select';
 import type { HelpTextProps } from "../help-text/HelpText";
-import type { ICountryOption } from "../../types/ICountry";
-import type { IOption } from "../../types/IOption";
-export interface CountryPhoneSelectProps<Option extends IOption = IOption, IsMulti extends false = false, Group extends GroupBase<Option> = GroupBase<Option>> extends Omit<Props<Option, IsMulti, Group>, 'isMulti' | 'onChange' | 'value'>, HelpTextProps {
+import type { CountryOption } from "../../types/Country";
+import type { SelectOption } from "../../types/SelectOption";
+export interface CountryPhoneSelectProps<Option extends SelectOption = SelectOption, IsMulti extends false = false, Group extends GroupBase<Option> = GroupBase<Option>> extends Omit<Props<Option, IsMulti, Group>, 'isMulti' | 'onChange' | 'value'>, HelpTextProps {
     components?: SelectComponentsConfig<Option, IsMulti, Group>;
-    countryOptions: ICountryOption[];
+    countryOptions: CountryOption[];
     hasGroups?: boolean;
     icon?: ReactNode;
     label?: string;
     phone: string;
-    phoneCountry: ICountryOption | null;
+    phoneCountry: CountryOption | null;
     styles?: StylesConfig<Option, IsMulti, Group>;
     setPhone: (changed: string) => void;
-    setPhoneCountry: (changed: ICountryOption | null) => void;
+    setPhoneCountry: (changed: CountryOption | null) => void;
 }
-export declare const CountryPhoneSelect: ({ countryOptions, icon, label, phone, phoneCountry, setPhone, setPhoneCountry, ...props }: CountryPhoneSelectProps<ICountryOption>) => import("react/jsx-runtime").JSX.Element;
+export declare const CountryPhoneSelect: ({ countryOptions, icon, label, phone, phoneCountry, setPhone, setPhoneCountry, ...props }: CountryPhoneSelectProps<CountryOption>) => import("react/jsx-runtime").JSX.Element;

package/components/select/CountrySelect.d.ts

@@ -1,14 +1,14 @@
 import { type SelectProps } from "./Select";
-import type { ICountryOption } from "../../types/ICountry";
+import type { CountryOption } from "../../types/Country";
 type CountrySelectType<T extends string> = {
     autoFocus?: SelectProps['autoFocus'];
-    countryOptions: ICountryOption<T>[];
+    countryOptions: CountryOption<T>[];
     label?: string;
-    onChange: SelectProps<ICountryOption<T>>['onChange'];
+    onChange: SelectProps<CountryOption<T>>['onChange'];
     placeholder?: string;
     value: T | null;
-    filter?: (country: ICountryOption<T>) => boolean;
+    filter?: (country: CountryOption<T>) => boolean;
 };
-export type CountrySelectProps<T extends string = string> = CountrySelectType<T> & Omit<SelectProps<ICountryOption<T>>, keyof CountrySelectType<T> | 'options'>;
+export type CountrySelectProps<T extends string = string> = CountrySelectType<T> & Omit<SelectProps<CountryOption<T>>, keyof CountrySelectType<T> | 'options'>;
 export declare const CountrySelect: <T extends string>({ autoFocus, countryOptions, filter, label, onChange, placeholder, value, ...props }: CountrySelectProps<T>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/components/select/MultiSelect.d.ts

@@ -1,9 +1,9 @@
 import type { ReactNode } from 'react';
 import type { GroupBase, Props, PropsValue, SelectComponentsConfig, StylesConfig } from 'react-select';
 import { type HelpTextProps } from "../help-text/HelpText";
-import type { IOption } from "../../types/IOption";
+import type { SelectOption } from "../../types/SelectOption";
 type RequiredProps = 'onChange' | 'options' | 'value';
-export interface MultiSelectProps<Option extends IOption = IOption, IsMulti extends true = true, Group extends GroupBase<Option> = GroupBase<Option>> extends Omit<Props<Option, IsMulti, Group>, 'isMulti' | RequiredProps>, Required<Pick<Props<Option, IsMulti, Group>, RequiredProps>>, HelpTextProps {
+export interface MultiSelectProps<Option extends SelectOption = SelectOption, IsMulti extends true = true, Group extends GroupBase<Option> = GroupBase<Option>> extends Omit<Props<Option, IsMulti, Group>, 'isMulti' | RequiredProps>, Required<Pick<Props<Option, IsMulti, Group>, RequiredProps>>, HelpTextProps {
     components?: SelectComponentsConfig<Option, IsMulti, Group>;
     hasGroups?: boolean;
     icon?: ReactNode;
@@ -15,12 +15,12 @@ export interface MultiSelectProps<Option extends IOption = IOption, IsMulti exte
      */
     value: PropsValue<Option>;
 }
-export type IGroupOption<Option extends IOption> = {
+export type GroupOption<Option extends SelectOption> = {
     data: Option;
     index: 0;
     isDisabled: false;
     isSelected: false;
     type: 'option';
-} & IOption;
-export declare const MultiSelect: <Option extends IOption<string | number>, Group extends GroupBase<Option>>({ closeMenuOnSelect, hideSelectedOptions, ...props }: MultiSelectProps<Option, true, Group>) => import("react/jsx-runtime").JSX.Element;
+} & SelectOption;
+export declare const MultiSelect: <Option extends SelectOption, Group extends GroupBase<Option>>({ closeMenuOnSelect, hideSelectedOptions, ...props }: MultiSelectProps<Option, true, Group>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/components/select/Select.d.ts

@@ -1,10 +1,10 @@
 import type { ReactNode } from 'react';
 import type { ActionMeta, GroupBase, Props, SelectComponentsConfig, StylesConfig } from 'react-select';
 import { type HelpTextProps } from "../help-text/HelpText";
-import type { IOption } from "../../types/IOption";
+import type { SelectOption } from "../../types/SelectOption";
 import type { Size } from "../../types/Size";
 type RequiredProps = 'options' | 'value';
-export interface SelectProps<Option extends IOption = IOption, IsMulti extends false = false, Group extends GroupBase<Option> = GroupBase<Option>> extends Omit<Props<Option, IsMulti, Group>, 'isMulti' | RequiredProps>, Required<Pick<Props<Option, IsMulti, Group>, RequiredProps>>, HelpTextProps {
+export interface SelectProps<Option extends SelectOption = SelectOption, IsMulti extends false = false, Group extends GroupBase<Option> = GroupBase<Option>> extends Omit<Props<Option, IsMulti, Group>, 'isMulti' | RequiredProps>, Required<Pick<Props<Option, IsMulti, Group>, RequiredProps>>, HelpTextProps {
     /** Close the select dropdown menu when scrolling outside of menu to prevent graphical jank */
     closeOnOutsideScroll?: boolean;
     components?: SelectComponentsConfig<Option, IsMulti, Group>;
@@ -28,5 +28,5 @@ export interface SelectProps<Option extends IOption = IOption, IsMulti extends f
      */
     onChange: (changed: Option | null, actionMeta: ActionMeta<Option>) => void;
 }
-export declare const Select: <Option extends IOption<string | number>, Group extends GroupBase<Option> = GroupBase<Option>>({ isClearable, label, value, ...props }: SelectProps<Option, false, Group>) => import("react/jsx-runtime").JSX.Element;
+export declare const Select: <Option extends SelectOption, Group extends GroupBase<Option> = GroupBase<Option>>({ isClearable, label, value, ...props }: SelectProps<Option, false, Group>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/components/select/_StyledReactSelect.d.ts

@@ -1,7 +1,7 @@
 import { type ReactNode } from 'react';
 import type { GroupBase, OptionProps, Props, SelectComponentsConfig, StylesConfig } from 'react-select';
 import { type HelpTextProps } from "../help-text/HelpText";
-import type { IOption } from "../../types/IOption";
+import type { SelectOption } from "../../types/SelectOption";
 import type { Size } from "../../types/Size";
 type AdditionalProps<Value> = {
     hasGroups?: boolean;
@@ -10,12 +10,12 @@ type AdditionalProps<Value> = {
     size?: Size;
     customOption?: (value: Value) => ReactNode;
 };
-export declare const CheckboxOptionComponent: <Option extends IOption<string | number>, IsMulti extends boolean, Group extends GroupBase<Option>>(props: OptionProps<Option, IsMulti, Group>) => import("react/jsx-runtime").JSX.Element;
-export interface StyledReactSelectProps<Option extends IOption, IsMulti extends boolean, Group extends GroupBase<Option>> extends Props<Option, IsMulti, Group>, HelpTextProps, AdditionalProps<Option['value']> {
+export declare const CheckboxOptionComponent: <Option extends SelectOption, IsMulti extends boolean, Group extends GroupBase<Option>>(props: OptionProps<Option, IsMulti, Group>) => import("react/jsx-runtime").JSX.Element;
+export interface StyledReactSelectProps<Option extends SelectOption, IsMulti extends boolean, Group extends GroupBase<Option>> extends Props<Option, IsMulti, Group>, HelpTextProps, AdditionalProps<Option['value']> {
     closeOnOutsideScroll?: boolean;
     components?: SelectComponentsConfig<Option, IsMulti, Group>;
     size?: Size;
     styles?: StylesConfig<Option, IsMulti, Group>;
 }
-export declare const StyledReactSelect: <Option extends IOption<string | number>, IsMulti extends boolean, Group extends GroupBase<Option>>({ closeOnOutsideScroll, components, customOption, error, hasGroups, helpText, icon, label, menuPosition, placeholder, size, styles, ...props }: StyledReactSelectProps<Option, IsMulti, Group>) => import("react/jsx-runtime").JSX.Element;
+export declare const StyledReactSelect: <Option extends SelectOption, IsMulti extends boolean, Group extends GroupBase<Option>>({ closeOnOutsideScroll, components, customOption, error, hasGroups, helpText, icon, label, menuPosition, placeholder, size, styles, ...props }: StyledReactSelectProps<Option, IsMulti, Group>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/components/split-panel/SplitPanel.d.ts

@@ -1,5 +1,5 @@
 import { type Dispatch, type SetStateAction } from 'react';
-type IProps = {
+type SplitPanelProps = {
     children: any;
     className?: string;
     collapseAll?: boolean;
@@ -26,5 +26,5 @@ type IProps = {
  * Split panel component
  * @ref https://greggman.github.io/react-split-it/
  */
-export declare const SplitPanel: ({ children, className, collapseAll, direction, gutterSize, onSetSizes, sizes, ...props }: IProps) => import("react/jsx-runtime").JSX.Element;
+export declare const SplitPanel: ({ children, className, collapseAll, direction, gutterSize, onSetSizes, sizes, ...props }: SplitPanelProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/icons/flag-icon/FlagIcon.d.ts

@@ -1,14 +1,14 @@
 /// <reference types="react" />
 import * as flags from "../flags/FlagIndex";
-export type IFlag = keyof typeof flags;
-export type IFlagScale = 'small' | 'medium' | 'large';
+export type Flag = keyof typeof flags;
+export type FlagScale = 'small' | 'medium' | 'large';
 export type FlagIconProps = {
-    iconScale: IFlagScale;
+    iconScale: FlagScale;
 } & {
-    code: IFlag;
+    code: Flag;
 };
 export declare const FlagIcon: import("react").ForwardRefExoticComponent<{
-    iconScale: IFlagScale;
+    iconScale: FlagScale;
 } & {
-    code: IFlag;
+    code: Flag;
 } & import("react").RefAttributes<SVGSVGElement>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zonos/amino",
-  "version": "5.1.38",
+  "version": "5.1.39",
   "description": "Core UI components for Amino",
   "repository": "git@github.com:Zonos/amino.git",
   "license": "MIT",

package/types/{ICountry.d.ts → Country.d.ts}

@@ -1,8 +1,8 @@
-import type { IOption } from "./IOption";
+import type { SelectOption } from "./SelectOption";
 export declare const regions: readonly ["Africa", "Americas", "Asia", "Central America", "Europe", "North America", "Oceania", "South America"];
-type IRegion = (typeof regions)[number];
+type Region = (typeof regions)[number];
 /** @desc /api/address/getCountries */
-export interface ICountry<CountryCode extends string = string> {
+export interface Country<CountryCode extends string = string> {
     active: boolean;
     code: CountryCode;
     code3: string | null;
@@ -11,23 +11,23 @@ export interface ICountry<CountryCode extends string = string> {
     fraudRisk: number;
     languageCode: string | null;
     numericCode: string | null;
-    region: IRegion;
+    region: Region;
     upsCode: string | null;
     zipRegex: string | null;
 }
-export interface ICountryOption<CountryCode extends string = string> extends ICountry<CountryCode>, IOption<CountryCode> {
+export interface CountryOption<CountryCode extends string = string> extends Country<CountryCode>, SelectOption<CountryCode> {
     phoneCode: string[];
 }
-export interface IRegionCountryOption {
-    label: IRegion;
-    options: ICountryOption[];
+export interface RegionCountryOption {
+    label: Region;
+    options: CountryOption[];
 }
-export interface IUnavailableCountry {
+export interface UnavailableCountry {
     code: string;
     message: string;
 }
 /** @desc /api/address/getCountries */
-export interface IGetCountriesResponse<CountryCode extends string = string> {
-    [key: string]: ICountry<CountryCode>;
+export interface GetCountriesResponse<CountryCode extends string = string> {
+    [key: string]: Country<CountryCode>;
 }
 export {};

package/types/{IGeoJsonWorld.d.ts → GeoJsonWorld.d.ts}

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

package/types/{IOption.d.ts → SelectOption.d.ts}

@@ -1,8 +1,8 @@
 import type { ReactNode } from 'react';
-export interface IOption<V extends string | number = string | number> {
+export type SelectOption<V extends string | number = string | number> = {
     icon?: ReactNode;
     isDisabled?: boolean;
     label: string;
     labelDescription?: string;
     value: V;
-}
+};

package/utils/_graphiqlFetcher.d.ts

@@ -19,7 +19,7 @@ export type GraphiqlFetcher = (graphQLParams: FetcherParams, opts?: FetcherOpts)
 export type HandleFetchFetcher = <ResponseBody extends unknown, RequestBody = unknown>(url: string, _opts?: RequestOptions<ResponseBody, RequestBody> & {
     logRequestIfError?: boolean;
 }) => Promise<HandleFetchReturn<ResponseBody>>;
-type IFetcher = (props: {
+type Fetcher = (props: {
     customFetcher: HandleFetchFetcher | null;
     url: string | null;
 }) => GraphiqlFetcher;
@@ -27,5 +27,5 @@ type IFetcher = (props: {
  * Graphiql fetcher to send a GraphQl request
  * @param url url to fetch
  */
-export declare const graphiqlFetcher: IFetcher;
+export declare const graphiqlFetcher: Fetcher;
 export {};

package/utils/getCountryCodeByName.d.ts

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

package/utils/prepCountryOptions.d.ts

@@ -1,6 +1,6 @@
-import type { IGetCountriesResponse } from "../types/ICountry";
+import type { GetCountriesResponse } from "../types/Country";
 export declare const prepCountryOptions: <CountryCode extends string = string>({ json, }: {
-    json: IGetCountriesResponse<CountryCode>;
+    json: GetCountriesResponse<CountryCode>;
 }) => {
     label: string;
     phoneCode: string[];

package/utils/prepRegionCountryOptions.d.ts

@@ -1,5 +1,5 @@
-import { type ICountryOption } from "../types/ICountry";
-export declare const prepRegionCountryOptions: <T extends string = string>(countries: ICountryOption<T>[]) => {
+import { type CountryOption } from "../types/Country";
+export declare const prepRegionCountryOptions: <T extends string = string>(countries: CountryOption<T>[]) => {
     label: "Africa" | "Americas" | "Asia" | "Central America" | "Europe" | "North America" | "Oceania" | "South America";
-    options: ICountryOption<T>[];
+    options: CountryOption<T>[];
 }[];