@blimu/client 0.5.0

package/README.md

@@ -0,0 +1,167 @@
+# Blimu TypeScript SDK
+
+This is an auto-generated TypeScript/JavaScript SDK for the Blimu API.
+
+## Installation
+
+```bash
+npm install @blimu/client
+# or
+yarn add @blimu/client
+```
+
+## Quick Start
+
+```typescript
+import { BlimuClient } from '@blimu/client';
+
+// Create a new client
+const client = new BlimuClient({
+  baseURL: 'https://api.example.com',
+  timeoutMs: 10000,
+  retry: { retries: 2, backoffMs: 300, retryOn: [429, 500, 502, 503, 504] },
+  // Environment-based baseURL (optional)
+  env: 'sandbox',
+  envBaseURLs: {
+    sandbox: 'https://api-sandbox.example.com',
+    production: 'https://api.example.com',
+  },
+  // Auth (generic API Key or Bearer header)
+  accessToken: process.env.API_TOKEN,
+  headerName: 'access_token', // or 'Authorization' (defaults to Authorization: Bearer <token>)
+});
+// Example: Logout and invalidate session
+try {
+  const result = await client.auth.logout();
+  console.log('Result:', result);
+} catch (error) {
+  // ApiError with structured data
+  console.error(error);
+}
+```
+
+## Environment & Auth
+
+```typescript
+const client = new BlimuClient({
+  env: 'sandbox',
+  envBaseURLs: {
+    sandbox: 'https://api-sandbox.example.com',
+    production: 'https://api.example.com',
+  },
+  accessToken: async () => process.env.API_TOKEN!,
+  headerName: 'access_token',
+});
+client.setAccessToken('new-token');
+```
+
+## Pagination
+
+```typescript
+import { listAll } from '@blimu/client';
+
+const allPayments = await listAll((query) => client.payment.listPayments(query), { limit: 100 });
+```
+
+## Interceptors
+
+```typescript
+const client = new BlimuClient({
+  onRequest: ({ url, init }) => console.debug('->', init.method, url),
+  onResponse: ({ response }) => console.debug('<-', response.status),
+  onError: (err) => console.warn('request error', err),
+});
+```
+
+## Authentication
+
+This SDK supports the following authentication methods:
+
+### Bearer
+
+Bearer token authentication:
+
+```typescript
+const client = new BlimuClient({
+  bearer: 'your-bearer-token',
+});
+```
+
+## Subpath imports
+
+```typescript
+import { PaymentService, Schema } from '@blimu/client';
+```
+
+## Available Services
+
+### AuthService
+
+- **logout**: POST /v1/auth/logout - Logout and invalidate session
+- **refresh**: POST /v1/auth/refresh - Refresh session token
+- **getSession**: GET /v1/auth/session - Get current session
+
+## TypeScript Support
+
+This SDK is written in TypeScript and provides full type safety:
+
+```typescript
+import { BlimuClient, Schema } from '@blimu/client';
+
+const client = new BlimuClient({
+  /* config */
+});
+
+// All methods are fully typed
+const result: unknown = await client.auth.logout(/* ... */);
+
+// Schema types are available
+const data: Schema.RefreshResponse = {
+  // Fully typed object
+};
+```
+
+## Node.js Usage
+
+For Node.js environments, you may need to provide a fetch implementation:
+
+```bash
+npm install undici
+```
+
+```typescript
+import { fetch } from 'undici';
+import { BlimuClient } from '@blimu/client';
+
+const client = new BlimuClient({
+  baseURL: 'https://api.example.com',
+  fetch,
+});
+```
+
+## Models and Types
+
+The SDK includes the following TypeScript interfaces:
+
+- **RefreshResponse**
+- **SessionResponse**
+
+All types are available under the `Schema` namespace:
+
+```typescript
+import { Schema } from '@blimu/client';
+
+// Use any model type
+const user: Schema.User = {
+  /* ... */
+};
+```
+
+## Contributing
+
+This SDK is auto-generated. Please do not edit the generated files directly.
+If you find issues, please report them in the main project repository.
+
+## License
+
+This SDK is generated from the Blimu API specification.

package/dist/chunk-7SBLH5KM.mjs

@@ -0,0 +1,6 @@
+// src/schema.ts
+var schema_exports = {};
+
+export {
+  schema_exports
+};

package/dist/chunk-GA44NLBR.mjs

