@storecraft/dashboard 1.0.0

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

@@ -0,0 +1,38 @@
+export default ProductVariants;
+export type ProductOptionParams = {
+    option: import('@storecraft/core/v-api').VariantOption;
+    onRemove: (option: import('@storecraft/core/v-api').VariantOption) => void;
+    onChange: (option: import('@storecraft/core/v-api').VariantOption) => void;
+};
+export type ProductOptionsParams = {
+    options: import('@storecraft/core/v-api').VariantOption[];
+    onChange: (option: import('@storecraft/core/v-api').VariantOption[]) => void;
+};
+export type VariantParams = {
+    options: import('@storecraft/core/v-api').VariantOption[];
+    combination: import('@storecraft/core/v-api').VariantOptionSelection[];
+    context: Context;
+    setError: (error: string) => void;
+};
+export type VariantsViewParams = {
+    options: import('@storecraft/core/v-api').VariantOption[];
+    context: Context;
+    setError: (error: string) => void;
+};
+export type Context = import('./fields-view.jsx').FieldContextData<import('@storecraft/core/v-api').VariantType & import('@storecraft/core/v-api').ProductType> & import('../pages/product.jsx').Context;
+/**
+ * @typedef {import('./fields-view.jsx').FieldContextData<
+ *  import('@storecraft/core/v-api').VariantType &
+ *  import('@storecraft/core/v-api').ProductType> &
+ *  import('../pages/product.jsx').Context
+ * } Context
+ *
+ *
+ * @param {import('./fields-view.jsx').FieldLeafViewParams<
+ *  import('@storecraft/core/v-api').VariantOption[],
+ *  Context> &
+ *  React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>
+ * } params
+ *
+ */
+declare function ProductVariants({ value, onChange, context, setError, ...rest }: import('./fields-view.jsx').FieldLeafViewParams<import('@storecraft/core/v-api').VariantOption[], Context> & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>): import("react").JSX.Element | "You have to create the product before you add variants";

package/dist/lib/src/comps/quick-search-browser.d.ts

@@ -0,0 +1,32 @@
+export function QuickSearchButton({ onClick, ...rest }: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>): import("react").JSX.Element;
+export default QuickSearchBrowser;
+export type SearchGroupParams = {
+    name: string;
+    group: import('@storecraft/core/v-api').QuickSearchResource[];
+    /**
+     * The group index
+     */
+    index: number;
+    /**
+     * The item index
+     */
+    selectedItemIndex: number;
+    /**
+     * The item index
+     */
+    scrollIntoView?: boolean;
+    onHover: (groupindex: number, itemIndex: number) => any;
+    onClick: (groupindex: number, itemIndex: number) => any;
+};
+export type QuickSearchBrowserParams = {
+    onCancel?: () => any;
+    onSelect?: (name: string, value: import('@storecraft/core/v-api').QuickSearchResource) => any;
+};
+/**
+ * @typedef {object} QuickSearchBrowserParams
+ * @prop {() => any} [onCancel]
+ * @prop {(name: string, value: import('@storecraft/core/v-api').QuickSearchResource) => any} [onSelect]
+ *
+ * @param {QuickSearchBrowserParams} params
+ */
+declare function QuickSearchBrowser({ onCancel, onSelect }: QuickSearchBrowserParams): import("react").JSX.Element;

package/dist/lib/src/comps/resource-browse.d.ts

