routesync 1.0.0

package/dist/sdk.mjs

@@ -0,0 +1,476 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// packages/core/src/client/HttpClient.ts
+import axios from "axios";
+var HttpClient = class {
+  constructor(config) {
+    this.client = axios.create({
+      baseURL: config.baseURL,
+      timeout: config.timeout ?? 1e4,
+      headers: {
+        "Content-Type": "application/json",
+        ...config.headers ?? {}
+      }
+    });
+    if (config.token) {
+      this.setToken(config.token);
+    }
+    this.setupInterceptors();
+  }
+  setupInterceptors() {
+    this.client.interceptors.response.use(
+      (response) => response,
+      (error) => {
+        const message = error.response?.data?.message ?? error.message ?? "Unknown error";
+        return Promise.reject({
+          success: false,
+          message,
+          status: error.response?.status,
+          errors: error.response?.data?.errors
+        });
+      }
+    );
+  }
+  setToken(token) {
+    this.client.defaults.headers.common["Authorization"] = `Bearer ${token}`;
+  }
+  removeToken() {
+    delete this.client.defaults.headers.common["Authorization"];
+  }
+  async get(url, config) {
+    const response = await this.client.get(url, config);
+    return response.data;
+  }
+  async post(url, body, config) {
+    const response = await this.client.post(url, body, config);
+    return response.data;
+  }
+  async put(url, body, config) {
+    const response = await this.client.put(url, body, config);
+    return response.data;
+  }
+  async patch(url, body, config) {
+    const response = await this.client.patch(url, body, config);
+    return response.data;
+  }
+  async delete(url, config) {
+    const response = await this.client.delete(url, config);
+    return response.data;
+  }
+  async upload(url, formData) {
+    const response = await this.client.post(url, formData, {
+      headers: { "Content-Type": "multipart/form-data" }
+    });
+    return response.data;
+  }
+  getInstance() {
+    return this.client;
+  }
+};
+
+// packages/core/src/auth/TokenManager.ts
+var _TokenManager = class _TokenManager {
+  constructor() {
+    this.token = null;
+  }
+  set(token) {
+    this.token = token;
+    if (typeof localStorage !== "undefined") {
+      localStorage.setItem(_TokenManager.TOKEN_KEY, token);
+    }
+  }
+  get() {
+    if (this.token) return this.token;
+    if (typeof localStorage !== "undefined") {
+      return localStorage.getItem(_TokenManager.TOKEN_KEY);
+    }
+    return null;
+  }
+  clear() {
+    this.token = null;
+    if (typeof localStorage !== "undefined") {
+      localStorage.removeItem(_TokenManager.TOKEN_KEY);
+    }
+  }
+  exists() {
+    return this.get() !== null;
+  }
+};
+_TokenManager.TOKEN_KEY = "routesync_token";
+var TokenManager = _TokenManager;
+
+// packages/core/src/routing/PathResolver.ts
+var PathResolver = class {
+  /**
+   * Resolve path params.
+   * e.g. resolvePath('/produk/:id', { id: 10 }) => '/produk/10'
+   */
+  static resolve(path, params) {
+    if (!params) return path;
+    let resolved = path;
+    for (const [key, value] of Object.entries(params)) {
+      resolved = resolved.replace(`:${key}`, String(value));
+    }
+    const unresolved = resolved.match(/:([a-zA-Z_]+)/g);
+    if (unresolved) {
+      throw new Error(
+        `Unresolved path params: ${unresolved.join(", ")}`
+      );
+    }
+    return resolved;
+  }
+  static extractParams(path) {
+    const matches = path.match(/:([a-zA-Z_]+)/g) ?? [];
+    return matches.map((m) => m.slice(1));
+  }
+  static hasParams(path) {
+    return /:([a-zA-Z_]+)/.test(path);
+  }
+};
+
+// packages/sdk/src/mappers/schema.ts
+function parseWithSchema(schema, value) {
+  if (!schema) return value;
+  if (typeof schema === "function") {
+    return schema(value);
+  }
+  if (schema.safeParse) {
+    const result = schema.safeParse(value);
+    if (result.success) return result.data;
+    throw result.error;
+  }
+  if (schema.parse) {
+    return schema.parse(value);
+  }
+  return value;
+}
+
+// packages/sdk/src/defineApi.ts
+var _client = null;
+function getClient() {
+  if (!_client) {
+    throw new Error("RouteSync not initialized. Call createClient() first.");
+  }
+  return _client;
+}
+function createClient(config) {
+  _client = new HttpClient(config);
+  return _client;
+}
+function defineApi(definition, config) {
+  if (config) {
+    createClient(config);
+  }
+  const proxy = {};
+  for (const group in definition) {
+    const groupDef = definition[group];
+    const groupProxy = {};
+    for (const action in groupDef) {
+      const route = groupDef[action];
+      const callable = async (options) => {
+        const client = getClient();
+        const params = applyMapper(
+          route,
+          "params",
+          parseRouteSchema(route, "params", options?.params)
+        );
+        const query = applyMapper(
+          route,
+          "query",
+          parseRouteSchema(route, "query", options?.query)
+        );
+        const body = applyMapper(
+          route,
+          "body",
+          parseRouteSchema(route, "body", options?.body)
+        );
+        const resolvedPath = PathResolver.resolve(route.path, params);
+        const method = route.method.toLowerCase();
+        const requestConfig = { params: query, headers: route.headers };
+        let response;
+        if (method === "get" || method === "delete") {
+          response = await client[method](resolvedPath, requestConfig);
+        } else {
+          response = await client[method](resolvedPath, body, requestConfig);
+        }
+        return applyMapper(
+          route,
+          "response",
+          parseRouteSchema(route, "response", response)
+        );
+      };
+      callable.$def = route;
+      callable.$key = [group, action];
+      groupProxy[action] = callable;
+    }
+    ;
+    proxy[group] = groupProxy;
+  }
+  return proxy;
+}
+var routeSchemaKeys = ["params", "query", "body", "request", "response"];
+function parseRouteSchema(route, part, value) {
+  if (value === void 0) return void 0;
+  const schema = pickRouteSchema(route, part);
+  return parseWithSchema(schema, value);
+}
+function pickRouteSchema(route, part) {
+  const schema = route.schema;
+  if (!schema) return void 0;
+  if (hasRouteSchemaKeys(schema)) {
+    return schema[part] ?? (part === "body" ? schema.request : void 0);
+  }
+  return defaultSchemaPart(route.method) === part ? schema : void 0;
+}
+function hasRouteSchemaKeys(value) {
+  return Boolean(
+    value && typeof value === "object" && routeSchemaKeys.some((key) => key in value)
+  );
+}
+function defaultSchemaPart(method) {
+  return method === "GET" || method === "DELETE" ? "response" : "body";
+}
+function applyMapper(route, part, value) {
+  if (value === void 0 || !route.mapper) return value;
+  if (typeof route.mapper === "function") {
+    return part === "response" ? route.mapper(value) : value;
+  }
+  const mapper = route.mapper[part] ?? (part === "body" ? route.mapper.request : void 0);
+  return mapper ? mapper(value) : value;
+}
+
+// packages/sdk/src/endpoint.ts
+function endpoint(def) {
+  return def;
+}
+
+// packages/sdk/src/resource.ts
+function resource(config) {
+  const result = {};
+  for (const key in config.endpoints) {
+    const ep = config.endpoints[key];
+    result[key] = {
+      ...ep,
+      // Endpoint-level overrides cascade defaults, never the other way around
+      auth: ep.auth ?? config.auth,
+      headers: {
+        ...config.headers ?? {},
+        ...ep.headers ?? {}
+      },
+      cache: ep.cache ?? config.cache,
+      retry: ep.retry ?? config.retry
+    };
+  }
+  return result;
+}
+
+// packages/sdk/src/mappers/case.ts
+function snakeToCamelKey(key) {
+  return key.replace(/_([a-zA-Z0-9])/g, (_, char) => char.toUpperCase());
+}
+function camelToSnakeKey(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase();
+}
+function isPlainObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function mapKeysDeep(value, keyCase) {
+  if (Array.isArray(value)) {
+    return value.map((item) => mapKeysDeep(item, keyCase));
+  }
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  const mapper = keyCase === "camel" ? snakeToCamelKey : camelToSnakeKey;
+  const mapped = {};
+  for (const [key, child] of Object.entries(value)) {
+    mapped[mapper(key)] = mapKeysDeep(child, keyCase);
+  }
+  return mapped;
+}
+function toCamelCase(value) {
+  return mapKeysDeep(value, "camel");
+}
+function toSnakeCase(value) {
+  return mapKeysDeep(value, "snake");
+}
+
+// packages/sdk/src/createService.ts
+var GenericService = class {
+  constructor(client, endpoint2, options = {}) {
+    this.client = client;
+    this.endpoint = endpoint2;
+    this.options = options;
+  }
+  async findAll(params) {
+    const response = await this.client.get(this.endpoint, {
+      params: this.mapRequest(params)
+    });
+    const items = parseWithSchema(this.options.listSchema, this.extractData(response));
+    return items.map((item) => this.mapEntity(item));
+  }
+  async findById(id, params) {
+    const response = await this.client.get(`${this.endpoint}/${id}`, {
+      params: this.mapRequest(params)
+    });
+    return this.mapEntity(this.parseEntity(this.extractData(response)));
+  }
+  async create(payload) {
+    const validated = parseWithSchema(this.options.createSchema, payload);
+    const response = await this.client.post(this.endpoint, this.mapRequest(validated));
+    return this.mapEntity(this.parseEntity(this.extractData(response)));
+  }
+  async update(id, payload) {
+    const validated = parseWithSchema(this.options.updateSchema, payload);
+    const response = await this.client.put(
+      `${this.endpoint}/${id}`,
+      this.mapRequest(validated)
+    );
+    return this.mapEntity(this.parseEntity(this.extractData(response)));
+  }
+  async patch(id, payload) {
+    const validated = parseWithSchema(this.options.updateSchema, payload);
+    const response = await this.client.patch(
+      `${this.endpoint}/${id}`,
+      this.mapRequest(validated)
+    );
+    return this.mapEntity(this.parseEntity(this.extractData(response)));
+  }
+  async delete(id) {
+    const response = await this.client.delete(`${this.endpoint}/${id}`);
+    return this.extractData(response);
+  }
+  async upload(file) {
+    const response = await this.client.upload(`${this.endpoint}/upload`, file);
+    return this.mapEntity(this.parseEntity(this.extractData(response)));
+  }
+  extractData(response) {
+    if (response && typeof response === "object" && "data" in response) {
+      return response.data;
+    }
+    return response;
+  }
+  parseEntity(value) {
+    return parseWithSchema(this.options.entitySchema, value);
+  }
+  mapEntity(value) {
+    if (this.options.fromBackend) {
+      return this.options.fromBackend(value);
+    }
+    if (this.options.mapResponseKeys === false) {
+      return value;
+    }
+    return toCamelCase(value);
+  }
+  mapRequest(value) {
+    if (value === void 0) return void 0;
+    if (this.options.toBackend) {
+      return this.options.toBackend(value);
+    }
+    if (this.options.mapRequestKeys === false) {
+      return value;
+    }
+    return toSnakeCase(value);
+  }
+};
+function createService(client, endpoint2, options) {
+  return new GenericService(
+    client,
+    endpoint2,
+    options
+  );
+}
+
+// packages/sdk/src/createClient.ts
+function createClient2(config) {
+  const client = new HttpClient(config);
+  const tokenManager = new TokenManager();
+  if (config.token) {
+    tokenManager.set(config.token);
+  }
+  return {
+    client,
+    tokenManager,
+    setToken(token) {
+      tokenManager.set(token);
+      client.setToken(token);
+    },
+    clearToken() {
+      tokenManager.clear();
+      client.removeToken();
+    }
+  };
+}
+
+// packages/sdk/src/generateHooks.ts
+function generateHooks(api) {
+  let useQuery;
+  let useMutation;
+  let useQueryClient;
+  try {
+    const rq = __require("@tanstack/react-query");
+    useQuery = rq.useQuery;
+    useMutation = rq.useMutation;
+    useQueryClient = rq.useQueryClient;
+  } catch {
+    throw new Error(
+      "@tanstack/react-query is required to use generateHooks. Install it with: npm install @tanstack/react-query"
+    );
+  }
+  const hooks = {};
+  for (const [group, actions] of Object.entries(api)) {
+    for (const [action, endpoint2] of Object.entries(actions)) {
+      const method = endpoint2.$def.method;
+      const hookName = toHookName(group, action);
+      if (method === "GET" || method === "DELETE") {
+        hooks[hookName] = (options, queryOptions) => useQuery({
+          queryKey: options ? [...endpoint2.$key, options] : endpoint2.$key,
+          queryFn: () => endpoint2(options),
+          ...queryOptions
+        });
+      } else {
+        hooks[hookName] = (mutationOptions) => {
+          const qc = useQueryClient();
+          return useMutation({
+            ...mutationOptions,
+            mutationFn: (options) => endpoint2(options),
+            onSuccess: (...args) => {
+              qc.invalidateQueries({ queryKey: [group] });
+              mutationOptions?.invalidate?.forEach((ep) => {
+                qc.invalidateQueries({ queryKey: ep.$key });
+              });
+              mutationOptions?.onSuccess?.(...args);
+            }
+          });
+        };
+      }
+    }
+  }
+  return hooks;
+}
+function toHookName(group, action) {
+  const g = group.charAt(0).toUpperCase() + group.slice(1);
+  const a = action.charAt(0).toUpperCase() + action.slice(1);
+  return `use${g}${a}`;
+}
+export {
+  GenericService,
+  camelToSnakeKey,
+  createClient,
+  createClient2 as createHttpClient,
+  createService,
+  defineApi,
+  endpoint,
+  generateHooks,
+  mapKeysDeep,
+  parseWithSchema,
+  resource,
+  snakeToCamelKey,
+  toCamelCase,
+  toSnakeCase
+};