@@ -0,0 +1,122 @@
+// src/client.ts
+var FetchError = class extends Error {
+  constructor(message, status, data, headers) {
+    super(message);
+    this.status = status;
+    this.data = data;
+    this.headers = headers;
+    this.name = "FetchError";
+  }
+};
+var CoreClient = class {
+  constructor(cfg = {}) {
+    this.cfg = cfg;
+    if (!this.cfg.baseURL) {
+      if (this.cfg.env && this.cfg.envBaseURLs) {
+        this.cfg.baseURL = this.cfg.env === "production" ? this.cfg.envBaseURLs.production : this.cfg.envBaseURLs.sandbox;
+      } else {
+        this.cfg.baseURL = "https://api.blimu.dev";
+      }
+    }
+  }
+  setAccessToken(token) {
+    this.cfg.accessToken = token;
+  }
+  async request(init) {
+    let normalizedPath = init.path || "";
+    if (normalizedPath.length > 1 && normalizedPath.endsWith("/")) {
+      normalizedPath = normalizedPath.slice(0, -1);
+    }
+    const url = new URL((this.cfg.baseURL || "") + normalizedPath);
+    if (init.query) {
+      Object.entries(init.query).forEach(([k, v]) => {
+        if (v === void 0 || v === null) return;
+        if (Array.isArray(v)) v.forEach((vv) => url.searchParams.append(k, String(vv)));
+        else url.searchParams.set(k, String(v));
+      });
+    }
+    const headers = new Headers({
+      ...this.cfg.headers || {},
+      ...init.headers
+    });
+    if (this.cfg.accessToken) {
+      const token = typeof this.cfg.accessToken === "function" ? await this.cfg.accessToken() : this.cfg.accessToken;
+      if (token != null) {
+        const name = this.cfg.headerName || "Authorization";
+        if (name.toLowerCase() === "authorization") headers.set(name, `Bearer ${String(token)}`);
+        else headers.set(name, String(token));
+      }
+    }
+    if (this.cfg.bearer) headers.set("Authorization", `Bearer ${this.cfg.bearer}`);
+    const doFetch = async (attempt) => {
+      const requestHeaders = new Headers(headers);
+      const fetchInit = {
+        ...init,
+        headers: requestHeaders
+      };
+      if (this.cfg.onRequest)
+        await this.cfg.onRequest({ url: url.toString(), init: fetchInit, attempt });
+      let controller;
+      let timeoutId;
+      if (this.cfg.timeoutMs && typeof AbortController !== "undefined") {
+        controller = new AbortController();
+        fetchInit.signal = controller.signal;
+        timeoutId = setTimeout(() => controller?.abort(), this.cfg.timeoutMs);
+      }
+      try {
+        const res = await (this.cfg.fetch || fetch)(url.toString(), fetchInit);
+        if (this.cfg.onResponse)
+          await this.cfg.onResponse({
+            url: url.toString(),
+            init: fetchInit,
+            attempt,
+            response: res
+          });
+        const ct = res.headers.get("content-type") || "";
+        let parsed;
+        if (ct.includes("application/json")) {
+          parsed = await res.json();
+        } else if (ct.startsWith("text/")) {
+          parsed = await res.text();
+        } else {
+          parsed = await res.arrayBuffer();
+        }
+        if (!res.ok) {
+          throw new FetchError(`HTTP ${res.status}`, res.status, parsed, res.headers);
+        }
+        return parsed;
+      } catch (err) {
+        if (this.cfg.onError) await this.cfg.onError(err, { url: url.toString(), init, attempt });
+        throw err;
+      } finally {
+        if (timeoutId) clearTimeout(timeoutId);
+      }
+    };
+    const retries = this.cfg.retry?.retries ?? 0;
+    const baseBackoff = this.cfg.retry?.backoffMs ?? 300;
+    const retryOn = this.cfg.retry?.retryOn ?? [429, 500, 502, 503, 504];
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        return await doFetch(attempt);
+      } catch (err) {
+        const status = err?.status;
+        const shouldRetry = status ? retryOn.includes(status) : true;
+        if (attempt < retries && shouldRetry) {
+          const delay = baseBackoff * Math.pow(2, attempt);
+          await new Promise((r) => setTimeout(r, delay));
+          lastError = err;
+          continue;
+        }
+        if (err instanceof FetchError) throw err;
+        throw new FetchError(err?.message || "Network error", status ?? 0);
+      }
+    }
+    throw lastError;
+  }
+};
+
+export {
+  FetchError,
+  CoreClient
+};

package/dist/chunk-LZ27JJ4R.mjs

