@mframework/core 0.0.1

package/dist/types/config.d.ts

@@ -0,0 +1,8 @@
+export interface AlternateConfig {
+    env: 'development' | 'production' | 'test';
+    appName?: string;
+    logger?: {
+        level?: 'debug' | 'info' | 'warn' | 'error';
+    };
+    [key: string]: unknown;
+}

package/dist/types/config.js

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

package/dist/types/events.d.ts

@@ -0,0 +1,16 @@
+export interface AlternateEventMap {
+    'app:ready': {
+        context: unknown;
+    };
+    'app:error': {
+        error: unknown;
+    };
+}
+export type AlternateEventKey = keyof AlternateEventMap;
+export type AlternateEventHandler<K extends AlternateEventKey> = (payload: AlternateEventMap[K]) => void | Promise<void>;
+export interface AlternateEventBus {
+    on<K extends AlternateEventKey>(event: K, handler: AlternateEventHandler<K>): void;
+    off<K extends AlternateEventKey>(event: K, handler: AlternateEventHandler<K>): void;
+    emit<K extends AlternateEventKey>(event: K, payload: AlternateEventMap[K]): Promise<void>;
+}
+export declare function createEventBus(): AlternateEventBus;

package/dist/types/events.js

@@ -0,0 +1,22 @@
+export function createEventBus() {
+    const handlers = new Map();
+    return {
+        on(event, handler) {
+            if (!handlers.has(event)) {
+                handlers.set(event, new Set());
+            }
+            handlers.get(event).add(handler);
+        },
+        off(event, handler) {
+            handlers.get(event)?.delete(handler);
+        },
+        async emit(event, payload) {
+            const set = handlers.get(event);
+            if (!set || set.size === 0)
+                return;
+            for (const handler of set) {
+                await handler(payload);
+            }
+        }
+    };
+}

package/dist/types/module.d.ts

@@ -0,0 +1,15 @@
+import type { AlternateContext } from '../runtime/context';
+import type { AlternateAdapterKey, AlternateAdapterOf } from './adapters';
+export type AlternateModuleAdapters = Partial<{
+    [K in AlternateAdapterKey]: AlternateAdapterOf<K>;
+}>;
+export interface AlternateModuleLifecycle {
+    onAppInit?(ctx: AlternateContext): Promise<void> | void;
+    onBeforeRequest?(ctx: AlternateContext): Promise<void> | void;
+    onAfterRequest?(ctx: AlternateContext): Promise<void> | void;
+}
+export interface AlternateModule extends AlternateModuleLifecycle {
+    id: string;
+    adapters?: AlternateModuleAdapters;
+    setup?(ctx: AlternateContext): void | Promise<void>;
+}

package/dist/types/module.js

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

package/dist/utils/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class MeeoviError extends Error {
+    code?: string;
+    cause?: unknown;
+    constructor(message: string, options?: {
+        code?: string;
+        cause?: unknown;
+    });
+}
+export declare function isAlternateError(err: unknown): err is MeeoviError;

package/dist/utils/errors.js