package/dist/vue.d.mts

@@ -0,0 +1,108 @@
+import * as _tanstack_query_core from '@tanstack/query-core';
+import * as _tanstack_vue_query from '@tanstack/vue-query';
+import { AxiosRequestConfig, AxiosInstance } from 'axios';
+
+interface ServiceConfig {
+    baseURL: string;
+    token?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    retry?: RetryConfig;
+    cache?: boolean;
+}
+interface RetryConfig {
+    attempts: number;
+    delay?: number;
+    statusCodes?: number[];
+}
+
+declare class HttpClient {
+    private client;
+    constructor(config: ServiceConfig);
+    private setupInterceptors;
+    setToken(token: string): void;
+    removeToken(): void;
+    get<T>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    post<T>(url: string, body?: any, config?: AxiosRequestConfig): Promise<T>;
+    put<T>(url: string, body?: any, config?: AxiosRequestConfig): Promise<T>;
+    patch<T>(url: string, body?: any, config?: AxiosRequestConfig): Promise<T>;
+    delete<T>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    upload<T>(url: string, formData: FormData): Promise<T>;
+    getInstance(): AxiosInstance;
+}
+
+type ParseResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: unknown;
+};
+interface ParserSchema<T> {
+    parse?: (value: unknown) => T;
+    safeParse?: (value: unknown) => ParseResult<T>;
+}
+type SchemaLike<T> = ParserSchema<T> | ((value: unknown) => T);
+
+type Id = string | number;
+type QueryParams = Record<string, any>;
+interface GenericServiceOptions<TEntity, TCreateInput = Partial<TEntity>, TUpdateInput = Partial<TCreateInput>, TBackendEntity = unknown> {
+    /** Validate one backend entity before it is mapped to frontend shape. Works with Zod schemas. */
+    entitySchema?: SchemaLike<TBackendEntity>;
+    /** Validate backend list responses before each item is mapped to frontend shape. Works with Zod arrays. */
+    listSchema?: SchemaLike<TBackendEntity[]>;
+    /** Validate frontend create payloads before they are mapped to backend snake_case. Works with Zod schemas. */
+    createSchema?: SchemaLike<TCreateInput>;
+    /** Validate frontend update/patch payloads before they are mapped to backend snake_case. Works with Zod schemas. */
+    updateSchema?: SchemaLike<TUpdateInput>;
+    /** Override backend -> frontend mapping. Defaults to deep snake_case -> camelCase. */
+    fromBackend?: (value: TBackendEntity) => TEntity;
+    /** Override frontend -> backend mapping. Defaults to deep camelCase -> snake_case. */
+    toBackend?: (value: TCreateInput | TUpdateInput | QueryParams) => unknown;
+    /** Disable if your backend already returns camelCase. Defaults to true. */
+    mapResponseKeys?: boolean;
+    /** Disable if your backend accepts camelCase. Defaults to true. */
+    mapRequestKeys?: boolean;
+}
+declare class GenericService<TEntity = any, TCreateInput = Partial<TEntity>, TUpdateInput = Partial<TCreateInput>, TBackendEntity = unknown> {
+    private client;
+    private endpoint;
+    private options;
+    constructor(client: HttpClient, endpoint: string, options?: GenericServiceOptions<TEntity, TCreateInput, TUpdateInput, TBackendEntity>);
+    findAll(params?: QueryParams): Promise<TEntity[]>;
+    findById(id: Id, params?: QueryParams): Promise<TEntity>;
+    create(payload: TCreateInput): Promise<TEntity>;
+    update(id: Id, payload: TUpdateInput): Promise<TEntity>;
+    patch(id: Id, payload: TUpdateInput): Promise<TEntity>;
+    delete<TDeleteResponse = unknown>(id: Id): Promise<TDeleteResponse>;
+    upload(file: FormData): Promise<TEntity>;
+    private extractData;
+    private parseEntity;
+    private mapEntity;
+    private mapRequest;
+}
+
+declare function createComposables(service: GenericService, resourceKey: string): {
+    useList: (params?: Record<string, any>) => _tanstack_vue_query.UseQueryReturnType<any[], Error>;
+    useDetail: (id: string | number) => _tanstack_vue_query.UseQueryReturnType<any, Error>;
+    useCreate: () => _tanstack_vue_query.UseMutationReturnType<any, Error, any, unknown, Omit<_tanstack_query_core.MutationObserverIdleResult<any, Error, any, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverLoadingResult<any, Error, any, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverErrorResult<any, Error, any, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverSuccessResult<any, Error, any, unknown>, "mutate" | "reset">>;
+    useUpdate: () => _tanstack_vue_query.UseMutationReturnType<any, Error, {
+        id: string | number;
+        data: any;
+    }, unknown, Omit<_tanstack_query_core.MutationObserverIdleResult<any, Error, {
+        id: string | number;
+        data: any;
+    }, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverLoadingResult<any, Error, {
+        id: string | number;
+        data: any;
+    }, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverErrorResult<any, Error, {
+        id: string | number;
+        data: any;
+    }, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverSuccessResult<any, Error, {
+        id: string | number;
+        data: any;
+    }, unknown>, "mutate" | "reset">>;
+    useDelete: () => _tanstack_vue_query.UseMutationReturnType<unknown, Error, string | number, unknown, Omit<_tanstack_query_core.MutationObserverIdleResult<unknown, Error, string | number, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverLoadingResult<unknown, Error, string | number, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverErrorResult<unknown, Error, string | number, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverSuccessResult<unknown, Error, string | number, unknown>, "mutate" | "reset">>;
+};
+
+export { createComposables, createComposables as createVueComposables };