@@ -0,0 +1,25 @@
+// src/utils.ts
+async function* paginate(fetchPage, initialQuery = {}, pageSize = 100) {
+  let offset = Number(initialQuery.offset ?? 0);
+  const limit = Number(initialQuery.limit ?? pageSize);
+  const baseQuery = { ...initialQuery };
+  while (true) {
+    const page = await fetchPage({ ...baseQuery, limit, offset });
+    const items = page.data ?? [];
+    for (const item of items) {
+      yield item;
+    }
+    if (!page.hasMore || items.length < limit) break;
+    offset += limit;
+  }
+}
+async function listAll(fetchPage, query = {}, pageSize = 100) {
+  const out = [];
+  for await (const item of paginate(fetchPage, query, pageSize)) out.push(item);
+  return out;
+}
+
+export {
+  paginate,
+  listAll
+};

package/dist/chunk-UTMQXMDQ.mjs

@@ -0,0 +1,43 @@
+// src/services/auth.ts
+var AuthService = class {
+  constructor(core) {
+    this.core = core;
+  }
+  /**
+   * POST /v1/auth/logout
+   * @summary Logout and invalidate session
+   */
+  logout(init) {
+    return this.core.request({
+      method: "POST",
+      path: `/v1/auth/logout`,
+      ...init || {}
+    });
+  }
+  /**
+   * POST /v1/auth/refresh
+   * @summary Refresh session token
+   */
+  refresh(init) {
+    return this.core.request({
+      method: "POST",
+      path: `/v1/auth/refresh`,
+      ...init || {}
+    });
+  }
+  /**
+   * GET /v1/auth/session
+   * @summary Get current session
+   */
+  getSession(init) {
+    return this.core.request({
+      method: "GET",
+      path: `/v1/auth/session`,
+      ...init || {}
+    });
+  }
+};
+
+export {
+  AuthService
+};

package/dist/client.d.mts

@@ -0,0 +1,67 @@
+type ClientOption = {
+    baseURL?: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    retry?: {
+        retries: number;
+        backoffMs: number;
+        retryOn?: number[];
+    };
+    onRequest?: (ctx: {
+        url: string;
+        init: RequestInit & {
+            path: string;
+            method: string;
+            query?: Record<string, any>;
+            headers: Headers;
+        };
+        attempt: number;
+    }) => void | Promise<void>;
+    onResponse?: (ctx: {
+        url: string;
+        init: RequestInit & {
+            path: string;
+            method: string;
+            query?: Record<string, any>;
+            headers: Headers;
+        };
+        attempt: number;
+        response: Response;
+    }) => void | Promise<void>;
+    onError?: (err: unknown, ctx: {
+        url: string;
+        init: RequestInit & {
+            path: string;
+            method: string;
+            query?: Record<string, any>;
+        };
+        attempt: number;
+    }) => void | Promise<void>;
+    env?: 'sandbox' | 'production';
+    envBaseURLs?: {
+        sandbox: string;
+        production: string;
+    };
+    accessToken?: string | undefined | (() => string | undefined | Promise<string | undefined>);
+    headerName?: string;
+    bearer?: string;
+    fetch?: typeof fetch;
+};
+declare class FetchError<T = unknown> extends Error {
+    readonly status: number;
+    readonly data?: T | undefined;
+    readonly headers?: Headers | undefined;
+    constructor(message: string, status: number, data?: T | undefined, headers?: Headers | undefined);
+}
+declare class CoreClient {
+    private cfg;
+    constructor(cfg?: ClientOption);
+    setAccessToken(token: string | undefined | (() => string | undefined | Promise<string | undefined>)): void;
+    request(init: RequestInit & {
+        path: string;
+        method: string;
+        query?: Record<string, any>;
+    }): Promise<any>;
+}
+
+export { type ClientOption, CoreClient, FetchError };

package/dist/client.d.ts

@@ -0,0 +1,67 @@
+type ClientOption = {
+    baseURL?: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    retry?: {
+        retries: number;
+        backoffMs: number;
+        retryOn?: number[];
+    };
+    onRequest?: (ctx: {
+        url: string;
+        init: RequestInit & {
+            path: string;
+            method: string;
+            query?: Record<string, any>;
+            headers: Headers;
+        };
+        attempt: number;
+    }) => void | Promise<void>;
+    onResponse?: (ctx: {
+        url: string;
+        init: RequestInit & {
+            path: string;
+            method: string;
+            query?: Record<string, any>;
+            headers: Headers;
+        };
+        attempt: number;
+        response: Response;
+    }) => void | Promise<void>;
+    onError?: (err: unknown, ctx: {
+        url: string;
+        init: RequestInit & {
+            path: string;
+            method: string;
+            query?: Record<string, any>;
+        };
+        attempt: number;
+    }) => void | Promise<void>;
+    env?: 'sandbox' | 'production';
+    envBaseURLs?: {
+        sandbox: string;
+        production: string;
+    };
+    accessToken?: string | undefined | (() => string | undefined | Promise<string | undefined>);
+    headerName?: string;
+    bearer?: string;
+    fetch?: typeof fetch;
+};
+declare class FetchError<T = unknown> extends Error {
+    readonly status: number;
+    readonly data?: T | undefined;
+    readonly headers?: Headers | undefined;
+    constructor(message: string, status: number, data?: T | undefined, headers?: Headers | undefined);
+}
+declare class CoreClient {
+    private cfg;
+    constructor(cfg?: ClientOption);
+    setAccessToken(token: string | undefined | (() => string | undefined | Promise<string | undefined>)): void;
+    request(init: RequestInit & {
+        path: string;
+        method: string;
+        query?: Record<string, any>;
+    }): Promise<any>;
+}
+
+export { type ClientOption, CoreClient, FetchError };