@@ -0,0 +1,13 @@
+export class MeeoviError extends Error {
+    code;
+    cause;
+    constructor(message, options) {
+        super(message);
+        this.name = 'MeeoviError';
+        this.code = options?.code;
+        this.cause = options?.cause;
+    }
+}
+export function isAlternateError(err) {
+    return err instanceof MeeoviError;
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,9 @@
+export type AlternateLogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface AlternateLogger {
+    level: AlternateLogLevel;
+    debug(message: string, meta?: unknown): void;
+    info(message: string, meta?: unknown): void;
+    warn(message: string, meta?: unknown): void;
+    error(message: string, meta?: unknown): void;
+}
+export declare function createLogger(level?: AlternateLogLevel): AlternateLogger;

package/dist/utils/logger.js

@@ -0,0 +1,29 @@
+export function createLogger(level = 'info') {
+    const levels = ['debug', 'info', 'warn', 'error'];
+    function shouldLog(target) {
+        return levels.indexOf(target) >= levels.indexOf(level);
+    }
+    return {
+        level,
+        debug(message, meta) {
+            if (!shouldLog('debug'))
+                return;
+            console.debug(`[Alternate][debug] ${message}`, meta ?? '');
+        },
+        info(message, meta) {
+            if (!shouldLog('info'))
+                return;
+            console.info(`[Alternate][info] ${message}`, meta ?? '');
+        },
+        warn(message, meta) {
+            if (!shouldLog('warn'))
+                return;
+            console.warn(`[Alternate][warn] ${message}`, meta ?? '');
+        },
+        error(message, meta) {
+            if (!shouldLog('error'))
+                return;
+            console.error(`[Alternate][error] ${message}`, meta ?? '');
+        }
+    };
+}

package/errors.ts

@@ -0,0 +1,21 @@
+export class ValidationError extends Error {
+	path: string[]
+	code?: string
+
+	constructor(message: string, path: string[] = [], code?: string) {
+		super(message)
+		this.name = 'ValidationError'
+		this.path = path
+		this.code = code
+	}
+
+	toString() {
+		if (this.path && this.path.length) {
+			return `${this.name} [${this.path.join('.')}]: ${this.message}`
+		}
+		return `${this.name}: ${this.message}`
+	}
+}
+
+export const isValidationError = (v: unknown): v is ValidationError =>
+	v instanceof ValidationError

package/index.ts

@@ -0,0 +1,93 @@
+// src/index.ts
+export * from './src/runtime/app'
+export * from './src/runtime/context'
+export * from './src/runtime/config'
+// src/index.ts
+export * from './src/runtime/app'
+export * from './src/runtime/context'
+export * from './src/runtime/config'
+export * from './src/runtime/hooks'
+
+export * from './src/plugins/defineModule'
+export * from './src/plugins/defineAdapter'
+export * from './src/plugins/registry'
+
+export * from './src/adapters/common'
+export * from './src/adapters/auth'
+export * from './src/adapters/search'
+export * from './src/adapters/catalog'
+export * from './src/adapters/cart'
+export * from './src/adapters/lists'
+
+export * from './src/types/module'
+export * from './src/types/app'
+export * from './src/types/config'
+export * from './src/types/events'
+
+//// Types and Utilities ////
+
+// Core
+export * from './src/types/core/result'
+export * from './src/types/core/utility'
+export * from './src/types/core/pagination'
+export * from './src/types/core/id'
+export { Maybe } from './src/types/core/common'
+export * from './src/types/core/error'
+
+// Auth
+export * from './src/types/auth/user'
+export * from './src/types/auth/session'
+export * from './src/types/auth/providers'
+export * from './src/types/auth/inputs'
+export type { AuthAdapter } from './src/types/auth/adapter'
+
+// Commerce
+export * from './src/types/commerce/product'
+export * from './src/types/commerce/cart'
+export * from './src/types/commerce/order'
+export * from './src/types/commerce/adapter'
+export * from './src/types/commerce/category'
+// Legacy compat exports (for older @mframework/types consumers)
+// Export specific legacy names to avoid symbol collisions with other re-exports
+export type { Product } from './src/types/compat/legacy'
+export type { Session, User } from './src/types/compat/legacy'
+
+// Search
+export type { SearchQuery } from './src/types/search/query'
+export type { SearchResult } from './src/types/search/result'
+export * from './src/types/search/facet'
+export * from './src/types/search/result'
+export * from './src/types/search/opensearch'
+export type { SearchAdapter } from './src/types/search/adapter'
+
+// UI
+export * from './src/types/ui/form'
+export * from './src/types/ui/state'
+export * from './src/types/ui/pagination'
+export * from './src/types/ui/component'
+export * from './src/types/ui/blocks'
+export * from './src/types/ui/content'
+export * from './src/types/ui/meta'
+export * from './src/types/ui/system'
+export * from './src/types/ui/help'
+export * from './src/types/ui/os'
+export * from './src/types/ui/schema'
+
+// SDK
+export * from './src/types/sdk/errors'
+export * from './src/types/sdk/endpoint'
+export * from './src/types/sdk/request'
+export * from './src/types/sdk/response'
+export * from './src/types/sdk/adapter'
+
+// Normalizers
+export * from './src/normalizers/factories'
+export * from './src/normalizers/factories/apiClientFactory'
+export * from './src/normalizers/utils/context'
+export * from './src/normalizers/utils/factoryParams'
+export * from './src/normalizers/utils/helpers'
+export * from './src/normalizers/utils/i18n-redirects'
+export * from './src/normalizers/utils/logger'
+export * from './src/normalizers/utils/shared'
+export * from './src/normalizers/utils/ssr'
+export * from './src/normalizers/utils/wrap'

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@mframework/core",
+  "version": "0.0.1",
+  "description": "The core package of the M Framework.",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc -p tsconfig.json"
+  },
+  "keywords": [
+    "meeovi",
+    "mframework-framework",
+    "mframework-core",
+    "vue",
+    "react",
+    "typescript"
+  ],
+  "author": "M Framework",
+  "type": "module",
+  "dependencies": {
+    "typescript": "^5.9.3",
+    "zod": "^4.3.6"
+  },
+  "bin": {
+    "mframework-create-adapter": "./bin/create-adapter.cjs"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.10"
+  }
+}

