@diphyx/harlemify 3.0.0 → 4.0.1

package/dist/runtime/core/utils/model.js

@@ -0,0 +1,227 @@
+import { defu } from "defu";
+import { resolveShape } from "./shape.js";
+import {
+  ModelKind
+} from "../types/model.js";
+import { ActionOneMode, ActionManyMode, AUTO } from "../types/action.js";
+export function initializeState(model) {
+  const state = {};
+  for (const [key, definition] of Object.entries(model)) {
+    if (definition.kind === ModelKind.OBJECT) {
+      state[key] = definition.options?.default ?? null;
+    } else {
+      state[key] = definition.options?.default ?? [];
+    }
+  }
+  return state;
+}
+function getIdentifier(definition) {
+  if (definition.options?.identifier) {
+    return definition.options.identifier;
+  }
+  const { identifier } = resolveShape(definition.shape);
+  if (identifier) {
+    return identifier;
+  }
+  return "id";
+}
+function createOneMutations(source, definition, key) {
+  const setOperation = source.mutation(`${key}:set`, (state, value) => {
+    state[key] = value;
+  });
+  const resetOperation = source.mutation(`${key}:reset`, (state) => {
+    state[key] = definition.options?.default ?? null;
+  });
+  const patchOperation = source.mutation(`${key}:patch`, (state, payload) => {
+    if (state[key] === null) {
+      return;
+    }
+    if (payload.options?.deep) {
+      state[key] = defu(payload.value, state[key]);
+      return;
+    }
+    state[key] = {
+      ...state[key],
+      ...payload.value
+    };
+  });
+  function set(value) {
+    definition.logger?.debug("Model mutation", {
+      model: key,
+      mutation: "set"
+    });
+    setOperation(value);
+  }
+  function reset() {
+    definition.logger?.debug("Model mutation", {
+      model: key,
+      mutation: "reset"
+    });
+    resetOperation();
+  }
+  function patch(value, options) {
+    definition.logger?.debug("Model mutation", {
+      model: key,
+      mutation: "patch"
+    });
+    patchOperation({
+      value,
+      options
+    });
+  }
+  return {
+    set,
+    reset,
+    patch
+  };
+}
+function createManyMutations(source, definition, key) {
+  const identifier = getIdentifier(definition);
+  const setOperation = source.mutation(`${key}:set`, (state, value) => {
+    state[key] = value;
+  });
+  const resetOperation = source.mutation(`${key}:reset`, (state) => {
+    state[key] = definition.options?.default ?? [];
+  });
+  const patchOperation = source.mutation(
+    `${key}:patch`,
+    (state, payload) => {
+      const items = Array.isArray(payload.value) ? payload.value : [payload.value];
+      const by = payload.options?.by ?? identifier;
+      state[key] = state[key].map((item) => {
+        const found = items.find((p) => {
+          return p[by] === item[by];
+        });
+        if (!found) {
+          return item;
+        }
+        if (payload.options?.deep) {
+          return defu(found, item);
+        }
+        return {
+          ...item,
+          ...found
+        };
+      });
+    }
+  );
+  const removeOperation = source.mutation(`${key}:remove`, (state, payload) => {
+    const items = Array.isArray(payload.value) ? payload.value : [payload.value];
+    const by = payload.options?.by ?? identifier;
+    const ids = new Set(
+      items.map((item) => {
+        return item[by];
+      })
+    );
+    state[key] = state[key].filter((item) => {
+      return !ids.has(item[by]);
+    });
+  });
+  const addOperation = source.mutation(`${key}:add`, (state, payload) => {
+    let items = Array.isArray(payload.value) ? payload.value : [payload.value];
+    if (payload.options?.unique) {
+      const by = payload.options.by ?? identifier;
+      const existingIds = new Set(
+        state[key].map((item) => {
+          return item[by];
+        })
+      );
+      items = items.filter((item) => {
+        return !existingIds.has(item[by]);
+      });
+    }
+    if (payload.options?.prepend) {
+      state[key] = [...items, ...state[key]];
+      return;
+    }
+    state[key] = [...state[key], ...items];
+  });
+  function set(value) {
+    definition.logger?.debug("Model mutation", {
+      model: key,
+      mutation: "set"
+    });
+    setOperation(value);
+  }
+  function reset() {
+    definition.logger?.debug("Model mutation", {
+      model: key,
+      mutation: "reset"
+    });
+    resetOperation();
+  }
+  function patch(value, options) {
+    definition.logger?.debug("Model mutation", {
+      model: key,
+      mutation: "patch"
+    });
+    patchOperation({
+      value,
+      options
+    });
+  }
+  function remove(value, options) {
+    definition.logger?.debug("Model mutation", {
+      model: key,
+      mutation: "remove"
+    });
+    removeOperation({
+      value,
+      options
+    });
+  }
+  function add(value, options) {
+    definition.logger?.debug("Model mutation", {
+      model: key,
+      mutation: "add"
+    });
+    addOperation({
+      value,
+      options
+    });
+  }
+  return {
+    set,
+    reset,
+    patch,
+    remove,
+    add
+  };
+}
+export function createMutations(source, model) {
+  const mutations = {};
+  for (const [key, definition] of Object.entries(model)) {
+    definition.logger?.debug("Model registered", {
+      model: key,
+      kind: definition.kind
+    });
+    if (definition.kind === ModelKind.OBJECT) {
+      mutations[key] = createOneMutations(source, definition, key);
+    } else {
+      mutations[key] = createManyMutations(source, definition, key);
+    }
+  }
+  return mutations;
+}
+export function executeCommit(definition, mutations, result) {
+  const handler = mutations[definition.model][definition.mode];
+  switch (definition.mode) {
+    case ActionOneMode.RESET:
+    case ActionManyMode.RESET: {
+      handler();
+      break;
+    }
+    default: {
+      handler(
+        definition.value === AUTO || definition.value === void 0 ? result : definition.value,
+        definition.options
+      );
+    }
+  }
+}
+export function createCommitter(mutations) {
+  function committer(model, mode, value, options) {
+    executeCommit({ model, mode, value, options }, mutations);
+  }
+  return committer;
+}