package/dist/client.js

@@ -0,0 +1,146 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  CoreClient: () => CoreClient,
+  FetchError: () => FetchError
+});
+module.exports = __toCommonJS(client_exports);
+var FetchError = class extends Error {
+  constructor(message, status, data, headers) {
+    super(message);
+    this.status = status;
+    this.data = data;
+    this.headers = headers;
+    this.name = "FetchError";
+  }
+};
+var CoreClient = class {
+  constructor(cfg = {}) {
+    this.cfg = cfg;
+    if (!this.cfg.baseURL) {
+      if (this.cfg.env && this.cfg.envBaseURLs) {
+        this.cfg.baseURL = this.cfg.env === "production" ? this.cfg.envBaseURLs.production : this.cfg.envBaseURLs.sandbox;
+      } else {
+        this.cfg.baseURL = "https://api.blimu.dev";
+      }
+    }
+  }
+  setAccessToken(token) {
+    this.cfg.accessToken = token;
+  }
+  async request(init) {
+    let normalizedPath = init.path || "";
+    if (normalizedPath.length > 1 && normalizedPath.endsWith("/")) {
+      normalizedPath = normalizedPath.slice(0, -1);
+    }
+    const url = new URL((this.cfg.baseURL || "") + normalizedPath);
+    if (init.query) {
+      Object.entries(init.query).forEach(([k, v]) => {
+        if (v === void 0 || v === null) return;
+        if (Array.isArray(v)) v.forEach((vv) => url.searchParams.append(k, String(vv)));
+        else url.searchParams.set(k, String(v));
+      });
+    }
+    const headers = new Headers({
+      ...this.cfg.headers || {},
+      ...init.headers
+    });
+    if (this.cfg.accessToken) {
+      const token = typeof this.cfg.accessToken === "function" ? await this.cfg.accessToken() : this.cfg.accessToken;
+      if (token != null) {
+        const name = this.cfg.headerName || "Authorization";
+        if (name.toLowerCase() === "authorization") headers.set(name, `Bearer ${String(token)}`);
+        else headers.set(name, String(token));
+      }
+    }
+    if (this.cfg.bearer) headers.set("Authorization", `Bearer ${this.cfg.bearer}`);
+    const doFetch = async (attempt) => {
+      const requestHeaders = new Headers(headers);
+      const fetchInit = {
+        ...init,
+        headers: requestHeaders
+      };
+      if (this.cfg.onRequest)
+        await this.cfg.onRequest({ url: url.toString(), init: fetchInit, attempt });
+      let controller;
+      let timeoutId;
+      if (this.cfg.timeoutMs && typeof AbortController !== "undefined") {
+        controller = new AbortController();
+        fetchInit.signal = controller.signal;
+        timeoutId = setTimeout(() => controller?.abort(), this.cfg.timeoutMs);
+      }
+      try {
+        const res = await (this.cfg.fetch || fetch)(url.toString(), fetchInit);
+        if (this.cfg.onResponse)
+          await this.cfg.onResponse({
+            url: url.toString(),
+            init: fetchInit,
+            attempt,
+            response: res
+          });
+        const ct = res.headers.get("content-type") || "";
+        let parsed;
+        if (ct.includes("application/json")) {
+          parsed = await res.json();
+        } else if (ct.startsWith("text/")) {
+          parsed = await res.text();
+        } else {
+          parsed = await res.arrayBuffer();
+        }
+        if (!res.ok) {
+          throw new FetchError(`HTTP ${res.status}`, res.status, parsed, res.headers);
+        }
+        return parsed;
+      } catch (err) {
+        if (this.cfg.onError) await this.cfg.onError(err, { url: url.toString(), init, attempt });
+        throw err;
+      } finally {
+        if (timeoutId) clearTimeout(timeoutId);
+      }
+    };
+    const retries = this.cfg.retry?.retries ?? 0;
+    const baseBackoff = this.cfg.retry?.backoffMs ?? 300;
+    const retryOn = this.cfg.retry?.retryOn ?? [429, 500, 502, 503, 504];
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        return await doFetch(attempt);
+      } catch (err) {
+        const status = err?.status;
+        const shouldRetry = status ? retryOn.includes(status) : true;
+        if (attempt < retries && shouldRetry) {
+          const delay = baseBackoff * Math.pow(2, attempt);
+          await new Promise((r) => setTimeout(r, delay));
+          lastError = err;
+          continue;
+        }
+        if (err instanceof FetchError) throw err;
+        throw new FetchError(err?.message || "Network error", status ?? 0);
+      }
+    }
+    throw lastError;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CoreClient,
+  FetchError
+});