package/src/adapters/auth.ts

@@ -0,0 +1,11 @@
+import { BaseAdapterConfig } from './common'
+
+export interface AuthAdapterConfig extends BaseAdapterConfig {
+  provider: 'custom' | 'auth0' | 'cognito' | string
+}
+
+export interface AuthAdapter {
+  login(payload: unknown): Promise<unknown>
+  logout(): Promise<void>
+  getSession(): Promise<unknown | null>
+}

package/src/adapters/cart.ts

@@ -0,0 +1,27 @@
+import { BaseAdapter, BaseAdapterConfig } from './common'
+
+export interface CartAdapterConfig extends BaseAdapterConfig {
+  provider: string
+}
+
+export interface CartItem {
+  id: string
+  productId: string
+  quantity: number
+  [key: string]: unknown
+}
+
+export interface Cart<TItem extends CartItem = CartItem> {
+  id: string
+  items: TItem[]
+  [key: string]: unknown
+}
+
+export interface CartAdapter<TItem extends CartItem = CartItem>
+  extends BaseAdapter<CartAdapterConfig> {
+  type: 'cart'
+  getCart(id: string): Promise<Cart<TItem> | null>
+  addItem(cartId: string, item: TItem): Promise<Cart<TItem>>
+  removeItem(cartId: string, itemId: string): Promise<Cart<TItem>>
+  clearCart(cartId: string): Promise<Cart<TItem>>
+}

package/src/adapters/catalog.ts

@@ -0,0 +1,21 @@
+import { BaseAdapter, BaseAdapterConfig } from './common'
+
+export interface CatalogAdapterConfig extends BaseAdapterConfig {
+  provider: string
+}
+
+export interface CatalogProduct {
+  id: string
+  slug: string
+  name: string
+  price: number
+  [key: string]: unknown
+}
+
+export interface CatalogAdapter<TProduct extends CatalogProduct = CatalogProduct>
+  extends BaseAdapter<CatalogAdapterConfig> {
+  type: 'catalog'
+  getProductById(id: string): Promise<TProduct | null>
+  getProductBySlug(slug: string): Promise<TProduct | null>
+  listProducts(params?: Record<string, unknown>): Promise<TProduct[]>
+}

package/src/adapters/common.ts

@@ -0,0 +1,10 @@
+export interface BaseAdapterConfig {
+  enabled?: boolean
+  timeoutMs?: number
+}
+
+export interface BaseAdapter<TConfig extends BaseAdapterConfig = BaseAdapterConfig> {
+  id: string
+  type: string
+  config?: TConfig
+}

package/src/adapters/lists.ts

