@zonos/amino 5.1.38 → 5.1.40

package/components/button/RippleGroup.d.ts

@@ -1,8 +1,8 @@
 import * as React from 'react';
 import type { Color } from "../../types";
-export interface IRippleActions {
+export type RippleActions = {
     start: (event: React.SyntheticEvent) => void;
-}
+};
 export type RippleGroupProps = {
     /**
      * @default 'inherit'
@@ -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,16 +1,16 @@
 import * as React from 'react';
-import type { IRippleActions } from "./RippleGroup";
-interface IRippleEventHandlers {
+import type { RippleActions } from "./RippleGroup";
+type RippleEventHandlers = {
     onMouseDown: React.MouseEventHandler;
-}
+};
 type Props = {
     disabled: boolean;
     rippleEnabled: boolean;
-    rippleRef: React.RefObject<IRippleActions>;
+    rippleRef: React.RefObject<RippleActions>;
 };
 type Return = {
     /** Combines event handlers */
-    getRippleHandlers(otherEvents: Partial<IRippleEventHandlers>): IRippleEventHandlers;
+    getRippleHandlers(otherEvents: Partial<RippleEventHandlers>): RippleEventHandlers;
     rippleEnabled: boolean;
 };
 export declare const useRipple: ({ disabled, rippleEnabled, rippleRef, }: Props) => Return;

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 type CountryMultiSelectProps<Option extends SelectOption<string> = SelectOption<string>, IsMulti extends true = true, Group extends GroupBase<Option> = GroupBase<Option>> = {
     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;
+} & Omit<Props<Option, IsMulti, Group>, 'isMulti' | 'onChange' | 'options' | 'value'> & HelpTextProps;
+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 type CountryPhoneSelectProps<Option extends SelectOption = SelectOption, IsMulti extends false = false, Group extends GroupBase<Option> = GroupBase<Option>> = {
     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;
-}
-export declare const CountryPhoneSelect: ({ countryOptions, icon, label, phone, phoneCountry, setPhone, setPhoneCountry, ...props }: CountryPhoneSelectProps<ICountryOption>) => import("react/jsx-runtime").JSX.Element;
+    setPhoneCountry: (changed: CountryOption | null) => void;
+} & Omit<Props<Option, IsMulti, Group>, 'isMulti' | 'onChange' | 'value'> & HelpTextProps;
+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 type MultiSelectProps<Option extends SelectOption = SelectOption, IsMulti extends true = true, Group extends GroupBase<Option> = GroupBase<Option>> = {
     components?: SelectComponentsConfig<Option, IsMulti, Group>;
     hasGroups?: boolean;
     icon?: ReactNode;
@@ -14,13 +14,13 @@ export interface MultiSelectProps<Option extends IOption = IOption, IsMulti exte
      * value: { label: string; value: string; }[];
      */
     value: PropsValue<Option>;
-}
-export type IGroupOption<Option extends IOption> = {
+} & Omit<Props<Option, IsMulti, Group>, 'isMulti' | RequiredProps> & Required<Pick<Props<Option, IsMulti, Group>, RequiredProps>> & HelpTextProps;
+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 type SelectProps<Option extends SelectOption = SelectOption, IsMulti extends false = false, Group extends GroupBase<Option> = GroupBase<Option>> = {
     /** Close the select dropdown menu when scrolling outside of menu to prevent graphical jank */
     closeOnOutsideScroll?: boolean;
     components?: SelectComponentsConfig<Option, IsMulti, Group>;
@@ -27,6 +27,6 @@ export interface SelectProps<Option extends IOption = IOption, IsMulti extends f
      * onChange={changed => setExampleValue(changed?.value || null)}
      */
     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;
+} & Omit<Props<Option, IsMulti, Group>, 'isMulti' | RequiredProps> & Required<Pick<Props<Option, IsMulti, Group>, RequiredProps>> & HelpTextProps;
+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 type StyledReactSelectProps<Option extends SelectOption, IsMulti extends boolean, Group extends GroupBase<Option>> = {
     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;
+} & Props<Option, IsMulti, Group> & HelpTextProps & AdditionalProps<Option['value']>;
+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/sortable-list/SortableList.d.ts