@@ -0,0 +1,51 @@
+import { App } from '@storecraft/core';
+export function BrowseCustomers({ onSave, onCancel }: BrowseCustomersParams): import("react").JSX.Element;
+export function BrowseProducts({ onSave, onCancel }: BrowseProductsParams): import("react").JSX.Element;
+export default BrowseCollection;
+/**
+ * `BrowseCollection` is used to :
+ * - **view** and **select** items in big collections
+ * - Infinite pagination
+ * - query and filtering with `vql` search query
+ * - designed to be used inside a popup modal.
+ */
+export type BrowseCollectionParams<T extends import('@storecraft/core/v-api').BaseType = import('@storecraft/core/v-api').BaseType> = {
+    resource: keyof App["db"]["resources"];
+    title?: string;
+    Comp?: React.FC<{
+        data: object;
+    }>;
+    onSave: (v: T[]) => void;
+    onCancel: () => void;
+};
+export type BrowseCustomersParams = {
+    onSave: (v: import('@storecraft/core/v-api').CustomerType[]) => void;
+    onCancel: () => void;
+};
+export type BrowseProductsParams = {
+    onSave: (v: import('@storecraft/core/v-api').ProductType[]) => void;
+    onCancel: () => void;
+};
+/**
+ * `BrowseCollection` is used to :
+ * - **view** and **select** items in big collections
+ * - Infinite pagination
+ * - query and filtering with `vql` search query
+ * - designed to be used inside a popup modal.
+ *
+ * @template {import('@storecraft/core/v-api').BaseType} [T=import('@storecraft/core/v-api').BaseType]
+ *
+ *
+ * @typedef {object} BrowseCollectionParams
+ * @prop {keyof App["db"]["resources"]} resource
+ * @prop {string} [title]
+ * @prop {React.FC<{data: object}>} [Comp]
+ * @prop {(v: T[]) => void} onSave
+ * @prop {() => void} onCancel
+ */
+/**
+ * @template {import('@storecraft/core/v-api').BaseType} [T=import('@storecraft/core/v-api').BaseType]
+ *
+ * @param {BrowseCollectionParams<T>} params
+ */
+declare function BrowseCollection<T extends import('@storecraft/core/v-api').BaseType = import('@storecraft/core/v-api').BaseType>({ resource, title, Comp, onSave, onCancel }: BrowseCollectionParams<T>): import("react").JSX.Element;

package/dist/lib/src/comps/resource-onboard-svg.d.ts

@@ -0,0 +1,2 @@
+export function ResourceOnboardSvg(props: React.SVGProps<SVGSVGElement>): React.JSX.Element;
+import * as React from "react";

package/dist/lib/src/comps/resource-title.d.ts

@@ -0,0 +1,7 @@
+export function ResourceTitle({ resource, should_onboard, hasLoaded, overallColelctionCount: overallCollectionCount }: ResourceTitleParams): import("react").JSX.Element;
+export type ResourceTitleParams = {
+    resource: string;
+    should_onboard?: boolean;
+    hasLoaded?: boolean;
+    overallColelctionCount?: number;
+};

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

@@ -0,0 +1,25 @@
+export default ResourceView;
+export type ImpInterface = {
+    refresh: () => Promise<void>;
+};
+export type ResourceViewParams = {
+    /**
+     * `resource` at the backend endpoint, that supports
+     * querying
+     */
+    resource: string;
+    /**
+     * `limit` of query
+     */
+    limit?: number;
+    schema: any[];
+    /**
+     * context
+     */
+    context?: any;
+};
+/**
+ * `ResourceView` lets you view and paginate big collections
+ * rendered in `TableSchemaView`
+ */
+declare const ResourceView: import('react').ForwardRefExoticComponent<ResourceViewParams & import('react').RefAttributes<any>>;

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

@@ -0,0 +1,9 @@
+export default SecretView;
+/**
+ *
+ * @param {import('./fields-view.jsx').FieldLeafViewParams<
+ *  string> &
+ *  React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>
+ * } params
+ */
+declare function SecretView({ value, field, onChange, context, setError, ...rest }: import('./fields-view.jsx').FieldLeafViewParams<string> & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>): import("react").JSX.Element;

package/dist/lib/src/comps/select-resource.d.ts

