@ipetsadmin/api-client 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+### Changed
+
+### Deprecated
+
+### Removed
+
+### Fixed
+
+### Security
+
+## [1.0.0] - 2026-04-02
+
+### Added
+
+- Initial public release of `@ipetsadmin/api-client`.
+- MIT license, README, and npm publish tooling (validate, build, Husky, lint-staged).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ipetsadmin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,387 @@
+# `@ipetsadmin/api-client`
+
+Typed HTTP client for the Truffa API. This package is meant to be consumed by front-end and mobile apps. It does **not** own API URL configuration: you pass in a preconfigured HTTP implementation (typically an [Axios](https://axios-http.com/) instance with `baseURL` already set). Request and response **shapes** come from [`@ipetsadmin/contracts`](https://www.npmjs.com/package/@ipetsadmin/contracts) (or domain-specific types you align with that package).
+
+## Requirements
+
+- **Node.js** ≥ 18.18
+- **Peer dependency:** `@ipetsadmin/contracts` (install it next to this package in your app)
+
+## Installation
+
+```bash
+pnpm add @ipetsadmin/api-client @ipetsadmin/contracts
+# or
+npm install @ipetsadmin/api-client @ipetsadmin/contracts
+```
+
+## Current implementation
+
+### What ships today
+
+| Export                     | Description                                                             |
+| -------------------------- | ----------------------------------------------------------------------- |
+| `createApiClient(options)` | Factory that returns an object of API methods.                          |
+| `ApiClient`                | Type of the object returned by `createApiClient`.                       |
+| `CreateApiClientOptions`   | `{ http: HttpClient }`.                                                 |
+| `HttpClient`               | Minimal interface your HTTP layer must satisfy (today: **`get` only**). |
+| `HttpGet`                  | Type of the `get` method.                                               |
+
+### Endpoints implemented
+
+| Method | Path                   | Client method          |
+| ------ | ---------------------- | ---------------------- |
+| `GET`  | `/api/v1/health-check` | `client.healthCheck()` |
+
+The health check returns `Promise<IApiResponse<unknown>>` using the shared envelope from `@ipetsadmin/contracts`. When the canonical health payload exists in contracts, replace `unknown` with that type in `src/endpoints/health-check.ts`.
+
+### Usage example (Axios)
+
+Configure Axios once in your app (base URL, timeouts, auth interceptors). Paths in this library are **relative to `baseURL`** (e.g. `/api/v1/...`).
+
+```typescript
+import axios from 'axios';
+import { createApiClient } from '@ipetsadmin/api-client';
+
+const http = axios.create({
+  baseURL: process.env.API_BASE_URL, // e.g. https://api.example.com
+  timeout: 15_000,
+  headers: { 'Content-Type': 'application/json' },
+});
+
+const api = createApiClient({ http });
+
+const health = await api.healthCheck();
+// health is IApiResponse<unknown>
+```
+
+Axios’s `get` signature matches what this library expects: it returns a `Promise` that resolves to an object with a `data` property.
+
+### Why a factory?
+
+`createApiClient({ http })` keeps this package free of environment-specific configuration, supports multiple backends or tenants in one app, and makes tests trivial by injecting a mock `http` object.
+
+---
+
+## Architecture overview
+
+1. **`HttpClient`** — Abstraction over “how” HTTP is performed (Axios, `fetch` wrapper, etc.).
+2. **`src/endpoints/*.ts`** — One module per route (or per resource): pure async functions that take `http` and return typed data.
+3. **`createApiClient`** — Wires `http` into those functions and exposes a stable, discoverable API.
+4. **`@ipetsadmin/contracts`** — Source of truth for DTOs shared with the server (e.g. `IApiResponse<T>`).
+
+When the API adds a route, add an endpoint module, extend `HttpClient` if you need new verbs, and add a method on the object returned by `createApiClient`.
+
+---
+
+## Extending `HttpClient` for all HTTP verbs
+
+Right now `HttpClient` only declares `get`. For **POST**, **PATCH**, **PUT**, and **DELETE**, extend the interface so adapters (Axios) stay type-safe and consistent.
+
+Axios maps HTTP concepts roughly as follows:
+
+| Concern      | Axios request config field                                     |
+| ------------ | -------------------------------------------------------------- |
+| URL path     | First argument `url` (often built from path + **path params**) |
+| Query string | `params`                                                       |
+| JSON body    | `data`                                                         |
+| Headers      | `headers`                                                      |
+
+Recommended shape (mirror Axios so an `AxiosInstance` is assignable with minimal wrapping):
+
+```typescript
+// src/http-client.ts — extend when you add non-GET endpoints
+
+/** Optional config aligned with Axios (params, data, headers, etc.). */
+export type HttpRequestConfig = {
+  params?: Record<string, unknown>;
+  data?: unknown;
+  headers?: Record<string, string>;
+};
+
+export type HttpGet = <TResponse>(
+  url: string,
+  config?: HttpRequestConfig,
+) => Promise<{ data: TResponse }>;
+
+export type HttpPost = <TResponse>(
+  url: string,
+  config?: HttpRequestConfig,
+) => Promise<{ data: TResponse }>;
+
+export type HttpPut = HttpPost;
+export type HttpPatch = HttpPost;
+
+export type HttpDelete = <TResponse>(
+  url: string,
+  config?: HttpRequestConfig,
+) => Promise<{ data: TResponse }>;
+
+export interface HttpClient {
+  readonly get: HttpGet;
+  readonly post: HttpPost;
+  readonly put: HttpPut;
+  readonly patch: HttpPatch;
+  readonly delete: HttpDelete;
+}
+```
+
+**Adapter example (Axios):** if TypeScript complains about `config` width, use a typed wrapper:
+
+```typescript
+import type { AxiosInstance } from 'axios';
+import type { HttpClient, HttpRequestConfig } from '@ipetsadmin/api-client';
+
+export function createAxiosHttpClient(instance: AxiosInstance): HttpClient {
+  return {
+    get: (url, config) => instance.get(url, config),
+    post: (url, config) => instance.post(url, config?.data, config),
+    put: (url, config) => instance.put(url, config?.data, config),
+    patch: (url, config) => instance.patch(url, config?.data, config),
+    delete: (url, config) => instance.delete(url, config),
+  };
+}
+```
+
+Note: Axios’s `post`/`put`/`patch` take `data` as the second argument and `config` as the third; the wrapper above keeps your **endpoint** code calling `http.post(url, { data, params, headers })` in one place. Adjust the wrapper to match how you prefer to thread `config`.
+
+---
+
+## Implementing endpoints: patterns by verb
+
+Conventions used below:
+
+- **Path** — string constant; combine with **path parameters** via a small helper or template.
+- **Query** — `config.params` (Axios serializes to the query string).
+- **Body** — `config.data` for JSON bodies.
+- **Headers** — `config.headers` for per-request headers (auth, idempotency keys, etc.).
+- **Types** — import request/response types from `@ipetsadmin/contracts` when they exist.
+
+Assume:
+
+```typescript
+import type { IApiResponse } from '@ipetsadmin/contracts';
+import type { HttpClient } from '../http-client';
+```
+
+### Path parameters
+
+Build the URL in the endpoint (keep templates next to the constant for clarity):
+
+```typescript
+const USER_BY_ID_PATH = '/api/v1/users/:userId' as const;
+
+function buildUserPath(userId: string): string {
+  return USER_BY_ID_PATH.replace(':userId', encodeURIComponent(userId));
+}
+
+// GET /api/v1/users/42
+await http.get<IApiResponse<UserDto>>(buildUserPath('42'));
+```
+
+For many segments, a tiny helper avoids mistakes:
+
+```typescript
+function buildPath(template: string, params: Record<string, string | number>): string {
+  let path = template;
+  for (const [key, value] of Object.entries(params)) {
+    path = path.replace(`:${key}`, encodeURIComponent(String(value)));
+  }
+  return path;
+}
+
+// '/api/v1/orgs/:orgId/projects/:projectId'
+buildPath('/api/v1/orgs/:orgId/projects/:projectId', {
+  orgId: 'acme',
+  projectId: 'proj-1',
+});
+```
+
+### GET — query and headers
+
+```typescript
+const SEARCH_PATH = '/api/v1/items' as const;
+
+export interface ListItemsParams {
+  readonly query?: Record<string, string | number | boolean | undefined>;
+  readonly headers?: Record<string, string>;
+}
+
+export async function fetchItems(
+  http: HttpClient,
+  args: ListItemsParams = {},
+): Promise<IApiResponse<ItemSummary[]>> {
+  const { data } = await http.get<IApiResponse<ItemSummary[]>>(SEARCH_PATH, {
+    params: args.query,
+    headers: args.headers,
+  });
+  return data;
+}
+```
+
+### POST — body, query, headers
+
+```typescript
+const CREATE_ITEM_PATH = '/api/v1/items' as const;
+
+export interface CreateItemInput {
+  readonly body: CreateItemRequestDto;
+  readonly query?: Record<string, string | number | boolean | undefined>;
+  readonly headers?: Record<string, string>;
+}
+
+export async function createItem(
+  http: HttpClient,
+  input: CreateItemInput,
+): Promise<IApiResponse<ItemDto>> {
+  const { data } = await http.post<IApiResponse<ItemDto>>(CREATE_ITEM_PATH, {
+    data: input.body,
+    params: input.query,
+    headers: input.headers,
+  });
+  return data;
+}
+```
+
+### PATCH — partial body, path id
+
+```typescript
+const ITEM_PATH = '/api/v1/items/:itemId' as const;
+
+export interface UpdateItemInput {
+  readonly itemId: string;
+  readonly body: Partial<UpdateItemRequestDto>;
+  readonly headers?: Record<string, string>;
+}
+
+export async function updateItem(
+  http: HttpClient,
+  input: UpdateItemInput,
+): Promise<IApiResponse<ItemDto>> {
+  const path = buildPath(ITEM_PATH, { itemId: input.itemId });
+  const { data } = await http.patch<IApiResponse<ItemDto>>(path, {
+    data: input.body,
+    headers: input.headers,
+  });
+  return data;
+}
+```
+
+### PUT — full replacement body
+
+Same pattern as PATCH; use when the API semantics are “replace resource”:
+
+```typescript
+export async function replaceItem(
+  http: HttpClient,
+  input: { itemId: string; body: ReplaceItemRequestDto; headers?: Record<string, string> },
+): Promise<IApiResponse<ItemDto>> {
+  const path = buildPath('/api/v1/items/:itemId', { itemId: input.itemId });
+  const { data } = await http.put<IApiResponse<ItemDto>>(path, {
+    data: input.body,
+    headers: input.headers,
+  });
+  return data;
+}
+```
+
+### DELETE — path params; optional body for APIs that require one
+
+Many DELETE endpoints have **no body**; omit `data`:
+
+```typescript
+export async function deleteItem(
+  http: HttpClient,
+  itemId: string,
+  headers?: Record<string, string>,
+): Promise<IApiResponse<void>> {
+  const path = buildPath('/api/v1/items/:itemId', { itemId });
+  const { data } = await http.delete<IApiResponse<void>>(path, { headers });
+  return data;
+}
+```
+
+If your API uses a JSON body on DELETE (uncommon but possible):
+
+```typescript
+await http.delete<IApiResponse<void>>(path, {
+  data: { reason: 'user_request' },
+  headers: { 'Content-Type': 'application/json' },
+});
+```
+
+---
+
+## Wiring new endpoints into `createApiClient`
+
+1. Add `src/endpoints/your-endpoint.ts` with a `fetch*` / `create*` / `update*` function that takes `http` first (and an `input` object for non-trivial inputs).
+2. Extend `HttpClient` if the verb is not available yet.
+3. Add a method on `ApiClient` and delegate to the endpoint function.
+
+Example after adding `fetchItems` and `createItem`:
+
+```typescript
+// src/create-api-client.ts
+import { createItem } from './endpoints/create-item';
+import { fetchItems } from './endpoints/list-items';
+import { fetchHealthCheck } from './endpoints/health-check';
+import type { HttpClient } from './http-client';
+
+export function createApiClient(options: { http: HttpClient }) {
+  const { http } = options;
+
+  return {
+    healthCheck: () => fetchHealthCheck(http),
+    listItems: (params?: ListItemsParams) => fetchItems(http, params),
+    createItem: (input: CreateItemInput) => createItem(http, input),
+  };
+}
+```
+
+Export new types (`ListItemsParams`, `CreateItemInput`, etc.) from `src/index.ts` if consumers need them.
+
+---
+
+## Testing
+
+Inject a fake `HttpClient` and assert the right URL, method, and payload were used.
+
+**With the current `HttpClient` (only `get`):**
+
+```typescript
+import type { HttpClient } from '@ipetsadmin/api-client';
+import { createApiClient } from '@ipetsadmin/api-client';
+
+const http: HttpClient = {
+  get: jest.fn().mockResolvedValue({ data: { success: true, data: {} } }),
+};
+
+const api = createApiClient({ http });
+await api.healthCheck();
+
+expect(http.get).toHaveBeenCalledWith('/api/v1/health-check', undefined);
+```
+
+**After you extend `HttpClient` with `post` / `put` / `patch` / `delete`,** add matching mocks (e.g. `post: jest.fn()`) so the object satisfies the full interface.
+
+---
+
+## Development (this repository)
+
+| Script                    | Purpose                                                                   |
+| ------------------------- | ------------------------------------------------------------------------- |
+| `pnpm run build`          | Produce `dist/` (CJS, ESM, `.d.ts`) via [tsup](https://tsup.egoist.dev/). |
+| `pnpm run typecheck`      | `tsc --noEmit`                                                            |
+| `pnpm run lint`           | ESLint                                                                    |
+| `pnpm run validate`       | typecheck + lint + Prettier check                                         |
+| `pnpm run prepublishOnly` | runs validate and build before publish                                    |
+
+---
+
+## Summary
+
+- **Today:** `createApiClient({ http })` + `healthCheck()` + `HttpClient` with **`get` only**.
+- **Next:** Extend `HttpClient` with `post` / `put` / `patch` / `delete` and optional `HttpRequestConfig`, then add endpoint modules that use **path helpers**, **`params`**, **`data`**, and **`headers`** as shown above.
+- **Types:** Prefer `@ipetsadmin/contracts` for DTOs and `IApiResponse<T>` for envelope responses.
+
+For changes to this package, see [CHANGELOG.md](./CHANGELOG.md).

package/dist/index.d.mts

@@ -0,0 +1,20 @@
+import { IApiResponse } from '@ipetsadmin/contracts';
+
+type HttpGet = <TResponse>(url: string, config?: unknown) => Promise<{
+    data: TResponse;
+}>;
+interface HttpClient {
+    readonly get: HttpGet;
+}
+
+declare function fetchHealthCheck(http: HttpClient): Promise<IApiResponse<unknown>>;
+
+interface CreateApiClientOptions {
+    readonly http: HttpClient;
+}
+interface ApiClient {
+    readonly healthCheck: () => ReturnType<typeof fetchHealthCheck>;
+}
+declare function createApiClient(options: CreateApiClientOptions): ApiClient;
+
+export { type ApiClient, type CreateApiClientOptions, type HttpClient, type HttpGet, createApiClient };

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import { IApiResponse } from '@ipetsadmin/contracts';
+
+type HttpGet = <TResponse>(url: string, config?: unknown) => Promise<{
+    data: TResponse;
+}>;
+interface HttpClient {
+    readonly get: HttpGet;
+}
+
+declare function fetchHealthCheck(http: HttpClient): Promise<IApiResponse<unknown>>;
+
+interface CreateApiClientOptions {
+    readonly http: HttpClient;
+}
+interface ApiClient {
+    readonly healthCheck: () => ReturnType<typeof fetchHealthCheck>;
+}
+declare function createApiClient(options: CreateApiClientOptions): ApiClient;
+
+export { type ApiClient, type CreateApiClientOptions, type HttpClient, type HttpGet, createApiClient };

package/dist/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+// src/endpoints/health-check.ts
+var HEALTH_CHECK_PATH = "/api/v1/health-check";
+async function fetchHealthCheck(http) {
+  const { data } = await http.get(HEALTH_CHECK_PATH);
+  return data;
+}
+
+// src/create-api-client.ts
+function createApiClient(options) {
+  const { http } = options;
+  return {
+    healthCheck: () => fetchHealthCheck(http)
+  };
+}
+
+exports.createApiClient = createApiClient;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endpoints/health-check.ts","../src/create-api-client.ts"],"names":[],"mappings":";;;AAGA,IAAM,iBAAA,GAAoB,sBAAA;AAO1B,eAAsB,iBAAiB,IAAA,EAAkD;AACvF,EAAA,MAAM,EAAE,IAAA,EAAK,GAAI,MAAM,IAAA,CAAK,IAA2B,iBAAiB,CAAA;AACxE,EAAA,OAAO,IAAA;AACT;;;ACKO,SAAS,gBAAgB,OAAA,EAA4C;AAC1E,EAAA,MAAM,EAAE,MAAK,GAAI,OAAA;AAEjB,EAAA,OAAO;AAAA,IACL,WAAA,EAAa,MAAM,gBAAA,CAAiB,IAAI;AAAA,GAC1C;AACF","file":"index.js","sourcesContent":["import type { IApiResponse } from '@ipetsadmin/contracts';\nimport type { HttpClient } from '../http-client';\n\nconst HEALTH_CHECK_PATH = '/api/v1/health-check' as const;\n\n/**\n * GET /api/v1/health-check — server liveness.\n * Response shape is the standard API envelope; payload typing can be refined\n * in `@ipetsadmin/contracts` when the health payload is finalized.\n */\nexport async function fetchHealthCheck(http: HttpClient): Promise<IApiResponse<unknown>> {\n  const { data } = await http.get<IApiResponse<unknown>>(HEALTH_CHECK_PATH);\n  return data;\n}\n","import { fetchHealthCheck } from './endpoints/health-check';\nimport type { HttpClient } from './http-client';\n\nexport interface CreateApiClientOptions {\n  /**\n   * Preconfigured HTTP client (e.g. Axios instance with `baseURL` set).\n   * Paths in this library are relative to that base (e.g. `/api/v1/...`).\n   */\n  readonly http: HttpClient;\n}\n\nexport interface ApiClient {\n  readonly healthCheck: () => ReturnType<typeof fetchHealthCheck>;\n}\n\n/**\n * Creates a typed API client backed by the provided HTTP implementation.\n */\nexport function createApiClient(options: CreateApiClientOptions): ApiClient {\n  const { http } = options;\n\n  return {\n    healthCheck: () => fetchHealthCheck(http),\n  };\n}\n"]}

package/dist/index.mjs

@@ -0,0 +1,18 @@
+// src/endpoints/health-check.ts
+var HEALTH_CHECK_PATH = "/api/v1/health-check";
+async function fetchHealthCheck(http) {
+  const { data } = await http.get(HEALTH_CHECK_PATH);
+  return data;
+}
+
+// src/create-api-client.ts
+function createApiClient(options) {
+  const { http } = options;
+  return {
+    healthCheck: () => fetchHealthCheck(http)
+  };
+}
+
+export { createApiClient };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/endpoints/health-check.ts","../src/create-api-client.ts"],"names":[],"mappings":";AAGA,IAAM,iBAAA,GAAoB,sBAAA;AAO1B,eAAsB,iBAAiB,IAAA,EAAkD;AACvF,EAAA,MAAM,EAAE,IAAA,EAAK,GAAI,MAAM,IAAA,CAAK,IAA2B,iBAAiB,CAAA;AACxE,EAAA,OAAO,IAAA;AACT;;;ACKO,SAAS,gBAAgB,OAAA,EAA4C;AAC1E,EAAA,MAAM,EAAE,MAAK,GAAI,OAAA;AAEjB,EAAA,OAAO;AAAA,IACL,WAAA,EAAa,MAAM,gBAAA,CAAiB,IAAI;AAAA,GAC1C;AACF","file":"index.mjs","sourcesContent":["import type { IApiResponse } from '@ipetsadmin/contracts';\nimport type { HttpClient } from '../http-client';\n\nconst HEALTH_CHECK_PATH = '/api/v1/health-check' as const;\n\n/**\n * GET /api/v1/health-check — server liveness.\n * Response shape is the standard API envelope; payload typing can be refined\n * in `@ipetsadmin/contracts` when the health payload is finalized.\n */\nexport async function fetchHealthCheck(http: HttpClient): Promise<IApiResponse<unknown>> {\n  const { data } = await http.get<IApiResponse<unknown>>(HEALTH_CHECK_PATH);\n  return data;\n}\n","import { fetchHealthCheck } from './endpoints/health-check';\nimport type { HttpClient } from './http-client';\n\nexport interface CreateApiClientOptions {\n  /**\n   * Preconfigured HTTP client (e.g. Axios instance with `baseURL` set).\n   * Paths in this library are relative to that base (e.g. `/api/v1/...`).\n   */\n  readonly http: HttpClient;\n}\n\nexport interface ApiClient {\n  readonly healthCheck: () => ReturnType<typeof fetchHealthCheck>;\n}\n\n/**\n * Creates a typed API client backed by the provided HTTP implementation.\n */\nexport function createApiClient(options: CreateApiClientOptions): ApiClient {\n  const { http } = options;\n\n  return {\n    healthCheck: () => fetchHealthCheck(http),\n  };\n}\n"]}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@ipetsadmin/api-client",
+  "version": "1.0.0",
+  "description": "Client used to interact with Truffa project API",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "lint-staged": {
+    "src/**/*.{ts,tsx}": [
+      "eslint --fix --max-warnings 0",
+      "prettier --write"
+    ],
+    "tsup.config.ts": "prettier --write",
+    "*.{json,md}": "prettier --write"
+  },
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "keywords": [
+    "types",
+    "typescript",
+    "shared"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@ipetsadmin/contracts": "^1.0.3",
+    "@eslint/js": "^10.0.1",
+    "@types/express": "^5.0.5",
+    "@types/node": "^24.10.0",
+    "eslint": "^10.1.0",
+    "eslint-config-prettier": "^10.1.8",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "prettier": "^3.8.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.58.0"
+  },
+  "peerDependencies": {
+    "@ipetsadmin/contracts": "^1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint . --cache --cache-location .eslintcache",
+    "lint:fix": "eslint . --fix --cache --cache-location .eslintcache",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "validate": "pnpm run typecheck && pnpm run lint && pnpm run format:check",
+    "publish:npm": "pnpm publish --access public --no-git-checks"
+  }
+}