@@ -1,10 +1,10 @@
 import type { ReactNode } from 'react';
 import type { SortingStrategy } from '@dnd-kit/sortable/dist/types';
 import type { DragEndEvent } from "./SortableListDeps";
-export interface SortableListProps {
+export type SortableListProps = {
     children: ReactNode;
     itemIds: string[];
     sortingStrategy?: SortingStrategy;
     handleDragEnd: (e: DragEndEvent) => void;
-}
+};
 export declare const SortableList: ({ children, handleDragEnd, itemIds, sortingStrategy, }: SortableListProps) => import("react/jsx-runtime").JSX.Element;

package/components/sortable-list/SortableListItem.d.ts

@@ -1,9 +1,9 @@
 import type { ReactNode } from 'react';
-export interface SortableListItemProps {
+export type SortableListItemProps = {
     children: ReactNode;
     handleIconSize?: number;
     id: string;
     useHandle?: boolean;
-}
+};
 /** @description This must be a direct child of SortableList */
 export declare const SortableListItem: ({ children, handleIconSize, id, useHandle, }: SortableListItemProps) => import("react/jsx-runtime").JSX.Element;

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/components/stack/Stack.d.ts

@@ -1,12 +1,12 @@
 import type { HTMLAttributes, ReactNode } from 'react';
 import type { GridAlignment, GridSpacing } from "../../types";
 type DivProps = Omit<HTMLAttributes<HTMLDivElement>, 'translate' | 'style' | 'prefix' | 'contentEditable' | 'inputMode' | 'children'>;
-export interface StackProps extends DivProps {
+export type StackProps = {
     /** @default 'unset' */
     alignment?: GridAlignment;
     children: ReactNode;
     /** @default 24 */
     spacing?: GridSpacing;
-}
+} & DivProps;
 export declare const Stack: ({ alignment, children, ...otherProps }: StackProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/components/tag/Tag.d.ts

@@ -1,6 +1,6 @@
 import type { ReactNode } from 'react';
 type TagSize = 'base' | 'lg';
-export interface TagProps {
+export type TagProps = {
     children?: ReactNode | string;
     className?: string;
     icon?: ReactNode;
@@ -8,6 +8,6 @@ export interface TagProps {
     size?: TagSize;
     onClick?: () => void;
     onClose: () => void;
-}
+};
 export declare const Tag: ({ children, className, icon, iconRight, onClick, onClose, size, }: TagProps) => 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.40",
   "description": "Core UI components for Amino",
   "repository": "git@github.com:Zonos/amino.git",
   "license": "MIT",

package/types/BaseProps.d.ts

@@ -1,7 +1,7 @@
 /**
  * All components props should extend this interface.
  */
-export interface BaseProps {
+export type BaseProps = {
     /** For styled-components styling */
     className?: string;
-}
+};

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 type 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 type CountryOption<CountryCode extends string = string> = {
     phoneCode: string[];
-}
-export interface IRegionCountryOption {
-    label: IRegion;
-    options: ICountryOption[];
-}
-export interface IUnavailableCountry {
+} & Country<CountryCode> & SelectOption<CountryCode>;
+export type RegionCountryOption = {
+    label: Region;
+    options: CountryOption[];
+};
+export type UnavailableCountry = {
     code: string;
     message: string;
-}
+};
 /** @desc /api/address/getCountries */
-export interface IGetCountriesResponse<CountryCode extends string = string> {
-    [key: string]: ICountry<CountryCode>;
-}
+export type GetCountriesResponse<CountryCode extends string = string> = {
+    [key: string]: Country<CountryCode>;
+};
 export {};

package/types/FetcherError.d.ts

@@ -1,5 +1,5 @@
 import type { JsonError } from "./JsonError";
-export interface FetcherError {
+export type FetcherError = {
     errors: JsonError[];
     status: number;
-}
+};

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/JsonError.d.ts

@@ -1,5 +1,5 @@
-export interface JsonError {
+export type JsonError = {
     errorId?: number;
     message: string;
     type: string;
-}
+};

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/types/SwrtParams.d.ts

@@ -1,4 +1,4 @@
-export interface SwrtParams<T> {
+export type SwrtParams<T> = {
     json: T | null;
     response: Response | null;
-}
+};

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>[];
 }[];