@diphyx/harlemify 0.0.2 → 1.0.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Amir Reza Dalir
+Copyright (c) 2026 DiPhyx
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,16 +1,18 @@
 # Harlemify
 
-API state management for Nuxt powered by [Harlem](https://harlemjs.com/)
+> Schema-driven state management for Nuxt powered by [Harlem](https://harlemjs.com/)
 
 ![Harlemify](https://raw.githubusercontent.com/diphyx/harlemify/main/docs/_media/icon.svg)
 
+Define your data schema once with Zod, and Harlemify handles the rest: type-safe API calls, reactive state, request monitoring, and automatic memory management. Your schema becomes the single source of truth for types, validation, and API payloads.
+
 ## Features
 
-- Zod schema validation with field metadata
-- Automatic API client with runtime config
-- CRUD operations with endpoint status tracking
-- Type-safe endpoint URL parameters
-- SSR support via Harlem SSR plugin
+- **Schema-Driven** - Zod schema defines types, validation, and API payloads
+- **Automatic API Client** - Built-in HTTP client with runtime configuration
+- **Reactive Memory** - Unit and collection caching with Vue reactivity
+- **Request Monitoring** - Track pending, success, and failed states
+- **SSR Support** - Server-side rendering via Harlem SSR plugin
 
 ## Installation
 
@@ -34,39 +36,35 @@ export default defineNuxtConfig({
 
 ```typescript
 // stores/user.ts
-import { z, createStore, Endpoint, ApiAction } from "@diphyx/harlemify";
+import { z } from "zod";
+import { createStore, Endpoint, EndpointMethod } from "@diphyx/harlemify";
 
 const UserSchema = z.object({
-    id: z.number().meta({
-        indicator: true,
-    }),
+    id: z.number().meta({ indicator: true }),
     name: z.string().meta({
-        actions: [ApiAction.POST, ApiAction.PATCH],
+        methods: [EndpointMethod.POST, EndpointMethod.PATCH],
     }),
 });
 
 export type User = z.infer<typeof UserSchema>;
 
 export const userStore = createStore("user", UserSchema, {
-    [Endpoint.GET_UNITS]: {
-        action: ApiAction.GET,
-        url: "/users",
-    },
-    [Endpoint.POST_UNITS]: {
-        action: ApiAction.POST,
-        url: "/users",
-    },
-    [Endpoint.PATCH_UNITS]: {
-        action: ApiAction.PATCH,
-        url: (params) => `/users/${params.id}`,
-    },
-    [Endpoint.DELETE_UNITS]: {
-        action: ApiAction.DELETE,
-        url: (params) => `/users/${params.id}`,
-    },
+    [Endpoint.GET_UNITS]: { method: EndpointMethod.GET, url: "/users" },
+    [Endpoint.POST_UNITS]: { method: EndpointMethod.POST, url: "/users" },
+    [Endpoint.PATCH_UNITS]: { method: EndpointMethod.PATCH, url: (p) => `/users/${p.id}` },
+    [Endpoint.DELETE_UNITS]: { method: EndpointMethod.DELETE, url: (p) => `/users/${p.id}` },
 });
 ```
 
+## Why Harlemify?
+
+|                 |                                                   |
+| --------------- | ------------------------------------------------- |
+| **Type-Safe**   | Full TypeScript support with Zod schema inference |
+| **Declarative** | Define schema once, derive everything else        |
+| **Reactive**    | Powered by Vue's reactivity through Harlem        |
+| **Simple**      | Minimal boilerplate, maximum productivity         |
+
 ## Documentation
 
 Full documentation available at [https://diphyx.github.io/harlemify/](https://diphyx.github.io/harlemify/)

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.0.0 || >=4.0.0"
   },
-  "version": "0.0.2",
+  "version": "1.0.0",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -15,6 +15,8 @@ const module = defineNuxtModule({
     const { resolve } = createResolver(import.meta.url);
     addPlugin(resolve("./runtime", "plugin"));
     addImportsDir(resolve("./runtime", "core"));
+    addImportsDir(resolve("./runtime", "composables"));
+    addImportsDir(resolve("./runtime", "utils"));
     updateRuntimeConfig({
       public: {
         harlemify: options

package/dist/runtime/composables/use.d.ts

@@ -0,0 +1,30 @@
+import type { ComputedRef } from "vue";
+import { EndpointMethod } from "../utils/endpoint.js";
+import type { Store } from "../core/store.js";
+import type { Pluralize, Capitalize } from "../utils/transform.js";
+import type { EndpointStatusFlag } from "../utils/endpoint.js";
+type Indicator<T, I extends keyof T> = Required<Pick<T, I>>;
+type PartialWithIndicator<T, I extends keyof T> = Indicator<T, I> & Partial<T>;
+type MemoryState<E extends string, T> = {
+    [P in E]: ComputedRef<T | null>;
+} & {
+    [P in Pluralize<E>]: ComputedRef<T[]>;
+};
+type MemoryAction<A extends string, E extends string, U> = {
+    [K in `${A}${Capitalize<E>}`]: (unit: U) => void;
+} & {
+    [K in `${A}${Capitalize<Pluralize<E>>}`]: (units: U[]) => void;
+};
+type EndpointAction<E extends string, T> = {
+    [M in EndpointMethod as `${M}${Capitalize<E>}`]: (unit?: Partial<T>) => Promise<T>;
+} & {
+    [M in EndpointMethod as `${M}${Capitalize<Pluralize<E>>}`]: (units?: Partial<T>[]) => Promise<T[]>;
+};
+type EndpointMonitor<E extends string> = {
+    [M in EndpointMethod as `${M}${Capitalize<E>}${EndpointStatusFlag}`]: ComputedRef<boolean>;
+} & {
+    [M in EndpointMethod as `${M}${Capitalize<Pluralize<E>>}${EndpointStatusFlag}`]: ComputedRef<boolean>;
+};
+type StoreAlias<E extends string, T, I extends keyof T = keyof T> = MemoryState<E, T> & MemoryAction<"set", E, T | null> & MemoryAction<"edit", E, PartialWithIndicator<T, I>> & MemoryAction<"drop", E, PartialWithIndicator<T, I>> & EndpointAction<E, T> & EndpointMonitor<E>;
+export declare function useStoreAlias<E extends string, T, I extends keyof T = keyof T>(store: Store<E, T, I>): StoreAlias<E, T, I>;
+export {};

package/dist/runtime/composables/use.js

@@ -0,0 +1,25 @@
+import { capitalize } from "../utils/transform.js";
+import { EndpointMethod, EndpointStatus, makeEndpointStatusFlag } from "../utils/endpoint.js";
+import { StoreMemoryAction } from "../core/store.js";
+export function useStoreAlias(store) {
+  const capitalizedUnit = capitalize(store.alias.unit);
+  const capitalizedUnits = capitalize(store.alias.units);
+  const output = {
+    [store.alias.unit]: store.unit,
+    [store.alias.units]: store.units
+  };
+  for (const action of Object.values(StoreMemoryAction)) {
+    output[`${action}${capitalizedUnit}`] = store.memory[`${action}Unit`];
+    output[`${action}${capitalizedUnits}`] = store.memory[`${action}Units`];
+  }
+  for (const method of Object.values(EndpointMethod)) {
+    output[`${method}${capitalizedUnit}`] = store.endpoint[`${method}Unit`];
+    output[`${method}${capitalizedUnits}`] = store.endpoint[`${method}Units`];
+    for (const status of Object.values(EndpointStatus)) {
+      const statusFlag = makeEndpointStatusFlag(status);
+      output[`${method}${capitalizedUnit}${statusFlag}`] = store.monitor[`${method}Unit${statusFlag}`];
+      output[`${method}${capitalizedUnits}${statusFlag}`] = store.monitor[`${method}Units${statusFlag}`];
+    }
+  }
+  return output;
+}

package/dist/runtime/core/api.d.ts

@@ -1,11 +1,5 @@
-import { type MaybeRefOrGetter } from "vue";
-export declare enum ApiAction {
-    GET = "get",
-    POST = "post",
-    PUT = "put",
-    PATCH = "patch",
-    DELETE = "delete"
-}
+import type { MaybeRefOrGetter } from "vue";
+import { EndpointMethod } from "../utils/endpoint.js";
 export declare enum ApiResponseType {
     JSON = "json",
     TEXT = "text",
@@ -19,15 +13,17 @@ export declare enum ApiErrorSource {
 export type ApiRequestHeader = MaybeRefOrGetter<Record<string, unknown>>;
 export type ApiRequestQuery = MaybeRefOrGetter<Record<string, unknown>>;
 export type ApiRequestBody = MaybeRefOrGetter<string | number | ArrayBuffer | FormData | Blob | Record<string, any>>;
-export interface ApiRequestOptions<A extends ApiAction = ApiAction, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody> {
+export interface ApiRequestOptions<A extends EndpointMethod = EndpointMethod, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody> {
     action?: A;
     headers?: H;
     query?: Q;
     body?: B;
+    timeout?: number;
     responseType?: ApiResponseType;
     retry?: number | false;
     retryDelay?: number;
     retryStatusCodes?: number[];
+    signal?: AbortSignal;
 }
 export interface ApiOptions {
     url?: string;
@@ -35,7 +31,7 @@ export interface ApiOptions {
     query?: ApiRequestQuery;
     timeout?: number;
 }
-export type ApiActionOptions<A extends ApiAction, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody> = Omit<ApiRequestOptions<A, H, Q, B>, "action">;
+export type EndpointMethodOptions<A extends EndpointMethod, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody> = Omit<ApiRequestOptions<A, H, Q, B>, "action">;
 export interface ApiErrorOptions {
     source: ApiErrorSource;
     method: string;
@@ -54,10 +50,11 @@ export declare class ApiRequestError extends ApiError {
 export declare class ApiResponseError extends ApiError {
     constructor(options: Omit<ApiErrorOptions, "source">);
 }
-export declare function createApi(options?: ApiOptions): {
-    get: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery>(url: string, options?: ApiActionOptions<ApiAction.GET, H, Q, never>) => Promise<T>;
-    post: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: ApiActionOptions<ApiAction.POST, H, Q, B>) => Promise<T>;
-    put: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: ApiActionOptions<ApiAction.PUT, H, Q, B>) => Promise<T>;
-    patch: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: ApiActionOptions<ApiAction.PATCH, H, Q, B>) => Promise<T>;
-    del: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery>(url: string, options?: ApiActionOptions<ApiAction.DELETE, H, Q, never>) => Promise<T>;
-};
+export interface Api {
+    get: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery>(url: string, options?: EndpointMethodOptions<EndpointMethod.GET, H, Q, never>) => Promise<T>;
+    post: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: EndpointMethodOptions<EndpointMethod.POST, H, Q, B>) => Promise<T>;
+    put: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: EndpointMethodOptions<EndpointMethod.PUT, H, Q, B>) => Promise<T>;
+    patch: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody>(url: string, options?: EndpointMethodOptions<EndpointMethod.PATCH, H, Q, B>) => Promise<T>;
+    del: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery>(url: string, options?: EndpointMethodOptions<EndpointMethod.DELETE, H, Q, never>) => Promise<T>;
+}
+export declare function createApi(options?: ApiOptions): Api;

package/dist/runtime/core/api.js

@@ -1,12 +1,5 @@
 import { toValue } from "vue";
-export var ApiAction = /* @__PURE__ */ ((ApiAction2) => {
-  ApiAction2["GET"] = "get";
-  ApiAction2["POST"] = "post";
-  ApiAction2["PUT"] = "put";
-  ApiAction2["PATCH"] = "patch";
-  ApiAction2["DELETE"] = "delete";
-  return ApiAction2;
-})(ApiAction || {});
+import { EndpointMethod } from "../utils/endpoint.js";
 export var ApiResponseType = /* @__PURE__ */ ((ApiResponseType2) => {
   ApiResponseType2["JSON"] = "json";
   ApiResponseType2["TEXT"] = "text";
@@ -24,7 +17,7 @@ export class ApiError extends Error {
   method;
   url;
   constructor(options) {
-    super(options.message || "Unknown error");
+    super(options.message ?? "Unknown error");
     this.name = "ApiError";
     this.source = options.source;
     this.method = options.method;
@@ -51,7 +44,7 @@ export function createApi(options) {
   async function request(url, requestOptions) {
     return $fetch(url, {
       baseURL: options?.url,
-      method: requestOptions?.action ?? "get" /* GET */,
+      method: requestOptions?.action ?? EndpointMethod.GET,
       headers: {
         ...toValue(options?.headers),
         ...toValue(requestOptions?.headers)
@@ -66,6 +59,7 @@ export function createApi(options) {
       retry: requestOptions?.retry,
       retryDelay: requestOptions?.retryDelay,
       retryStatusCodes: requestOptions?.retryStatusCodes,
+      signal: requestOptions?.signal,
       onRequestError({ request: request2, options: options2, error }) {
         throw new ApiRequestError({
           method: options2.method,
@@ -85,31 +79,31 @@ export function createApi(options) {
   async function get(url, options2) {
     return request(url, {
       ...options2,
-      action: "get" /* GET */
+      action: EndpointMethod.GET
     });
   }
   async function post(url, options2) {
     return request(url, {
       ...options2,
-      action: "post" /* POST */
+      action: EndpointMethod.POST
     });
   }
   async function put(url, options2) {
     return request(url, {
       ...options2,
-      action: "put" /* PUT */
+      action: EndpointMethod.PUT
     });
   }
   async function patch(url, options2) {
     return request(url, {
       ...options2,
-      action: "patch" /* PATCH */
+      action: EndpointMethod.PATCH
     });
   }
   async function del(url, options2) {
     return request(url, {
       ...options2,
-      action: "delete" /* DELETE */
+      action: EndpointMethod.DELETE
     });
   }
   return {

package/dist/runtime/core/store.d.ts

@@ -1,106 +1,74 @@
-import { z } from "zod";
-import { type Extension, type BaseState } from "@harlem/core";
-import { Endpoint, type EndpointDefinition, type EndpointMemory } from "../utils/endpoint.js";
+import type { z } from "zod";
+import type { ComputedRef } from "vue";
+import type { Extension, BaseState } from "@harlem/core";
+import { Endpoint, EndpointStatus } from "../utils/endpoint.js";
+import type { EndpointMethodOptions, ApiOptions } from "./api.js";
+import type { EndpointDefinition, EndpointStatusName } from "../utils/endpoint.js";
+import type { Pluralize } from "../utils/transform.js";
+export declare enum StoreMemoryAction {
+    SET = "set",
+    EDIT = "edit",
+    DROP = "drop"
+}
 export declare enum StoreMemoryPosition {
     FIRST = "first",
     LAST = "last"
 }
-import { ApiAction, type ApiActionOptions, type ApiOptions } from "./api.js";
-export declare function createStore<T extends z.ZodRawShape, K extends keyof z.infer<z.ZodObject<T>> = "id" & keyof z.infer<z.ZodObject<T>>>(name: string, schema: z.ZodObject<T>, endpoints?: Partial<Record<Endpoint, EndpointDefinition<Partial<z.infer<z.ZodObject<T>>>>>>, options?: {
+export interface StoreHooks {
+    before?: () => Promise<void> | void;
+    after?: (error?: Error) => Promise<void> | void;
+}
+export interface StoreOptions {
     api?: ApiOptions;
+    indicator?: string;
+    hooks?: StoreHooks;
     extensions?: Extension<BaseState>[];
-}): {
-    api: () => {
-        get: <T_1, H extends import("./api").ApiRequestHeader = import("./api").ApiRequestHeader, Q extends import("./api").ApiRequestQuery = import("./api").ApiRequestQuery>(url: string, options?: ApiActionOptions<ApiAction.GET, H, Q, never>) => Promise<T_1>;
-        post: <T_1, H extends import("./api").ApiRequestHeader = import("./api").ApiRequestHeader, Q extends import("./api").ApiRequestQuery = import("./api").ApiRequestQuery, B extends import("./api").ApiRequestBody = import("./api").ApiRequestBody>(url: string, options?: ApiActionOptions<ApiAction.POST, H, Q, B>) => Promise<T_1>;
-        put: <T_1, H extends import("./api").ApiRequestHeader = import("./api").ApiRequestHeader, Q extends import("./api").ApiRequestQuery = import("./api").ApiRequestQuery, B extends import("./api").ApiRequestBody = import("./api").ApiRequestBody>(url: string, options?: ApiActionOptions<ApiAction.PUT, H, Q, B>) => Promise<T_1>;
-        patch: <T_1, H extends import("./api").ApiRequestHeader = import("./api").ApiRequestHeader, Q extends import("./api").ApiRequestQuery = import("./api").ApiRequestQuery, B extends import("./api").ApiRequestBody = import("./api").ApiRequestBody>(url: string, options?: ApiActionOptions<ApiAction.PATCH, H, Q, B>) => Promise<T_1>;
-        del: <T_1, H extends import("./api").ApiRequestHeader = import("./api").ApiRequestHeader, Q extends import("./api").ApiRequestQuery = import("./api").ApiRequestQuery>(url: string, options?: ApiActionOptions<ApiAction.DELETE, H, Q, never>) => Promise<T_1>;
-    };
-    store: Omit<import("@harlem/core").Store<{
-        memory: {
-            unit: z.core.$InferObjectOutput<T, {}> | null;
-            units: z.core.$InferObjectOutput<T, {}>[];
-        };
-        endpoints: Record<Endpoint, EndpointMemory>;
-    }>, never>;
-    memorizedUnit: import("@vue/reactivity").ComputedRef<import("@vue/reactivity").DeepReadonly<z.core.$InferObjectOutput<T, {}>> | null>;
-    memorizedUnits: import("@vue/reactivity").ComputedRef<readonly import("@vue/reactivity").DeepReadonly<z.core.$InferObjectOutput<T, {}>>[]>;
-    hasMemorizedUnits: (...units: (Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>)[]) => Record<string | number, boolean>;
-    endpointsStatus: {
-        getUnitIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        getUnitIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        getUnitIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        getUnitIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        getUnitsIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        getUnitsIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        getUnitsIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        getUnitsIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        postUnitIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        postUnitIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        postUnitIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        postUnitIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        postUnitsIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        postUnitsIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        postUnitsIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        postUnitsIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        putUnitIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        putUnitIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        putUnitIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        putUnitIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        putUnitsIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        putUnitsIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        putUnitsIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        putUnitsIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        patchUnitIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        patchUnitIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        patchUnitIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        patchUnitIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        patchUnitsIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        patchUnitsIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        patchUnitsIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        patchUnitsIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        deleteUnitIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        deleteUnitIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        deleteUnitIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        deleteUnitIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
-        deleteUnitsIsIdle: import("@vue/reactivity").ComputedRef<boolean>;
-        deleteUnitsIsPending: import("@vue/reactivity").ComputedRef<boolean>;
-        deleteUnitsIsSuccess: import("@vue/reactivity").ComputedRef<boolean>;
-        deleteUnitsIsFailed: import("@vue/reactivity").ComputedRef<boolean>;
+}
+type Indicator<T, I extends keyof T> = Required<Pick<T, I>>;
+type WithIndicator<T, I extends keyof T> = Indicator<T, I> & T;
+type PartialWithIndicator<T, I extends keyof T> = Indicator<T, I> & Partial<T>;
+type StoreEndpointReadOptions = Omit<EndpointMethodOptions<any>, "body">;
+type StoreEndpointWriteOptions = EndpointMethodOptions<any> & {
+    validate?: boolean;
+};
+type StoreEndpointWriteMultipleOptions = StoreEndpointWriteOptions & {
+    position?: StoreMemoryPosition;
+};
+type StoreMemory<T = unknown, I extends keyof T = keyof T> = {
+    setUnit: (unit: T | null) => void;
+    setUnits: (units: T[]) => void;
+    editUnit: (unit: PartialWithIndicator<T, I>) => void;
+    editUnits: (units: PartialWithIndicator<T, I>[]) => void;
+    dropUnit: (unit: PartialWithIndicator<T, I>) => void;
+    dropUnits: (units: PartialWithIndicator<T, I>[]) => void;
+};
+type StoreEndpoint<T = unknown, I extends keyof T = keyof T> = {
+    getUnit: (unit?: PartialWithIndicator<T, I>, options?: StoreEndpointReadOptions) => Promise<T>;
+    getUnits: (options?: StoreEndpointReadOptions) => Promise<T[]>;
+    postUnit: (unit: WithIndicator<T, I>, options?: StoreEndpointWriteOptions) => Promise<T>;
+    postUnits: (units: WithIndicator<T, I>[], options?: StoreEndpointWriteMultipleOptions) => Promise<T[]>;
+    putUnit: (unit: WithIndicator<T, I>, options?: StoreEndpointWriteOptions) => Promise<T>;
+    putUnits: (units: WithIndicator<T, I>[], options?: StoreEndpointWriteOptions) => Promise<T[]>;
+    patchUnit: (unit: PartialWithIndicator<T, I>, options?: StoreEndpointWriteOptions) => Promise<Partial<T>>;
+    patchUnits: (units: PartialWithIndicator<T, I>[], options?: StoreEndpointWriteOptions) => Promise<Partial<T>[]>;
+    deleteUnit: (unit: PartialWithIndicator<T, I>, options?: StoreEndpointReadOptions) => Promise<boolean>;
+    deleteUnits: (units: PartialWithIndicator<T, I>[], options?: StoreEndpointReadOptions) => Promise<boolean>;
+};
+type StoreMonitor = {
+    [K in Endpoint as EndpointStatusName<K, EndpointStatus>]: ComputedRef<boolean>;
+};
+export type Store<E extends string = string, T = unknown, I extends keyof T = keyof T> = {
+    store: any;
+    alias: {
+        unit: E;
+        units: Pluralize<E>;
     };
-    setMemorizedUnit: import("@harlem/core").Mutation<z.core.$InferObjectOutput<T, {}> | null, void>;
-    setMemorizedUnits: (payload: z.core.$InferObjectOutput<T, {}>[]) => void;
-    editMemorizedUnit: import("@harlem/core").Mutation<Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>, void>;
-    editMemorizedUnits: (payload: (Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>)[]) => void;
-    dropMemorizedUnit: import("@harlem/core").Mutation<Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>, void>;
-    dropMemorizedUnits: (payload: (Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>)[]) => void;
-    patchEndpointMemory: (payload: {
-        key: Endpoint;
-        memory: EndpointMemory;
-    }) => void;
-    purgeEndpointMemory: (payload?: unknown) => void;
-    getUnit: (unit?: Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>, options?: Omit<ApiActionOptions<ApiAction.GET>, "body">) => Promise<z.core.$InferObjectOutput<T, {}>>;
-    getUnits: (options?: Omit<ApiActionOptions<ApiAction.GET>, "body">) => Promise<z.core.$InferObjectOutput<T, {}>[]>;
-    postUnit: (unit: Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & z.core.$InferObjectOutput<T, {}>, options?: ApiActionOptions<ApiAction.POST> & {
-        validate?: boolean;
-    }) => Promise<Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & z.core.$InferObjectOutput<T, {}>>;
-    postUnits: (units: (Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & z.core.$InferObjectOutput<T, {}>)[], options?: ApiActionOptions<ApiAction.POST> & {
-        validate?: boolean;
-        position?: StoreMemoryPosition;
-    }) => Promise<(Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & z.core.$InferObjectOutput<T, {}>)[]>;
-    putUnit: (unit: Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & z.core.$InferObjectOutput<T, {}>, options?: ApiActionOptions<ApiAction.PUT> & {
-        validate?: boolean;
-    }) => Promise<Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & z.core.$InferObjectOutput<T, {}>>;
-    putUnits: (units: (Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & z.core.$InferObjectOutput<T, {}>)[], options?: ApiActionOptions<ApiAction.PUT> & {
-        validate?: boolean;
-    }) => Promise<(Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & z.core.$InferObjectOutput<T, {}>)[]>;
-    patchUnit: (unit: Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>, options?: ApiActionOptions<ApiAction.PATCH> & {
-        validate?: boolean;
-    }) => Promise<Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>>;
-    patchUnits: (units: (Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>)[], options?: ApiActionOptions<ApiAction.PATCH> & {
-        validate?: boolean;
-    }) => Promise<(Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>)[]>;
-    deleteUnit: (unit: Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>, options?: Omit<ApiActionOptions<ApiAction.DELETE>, "body">) => Promise<boolean>;
-    deleteUnits: (units: (Required<Pick<z.core.$InferObjectOutput<T, {}>, K>> & Partial<z.core.$InferObjectOutput<T, {}>>)[], options?: Omit<ApiActionOptions<ApiAction.DELETE>, "body">) => Promise<boolean>;
+    indicator: I;
+    unit: ComputedRef<T | null>;
+    units: ComputedRef<T[]>;
+    memory: StoreMemory<T, I>;
+    endpoint: StoreEndpoint<T, I>;
+    monitor: StoreMonitor;
 };
+export declare function createStore<E extends string, T extends z.ZodRawShape, S extends z.infer<z.ZodObject<T>> = z.infer<z.ZodObject<T>>, I extends keyof S = "id" & keyof S>(entity: E, schema: z.ZodObject<T>, endpoints?: Partial<Record<Endpoint, EndpointDefinition<Partial<S>>>>, options?: StoreOptions): Store<E, S, I>;
+export {};