@@ -0,0 +1,88 @@
+import { App } from '@storecraft/core';
+export function default_name_fn(it: import('@storecraft/core/v-api').BaseType): any;
+export function default_transform_fn(window: any[]): any[];
+export default SelectResource;
+export function SelectResourceWithTags<T extends import('@storecraft/core/v-api').BaseType>({ field, context, value, onChange, resource, add_all, transform_fn, name_fn, slug, label, className, ...rest }: SelectResourceWithTagsParams<T>): import("react").JSX.Element;
+/**
+ * A simple `select` control, that fetches all documents in a `collection`,
+ * this is a good option for super small collections/tables such as:
+ * - `Shipping Methods`
+ * - `Collections`
+ * - `Posts`
+ * - `Discounts`
+ * Which will mostly have no more that 50 items each.
+ *
+ * If you need something with pagination, try `BrowseCollection` instead.
+ */
+export type SelectResourceParams<T, TRANSFORM = T> = {
+    /**
+     * callback when selection is made (value) => any
+     */
+    onSelect: (value: TRANSFORM) => any;
+    header: string;
+    /**
+     * add all sentinal
+     */
+    add_all?: boolean;
+    /**
+     * add all sentinal
+     */
+    layout: 0 | 1;
+    /**
+     * table identifier to query
+     */
+    resource: keyof App["db"]["resources"];
+    /**
+     * number of item to query
+     */
+    limit?: number;
+    className?: string;
+    clsHeader?: string;
+    clsReload?: string;
+    transform_fn?: (value: T[]) => TRANSFORM[];
+    name_fn?: (value: TRANSFORM) => string;
+};
+/**
+ * A `FieldView` `select` control with `capsules`
+ */
+export type InnerSelectResourceWithTagsParams = {
+    label: string;
+    slug: string;
+};
+export type SelectResourceWithTagsParams<T> = InnerSelectResourceWithTagsParams & SelectResourceParams<T> & import('./fields-view.jsx').FieldLeafViewParams<T[], import('../pages/index.jsx').BaseDocumentContext>;
+/**
+ * A simple `select` control, that fetches all documents in a `collection`,
+ * this is a good option for super small collections/tables such as:
+ * - `Shipping Methods`
+ * - `Collections`
+ * - `Posts`
+ * - `Discounts`
+ * Which will mostly have no more that 50 items each.
+ *
+ * If you need something with pagination, try `BrowseCollection` instead.
+ *
+ * @template T
+ * @template [TRANSFORM=T]
+ *
+ * @typedef {object} SelectResourceParams
+ * @property {(value: TRANSFORM) => any} onSelect callback when selection is made (value) => any
+ * @property {string} header
+ * @property {boolean} [add_all] add all sentinal
+ * @property {0 | 1} layout add all sentinal
+ * @property {keyof App["db"]["resources"]} resource table identifier to query
+ * @property {number} [limit] number of item to query
+ * @property {string} [className]
+ * @property {string} [clsHeader]
+ * @property {string} [clsReload]
+ * @property {(value: T[]) => TRANSFORM[]} [transform_fn]
+ * @property {(value: TRANSFORM) => string} [name_fn]
+ */
+/**
+ *
+ * @template T
+ * @template [TRANSFORM=T]
+ *
+ * @param {SelectResourceParams<T, TRANSFORM>} params
+ *
+ */
+declare function SelectResource<T, TRANSFORM = T>({ onSelect, header, resource, limit, layout, add_all, transform_fn, name_fn, className, clsHeader, clsReload, ...rest }: SelectResourceParams<T, TRANSFORM>): import("react").JSX.Element;

package/dist/lib/src/comps/settings-api-keys.d.ts

@@ -0,0 +1,2 @@
+export function SettingsApiKeys({ ...rest }: SettingsApiKeysParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>): import("react").JSX.Element;
+export type SettingsApiKeysParams = object;

package/dist/lib/src/comps/settings-storage.d.ts

@@ -0,0 +1,15 @@
+export default StorageSettingsView;
+export type StorageProvider = {
+    key: string;
+    name: string;
+    select_comp: any;
+    config_comp: any;
+};
+/**
+ *
+ * @param {object} param0
+ * @param {StorageSettings} param0.value
+ */
+declare function StorageSettingsView({ field, value, onChange, className, ...rest }: {
+    value: StorageSettings;
+}): import("react").JSX.Element;