package/dist/runtime/core/utils/shape.d.ts

@@ -0,0 +1,3 @@
+import type { z } from "zod";
+import type { ShapeMeta } from "../types/shape.js";
+export declare function resolveShape(shape: z.ZodObject<z.ZodRawShape>): ShapeMeta;

package/dist/runtime/core/utils/shape.js

@@ -0,0 +1,29 @@
+export function resolveShape(shape) {
+  const meta = {
+    identifier: void 0,
+    defaults: {},
+    fields: []
+  };
+  for (const [key, field] of Object.entries(shape.shape)) {
+    meta.fields.push(key);
+    const fieldDefinition = field.def;
+    if (fieldDefinition?.meta?.identifier) {
+      meta.identifier = key;
+    }
+    if (fieldDefinition?.defaultValue !== void 0) {
+      if (typeof fieldDefinition.defaultValue === "function") {
+        meta.defaults[key] = fieldDefinition.defaultValue();
+        continue;
+      }
+      meta.defaults[key] = fieldDefinition.defaultValue;
+    }
+  }
+  if (!meta.identifier) {
+    if (meta.fields.includes("id")) {
+      meta.identifier = "id";
+    } else if (meta.fields.includes("_id")) {
+      meta.identifier = "_id";
+    }
+  }
+  return meta;
+}

package/dist/runtime/core/utils/view.d.ts

@@ -0,0 +1,5 @@
+import type { Store as SourceStore, BaseState } from "@harlem/core";
+import type { StoreView } from "../store.js";
+import type { Model } from "../types/model.js";
+import type { ViewDefinitions } from "../types/view.js";
+export declare function createView<M extends Model, VD extends ViewDefinitions<M>>(source: SourceStore<BaseState>, definitions: VD): StoreView<M, VD>;

package/dist/runtime/core/utils/view.js