package/dist/client.mjs

@@ -0,0 +1,8 @@
+import {
+  CoreClient,
+  FetchError
+} from "./chunk-GA44NLBR.mjs";
+export {
+  CoreClient,
+  FetchError
+};

package/dist/index.d.mts

@@ -0,0 +1,13 @@
+import { ClientOption, FetchError } from './client.mjs';
+import { AuthService } from './services/auth.mjs';
+export { PaginableQuery, listAll, paginate } from './utils.mjs';
+export { s as Schema } from './schema-C3_USjmu.mjs';
+
+declare class Blimu {
+    readonly auth: AuthService;
+    constructor(options?: ClientOption);
+}
+
+declare const BlimuError: typeof FetchError;
+
+export { AuthService, Blimu, BlimuError, ClientOption, FetchError };

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { ClientOption, FetchError } from './client.js';
+import { AuthService } from './services/auth.js';
+export { PaginableQuery, listAll, paginate } from './utils.js';
+export { s as Schema } from './schema-C3_USjmu.js';
+
+declare class Blimu {
+    readonly auth: AuthService;
+    constructor(options?: ClientOption);
+}
+
+declare const BlimuError: typeof FetchError;
+
+export { AuthService, Blimu, BlimuError, ClientOption, FetchError };

package/dist/index.js