package/dist/vue.d.ts

@@ -0,0 +1,108 @@
+import * as _tanstack_query_core from '@tanstack/query-core';
+import * as _tanstack_vue_query from '@tanstack/vue-query';
+import { AxiosRequestConfig, AxiosInstance } from 'axios';
+
+interface ServiceConfig {
+    baseURL: string;
+    token?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    retry?: RetryConfig;
+    cache?: boolean;
+}
+interface RetryConfig {
+    attempts: number;
+    delay?: number;
+    statusCodes?: number[];
+}
+
+declare class HttpClient {
+    private client;
+    constructor(config: ServiceConfig);
+    private setupInterceptors;
+    setToken(token: string): void;
+    removeToken(): void;
+    get<T>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    post<T>(url: string, body?: any, config?: AxiosRequestConfig): Promise<T>;
+    put<T>(url: string, body?: any, config?: AxiosRequestConfig): Promise<T>;
+    patch<T>(url: string, body?: any, config?: AxiosRequestConfig): Promise<T>;
+    delete<T>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    upload<T>(url: string, formData: FormData): Promise<T>;
+    getInstance(): AxiosInstance;
+}
+
+type ParseResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: unknown;
+};
+interface ParserSchema<T> {
+    parse?: (value: unknown) => T;
+    safeParse?: (value: unknown) => ParseResult<T>;
+}
+type SchemaLike<T> = ParserSchema<T> | ((value: unknown) => T);
+
+type Id = string | number;
+type QueryParams = Record<string, any>;
+interface GenericServiceOptions<TEntity, TCreateInput = Partial<TEntity>, TUpdateInput = Partial<TCreateInput>, TBackendEntity = unknown> {
+    /** Validate one backend entity before it is mapped to frontend shape. Works with Zod schemas. */
+    entitySchema?: SchemaLike<TBackendEntity>;
+    /** Validate backend list responses before each item is mapped to frontend shape. Works with Zod arrays. */
+    listSchema?: SchemaLike<TBackendEntity[]>;
+    /** Validate frontend create payloads before they are mapped to backend snake_case. Works with Zod schemas. */
+    createSchema?: SchemaLike<TCreateInput>;
+    /** Validate frontend update/patch payloads before they are mapped to backend snake_case. Works with Zod schemas. */
+    updateSchema?: SchemaLike<TUpdateInput>;
+    /** Override backend -> frontend mapping. Defaults to deep snake_case -> camelCase. */
+    fromBackend?: (value: TBackendEntity) => TEntity;
+    /** Override frontend -> backend mapping. Defaults to deep camelCase -> snake_case. */
+    toBackend?: (value: TCreateInput | TUpdateInput | QueryParams) => unknown;
+    /** Disable if your backend already returns camelCase. Defaults to true. */
+    mapResponseKeys?: boolean;
+    /** Disable if your backend accepts camelCase. Defaults to true. */
+    mapRequestKeys?: boolean;
+}
+declare class GenericService<TEntity = any, TCreateInput = Partial<TEntity>, TUpdateInput = Partial<TCreateInput>, TBackendEntity = unknown> {
+    private client;
+    private endpoint;
+    private options;
+    constructor(client: HttpClient, endpoint: string, options?: GenericServiceOptions<TEntity, TCreateInput, TUpdateInput, TBackendEntity>);
+    findAll(params?: QueryParams): Promise<TEntity[]>;
+    findById(id: Id, params?: QueryParams): Promise<TEntity>;
+    create(payload: TCreateInput): Promise<TEntity>;
+    update(id: Id, payload: TUpdateInput): Promise<TEntity>;
+    patch(id: Id, payload: TUpdateInput): Promise<TEntity>;
+    delete<TDeleteResponse = unknown>(id: Id): Promise<TDeleteResponse>;
+    upload(file: FormData): Promise<TEntity>;
+    private extractData;
+    private parseEntity;
+    private mapEntity;
+    private mapRequest;
+}
+
+declare function createComposables(service: GenericService, resourceKey: string): {
+    useList: (params?: Record<string, any>) => _tanstack_vue_query.UseQueryReturnType<any[], Error>;
+    useDetail: (id: string | number) => _tanstack_vue_query.UseQueryReturnType<any, Error>;
+    useCreate: () => _tanstack_vue_query.UseMutationReturnType<any, Error, any, unknown, Omit<_tanstack_query_core.MutationObserverIdleResult<any, Error, any, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverLoadingResult<any, Error, any, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverErrorResult<any, Error, any, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverSuccessResult<any, Error, any, unknown>, "mutate" | "reset">>;
+    useUpdate: () => _tanstack_vue_query.UseMutationReturnType<any, Error, {
+        id: string | number;
+        data: any;
+    }, unknown, Omit<_tanstack_query_core.MutationObserverIdleResult<any, Error, {
+        id: string | number;
+        data: any;
+    }, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverLoadingResult<any, Error, {
+        id: string | number;
+        data: any;
+    }, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverErrorResult<any, Error, {
+        id: string | number;
+        data: any;
+    }, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverSuccessResult<any, Error, {
+        id: string | number;
+        data: any;
+    }, unknown>, "mutate" | "reset">>;
+    useDelete: () => _tanstack_vue_query.UseMutationReturnType<unknown, Error, string | number, unknown, Omit<_tanstack_query_core.MutationObserverIdleResult<unknown, Error, string | number, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverLoadingResult<unknown, Error, string | number, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverErrorResult<unknown, Error, string | number, unknown>, "mutate" | "reset"> | Omit<_tanstack_query_core.MutationObserverSuccessResult<unknown, Error, string | number, unknown>, "mutate" | "reset">>;
+};
+
+export { createComposables, createComposables as createVueComposables };