@@ -0,0 +1,23 @@
+import { BaseAdapter, BaseAdapterConfig } from './common'
+
+export interface ListsAdapterConfig extends BaseAdapterConfig {
+  provider?: string
+}
+
+export interface ListsAdapter extends BaseAdapter<ListsAdapterConfig> {
+  type: 'lists'
+
+  getList(id: string): Promise<any>
+  listLists(params?: Record<string, any>): Promise<any[]>
+  createList(data: Partial<any>): Promise<any>
+  updateList(id: string, data: Partial<any>): Promise<any>
+  deleteList(id: string): Promise<void>
+
+  addItem(listId: string, item: Partial<any>): Promise<any>
+  updateItem(listId: string, itemId: string, data: Partial<any>): Promise<any>
+  deleteItem(listId: string, itemId: string): Promise<void>
+
+  reorderItems?(listId: string, itemIds: string[]): Promise<void>
+}
+
+export default ListsAdapter

package/src/adapters/search.ts

@@ -0,0 +1,26 @@
+import { BaseAdapter, BaseAdapterConfig } from './common'
+
+export interface SearchAdapterConfig extends BaseAdapterConfig {
+  provider: string
+}
+
+export interface SearchQuery {
+  term: string
+  filters?: Record<string, unknown>
+  page?: number
+  pageSize?: number
+}
+
+export interface SearchResult<TItem = unknown> {
+  items: TItem[]
+  total: number
+  page: number
+  pageSize: number
+}
+
+export interface SearchAdapter<TItem = unknown>
+  extends BaseAdapter<SearchAdapterConfig> {
+  type: 'search'
+  search(query: SearchQuery): Promise<SearchResult<TItem>>
+  suggest?(term: string): Promise<string[]>
+}

package/src/normalizers/factories/apiClientFactory/context.d.ts

@@ -0,0 +1,14 @@
+import { ApiClientMethod } from '../../types';
+interface ApplyingContextHooks {
+    before: ({ callName, args }: {
+        callName: any;
+        args: any;
+    }) => any[];
+    after: ({ callName, args, response }: {
+        callName: any;
+        args: any;
+        response: any;
+    }) => any;
+}
+declare const applyContextToApi: (api: Record<string, ApiClientMethod>, context: any, hooks?: ApplyingContextHooks) => {};
+export { applyContextToApi };

package/src/normalizers/factories/apiClientFactory/index.d.ts

@@ -0,0 +1,3 @@
+import { ApiClientFactoryParams, ApiClientConfig, ApiClientFactory } from '../../types';
+declare const apiClientFactory: <ALL_SETTINGS extends ApiClientConfig, ALL_FUNCTIONS>(factoryParams: ApiClientFactoryParams<ALL_SETTINGS, ALL_FUNCTIONS>) => ApiClientFactory;
+export { apiClientFactory };

package/src/normalizers/factories/index.d.ts

@@ -0,0 +1,19 @@
+export * from './apiClientFactory';
+export * from './useBillingFactory';
+export * from './useCartFactory';
+export * from './useCategoryFactory';
+export * from './useContentFactory';
+export * from './useFacetFactory';
+export * from './useMakeOrderFactory';
+export * from './useProductFactory';
+export * from './useReviewFactory';
+export * from './useShippingFactory';
+export * from './useUserBillingFactory';
+export * from './useUserFactory';
+export * from './useUserOrderFactory';
+export * from './useUserShippingFactory';
+export * from './useWishlistFactory';
+export * from './useShippingProviderFactory';
+export * from './useForgotPasswordFactory';
+export * from './useStoreFactory';
+export * from './useSearchFactory';

package/src/normalizers/factories/useBillingFactory.d.ts

@@ -0,0 +1,12 @@
+import { UseBilling, Context, FactoryParams, CustomQuery, PlatformApi } from '../types';
+export interface UseBillingParams<BILLING, BILLING_PARAMS, API extends PlatformApi = any> extends FactoryParams<API> {
+    load: (context: Context, params: {
+        customQuery?: CustomQuery;
+    }) => Promise<BILLING>;
+    save: (context: Context, params: {
+        params: BILLING_PARAMS;
+        billingDetails: BILLING;
+        customQuery?: CustomQuery;
+    }) => Promise<BILLING>;
+}
+export declare const useBillingFactory: <BILLING, BILLING_PARAMS, API extends PlatformApi = any>(factoryParams: UseBillingParams<BILLING, BILLING_PARAMS, API>) => () => UseBilling<BILLING, BILLING_PARAMS, API>;