@@ -0,0 +1,231 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthService: () => AuthService,
+  Blimu: () => Blimu,
+  BlimuError: () => BlimuError,
+  FetchError: () => FetchError,
+  Schema: () => schema_exports,
+  listAll: () => listAll,
+  paginate: () => paginate
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var FetchError = class extends Error {
+  constructor(message, status, data, headers) {
+    super(message);
+    this.status = status;
+    this.data = data;
+    this.headers = headers;
+    this.name = "FetchError";
+  }
+};
+var CoreClient = class {
+  constructor(cfg = {}) {
+    this.cfg = cfg;
+    if (!this.cfg.baseURL) {
+      if (this.cfg.env && this.cfg.envBaseURLs) {
+        this.cfg.baseURL = this.cfg.env === "production" ? this.cfg.envBaseURLs.production : this.cfg.envBaseURLs.sandbox;
+      } else {
+        this.cfg.baseURL = "https://api.blimu.dev";
+      }
+    }
+  }
+  setAccessToken(token) {
+    this.cfg.accessToken = token;
+  }
+  async request(init) {
+    let normalizedPath = init.path || "";
+    if (normalizedPath.length > 1 && normalizedPath.endsWith("/")) {
+      normalizedPath = normalizedPath.slice(0, -1);
+    }
+    const url = new URL((this.cfg.baseURL || "") + normalizedPath);
+    if (init.query) {
+      Object.entries(init.query).forEach(([k, v]) => {
+        if (v === void 0 || v === null) return;
+        if (Array.isArray(v)) v.forEach((vv) => url.searchParams.append(k, String(vv)));
+        else url.searchParams.set(k, String(v));
+      });
+    }
+    const headers = new Headers({
+      ...this.cfg.headers || {},
+      ...init.headers
+    });
+    if (this.cfg.accessToken) {
+      const token = typeof this.cfg.accessToken === "function" ? await this.cfg.accessToken() : this.cfg.accessToken;
+      if (token != null) {
+        const name = this.cfg.headerName || "Authorization";
+        if (name.toLowerCase() === "authorization") headers.set(name, `Bearer ${String(token)}`);
+        else headers.set(name, String(token));
+      }
+    }
+    if (this.cfg.bearer) headers.set("Authorization", `Bearer ${this.cfg.bearer}`);
+    const doFetch = async (attempt) => {
+      const requestHeaders = new Headers(headers);
+      const fetchInit = {
+        ...init,
+        headers: requestHeaders
+      };
+      if (this.cfg.onRequest)
+        await this.cfg.onRequest({ url: url.toString(), init: fetchInit, attempt });
+      let controller;
+      let timeoutId;
+      if (this.cfg.timeoutMs && typeof AbortController !== "undefined") {
+        controller = new AbortController();
+        fetchInit.signal = controller.signal;
+        timeoutId = setTimeout(() => controller?.abort(), this.cfg.timeoutMs);
+      }
+      try {
+        const res = await (this.cfg.fetch || fetch)(url.toString(), fetchInit);
+        if (this.cfg.onResponse)
+          await this.cfg.onResponse({
+            url: url.toString(),
+            init: fetchInit,
+            attempt,
+            response: res
+          });
+        const ct = res.headers.get("content-type") || "";
+        let parsed;
+        if (ct.includes("application/json")) {
+          parsed = await res.json();
+        } else if (ct.startsWith("text/")) {
+          parsed = await res.text();
+        } else {
+          parsed = await res.arrayBuffer();
+        }
+        if (!res.ok) {
+          throw new FetchError(`HTTP ${res.status}`, res.status, parsed, res.headers);
+        }
+        return parsed;
+      } catch (err) {
+        if (this.cfg.onError) await this.cfg.onError(err, { url: url.toString(), init, attempt });
+        throw err;
+      } finally {
+        if (timeoutId) clearTimeout(timeoutId);
+      }
+    };
+    const retries = this.cfg.retry?.retries ?? 0;
+    const baseBackoff = this.cfg.retry?.backoffMs ?? 300;
+    const retryOn = this.cfg.retry?.retryOn ?? [429, 500, 502, 503, 504];
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        return await doFetch(attempt);
+      } catch (err) {
+        const status = err?.status;
+        const shouldRetry = status ? retryOn.includes(status) : true;
+        if (attempt < retries && shouldRetry) {
+          const delay = baseBackoff * Math.pow(2, attempt);
+          await new Promise((r) => setTimeout(r, delay));
+          lastError = err;
+          continue;
+        }
+        if (err instanceof FetchError) throw err;
+        throw new FetchError(err?.message || "Network error", status ?? 0);
+      }
+    }
+    throw lastError;
+  }
+};
+
+// src/services/auth.ts
+var AuthService = class {
+  constructor(core) {
+    this.core = core;
+  }
+  /**
+   * POST /v1/auth/logout
+   * @summary Logout and invalidate session
+   */
+  logout(init) {
+    return this.core.request({
+      method: "POST",
+      path: `/v1/auth/logout`,
+      ...init || {}
+    });
+  }
+  /**
+   * POST /v1/auth/refresh
+   * @summary Refresh session token
+   */
+  refresh(init) {
+    return this.core.request({
+      method: "POST",
+      path: `/v1/auth/refresh`,
+      ...init || {}
+    });
+  }
+  /**
+   * GET /v1/auth/session
+   * @summary Get current session
+   */
+  getSession(init) {
+    return this.core.request({
+      method: "GET",
+      path: `/v1/auth/session`,
+      ...init || {}
+    });
+  }
+};
+
+// src/utils.ts
+async function* paginate(fetchPage, initialQuery = {}, pageSize = 100) {
+  let offset = Number(initialQuery.offset ?? 0);
+  const limit = Number(initialQuery.limit ?? pageSize);
+  const baseQuery = { ...initialQuery };
+  while (true) {
+    const page = await fetchPage({ ...baseQuery, limit, offset });
+    const items = page.data ?? [];
+    for (const item of items) {
+      yield item;
+    }
+    if (!page.hasMore || items.length < limit) break;
+    offset += limit;
+  }
+}
+async function listAll(fetchPage, query = {}, pageSize = 100) {
+  const out = [];
+  for await (const item of paginate(fetchPage, query, pageSize)) out.push(item);
+  return out;
+}
+
+// src/schema.ts
+var schema_exports = {};
+
+// src/index.ts
+var Blimu = class {
+  constructor(options) {
+    const core = new CoreClient(options);
+    this.auth = new AuthService(core);
+  }
+};
+var BlimuError = FetchError;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthService,
+  Blimu,
+  BlimuError,
+  FetchError,
+  Schema,
+  listAll,
+  paginate
+});

package/dist/index.mjs

@@ -0,0 +1,32 @@
+import {
+  CoreClient,
+  FetchError
+} from "./chunk-GA44NLBR.mjs";
+import {
+  schema_exports
+} from "./chunk-7SBLH5KM.mjs";
+import {
+  listAll,
+  paginate
+} from "./chunk-LZ27JJ4R.mjs";
+import {
+  AuthService
+} from "./chunk-UTMQXMDQ.mjs";
+
+// src/index.ts
+var Blimu = class {
+  constructor(options) {
+    const core = new CoreClient(options);
+    this.auth = new AuthService(core);
+  }
+};
+var BlimuError = FetchError;
+export {
+  AuthService,
+  Blimu,
+  BlimuError,
+  FetchError,
+  schema_exports as Schema,
+  listAll,
+  paginate
+};