package/dist/lib/src/comps/show-if.d.ts

@@ -0,0 +1,25 @@
+import { default as React } from 'react';
+export function ShowSwitch({ index, children, ...rest }: ShowSwitchParams): React.JSX.Element;
+export function ShowBinarySwitch({ toggle, children, ...rest }: InternalShowBinarySwitchParams & ShowSwitchParams): React.JSX.Element;
+export default ShowIf;
+export type ShowIfParams = {
+    show: any;
+    children: React.ReactNode;
+};
+export type internalShowSwitchParams = {
+    index?: number;
+};
+export type ShowSwitchParams = internalShowSwitchParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+export type InternalShowBinarySwitchParams = {
+    toggle?: any;
+};
+/**
+ *
+ * @typedef {object} ShowIfParams
+ * @prop {any} show
+ * @prop {React.ReactNode} children
+ *
+ *
+ * @param {ShowIfParams} params
+ */
+declare function ShowIf({ show, children }: ShowIfParams): React.ReactNode;

package/dist/lib/src/comps/side-menu.d.ts

@@ -0,0 +1,50 @@
+import { default as React } from 'react';
+export default SideMenu;
+export type MenuItemType = {
+    name: string;
+    slug?: string;
+    icon?: React.JSX.Element;
+    extra?: object;
+    items?: MenuItemType[];
+};
+export type MenuType = {
+    items: MenuItemType[];
+    info: {
+        name?: string;
+        icon?: React.JSX.Element;
+    };
+};
+export type InnerSideMenuParams = {
+    menu: MenuType;
+    onCloseClick: () => void;
+};
+/**
+ *
+ * @typedef {object} MenuItemType
+ * @prop {string} name
+ * @prop {string} [slug]
+ * @prop {React.JSX.Element} [icon]
+ * @prop {object} [extra]
+ * @prop {MenuItemType[]} [items]
+ *
+ *
+ * @typedef {object} MenuType
+ * @prop {MenuItemType[]} items
+ * @prop {object} info
+ * @prop {string} [info.name]
+ * @prop {React.JSX.Element} [info.icon]
+ *
+ */
+/**
+ *
+ * @typedef {object} InnerSideMenuParams
+ * @prop {MenuType} menu
+ * @prop {() => void} onCloseClick
+ *
+ *
+ * @param {InnerSideMenuParams &
+ *  React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>
+ * } params
+ *
+ */
+declare function SideMenu({ className, onCloseClick, menu: { items, info } }: InnerSideMenuParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>): React.JSX.Element;

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

@@ -0,0 +1 @@
+export function Splitter({ children, ...rest }: React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>): import("react").JSX.Element;

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

@@ -0,0 +1,12 @@
+export default StorefrontProducts;
+/**
+ * `StorefrontProducts` is located at the `storefront.jsx` page.
+ * It consists of abutton, that opens a modal to query `products`
+ * with pagination and selecting them.
+ *
+ * @param {import('./fields-view.jsx').FieldLeafViewParams<
+ *  import('@storecraft/core/v-api').ProductType[],
+ *  import('../pages/storefront.jsx').Context>} params
+ *
+ */
+declare function StorefrontProducts({ field, context, value, onChange }: import('./fields-view.jsx').FieldLeafViewParams<import('@storecraft/core/v-api').ProductType[], import('../pages/storefront.jsx').Context>): import("react").JSX.Element;

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

@@ -0,0 +1,4 @@
+export function WhiteSpace({ n }: {
+    n?: number;
+}): import("react").JSX.Element;
+export function SpaceShip(): import("react").JSX.Element;

package/dist/lib/src/comps/table-schema-view.d.ts