package/src/normalizers/factories/useCartFactory.d.ts

@@ -0,0 +1,45 @@
+import { CustomQuery, UseCart, Context, FactoryParams, PlatformApi } from '../types';
+export interface UseCartFactoryParams<CART, CART_ITEM, PRODUCT, API extends PlatformApi = any> extends FactoryParams<API> {
+    load: (context: Context, params: {
+        customQuery?: any;
+    }) => Promise<CART>;
+    addItem: (context: Context, params: {
+        currentCart: CART;
+        product: PRODUCT;
+        quantity: any;
+        customQuery?: CustomQuery;
+    }) => Promise<CART>;
+    removeItem: (context: Context, params: {
+        currentCart: CART;
+        product: CART_ITEM;
+        customQuery?: CustomQuery;
+    }) => Promise<CART>;
+    updateItemQty: (context: Context, params: {
+        currentCart: CART;
+        product: CART_ITEM;
+        quantity: number;
+        customQuery?: CustomQuery;
+    }) => Promise<CART>;
+    clear: (context: Context, params: {
+        currentCart: CART;
+    }) => Promise<CART>;
+    applyCoupon: (context: Context, params: {
+        currentCart: CART;
+        couponCode: string;
+        customQuery?: CustomQuery;
+    }) => Promise<{
+        updatedCart: CART;
+    }>;
+    removeCoupon: (context: Context, params: {
+        currentCart: CART;
+        couponCode: string;
+        customQuery?: CustomQuery;
+    }) => Promise<{
+        updatedCart: CART;
+    }>;
+    isInCart: (context: Context, params: {
+        currentCart: CART;
+        product: PRODUCT;
+    }) => boolean;
+}
+export declare const useCartFactory: <CART, CART_ITEM, PRODUCT, API extends PlatformApi = any>(factoryParams: UseCartFactoryParams<CART, CART_ITEM, PRODUCT, API>) => () => UseCart<CART, CART_ITEM, PRODUCT, API>;

package/src/normalizers/factories/useCategoryFactory.d.ts

@@ -0,0 +1,7 @@
+import { CustomQuery, UseCategory, Context, FactoryParams, PlatformApi } from '../types';
+export interface UseCategoryFactoryParams<CATEGORY, CATEGORY_SEARCH_PARAMS, API extends PlatformApi = any> extends FactoryParams<API> {
+    categorySearch: (context: Context, params: CATEGORY_SEARCH_PARAMS & {
+        customQuery?: CustomQuery;
+    }) => Promise<CATEGORY[]>;
+}
+export declare function useCategoryFactory<CATEGORY, CATEGORY_SEARCH_PARAMS, API extends PlatformApi = any>(factoryParams: UseCategoryFactoryParams<CATEGORY, CATEGORY_SEARCH_PARAMS, API>): (id: string) => UseCategory<CATEGORY, CATEGORY_SEARCH_PARAMS, API>;

package/src/normalizers/factories/useContentFactory.d.ts

@@ -0,0 +1,16 @@
+import { RenderComponent, UseContent, Context, FactoryParams, PlatformApi } from '../types';
+import type { PropType } from 'vue'
+
+export interface UseContentFactoryParams<CONTENT, CONTENT_SEARCH_PARAMS, API extends PlatformApi = any> extends FactoryParams<API> {
+    search: (context: Context, params: CONTENT_SEARCH_PARAMS) => Promise<CONTENT>;
+}
+export declare function useContentFactory<CONTENT, CONTENT_SEARCH_PARAMS, API extends PlatformApi = any>(factoryParams: UseContentFactoryParams<CONTENT, CONTENT_SEARCH_PARAMS, API>): (id: string) => UseContent<CONTENT, CONTENT_SEARCH_PARAMS, API>;
+export declare type RenderContentFactoryParams<CONTENT = any> = {
+    extractContent: (content: any) => CONTENT;
+};
+export declare function renderContentFactory(factoryParams: RenderContentFactoryParams<RenderComponent[]>): {
+    render: (createElement: any) => any;
+    props: {
+        content: PropType<any>;
+    };
+};