package/dist/schema-C3_USjmu.d.mts

@@ -0,0 +1,23 @@
+type Enum<T> = T[keyof T];
+interface RefreshResponse {
+    sessionToken: string;
+}
+interface SessionResponse {
+    isAuthenticated: boolean;
+    user: {
+        email: string;
+        emailVerified: boolean;
+        firstName: string | null;
+        id: string;
+        lastName: string | null;
+    } | null;
+}
+
+type schema_Enum<T> = Enum<T>;
+type schema_RefreshResponse = RefreshResponse;
+type schema_SessionResponse = SessionResponse;
+declare namespace schema {
+  export type { schema_Enum as Enum, schema_RefreshResponse as RefreshResponse, schema_SessionResponse as SessionResponse };
+}
+
+export { type Enum as E, type RefreshResponse as R, type SessionResponse as S, schema as s };

package/dist/schema-C3_USjmu.d.ts

@@ -0,0 +1,23 @@
+type Enum<T> = T[keyof T];
+interface RefreshResponse {
+    sessionToken: string;
+}
+interface SessionResponse {
+    isAuthenticated: boolean;
+    user: {
+        email: string;
+        emailVerified: boolean;
+        firstName: string | null;
+        id: string;
+        lastName: string | null;
+    } | null;
+}
+
+type schema_Enum<T> = Enum<T>;
+type schema_RefreshResponse = RefreshResponse;
+type schema_SessionResponse = SessionResponse;
+declare namespace schema {
+  export type { schema_Enum as Enum, schema_RefreshResponse as RefreshResponse, schema_SessionResponse as SessionResponse };
+}
+
+export { type Enum as E, type RefreshResponse as R, type SessionResponse as S, schema as s };

package/dist/schema.d.mts

@@ -0,0 +1 @@
+export { E as Enum, R as RefreshResponse, S as SessionResponse } from './schema-C3_USjmu.mjs';

package/dist/schema.d.ts

@@ -0,0 +1 @@
+export { E as Enum, R as RefreshResponse, S as SessionResponse } from './schema-C3_USjmu.js';

package/dist/schema.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/schema.ts
+var schema_exports = {};
+module.exports = __toCommonJS(schema_exports);

package/dist/schema.mjs

@@ -0,0 +1 @@
+import "./chunk-7SBLH5KM.mjs";

package/dist/services/auth.d.mts

@@ -0,0 +1,12 @@
+import { CoreClient } from '../client.mjs';
+import { R as RefreshResponse, S as SessionResponse } from '../schema-C3_USjmu.mjs';
+
+declare class AuthService {
+    private core;
+    constructor(core: CoreClient);
+    logout(init?: Omit<RequestInit, 'method' | 'body'>): Promise<unknown>;
+    refresh(init?: Omit<RequestInit, 'method' | 'body'>): Promise<RefreshResponse>;
+    getSession(init?: Omit<RequestInit, 'method' | 'body'>): Promise<SessionResponse>;
+}
+
+export { AuthService };

package/dist/services/auth.d.ts

@@ -0,0 +1,12 @@
+import { CoreClient } from '../client.js';
+import { R as RefreshResponse, S as SessionResponse } from '../schema-C3_USjmu.js';
+
+declare class AuthService {
+    private core;
+    constructor(core: CoreClient);
+    logout(init?: Omit<RequestInit, 'method' | 'body'>): Promise<unknown>;
+    refresh(init?: Omit<RequestInit, 'method' | 'body'>): Promise<RefreshResponse>;
+    getSession(init?: Omit<RequestInit, 'method' | 'body'>): Promise<SessionResponse>;
+}
+
+export { AuthService };

package/dist/services/auth.js