@@ -0,0 +1,68 @@
+export function TableSchemaView<T>({ context, fields, data, recordClassName, className }: {
+    context: any;
+    fields: TableSchemaViewField<T, keyof T, import('react').FC<TableSchemaViewComponentParams<T, keyof T>>>[];
+    data: object[];
+    recordClassName?: string;
+    className?: string;
+}): import("react").JSX.Element;
+/**
+ * The context provided to
+ * components of `TableSchemaView`
+ */
+export type TableSchemaViewContext<T extends import('@storecraft/core/v-api').BaseType> = {
+    /**
+     * item
+     */
+    item: T;
+    deleteDocument: (id: string) => Promise<void>;
+    editDocumentUrl: (id: string) => string;
+    viewDocumentUrl: (id: string) => string;
+};
+/**
+ * infer `params` of `react` functional component
+ */
+export type Params<T> = T extends import('react').FC<infer P> ? P : never;
+/**
+ * The `field` parameter given to `TableSchemaView`
+ * components
+ */
+export type TableSchemaViewField<T extends unknown, Key extends keyof T = keyof T, Comp extends import('react').FC<{}> = import('react').FC<TableSchemaViewComponentParams<T, Key>>> = {
+    /**
+     * Key of field in the data
+     */
+    key: Key;
+    /**
+     * Name of field
+     */
+    name: string;
+    /**
+     * Name of field
+     */
+    comp: React.FC<Params<Comp> & TableSchemaViewComponentParams<T[Key], T>>;
+    /**
+     * component parameters
+     */
+    comp_params?: Params<Comp>;
+    /**
+     * transform data
+     */
+    transform?: Key extends undefined ? (x: T) => any : (x: T[Key]) => T[Key];
+};
+/**
+ * The `params` of components of
+ * `TableSchemaView`
+ */
+export type TableSchemaViewComponentParams<V extends unknown, T extends unknown = any> = {
+    /**
+     * Key of field in the data
+     */
+    field?: TableSchemaViewField<T>;
+    /**
+     * Context
+     */
+    context?: TableSchemaViewContext<T>;
+    /**
+     * Value of field
+     */
+    value?: V;
+};

package/dist/lib/src/comps/tag-values.d.ts

@@ -0,0 +1,9 @@
+export function values_validator(v: any): (string | number)[];
+export default TagValues;
+/**
+ *
+ * @param {import("./fields-view.jsx").FieldLeafViewParams<
+ *  string[]>
+ * } params
+ */
+declare function TagValues({ field, value, onChange, ...rest }: import('./fields-view.jsx').FieldLeafViewParams<string[]>): import("react").JSX.Element;

package/dist/lib/src/comps/tags-edit.d.ts

@@ -0,0 +1,13 @@
+export function SelectTags({ onSelect, header, limit, layout, className, clsHeader, clsReload, ...rest }: Omit<import('./select-resource.jsx').SelectResourceParams<import('@storecraft/core/v-api').TagType, string>, 'resource' | 'transform_fn' | 'name_fn'>): import("react").JSX.Element;
+export default TagsEdit;
+export type InternalManualTagParams = {
+    onAdd: (values: string[]) => void;
+};
+/**
+ *
+ * @param {import("./fields-view.jsx").FieldLeafViewParams<string[],
+ *  import("../pages/index.jsx").BaseDocumentContext> &
+ *  React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>
+ * } param0
+ */
+declare function TagsEdit({ field, context, value, onChange, ...rest }: import('./fields-view.jsx').FieldLeafViewParams<string[], import('../pages/index.jsx').BaseDocumentContext> & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>): import("react").JSX.Element;

package/dist/lib/src/comps/template-example-input.d.ts

@@ -0,0 +1,3 @@
+export function TemplateExampleInput({ field, context, setError, value, onChange, ...rest }: TemplateTemplateParams & Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, 'onChange'>): import("react").JSX.Element;
+export default TemplateExampleInput;
+export type TemplateTemplateParams = import('./fields-view.jsx').FieldLeafViewParams<import('@storecraft/core/v-api').TemplateType["reference_example_input"]>;

package/dist/lib/src/comps/template-template.d.ts