package/src/normalizers/factories/useFacetFactory.d.ts

@@ -0,0 +1,6 @@
+import { UseFacet, FacetSearchResult, Context, FactoryParams } from '../types';
+export interface UseFacetFactoryParams<SEARCH_DATA> extends FactoryParams {
+    search: (context: Context, params?: FacetSearchResult<SEARCH_DATA>) => Promise<SEARCH_DATA>;
+}
+declare const useFacetFactory: <SEARCH_DATA>(factoryParams: UseFacetFactoryParams<SEARCH_DATA>) => (id?: string) => UseFacet<SEARCH_DATA>;
+export { useFacetFactory };

package/src/normalizers/factories/useForgotPasswordFactory.d.ts

@@ -0,0 +1,20 @@
+import { CustomQuery, Context, FactoryParams, UseForgotPassword } from '../types';
+interface SetNewPasswordParams {
+    tokenValue: string;
+    newPassword: string;
+}
+interface ResetPasswordParams {
+    email: string;
+}
+export interface UseForgotPasswordFactoryParams<RESULT> extends FactoryParams {
+    resetPassword: (context: Context, params: ResetPasswordParams & {
+        currentResult: RESULT;
+        customQuery?: CustomQuery;
+    }) => Promise<RESULT>;
+    setNewPassword: (context: Context, params: SetNewPasswordParams & {
+        currentResult: RESULT;
+        customQuery?: CustomQuery;
+    }) => Promise<RESULT>;
+}
+export declare function useForgotPasswordFactory<RESULT>(factoryParams: UseForgotPasswordFactoryParams<RESULT>): () => UseForgotPassword<RESULT>;
+export {};

package/src/normalizers/factories/useMakeOrderFactory.d.ts

@@ -0,0 +1,7 @@
+import { CustomQuery, Context, FactoryParams, UseMakeOrder, PlatformApi } from '../types';
+export interface UseMakeOrderFactoryParams<ORDER, API extends PlatformApi = any> extends FactoryParams<API> {
+    make: (context: Context, params: {
+        customQuery?: CustomQuery;
+    }) => Promise<ORDER>;
+}
+export declare const useMakeOrderFactory: <ORDER, API extends PlatformApi = any>(factoryParams: UseMakeOrderFactoryParams<ORDER, API>) => () => UseMakeOrder<ORDER, API>;

package/src/normalizers/factories/useProductFactory.d.ts

@@ -0,0 +1,7 @@
+import { CustomQuery, ProductsSearchParams, UseProduct, Context, FactoryParams, PlatformApi } from '../types';
+export interface UseProductFactoryParams<PRODUCTS, PRODUCT_SEARCH_PARAMS extends ProductsSearchParams, API extends PlatformApi = any> extends FactoryParams<API> {
+    productsSearch: (context: Context, params: PRODUCT_SEARCH_PARAMS & {
+        customQuery?: CustomQuery;
+    }) => Promise<PRODUCTS>;
+}
+export declare function useProductFactory<PRODUCTS, PRODUCT_SEARCH_PARAMS extends ProductsSearchParams, API extends PlatformApi = any>(factoryParams: UseProductFactoryParams<PRODUCTS, PRODUCT_SEARCH_PARAMS, API>): (id: string) => UseProduct<PRODUCTS, PRODUCT_SEARCH_PARAMS, API>;

package/src/normalizers/factories/useReviewFactory.d.ts