@@ -0,0 +1,66 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/services/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  AuthService: () => AuthService
+});
+module.exports = __toCommonJS(auth_exports);
+var AuthService = class {
+  constructor(core) {
+    this.core = core;
+  }
+  /**
+   * POST /v1/auth/logout
+   * @summary Logout and invalidate session
+   */
+  logout(init) {
+    return this.core.request({
+      method: "POST",
+      path: `/v1/auth/logout`,
+      ...init || {}
+    });
+  }
+  /**
+   * POST /v1/auth/refresh
+   * @summary Refresh session token
+   */
+  refresh(init) {
+    return this.core.request({
+      method: "POST",
+      path: `/v1/auth/refresh`,
+      ...init || {}
+    });
+  }
+  /**
+   * GET /v1/auth/session
+   * @summary Get current session
+   */
+  getSession(init) {
+    return this.core.request({
+      method: "GET",
+      path: `/v1/auth/session`,
+      ...init || {}
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthService
+});

package/dist/services/auth.mjs

@@ -0,0 +1,6 @@
+import {
+  AuthService
+} from "../chunk-UTMQXMDQ.mjs";
+export {
+  AuthService
+};

package/dist/utils.d.mts

@@ -0,0 +1,18 @@
+type PaginableQuery = {
+    limit?: number;
+    offset?: number;
+} & Record<string, unknown>;
+declare function paginate<T>(fetchPage: (query?: any, init?: Omit<RequestInit, 'method' | 'body'>) => Promise<{
+    data?: T[];
+    hasMore?: boolean;
+    limit?: number;
+    offset?: number;
+}>, initialQuery?: PaginableQuery, pageSize?: number): AsyncGenerator<T, void, unknown>;
+declare function listAll<T>(fetchPage: (query?: any, init?: Omit<RequestInit, 'method' | 'body'>) => Promise<{
+    data?: T[];
+    hasMore?: boolean;
+    limit?: number;
+    offset?: number;
+}>, query?: PaginableQuery, pageSize?: number): Promise<T[]>;
+
+export { type PaginableQuery, listAll, paginate };

package/dist/utils.d.ts

@@ -0,0 +1,18 @@
+type PaginableQuery = {
+    limit?: number;
+    offset?: number;
+} & Record<string, unknown>;
+declare function paginate<T>(fetchPage: (query?: any, init?: Omit<RequestInit, 'method' | 'body'>) => Promise<{
+    data?: T[];
+    hasMore?: boolean;
+    limit?: number;
+    offset?: number;
+}>, initialQuery?: PaginableQuery, pageSize?: number): AsyncGenerator<T, void, unknown>;
+declare function listAll<T>(fetchPage: (query?: any, init?: Omit<RequestInit, 'method' | 'body'>) => Promise<{
+    data?: T[];
+    hasMore?: boolean;
+    limit?: number;
+    offset?: number;
+}>, query?: PaginableQuery, pageSize?: number): Promise<T[]>;
+
+export { type PaginableQuery, listAll, paginate };

package/dist/utils.js

@@ -0,0 +1,49 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  listAll: () => listAll,
+  paginate: () => paginate
+});
+module.exports = __toCommonJS(utils_exports);
+async function* paginate(fetchPage, initialQuery = {}, pageSize = 100) {
+  let offset = Number(initialQuery.offset ?? 0);
+  const limit = Number(initialQuery.limit ?? pageSize);
+  const baseQuery = { ...initialQuery };
+  while (true) {
+    const page = await fetchPage({ ...baseQuery, limit, offset });
+    const items = page.data ?? [];
+    for (const item of items) {
+      yield item;
+    }
+    if (!page.hasMore || items.length < limit) break;
+    offset += limit;
+  }
+}
+async function listAll(fetchPage, query = {}, pageSize = 100) {
+  const out = [];
+  for await (const item of paginate(fetchPage, query, pageSize)) out.push(item);
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  listAll,
+  paginate
+});

package/dist/utils.mjs

@@ -0,0 +1,8 @@
+import {
+  listAll,
+  paginate
+} from "./chunk-LZ27JJ4R.mjs";
+export {
+  listAll,
+  paginate
+};

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@blimu/client",
+  "version": "0.5.0",
+  "description": "TypeScript SDK for Blimu API (auto-generated)",
+  "repository": "https://github.com/blimu/blimu-ts",
+  "author": "viniciusdacal",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**"
+  ],
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./services/*": {
+      "types": "./dist/services/*.d.ts",
+      "import": "./dist/services/*.mjs",
+      "require": "./dist/services/*.js"
+    },
+    "./schema": {
+      "import": {
+        "types": "./dist/schema.d.ts",
+        "default": "./dist/schema.mjs"
+      },
+      "require": {
+        "types": "./dist/schema.d.ts",
+        "default": "./dist/schema.js"
+      }
+    },
+    "./client": {
+      "import": {
+        "types": "./dist/client.d.ts",
+        "default": "./dist/client.mjs"
+      },
+      "require": {
+        "types": "./dist/client.d.ts",
+        "default": "./dist/client.js"
+      }
+    },
+    "./utils": {
+      "import": {
+        "types": "./dist/utils.d.ts",
+        "default": "./dist/utils.mjs"
+      },
+      "require": {
+        "types": "./dist/utils.d.ts",
+        "default": "./dist/utils.js"
+      }
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/services/*.ts src/schema.ts src/client.ts src/utils.ts --format cjs,esm --dts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint .",
+    "format": "eslint --fix . && prettier --write .",
+    "prepublishOnly": "npm run build && npm run typecheck || true"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1"
+  }
+}