@@ -0,0 +1,6 @@
+export function TemplateTemplate({ field, context, setError, value, onChange, ...rest }: TemplateTemplateParams & Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, 'onChange'>): import("react").JSX.Element;
+export default TemplateTemplate;
+export type DangerousHTMLViewParams = {
+    value?: string | TrustedHTML;
+};
+export type TemplateTemplateParams = import('./fields-view.jsx').FieldLeafViewParams<import('@storecraft/core/v-api').TemplateType["template_html" | "template_text"]>;

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

@@ -0,0 +1,51 @@
+export default Transition;
+export type InnerTransitionParams = {
+    show: boolean;
+    unMountOnExit: boolean;
+    duration: number;
+    /**
+     * class-names for `event`
+     */
+    enter: string;
+    /**
+     * class-names for `event`
+     */
+    enterFrom: string;
+    /**
+     * class-names for `event`
+     */
+    enterTo: string;
+    /**
+     * class-names for `event`
+     */
+    leave: string;
+    /**
+     * class-names for `event`
+     */
+    leaveFrom: string;
+    /**
+     * class-names for `event`
+     */
+    leaveTo: string;
+};
+/**
+ *
+ * @typedef {object} InnerTransitionParams
+ * @prop {boolean} show
+ * @prop {boolean} unMountOnExit
+ * @prop {number} duration
+ * @prop {string} enter class-names for `event`
+ * @prop {string} enterFrom class-names for `event`
+ * @prop {string} enterTo class-names for `event`
+ * @prop {string} leave class-names for `event`
+ * @prop {string} leaveFrom class-names for `event`
+ * @prop {string} leaveTo class-names for `event`
+ *
+ *
+ *
+ * @param {InnerTransitionParams &
+ *  React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>
+ * } params
+ *
+ */
+declare function Transition({ show, duration, unMountOnExit, enter, enterFrom, enterTo, leave, leaveFrom, leaveTo, children, className, ...rest }: InnerTransitionParams & React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>): import("react").JSX.Element;

package/dist/lib/src/hooks/createMediaQueryHook.d.ts

@@ -0,0 +1,8 @@
+export function create(screens: any): {
+    useBreakpoint: (breakpoint: any, defaultValue?: boolean) => boolean;
+    useBreakpointEffect: (breakpoint: any, effect: any) => any;
+    useBreakpointValue: (breakpoint: any, valid: any, invalid: any) => any;
+};
+export const isSSR: boolean;
+export const isBrowser: boolean;
+export default create;

package/dist/lib/src/hooks/useCollectionsActions.d.ts