@@ -0,0 +1,10 @@
+import { CustomQuery, UseReview, Context, FactoryParams, PlatformApi } from '../types';
+export interface UseReviewFactoryParams<REVIEW, REVIEWS_SEARCH_PARAMS, REVIEW_ADD_PARAMS, API extends PlatformApi = any> extends FactoryParams<API> {
+    searchReviews: (context: Context, params: REVIEWS_SEARCH_PARAMS & {
+        customQuery?: CustomQuery;
+    }) => Promise<REVIEW>;
+    addReview: (context: Context, params: REVIEW_ADD_PARAMS & {
+        customQuery?: CustomQuery;
+    }) => Promise<REVIEW>;
+}
+export declare function useReviewFactory<REVIEW, REVIEWS_SEARCH_PARAMS, REVIEW_ADD_PARAMS, API extends PlatformApi = any>(factoryParams: UseReviewFactoryParams<REVIEW, REVIEWS_SEARCH_PARAMS, REVIEW_ADD_PARAMS, API>): (id: string) => UseReview<REVIEW, REVIEWS_SEARCH_PARAMS, REVIEW_ADD_PARAMS>;

package/src/normalizers/factories/useSearchFactory.d.ts

@@ -0,0 +1,7 @@
+import { CustomQuery, UseSearch, Context, FactoryParams } from '../types';
+export interface UseSearchFactoryParams<RESULT, SEARCH_PARAMS> extends FactoryParams {
+    search: (context: Context, params: SEARCH_PARAMS & {
+        customQuery?: CustomQuery;
+    }) => Promise<RESULT>;
+}
+export declare function useSearchFactory<RESULT, SEARCH_PARAMS>(factoryParams: UseSearchFactoryParams<RESULT, SEARCH_PARAMS>): (id: string) => UseSearch<RESULT, SEARCH_PARAMS>;

package/src/normalizers/factories/useShippingFactory.d.ts

@@ -0,0 +1,12 @@
+import { UseShipping, Context, FactoryParams, CustomQuery, PlatformApi } from '../types';
+export interface UseShippingParams<SHIPPING, SHIPPING_PARAMS, API extends PlatformApi = any> extends FactoryParams<API> {
+    load: (context: Context, params: {
+        customQuery?: CustomQuery;
+    }) => Promise<SHIPPING>;
+    save: (context: Context, params: {
+        params: SHIPPING_PARAMS;
+        shippingDetails: SHIPPING;
+        customQuery?: CustomQuery;
+    }) => Promise<SHIPPING>;
+}
+export declare const useShippingFactory: <SHIPPING, SHIPPING_PARAMS, API extends PlatformApi = any>(factoryParams: UseShippingParams<SHIPPING, SHIPPING_PARAMS, API>) => () => UseShipping<SHIPPING, SHIPPING_PARAMS, API>;

package/src/normalizers/factories/useShippingProviderFactory.d.ts

@@ -0,0 +1,14 @@
+import { UseShippingProvider, Context, FactoryParams, CustomQuery, PlatformApi } from '../types';
+import { Ref } from 'vue';
+export interface UseShippingProviderParams<STATE, SHIPPING_METHOD, API extends PlatformApi = any> extends FactoryParams<API> {
+    load: (context: Context, params: {
+        state: Ref<STATE>;
+        customQuery?: CustomQuery;
+    }) => Promise<STATE>;
+    save: (context: Context, params: {
+        state: Ref<STATE>;
+        shippingMethod: SHIPPING_METHOD;
+        customQuery?: CustomQuery;
+    }) => Promise<STATE>;
+}
+export declare const useShippingProviderFactory: <STATE, SHIPPING_METHOD, API extends PlatformApi = any>(factoryParams: UseShippingProviderParams<STATE, SHIPPING_METHOD, API>) => () => UseShippingProvider<STATE, SHIPPING_METHOD, API>;

package/src/normalizers/factories/useStoreFactory.d.ts

@@ -0,0 +1,2 @@
+import { UseStoreFactoryParams, UseStore } from '../types';
+export declare function useStoreFactory<STORES>(factoryParams: UseStoreFactoryParams<STORES>): UseStore<STORES>;