@@ -0,0 +1,19 @@
+export function createView(source, definitions) {
+  const view = {};
+  for (const [key, definition] of Object.entries(definitions)) {
+    definition.logger?.debug("View registered", {
+      view: key,
+      sources: definition.sources
+    });
+    view[key] = source.getter(key, (state) => {
+      const values = definition.sources.map((sourceKey) => {
+        return state[sourceKey];
+      });
+      if (definition.resolver) {
+        return definition.resolver(...values);
+      }
+      return values[0];
+    });
+  }
+  return view;
+}

package/dist/runtime/index.d.ts

@@ -1,17 +1,9 @@
-export { defineApiAdapter } from "./utils/adapter.js";
-export { Endpoint, EndpointMethod, EndpointStatus, resolveEndpointUrl } from "./utils/endpoint.js";
-export { ApiErrorSource, ApiError, ApiRequestError, ApiResponseError } from "./utils/errors.js";
-export { Memory, createMemoryBuilder } from "./utils/memory.js";
-export { getMeta, resolveSchema } from "./utils/schema.js";
-export { createApi } from "./core/api.js";
 export { createStore } from "./core/store.js";
-export { useStoreAlias } from "./composables/use.js";
-export type { ApiAdapter, ApiAdapterRequest, ApiAdapterResponse, ApiFetchAdapterOptions, DefineApiAdapter, } from "./utils/adapter.js";
-export type { EndpointBuilder, EndpointChain, EndpointDefinition, EndpointUrl } from "./utils/endpoint.js";
-export type { ApiErrorOptions } from "./utils/errors.js";
-export type { MemoryBuilder, MemoryDefinition, MemoryMutation, MemoryTarget, EditOptions, AddOptions, UnitMemoryBuilder, UnitsMemoryBuilder, } from "./utils/memory.js";
-export type { SchemaMeta } from "./utils/schema.js";
-export type { Api, ApiOptions, ApiRequestBody, ApiRequestHeader, ApiRequestOptions, ApiRequestQuery, EndpointMethodOptions, } from "./core/api.js";
-export type { ActionDefinition, ActionFunction, ActionOptions, ActionStatus, ActionsConfig, Store, StoreActions, StoreHooks, StoreMemory, StoreMonitor, StoreOptions, } from "./core/store.js";
-export type { StoreAlias } from "./composables/use.js";
-export type { SharedConfig } from "./shared.js";
+export type { Store, StoreConfig } from "./core/store.js";
+export { shape } from "./core/layers/shape.js";
+export type { ShapeInfer } from "./core/types/shape.js";
+export { ModelKind } from "./core/types/model.js";
+export { AUTO, ActionOneMode, ActionManyMode, ActionStatus, ActionConcurrent, ActionApiMethod, } from "./core/types/action.js";
+export type { Action, ActionCallPayload, ActionApiShortcutDefinition, ActionError, ActionApiError, ActionHandleError, ActionCommitError, ActionConcurrentError, } from "./core/types/action.js";
+export { useIsolatedActionStatus, useIsolatedActionError } from "./composables/action.js";
+export type { RuntimeConfig } from "./config.js";

package/dist/runtime/index.js

@@ -1,8 +1,12 @@
-export { defineApiAdapter } from "./utils/adapter.js";
-export { Endpoint, EndpointMethod, EndpointStatus, resolveEndpointUrl } from "./utils/endpoint.js";
-export { ApiErrorSource, ApiError, ApiRequestError, ApiResponseError } from "./utils/errors.js";
-export { Memory, createMemoryBuilder } from "./utils/memory.js";
-export { getMeta, resolveSchema } from "./utils/schema.js";
-export { createApi } from "./core/api.js";
 export { createStore } from "./core/store.js";
-export { useStoreAlias } from "./composables/use.js";
+export { shape } from "./core/layers/shape.js";
+export { ModelKind } from "./core/types/model.js";
+export {
+  AUTO,
+  ActionOneMode,
+  ActionManyMode,
+  ActionStatus,
+  ActionConcurrent,
+  ActionApiMethod
+} from "./core/types/action.js";
+export { useIsolatedActionStatus, useIsolatedActionError } from "./composables/action.js";

package/dist/runtime/plugin.js

