@storecraft/dashboard 1.0.35 → 1.0.36

package/dist/lib/src/src/apps/gallery/gallery-image-grid.d.ts

@@ -0,0 +1,14 @@
+import { ImageType } from '@storecraft/core/api';
+export type ImageParams = {
+    data: ImageType;
+    onClickImage: (e: React.MouseEvent<HTMLAnchorElement, MouseEvent>, data: ImageType) => void;
+    className?: string;
+} & React.ComponentProps<'div'>;
+export type ImageGridParams = {
+    images: ImageType[];
+    onClickImage: (e: React.MouseEvent<HTMLAnchorElement, MouseEvent>, data: ImageType) => void;
+    className?: string;
+} & React.ComponentProps<'div'>;
+export declare const Image: ({ data, onClickImage, className, ...rest }: ImageParams) => import("react/jsx-runtime").JSX.Element;
+declare const ImageGrid: ({ images, onClickImage, className, ...rest }: ImageGridParams) => import("react/jsx-runtime").JSX.Element;
+export default ImageGrid;

package/dist/lib/src/src/apps/gallery/gallery-page.d.ts

@@ -0,0 +1,2 @@
+declare const _default: ({}: {}) => import("react/jsx-runtime").JSX.Element;
+export default _default;

package/dist/lib/src/{apps → src/apps}/gallery/gallery-searchbar.d.ts

@@ -1,17 +1,18 @@
-export default SearchBar;
 export type InnerSearchBarParams = {
     count: number;
     searchTitle: string;
     isLoading: boolean;
     reload: () => void;
 };
+export type SearchBarProps = {
+    count: number;
+    searchTitle: string;
+    isLoading: boolean;
+    reload: () => void;
+} & React.ComponentProps<'div'>;
 export type ImpInterface = {
     getSearch: () => string;
     setSearch: (value: string) => void;
 };
-/**
- * @typedef {object} ImpInterface
- * @prop {() => string} getSearch
- * @prop {(value: string) => void} setSearch
- */
-declare const SearchBar: import('react').ForwardRefExoticComponent<Omit<InnerSearchBarParams & import('react').ClassAttributes<HTMLDivElement> & import('react').HTMLAttributes<HTMLDivElement>, "ref"> & import('react').RefAttributes<any>>;
+declare const SearchBar: import('react').ForwardRefExoticComponent<Omit<SearchBarProps, "ref"> & import('react').RefAttributes<unknown>>;
+export default SearchBar;

package/dist/lib/src/src/apps/gallery/gallery-select.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { ImpInterface } from '../../comps/overlay';
+import { ApiQuery, ImageType } from '@storecraft/core/api';
+export type GallerySelectParams = {
+    query_params?: ApiQuery;
+    onSelect: (img: ImageType) => void;
+};
+declare const GallerySelect: React.ForwardRefExoticComponent<GallerySelectParams & React.RefAttributes<ImpInterface>>;
+export default GallerySelect;

package/dist/lib/src/src/apps/gallery/gallery.d.ts

@@ -0,0 +1,29 @@
+import { ApiQuery, ImageType } from '@storecraft/core/api';
+export type InnerGalleryParams = {
+    /**
+     * { vql: '', limit: 5}
+     */
+    query_params?: ApiQuery;
+    onClickImage?: (e: React.MouseEvent<HTMLAnchorElement, MouseEvent>, data: ImageType) => void;
+    /**
+     * Use url navigation
+     * to paginate through search params, as opposed to in-memory. This
+     * is suited for pages, the later for individual components.
+     */
+    useSearchParamsForQuery?: boolean;
+};
+export type GalleryParams = InnerGalleryParams & React.ComponentProps<'div'>;
+/**
+ * A `gallery` component. if contstrained on height, then image-grid
+ * will be scrollable
+ *
+ * Two modes of retrieving search:
+ * 1. onSearchUpdate=undefined will cause the comp to internally
+ *    fetch data when user searches data
+ * 2. onSearchUpdate!=undefined will cause the comp to delegate
+ *    the search params outside, where you can redirect again,
+ *    this is useful for re-routing of all kinds
+ *
+ */
+declare const Gallery: ({ query_params, onClickImage, useSearchParamsForQuery, className, ...rest }: GalleryParams) => import("react/jsx-runtime").JSX.Element;
+export default Gallery;