@@ -0,0 +1,66 @@
+import { App } from '@storecraft/core';
+export default useCollectionsActions;
+/**
+ * This `type` will give you the return type of the hook
+ */
+export type HookReturnType<T> = Omit<ReturnType<typeof useCollectionsActions<T>>, 'page' | 'pages'> & {
+    page: T[];
+    pages: T[][];
+};
+/**
+ * @template T the `document` type
+ *
+ * @typedef {Omit<ReturnType<typeof useCollectionsActions<T>>, 'page' | 'pages'> &
+ *  {
+ *    page: T[],
+ *    pages: T[][]
+ *  }
+ * } HookReturnType This `type` will give you the return type of the hook
+ *
+ */
+/**
+ * `useCollectionsActions` is a hook designed for the collections pages,
+ * for performing:
+ * - Viewing of collections
+ * - Pagination through querying or navigation
+ * - Querying
+ *
+ * This hook wraps `useCollection` hook
+ *
+ * @template {Partial<import('@storecraft/core/v-api').BaseType>} T
+ *
+ * @param {((keyof App["db"]["resources"]) | 'payments/gateways' | 'extensions')} resource the collection id in backend
+ * @param {string} [slug] front end slug
+ * @param {boolean} [autoLoad=true]
+ * @param {import('@storecraft/core/v-api').ApiQuery} [autoLoadQuery=q_initial]
+ */
+declare function useCollectionsActions<T extends Partial<import('@storecraft/core/v-api').BaseType>>(resource: ((keyof App["db"]["resources"]) | 'payments/gateways' | 'extensions'), slug?: string, autoLoad?: boolean, autoLoadQuery?: import('@storecraft/core/v-api').ApiQuery): {
+    resource: "search" | "products" | "collections" | "discounts" | "tags" | "shipping_methods" | "posts" | "auth_users" | "customers" | "storefronts" | "images" | "templates" | "notifications" | "orders" | "extensions" | "payments/gateways";
+    query_api: import('@storecraft/core/v-api').ApiQuery;
+    ref_actions: import('react').MutableRefObject<import('../comps/collection-actions.jsx').ImperativeInterface>;
+    context: {
+        viewDocumentUrl: (id: string) => string;
+        editDocumentUrl: (id: string) => string;
+        deleteDocument: (document: string) => Promise<string>;
+    };
+    pages: T[][];
+    page: T[];
+    loading: boolean;
+    hasLoaded: boolean;
+    resource_is_probably_empty: boolean;
+    error: any;
+    queryCount: number;
+    actions: {
+        onLimitChange: ($limit: number, perform_navigation?: boolean) => import('@storecraft/core/v-api').ApiQuery;
+        onReload: (perform_navigation?: boolean) => Promise<{
+            limit: number;
+            vql: string;
+            expand?: import('@storecraft/core/v-api').ExpandQuery;
+            vqlParsed?: import("@storecraft/core/v-ql").VQL.Node;
+            sortBy?: import('@storecraft/core/v-api').SortCursor;
+            order?: import('@storecraft/core/v-api').SortOrder;
+        }>;
+        prev: (perform_navigation?: boolean) => Promise<import('@storecraft/core/v-api').ApiQuery>;
+        next: (perform_navigation?: boolean) => Promise<import('@storecraft/core/v-api').ApiQuery>;
+    };
+};

package/dist/lib/src/hooks/useDarkMode.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * The `dark-mode` state hook
+ *
+ */
+export default function useDarkMode(): {
+    darkMode: boolean;
+    toggle: () => void;
+};

package/dist/lib/src/hooks/useDocumentActions.d.ts

@@ -0,0 +1,35 @@
+import { App } from '@storecraft/core';
+export function useDocumentActions<T extends {}>(resource: (keyof App["db"]["resources"] | 'payments/gateways' | 'extensions'), document: string, slug: string, mode?: DocumentActionsMode, base?: string): {
+    actions: {
+        reloadPromise: (try_cache?: boolean) => Promise<void>;
+        savePromise: () => Promise<T>;
+        deletePromise: () => Promise<string>;
+        duplicate: (state_next_extra?: Partial<T>) => Promise<void>;
+        navWithState: (to: import('react-router').To, current_state?: any, next_state?: any) => void;
+        reload: (try_cache?: boolean) => Promise<T>;
+        setError: import('react').Dispatch<any>;
+    };
+    error: any;
+    key: string;
+    ref_head: import('react').MutableRefObject<import('../comps/common-ui.jsx').CreateDateImperativeInterface>;
+    ref_root: import('react').MutableRefObject<import('../comps/fields-view.jsx').FieldViewImperativeInterface<T>>;
+    doc: T;
+    sdk: import('@storecraft/sdk').StorecraftSDK;
+    isEditMode: boolean;
+    isCreateMode: boolean;
+    isViewMode: boolean;
+    loading: boolean;
+    hasChanged: any;
+    hasLoaded: boolean;
+    context: import('../pages/index.jsx').BaseDocumentContext<{
+        hasChanged?: boolean;
+        data?: T;
+    }>;
+};
+/**
+ * This `type` will give you the return type of the hook
+ */
+export type HookReturnType<T> = Omit<ReturnType<typeof useDocumentActions<T>>, 'doc'> & {
+    doc: T;
+};
+export type DocumentActionsMode = 'edit' | 'view' | 'create';