@@ -1,15 +1,12 @@
-import { defineNuxtPlugin, useHead } from "#imports";
 import { createVuePlugin } from "@harlem/core";
 import { createServerSSRPlugin, createClientSSRPlugin, getBridgingScript } from "@harlem/plugin-ssr";
-import config from "#build/harlemify.config";
-import { sharedConfig } from "./shared.js";
+import { defineNuxtPlugin, useHead } from "#imports";
 export default defineNuxtPlugin((nuxtApp) => {
-  sharedConfig.api = config.api;
   const plugins = [];
   if (import.meta.server) {
     plugins.push(createServerSSRPlugin());
   }
-  if (import.meta.client && window.__harlemState) {
+  if (import.meta.client && window["__harlemState"]) {
     plugins.push(createClientSSRPlugin());
   }
   const harlem = createVuePlugin({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diphyx/harlemify",
-  "version": "3.0.0",
+  "version": "4.0.1",
   "description": "API state management for Nuxt powered by Harlem",
   "keywords": [
     "nuxt",
@@ -44,6 +44,7 @@
     "@harlem/core": "^3.0.0",
     "@harlem/plugin-ssr": "^3.0.0",
     "@nuxt/kit": "^3.14.0",
+    "consola": "^3.0.0",
     "defu": "^6.0.0",
     "zod": "^4.0.0"
   },

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

@@ -1,22 +0,0 @@
-import type { ComputedRef } from "vue";
-import type { ActionFunction, ActionStatus, ActionsConfig, Store, StoreMemory } from "../core/store.js";
-import type { Capitalize, Pluralize } from "../utils/transform.js";
-type MemoryState<E extends string, T> = {
-    [P in E]: ComputedRef<T | null>;
-} & {
-    [P in Pluralize<E>]: ComputedRef<T[]>;
-};
-type AliasActions<E extends string, A extends ActionsConfig<S>, S> = {
-    [K in keyof A as `${K & string}${Capitalize<E>}`]: ActionFunction<S>;
-};
-type AliasMemory<E extends string, S, I extends keyof S> = {
-    [K in `${E}Memory`]: StoreMemory<S, I>;
-};
-type AliasMonitor<E extends string, A extends ActionsConfig<any>> = {
-    [K in `${E}Monitor`]: {
-        [ActionName in keyof A]: ActionStatus;
-    };
-};
-export type StoreAlias<E extends string, S, I extends keyof S, A extends ActionsConfig<S>> = MemoryState<E, S> & AliasActions<E, A, S> & AliasMemory<E, S, I> & AliasMonitor<E, A>;
-export declare function useStoreAlias<E extends string, S, I extends keyof S, A extends ActionsConfig<S>>(store: Store<E, S, I, A>): StoreAlias<E, S, I, A>;
-export {};

package/dist/runtime/composables/use.js

@@ -1,14 +0,0 @@
-import { capitalize } from "../utils/transform.js";
-export function useStoreAlias(store) {
-  const capitalizedEntity = capitalize(store.alias.unit);
-  const output = {
-    [store.alias.unit]: store.unit,
-    [store.alias.units]: store.units,
-    [`${store.alias.unit}Memory`]: store.memory,
-    [`${store.alias.unit}Monitor`]: store.monitor
-  };
-  for (const actionName in store.action) {
-    output[`${actionName}${capitalizedEntity}`] = store.action[actionName];
-  }
-  return output;
-}

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

@@ -1,37 +0,0 @@
-import type { MaybeRefOrGetter } from "vue";
-import { EndpointMethod } from "../utils/endpoint.js";
-import type { ApiAdapter } from "../utils/adapter.js";
-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 EndpointMethod = EndpointMethod, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery, B extends ApiRequestBody = ApiRequestBody> {
-    action?: A;
-    headers?: H;
-    query?: Q;
-    body?: B;
-    signal?: AbortSignal;
-}
-export interface ApiOptions {
-    headers?: ApiRequestHeader;
-    query?: ApiRequestQuery;
-    adapter?: ApiAdapter<any>;
-}
-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 Api {
-    get: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery>(url: string, options?: EndpointMethodOptions<EndpointMethod.GET, H, Q, never> & {
-        adapter?: ApiAdapter<T>;
-    }) => 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> & {
-        adapter?: ApiAdapter<T>;
-    }) => 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> & {
-        adapter?: ApiAdapter<T>;
-    }) => 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> & {
-        adapter?: ApiAdapter<T>;
-    }) => Promise<T>;
-    del: <T, H extends ApiRequestHeader = ApiRequestHeader, Q extends ApiRequestQuery = ApiRequestQuery>(url: string, options?: EndpointMethodOptions<EndpointMethod.DELETE, H, Q, never> & {
-        adapter?: ApiAdapter<T>;
-    }) => Promise<T>;
-}
-export declare function createApi(options?: ApiOptions): Api;

package/dist/runtime/core/api.js

@@ -1,56 +0,0 @@
-import { toValue } from "vue";
-import { defineApiAdapter } from "../utils/adapter.js";
-import { EndpointMethod } from "../utils/endpoint.js";
-export function createApi(options) {
-  const defaultAdapter = options?.adapter ?? defineApiAdapter();
-  async function request(url, requestOptions) {
-    const adapter = requestOptions?.adapter ?? defaultAdapter;
-    const adapterRequest = {
-      method: requestOptions?.action ?? EndpointMethod.GET,
-      url,
-      body: toValue(requestOptions?.body),
-      query: Object.assign({}, toValue(options?.query), toValue(requestOptions?.query)),
-      headers: Object.assign({}, toValue(options?.headers), toValue(requestOptions?.headers)),
-      signal: requestOptions?.signal
-    };
-    const response = await adapter(adapterRequest);
-    return response.data;
-  }
-  async function get(url, options2) {
-    return request(url, {
-      ...options2,
-      action: EndpointMethod.GET
-    });
-  }
-  async function post(url, options2) {
-    return request(url, {
-      ...options2,
-      action: EndpointMethod.POST
-    });
-  }
-  async function put(url, options2) {
-    return request(url, {
-      ...options2,
-      action: EndpointMethod.PUT
-    });
-  }
-  async function patch(url, options2) {
-    return request(url, {
-      ...options2,
-      action: EndpointMethod.PATCH
-    });
-  }
-  async function del(url, options2) {
-    return request(url, {
-      ...options2,
-      action: EndpointMethod.DELETE
-    });
-  }
-  return {
-    get,
-    post,
-    put,
-    patch,
-    del
-  };
-}

package/dist/runtime/shared.d.ts

@@ -1,9 +0,0 @@
-import type { ApiFetchAdapterOptions } from "./utils/adapter.js";
-export type SharedConfig = {
-    api?: {
-        headers?: Record<string, string>;
-        query?: Record<string, unknown>;
-        adapter?: ApiFetchAdapterOptions;
-    };
-};
-export declare const sharedConfig: SharedConfig;

package/dist/runtime/shared.js

@@ -1,3 +0,0 @@
-export const sharedConfig = {
-  api: {}
-};

package/dist/runtime/utils/adapter.d.ts

@@ -1,24 +0,0 @@
-import type { EndpointMethod } from "./endpoint.js";
-export interface ApiAdapterRequest {
-    method: EndpointMethod;
-    url: string;
-    body?: unknown;
-    query?: Record<string, unknown>;
-    headers?: Record<string, string>;
-    signal?: AbortSignal;
-}
-export interface ApiAdapterResponse<T = unknown> {
-    data: T;
-    status?: number;
-}
-export type ApiAdapter<T = unknown> = (request: ApiAdapterRequest) => Promise<ApiAdapterResponse<T>>;
-export type DefineApiAdapter<T = unknown, O = unknown> = (options?: O) => ApiAdapter<T>;
-export interface ApiFetchAdapterOptions {
-    baseURL?: string;
-    timeout?: number;
-    retry?: number | false;
-    retryDelay?: number;
-    retryStatusCodes?: number[];
-    responseType?: "json" | "text" | "blob" | "arrayBuffer";
-}
-export declare function defineApiAdapter<T = unknown>(options?: ApiFetchAdapterOptions): ApiAdapter<T>;

package/dist/runtime/utils/adapter.js

@@ -1,35 +0,0 @@
-import { ApiRequestError, ApiResponseError } from "./errors.js";
-export function defineApiAdapter(options) {
-  return async (request) => {
-    const data = await $fetch(request.url, {
-      baseURL: options?.baseURL,
-      method: request.method,
-      headers: request.headers,
-      query: request.query,
-      body: request.body,
-      timeout: options?.timeout,
-      signal: request.signal,
-      retry: options?.retry,
-      retryDelay: options?.retryDelay,
-      retryStatusCodes: options?.retryStatusCodes,
-      responseType: options?.responseType,
-      onRequestError({ request: request2, options: options2, error }) {
-        throw new ApiRequestError({
-          method: options2.method,
-          url: request2.toString(),
-          message: error?.message
-        });
-      },
-      onResponseError({ request: request2, options: options2, error }) {
-        throw new ApiResponseError({
-          method: options2.method,
-          url: request2.toString(),
-          message: error?.message
-        });
-      }
-    });
-    return {
-      data
-    };
-  };
-}

package/dist/runtime/utils/cache.d.ts

@@ -1,10 +0,0 @@
-export interface Cache<K, V> {
-    get(key: K): V | undefined;
-    set(key: K, value: V): void;
-    delete(key: K): boolean;
-    clear(): void;
-    size(): number;
-    has(key: K): boolean;
-    entries(): IterableIterator<[K, V]>;
-}
-export declare function createCache<K, V>(): Cache<K, V>;

package/dist/runtime/utils/cache.js

@@ -1,26 +0,0 @@
-export function createCache() {
-  const map = /* @__PURE__ */ new Map();
-  return {
-    get(key) {
-      return map.get(key);
-    },
-    set(key, value) {
-      map.set(key, value);
-    },
-    delete(key) {
-      return map.delete(key);
-    },
-    clear() {
-      map.clear();
-    },
-    size() {
-      return map.size;
-    },
-    has(key) {
-      return map.has(key);
-    },
-    entries() {
-      return map.entries();
-    }
-  };
-}

package/dist/runtime/utils/endpoint.d.ts

@@ -1,38 +0,0 @@
-import type { ApiAdapter } from "./adapter.js";
-import type { Capitalize } from "./transform.js";
-export declare enum EndpointMethod {
-    GET = "get",
-    POST = "post",
-    PUT = "put",
-    PATCH = "patch",
-    DELETE = "delete"
-}
-export declare enum EndpointStatus {
-    IDLE = "idle",
-    PENDING = "pending",
-    SUCCESS = "success",
-    FAILED = "failed"
-}
-export type EndpointUrl<S> = string | ((params: Partial<S>) => string);
-export interface EndpointDefinition<S = Record<string, unknown>> {
-    readonly method: EndpointMethod;
-    readonly url: EndpointUrl<S>;
-    readonly adapter?: ApiAdapter<any>;
-}
-export interface EndpointChain<S> {
-    readonly method: EndpointMethod;
-    readonly url: EndpointUrl<S>;
-    readonly adapter?: ApiAdapter<any>;
-    withAdapter(adapter: ApiAdapter<any>): EndpointDefinition<S>;
-}
-export interface EndpointBuilder {
-    get<S = Record<string, unknown>>(url: EndpointUrl<S>): EndpointChain<S>;
-    post<S = Record<string, unknown>>(url: EndpointUrl<S>): EndpointChain<S>;
-    put<S = Record<string, unknown>>(url: EndpointUrl<S>): EndpointChain<S>;
-    patch<S = Record<string, unknown>>(url: EndpointUrl<S>): EndpointChain<S>;
-    delete<S = Record<string, unknown>>(url: EndpointUrl<S>): EndpointChain<S>;
-}
-export declare const Endpoint: EndpointBuilder;
-export type EndpointStatusFlag<S extends EndpointStatus = EndpointStatus> = `Is${Capitalize<S>}`;
-export declare function makeEndpointStatusFlag<S extends EndpointStatus>(status: S): EndpointStatusFlag<S>;
-export declare function resolveEndpointUrl<S>(endpoint: EndpointDefinition<S>, params?: Partial<S>): string;