package/dist/lib/src/src/apps/gallery/image-header.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export type HeaderParams = {
+    label: string;
+    Icon: React.FC<{
+        className: string;
+    }>;
+} & React.ComponentProps<'p'>;
+declare const Header: ({ label, Icon, className, ...rest }: HeaderParams) => import("react/jsx-runtime").JSX.Element;
+export default Header;

package/dist/lib/src/src/apps/gallery/image-page.d.ts

@@ -0,0 +1,16 @@
+export type LabelCapsuleParams = {
+    value: string;
+    label?: string | ((value: string) => string);
+    bgColor?: string | ((value: string) => string);
+} & React.ComponentProps<'div'>;
+export type TagsParams = {
+    search: string[];
+} & React.ComponentProps<'div'>;
+export type UsageParams = {
+    usage: string[];
+} & React.ComponentProps<'div'>;
+/**
+ *
+ */
+declare const ImagePage: ({}: {}) => import("react/jsx-runtime").JSX.Element;
+export default ImagePage;

package/dist/lib/src/src/apps/gallery/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const q2o: (q: any, base: any) => any;
+export declare const o2q: (o: any) => string;

package/dist/lib/src/src/apps/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Gallery } from './gallery/gallery-page';
+export { default as ImagePage } from './gallery/image-page';

package/dist/lib/src/src/comps/action-bar.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+export type ActionBarParams = {
+    menuOpen?: boolean;
+    className?: string;
+    onMenuClick?: React.MouseEventHandler;
+} & React.ComponentProps<'nav'>;
+declare const ActionBar: ({ menuOpen, className, onMenuClick, ...rest }: ActionBarParams) => import("react/jsx-runtime").JSX.Element;
+export default ActionBar;

package/dist/lib/src/src/comps/air-date-picker.d.ts

@@ -0,0 +1,6 @@
+import { AirDatepickerOptions } from 'air-datepicker';
+export declare const AirDatePicker: ({ air_datepicker, ...rest }: {
+    air_datepicker?: {
+        options?: AirDatepickerOptions;
+    };
+} & React.ComponentProps<"div">) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/src/src/comps/asset-favicon.d.ts

@@ -0,0 +1 @@
+export declare const Favicon: ({ ...rest }: Omit<React.ComponentProps<"svg">, "viewBox">) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/src/src/comps/attributes.d.ts

@@ -0,0 +1,23 @@
+import { FieldLeafViewParams } from './fields-view';
+import { AttributeType } from '@storecraft/core/api';
+export type AttributeParams = {
+    attribute: AttributeType;
+    onChange: (attribute: AttributeType) => void;
+    onDelete: () => void;
+} & FieldLeafViewParams<AttributeType[]> & React.ComponentProps<'div'>;
+/**
+ * @typedef {import('./fields-view.jsx').FieldLeafViewParams<
+ *  import('@storecraft/core/api').AttributeType[]> &
+ *  React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>
+ * } AttributesParams
+ *
+ * @param {AttributesParams} params
+ */
+declare const Attributes: ({ field, value, onChange, setError, ...rest }: {
+    [x: string]: any;
+    field: any;
+    value?: any[];
+    onChange: any;
+    setError: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export default Attributes;

package/dist/lib/src/src/comps/base-chart-view.d.ts

@@ -0,0 +1,31 @@
+import { SeriesDataItemTypeMap, DeepPartial, ChartOptions, SeriesType, SeriesDefinition, SeriesPartialOptionsMap, MouseEventParams, Point, HorzScaleOptions, PriceScaleOptions } from 'lightweight-charts';
+import { withDiv } from './types';
+export type ToolTipParams = {
+    chart?: {
+        data?: SeriesDataItemTypeMap[SeriesType];
+        point?: Point;
+        event_params?: MouseEventParams;
+    };
+};
+export type SeriesConfig<T extends SeriesType> = {
+    definition: SeriesDefinition<T>;
+    data: SeriesDataItemTypeMap[T][];
+    options?: SeriesPartialOptionsMap[T];
+    priceScaleOptions?: DeepPartial<PriceScaleOptions>;
+};
+export type BaseChartViewParams = withDiv<{
+    config: {
+        series: SeriesConfig<SeriesType>[];
+        chart: {
+            options?: DeepPartial<ChartOptions>;
+            timeScaleOptions?: DeepPartial<HorzScaleOptions>;
+            priceScaleOptions?: DeepPartial<PriceScaleOptions>;
+            fitContent?: boolean;
+        };
+        tooltip?: {
+            component?: React.FC<ToolTipParams>;
+        };
+    };
+}>;
+declare const BaseChartView: ({ config, ...rest }: BaseChartViewParams) => import("react/jsx-runtime").JSX.Element;
+export default BaseChartView;

package/dist/lib/src/src/comps/bulk-tag-products-in-collection.d.ts

@@ -0,0 +1,9 @@
+export type BulkTagProductsInCollectionProps = {
+    collectionId: string;
+    value?: {
+        handle: string;
+        id: string;
+    };
+} & React.ComponentProps<'div'>;
+declare const BulkTagProductsInCollection: ({ collectionId, value }: BulkTagProductsInCollectionProps) => import("react/jsx-runtime").JSX.Element;
+export default BulkTagProductsInCollection;

package/dist/lib/src/src/comps/capsule.d.ts

@@ -0,0 +1,8 @@
+import { withDiv } from './types';
+export type CapsuleParams = withDiv<{
+    className?: string;
+    bgColor?: string | ((v: string) => string);
+    value: string;
+    label?: string | ((v: string) => string);
+}>;
+export declare const LabelCapsule: ({ value, className, label, bgColor, ...rest }: CapsuleParams) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/src/src/comps/capsules-view.d.ts

@@ -0,0 +1,10 @@
+export type CapsulesViewParams<T = any> = {
+    tags: T[];
+    name_fn?: (x: T) => string;
+    clsCapsule?: string;
+    className?: string;
+    onRemove?: (v: T) => void;
+    onClick: (v: T) => void;
+};
+declare const CapsulesView: <T>({ tags, name_fn, className, clsCapsule, onRemove, onClick }: CapsulesViewParams<T>) => import("react/jsx-runtime").JSX.Element;
+export default CapsulesView;

package/dist/lib/src/src/comps/chart.demo.tsx.d.ts

@@ -0,0 +1,2 @@
+export declare const ChartComponent: (props: any) => import("react/jsx-runtime").JSX.Element;
+export declare function TTT(props: any): import("react/jsx-runtime").JSX.Element;

package/dist/lib/src/src/comps/client-only.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+export default function ClientOnly({ ...rest }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+export declare function withClient(Component: React.FC): (props: any) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/src/src/comps/collection-actions.d.ts

@@ -0,0 +1,21 @@
+export type ImperativeInterface = {
+    getSearch: () => string;
+    setSearch: (value: string) => void;
+};
+export type TopActionsParams = {
+    reload: () => void;
+    searchTitle: string;
+    isLoading: boolean;
+    createLink?: string;
+    className?: string;
+    isCollectionEmpty?: boolean;
+};
+export type BottomActionsParams = {
+    next: () => Promise<any>;
+    prev: () => Promise<any>;
+    limit?: number;
+    onLimitChange: (v: number) => void;
+    className?: string;
+};
+export declare const TopActions: import('react').ForwardRefExoticComponent<TopActionsParams & import('react').RefAttributes<unknown>>;
+export declare const BottomActions: ({ next, prev, limit, onLimitChange, className }: BottomActionsParams) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/src/src/comps/collection-products.d.ts

@@ -0,0 +1,26 @@
+import { FieldContextData, FieldLeafViewParams } from './fields-view';
+import { CollectionType } from '@storecraft/core/api';
+export type ImpInterface = {
+    refresh: () => Promise<void>;
+};
+export type CollectionBaseParams = {
+    /**
+     * `handle` or `id`
+     */
+    collection_handle_or_id: string;
+    /**
+     * `limit` of query
+     */
+    limit?: number;
+    /**
+     * when loaded reports query count
+     */
+    onLoaded: (count: number) => void;
+    /**
+     * context
+     */
+    context: FieldContextData<CollectionType> & import('../pages/collection.js').Context;
+};
+export type CollectionProductsParams = FieldLeafViewParams<CollectionType, import('../pages/collection.js').Context, CollectionType>;
+declare const CollectionProducts: ({ value, context }: CollectionProductsParams) => import("react/jsx-runtime").JSX.Element;
+export default CollectionProducts;

package/dist/lib/src/src/comps/common-button.d.ts

@@ -0,0 +1,78 @@
+import { InternalBlingParams } from './common-ui';
+export type ButtonParams = {
+    text?: string;
+    icon?: React.ReactElement;
+    className?: string;
+    classNameSpan?: string;
+    children?: any;
+    rightView?: any;
+} & React.ComponentProps<'button'>;
+export type Button2Params = {
+    text?: string;
+    icon?: React.ReactElement;
+    className?: string;
+    classNameSpan?: string;
+    children: any;
+} & React.ComponentProps<'button'>;
+export type LoadingButtonParams = {
+    Icon?: React.ReactNode | JSX.Element;
+    text?: string;
+    keep_text_on_load?: boolean;
+    className?: string;
+    classNameLoading?: string;
+    classNameLeft?: string;
+    loading?: boolean;
+    show?: boolean;
+} & React.ComponentProps<'button'>;
+/**
+ * A loading button which expects a promise for onClick
+ */
+export type InternalPromisableLoadingButton = {
+    onClick: () => Promise<any>;
+    loading?: boolean;
+};
+export type PromisableLoadingButtonParams = {
+    onClick: () => Promise<any>;
+    loading?: boolean;
+} & Omit<LoadingButtonParams, "onClick">;
+export type PromisableLoadingBlingButtonParams = {
+    onClick: () => Promise<any>;
+    show?: boolean;
+    loading?: boolean;
+    stroke?: string;
+    rounded?: string;
+    from?: string;
+    to?: string;
+} & Omit<LoadingButtonParams, "onClick">;
+export type GradientFillIconParams = {
+    from?: string;
+    to?: string;
+    Icon?: React.FC<{
+        style?: any;
+    }>;
+} & {
+    [x: string]: any;
+};
+export type GradientStrokeIconParams = {
+    from?: string;
+    to?: string;
+    Icon?: React.FC<{
+        style?: any;
+    }>;
+} & {
+    [x: string]: any;
+};
+export declare const Button: ({ text, icon, className, classNameSpan, children, rightView, ...rest }: ButtonParams) => import("react/jsx-runtime").JSX.Element;
+export declare const Button2: ({ text, icon, className, classNameSpan, children, ...rest }: Button2Params) => import("react/jsx-runtime").JSX.Element;
+export declare const LoadingButton: ({ Icon, show, text, keep_text_on_load, className, classNameLoading, classNameLeft, loading, ...rest }: LoadingButtonParams) => import("react/jsx-runtime").JSX.Element;
+export declare const PromisableLoadingButton: ({ onClick, loading: $loading, ...rest }: PromisableLoadingButtonParams) => import("react/jsx-runtime").JSX.Element;
+export declare const PromisableLoadingBlingButton: ({ onClick, show, className, loading: $loading, stroke, rounded, from, to, ...rest }: PromisableLoadingBlingButtonParams) => import("react/jsx-runtime").JSX.Element;
+export type BlingButtonParams = InternalBlingParams & {
+    btnClassName?: string;
+    text?: string;
+} & React.ComponentProps<'button'>;
+export declare const BlingButton: ({ from, to, rounded, stroke, children, text, className, btnClassName, ...rest }: BlingButtonParams) => import("react/jsx-runtime").JSX.Element;
+export type BlingButton2Params = InternalBlingParams & Button2Params;
+export declare const BlingButton2: ({ from, to, rounded, stroke, ...rest }: BlingButton2Params) => import("react/jsx-runtime").JSX.Element;
+export declare const GradientFillIcon: ({ Icon, from, to, ...rest }: GradientFillIconParams) => import("react/jsx-runtime").JSX.Element;
+export declare const GradientStrokeIcon: ({ Icon, from, to, ...rest }: GradientStrokeIconParams) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/src/src/comps/common-fields.d.ts

@@ -0,0 +1,83 @@
+import { InputParams } from './common-ui';
+import { FieldLeafViewParams } from './fields-view';
+import { TableSchemaViewComponentParams } from './table-schema-view';
+export type TextAreaParams = FieldLeafViewParams<string>;
+export type TimeStampViewParams = TableSchemaViewComponentParams<string>;
+export type RecordActionsParams<T> = TableSchemaViewComponentParams<any, T>;
+/**
+ * This is used in `TableSchemaView`
+ */
+export type InternalSpanParams = {
+    className?: string;
+    extra?: string;
+    children?: React.ReactNode;
+};
+export type SpanParams<T> = TableSchemaViewComponentParams<string, T> & InternalSpanParams & React.ComponentProps<'p'>;
+/**
+ * This is used in `TableSchemaView`
+ */
+export type InternalSpanArrayParams = {
+    className?: string;
+    classNameDelimiter?: string;
+    delimiter?: string;
+    name_fn?: (value: any) => string;
+};
+/**
+ * This is used in `TableSchemaView`
+ */
+export type SpanArrayParams = TableSchemaViewComponentParams<any[]> & InternalSpanArrayParams & React.ComponentProps<'p'>;
+export type InternalMInputParams = FieldLeafViewParams<string>;
+export type MInputParams = InternalMInputParams & InputParams;
+export type InternalInputWithClipboardParams = FieldLeafViewParams<string>;
+export type InputWithClipboardParams = InternalInputWithClipboardParams & React.ComponentProps<'div'>;
+export type InternalHandleParams = FieldLeafViewParams<string>;
+export type HandleParams = InternalHandleParams & React.ComponentProps<'div'>;
+export type InternalSwitchParams = FieldLeafViewParams<boolean>;
+export type SwitchParams = InternalSwitchParams & React.ComponentProps<'div'>;
+/**
+ * A `copy` to clipboard button
+ */
+export type ClipBoardCopyButtonParams = {
+    value: string;
+    config?: 0 | 1;
+    /**
+     * process the value
+     * before copying
+     */
+    process_before_copy?: (value: string) => string;
+};
+/**
+ * @param options [{id, name}, ...]
+ * @param defaultIndex do not use it (use defaultValue in fieldsview instead)
+ */
+export declare const create_select_view: (options: {
+    id: string | number;
+    name: string;
+}[], defaultIndex?: number) => ({ field, value, onChange }: FieldLeafViewParams<{
+    id: string;
+}>) => import("react/jsx-runtime").JSX.Element;
+export declare const TextArea: ({ field, value, onChange, ...rest }: TextAreaParams) => import("react/jsx-runtime").JSX.Element;
+export declare const Span: <T>({ value, children, className, extra, ...rest }: SpanParams<T>) => import("react/jsx-runtime").JSX.Element;
+/**
+ * This is used in `TableSchemaView`
+ */
+export declare const SpanArray: ({ field, value, className, name_fn, classNameDelimiter, delimiter, ...rest }: SpanArrayParams) => import("react/jsx-runtime").JSX.Element;
+/**
+ * This component is used in a `TableSchemaView`
+ */
+export declare const TimeStampView: ({ field, value, ...rest }: TimeStampViewParams) => import("react/jsx-runtime").JSX.Element;
+export declare const MInput: ({ field, value, onChange, type, ...rest }: MInputParams) => import("react/jsx-runtime").JSX.Element;
+export declare const InputWithClipboard: ({ value, field, onChange, setError, ...rest }: InputWithClipboardParams) => import("react/jsx-runtime").JSX.Element;
+export declare const Handle: ({ value, field, onChange, context, setError, ...rest }: HandleParams) => import("react/jsx-runtime").JSX.Element;
+export declare const Switch: ({ field, value, onChange, ...rest }: SwitchParams) => import("react/jsx-runtime").JSX.Element;
+/**
+ * A `copy` to clipboard button
+ */
+export declare const ClipBoardCopy: ({ value, config, process_before_copy }: ClipBoardCopyButtonParams) => import("react/jsx-runtime").JSX.Element;
+export declare const withCard: <P extends FieldLeafViewParams<any>>(Comp: React.FC<Partial<P>>, comp_params_inner?: Partial<P>, border?: boolean, copy?: boolean) => ({ field, value, disabled, onChange, children, error, setError, context, ...rest }: FieldLeafViewParams<any> & {
+    children?: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * This component is used in a `TableSchemaView`
+ */
+export declare const RecordActions: <T>({ context, field, value, ...rest }: RecordActionsParams<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/src/src/comps/common-table-fields.d.ts

@@ -0,0 +1,18 @@
+import { TableSchemaViewComponentParams } from './table-schema-view';
+/**
+ * This is used in `TableSchemaView`
+ */
+export type SpanParams<T extends unknown = any> = TableSchemaViewComponentParams<string, T> & {
+    className?: string;
+    extra?: string;
+    /**
+     * create a `url`
+     */
+    url_fn: (item: T) => string;
+    /**
+     * get current navigatio `state`
+     */
+    get_state: () => any;
+    children?: React.ReactNode;
+} & React.ComponentProps<'p'>;
+export declare const SimpleLink: <T>({ context, value, children, className, extra, url_fn, get_state, ...rest }: SpanParams<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/src/src/comps/common-ui.d.ts

@@ -0,0 +1,97 @@
+import { default as React } from 'react';
+export type CreateDate2Params = {
+    time: number;
+    className: string;
+} & React.ComponentProps<'div'>;
+export type HRParams = {
+    dashed?: boolean;
+} & React.ComponentProps<'input'>;
+export type TitleParams = {} & React.ComponentProps<'input'>;
+export type LabelParams = {} & React.ComponentProps<'div'>;
+export type DivParams = {
+    setError: any;
+} & React.ComponentProps<'div'>;
+export type InternalCreateDateParams = {
+    time: string;
+    changes_made?: boolean;
+    /**
+     * override
+     */
+    rightText?: string;
+    className: string;
+};
+export type CreateDateParams = InternalCreateDateParams & React.ComponentProps<'div'>;
+export type CreateDateImperativeInterface = {
+    get: () => boolean;
+    set: (value?: boolean) => void;
+};
+export type InputInternalParams = {
+    overrideClass?: boolean;
+    className?: string;
+};
+export type InputParams = InputInternalParams & React.ComponentProps<'input'>;
+export type BlingInputInternalParams = {
+    inputClsName?: string;
+};
+export type BlingInputParams = BlingInputInternalParams & InternalBlingParams & InputParams;
+/**
+ * Background container with gradient
+ */
+export type InternalBlingParams = {
+    className?: string;
+    rounded?: string;
+    children?: any;
+    stroke?: string;
+    from?: string;
+    to?: string;
+};
+/**
+ * Background container with gradient
+ */
+export type BlingParams = InternalBlingParams & React.ComponentProps<'div'>;
+export type InternalCardParams = {
+    name?: React.ReactNode;
+    setError?: (e: any) => void;
+    error?: string;
+    children: React.ReactNode;
+    border?: boolean;
+    desc?: string;
+    rightView?: React.ReactElement;
+    cardClass?: string;
+    rest?: any[];
+};
+export type CardParams = InternalCardParams & React.ComponentProps<'div'>;
+export declare const CreateDate: React.ForwardRefExoticComponent<Omit<CreateDateParams, "ref"> & React.RefAttributes<unknown>>;
+export declare const CreateDate2: ({ time, className, ...rest }: CreateDate2Params) => import("react/jsx-runtime").JSX.Element;
+export declare const HR: ({ dashed, ...rest }: HRParams) => import("react/jsx-runtime").JSX.Element;
+export declare const Title: ({ className, ...rest }: TitleParams) => import("react/jsx-runtime").JSX.Element;
+export declare const Label: ({ ...rest }: {
+    [x: string]: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const Input: React.ForwardRefExoticComponent<Omit<InputParams, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export declare const BlingInput: React.ForwardRefExoticComponent<Omit<BlingInputParams, "ref"> & React.RefAttributes<HTMLInputElement>>;
+/**
+ * @param color_stops
+ */
+export declare const border_bling_style: (color_stops?: string[]) => {
+    style: {
+        'background-image': string;
+        'background-clip': string;
+        'border-color': string;
+        'background-origin': string;
+    };
+};
+/**
+ * Background container with gradient
+ */
+export declare const Bling: ({ className, rounded, children, stroke, from, to, ...rest }: BlingParams) => import("react/jsx-runtime").JSX.Element;
+export declare const withBling: (Comp: any, params?: {}) => ({ ...rest }: {
+    [x: string]: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const withBling2: (Comp: any) => ({ ...rest }: {
+    [x: string]: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const Div: ({ setError, ...rest }: DivParams) => import("react/jsx-runtime").JSX.Element;
+/**
+ */
+export declare const Card: ({ name, setError, error, children, border, desc, rightView, cardClass, ...rest }: CardParams) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/src/{comps → src/comps}/copyable-view.d.ts

@@ -1,4 +1,3 @@
-export function CopyableView({ value, process_before_copy, ...rest }: CopyableViewParams & Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "value">): import("react").JSX.Element;
 /**
  * A view with `markdown` context, that is `copyable`
  */
@@ -12,4 +11,8 @@ export type CopyableViewParams = {
      * before copying
      */
     process_before_copy: (value: string) => string;
-};
+} & Omit<React.ComponentProps<'div'>, 'value'>;
+/**
+ * A view with `markdown` context, that is `copyable`
+ */
+export declare const CopyableView: ({ value, process_before_copy, ...rest }: CopyableViewParams) => import("react/jsx-runtime").JSX.Element;

package/dist/lib/src/src/comps/customer-orders.d.ts

@@ -0,0 +1,5 @@
+import { FieldLeafViewParams } from './fields-view';
+import { CustomerType } from '@storecraft/core/api';
+export type CustomerOrdersParams = FieldLeafViewParams<CustomerType, import('../pages/customer.js').Context, CustomerType> & React.ComponentProps<'div'>;
+declare const CustomerOrders: ({ value, field, context, error, setError, ...rest }: CustomerOrdersParams) => import("react/jsx-runtime").JSX.Element;
+export default CustomerOrders;

package/dist/lib/src/src/comps/dark-mode.d.ts

@@ -0,0 +1,2 @@
+declare const DarkMode: ({ ...rest }: React.ComponentProps<"div">) => import("react/jsx-runtime").JSX.Element;
+export default DarkMode;

package/dist/lib/src/src/comps/discount-details.d.ts

@@ -0,0 +1,54 @@
+import { BulkDiscountExtra, BundleDiscountExtra, BuyXGetYDiscountExtra, DiscountDetails, DiscountType, OrderDiscountExtra, RegularDiscountExtra } from '@storecraft/core/api';
+import { FieldContextData, FieldLeafViewParams } from './fields-view';
+export declare const discount_details_validator: (v: any) => (string | boolean)[];
+export type DiscountTypesParams = {
+    selectedType: DiscountDetails["meta"];
+    onChange: (meta: DiscountDetails["meta"]) => void;
+};
+export type BulkDiscountParams = {
+    type: "bulk";
+    value: BulkDiscountExtra;
+    onChange: (extra: BulkDiscountExtra) => void;
+};
+export type BundleDiscountParams = {
+    meta: "bundle";
+    value: BundleDiscountExtra;
+    context: FieldContextData;
+    onChange: (extra: BundleDiscountExtra) => void;
+};
+export type ExplainPriceParams = {
+    prefix: string;
+    percent: number;
+    fixed: number;
+};
+export type RegularDiscountParams = {
+    type: "regular";
+    value: RegularDiscountExtra;
+    onChange: (extra: RegularDiscountExtra) => void;
+};
+export type BuyXGetYDiscountParams = {
+    type: "buy_x_get_y";
+    value: BuyXGetYDiscountExtra;
+    onChange: (extra: BuyXGetYDiscountExtra) => void;
+    context: import('../pages/discount.js').Context;
+};
+export type OrderDiscountParams = {
+    type: "order";
+    value: OrderDiscountExtra;
+    onChange: (extra: OrderDiscountExtra) => void;
+};
+export type Type2CompParams = {
+    meta: DiscountDetails["meta"];
+    context: FieldContextData<DiscountType>;
+    onChange: (extra: DiscountDetails["extra"]) => void;
+    value: DiscountDetails["extra"];
+};
+export type DiscountDetailsViewParams = FieldLeafViewParams<DiscountDetails, import('../pages/discount.js').Context, DiscountType>;
+export declare const discount_types: {
+    id: number;
+    type: string;
+    name: string;
+    desc: string;
+}[];
+declare const DiscountDetailsView: ({ field, value, context, onChange, ...rest }: DiscountDetailsViewParams) => import("react/jsx-runtime").JSX.Element;
+export default DiscountDetailsView;