@expandai/sdk 0.17.0 → 0.17.2

package/LICENSE

@@ -1,3 +1,4 @@
+
                                  Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
@@ -186,7 +187,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2026 Expand
+   Copyright [yyyy] [name of copyright owner]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/README.md

@@ -1,361 +1,137 @@
-# expand.ai TypeScript API Library
+# @expandai/sdk
 
-[![NPM version](<https://img.shields.io/npm/v/@expandai/sdk.svg?label=npm%20(stable)>)](https://npmjs.org/package/@expandai/sdk) ![npm bundle size](https://img.shields.io/bundlephobia/minzip/@expandai/sdk)
+Official TypeScript SDK for the [ExpandAI](https://expand.ai) API.
 
-This library provides convenient access to the expand.ai REST API from server-side TypeScript or JavaScript.
+Built on [Effect](https://effect.website), with both a class-based client for promise-style usage and an `Effect.Service` for full Effect integration.
 
-The REST API documentation can be found on [expand.ai](https://expand.ai/docs). The full API of this library can be found in [api.md](api.md).
-
-It is generated with [Stainless](https://www.stainless.com/).
-
-## Installation
+## Install
 
 ```sh
 npm install @expandai/sdk
+# or
+bun add @expandai/sdk
+# or
+pnpm add @expandai/sdk
 ```
 
-## Usage
-
-The full API of this library can be found in [api.md](api.md).
-
-<!-- prettier-ignore -->
-```js
-import Expand from '@expandai/sdk';
-
-const client = new Expand({
-  apiKey: process.env['EXPAND_API_KEY'], // This is the default and can be omitted
-});
+## Authentication
 
-const response = await client.fetch({ url: 'https://news.ycombinator.com' });
+Set `EXPAND_API_KEY` in your environment, or pass `apiKey` explicitly when constructing the client.
 
-console.log(response.data);
+```sh
+export EXPAND_API_KEY=sk_...
 ```
 
-### Request & Response types
+## Quick start
 
-This library includes TypeScript definitions for all request params and response fields. You may import and use them like so:
+### Promise API
 
-<!-- prettier-ignore -->
 ```ts
-import Expand from '@expandai/sdk';
-
-const client = new Expand({
-  apiKey: process.env['EXPAND_API_KEY'], // This is the default and can be omitted
-});
-
-const params: Expand.FetchParams = { url: 'https://news.ycombinator.com' };
-const response: Expand.FetchResponse = await client.fetch(params);
-```
-
-Documentation for each method, request param, and response field are available in docstrings and will appear on hover in most modern editors.
+import { ExpandClient } from '@expandai/sdk'
 
-## Handling errors
+const expand = new ExpandClient()
 
-When the library is unable to connect to the API,
-or if the API returns a non-success status code (i.e., 4xx or 5xx response),
-a subclass of `APIError` will be thrown:
-
-<!-- prettier-ignore -->
-```ts
-const response = await client.fetch({ url: 'https://news.ycombinator.com' }).catch(async (err) => {
-  if (err instanceof Expand.APIError) {
-    console.log(err.status); // 400
-    console.log(err.name); // BadRequestError
-    console.log(err.headers); // {server: 'nginx', ...}
-  } else {
-    throw err;
-  }
-});
+const result = await expand.fetch({ url: 'https://example.com' })
+console.log(result)
 ```
 
-Error codes are as follows:
-
-| Status Code | Error Type                 |
-| ----------- | -------------------------- |
-| 400         | `BadRequestError`          |
-| 401         | `AuthenticationError`      |
-| 403         | `PermissionDeniedError`    |
-| 404         | `NotFoundError`            |
-| 422         | `UnprocessableEntityError` |
-| 429         | `RateLimitError`           |
-| >=500       | `InternalServerError`      |
-| N/A         | `APIConnectionError`       |
-
-### Retries
-
-Certain errors will be automatically retried 2 times by default, with a short exponential backoff.
-Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
-429 Rate Limit, and >=500 Internal errors will all be retried by default.
-
-You can use the `maxRetries` option to configure or disable this:
-
-<!-- prettier-ignore -->
-```js
-// Configure the default for all requests:
-const client = new Expand({
-  maxRetries: 0, // default is 2
-});
-
-// Or, configure per-request:
-await client.fetch({ url: 'https://news.ycombinator.com' }, {
-  maxRetries: 5,
-});
-```
-
-### Timeouts
-
-Requests time out after 1 minute by default. You can configure this with a `timeout` option:
+Constructor options:
 
-<!-- prettier-ignore -->
 ```ts
-// Configure the default for all requests:
-const client = new Expand({
-  timeout: 20 * 1000, // 20 seconds (default is 1 minute)
-});
-
-// Override per-request:
-await client.fetch({ url: 'https://news.ycombinator.com' }, {
-  timeout: 5 * 1000,
-});
+new ExpandClient({
+	apiKey: 'xpnd_...',         // defaults to process.env.EXPAND_API_KEY
+	baseUrl: 'https://api...',  // defaults to https://api.expand.ai
+	timeoutMs: 60_000,          // total wall-clock budget incl. retries
+	maxRetries: 2,              // retries on timeout / connection / 408,409,429,5xx
+})
 ```
 
-On timeout, an `APIConnectionTimeoutError` is thrown.
+Errors thrown:
 
-Note that requests which time out will be [retried twice by default](#retries).
+- `ExpandClientError` — invalid options (missing API key, empty `baseUrl`)
+- `ExpandClientApiError` — non-2xx HTTP response
+- `ExpandClientConnectionError` — network failure
+- `ExpandClientTimeoutError` — request timed out
 
-## Advanced Usage
+### Effect service
 
-### Accessing raw Response data (e.g., headers)
-
-The "raw" `Response` returned by `fetch()` can be accessed through the `.asResponse()` method on the `APIPromise` type that all methods return.
-This method returns as soon as the headers for a successful response are received and does not consume the response body, so you are free to write custom parsing or streaming logic.
-
-You can also use the `.withResponse()` method to get the raw `Response` along with the parsed data.
-Unlike `.asResponse()` this method consumes the body, returning once it is parsed.
-
-<!-- prettier-ignore -->
 ```ts
-const client = new Expand();
+import { NodeRuntime } from '@effect/platform-node'
+import { Effect } from 'effect'
+import { ExpandService } from '@expandai/sdk'
 
-const response = await client.fetch({ url: 'https://news.ycombinator.com' }).asResponse();
-console.log(response.headers.get('X-My-Header'));
-console.log(response.statusText); // access the underlying Response object
+const program = Effect.gen(function* () {
+	const expand = yield* ExpandService
+	const result = yield* expand.fetch({ url: 'https://example.com' })
+	yield* Effect.log(result)
+})
 
-const { data: response, response: raw } = await client
-  .fetch({ url: 'https://news.ycombinator.com' })
-  .withResponse();
-console.log(raw.headers.get('X-My-Header'));
-console.log(response.data);
+NodeRuntime.runMain(program.pipe(Effect.provide(ExpandService.layer({ apiKey: process.env.EXPAND_API_KEY }))))
 ```
 
-### Logging
-
-> [!IMPORTANT]
-> All log messages are intended for debugging only. The format and content of log messages
-> may change between releases.
-
-#### Log levels
-
-The log level can be configured in two ways:
-
-1. Via the `EXPAND_LOG` environment variable
-2. Using the `logLevel` client option (overrides the environment variable if set)
+Layer options (same shape as `ExpandClientOptions`):
 
 ```ts
-import Expand from '@expandai/sdk';
-
-const client = new Expand({
-  logLevel: 'debug', // Show all log messages
-});
+ExpandService.layer({
+	apiKey: 'xpnd_...',         // defaults to process.env.EXPAND_API_KEY
+	baseUrl: 'https://api...',  // defaults to https://api.expand.ai
+	timeoutMs: 60_000,          // total wall-clock budget incl. retries
+	maxRetries: 2,              // retries on timeout / connection / 408,409,429,5xx
+})
 ```
 
-Available log levels, from most to least verbose:
+Typed errors in the `Effect` channel:
 
-- `'debug'` - Show debug messages, info, warnings, and errors
-- `'info'` - Show info messages, warnings, and errors
-- `'warn'` - Show warnings and errors (default)
-- `'error'` - Show only errors
-- `'off'` - Disable all logging
+- `ExpandSdkError` — invalid options (missing API key, empty `baseUrl`)
+- `ExpandApiError` — non-2xx HTTP response
+- `ExpandConnectionError` — network failure
+- `ExpandTimeoutError` — request timed out
 
-At the `'debug'` level, all HTTP requests and responses are logged, including headers and bodies.
-Some authentication-related headers are redacted, but sensitive data in request and response bodies
-may still be visible.
+## Batched fetches
 
-#### Custom logger
+`batched` kicks off a job and returns immediately with an `id`. Poll `getBatched(id)` until `batchedStatus` is no longer `RUNNING` or `QUEUED`.
 
-By default, this library logs to `globalThis.console`. You can also provide a custom logger.
-Most logging libraries are supported, including [pino](https://www.npmjs.com/package/pino), [winston](https://www.npmjs.com/package/winston), [bunyan](https://www.npmjs.com/package/bunyan), [consola](https://www.npmjs.com/package/consola), [signale](https://www.npmjs.com/package/signale), and [@std/log](https://jsr.io/@std/log). If your logger doesn't work, please open an issue.
-
-When providing a custom logger, the `logLevel` option still controls which messages are emitted, messages
-below the configured level will not be sent to your logger.
+### Promise API
 
 ```ts
-import Expand from '@expandai/sdk';
-import pino from 'pino';
-
-const logger = pino();
+import { ExpandClient } from '@expandai/sdk'
 
-const client = new Expand({
-  logger: logger.child({ name: 'Expand' }),
-  logLevel: 'debug', // Send all messages to pino, allowing it to filter
-});
-```
-
-### Making custom/undocumented requests
-
-This library is typed for convenient access to the documented API. If you need to access undocumented
-endpoints, params, or response properties, the library can still be used.
+const expand = new ExpandClient()
 
-#### Undocumented endpoints
+const run = await expand.batched({ urls: ['https://example.com'] })
 
-To make requests to undocumented endpoints, you can use `client.get`, `client.post`, and other HTTP verbs.
-Options on the client, such as retries, will be respected when making these requests.
+let status = await expand.getBatched(run.id)
+while (status.batchedStatus === 'RUNNING' || status.batchedStatus === 'QUEUED') {
+	await new Promise((resolve) => setTimeout(resolve, 1000))
+	status = await expand.getBatched(run.id)
+}
 
-```ts
-await client.post('/some/path', {
-  body: { some_prop: 'foo' },
-  query: { some_query_arg: 'bar' },
-});
+console.log(status.results)
 ```
 
-#### Undocumented request params
-
-To make requests using undocumented parameters, you may use `// @ts-expect-error` on the undocumented
-parameter. This library doesn't validate at runtime that the request matches the type, so any extra values you
-send will be sent as-is.
+### Effect service
 
 ```ts
-client.fetch({
-  // ...
-  // @ts-expect-error baz is not yet public
-  baz: 'undocumented option',
-});
-```
-
-For requests with the `GET` verb, any extra params will be in the query, all other requests will send the
-extra param in the body.
-
-If you want to explicitly send an extra argument, you can do so with the `query`, `body`, and `headers` request
-options.
-
-#### Undocumented response properties
-
-To access undocumented response properties, you may access the response object with `// @ts-expect-error` on
-the response object, or cast the response object to the requisite type. Like the request params, we do not
-validate or strip extra properties from the response from the API.
+import { NodeRuntime } from '@effect/platform-node'
+import { Duration, Effect, Schedule } from 'effect'
+import { ExpandService, type GetBatchedResponse } from '@expandai/sdk'
 
-### Customizing the fetch client
-
-By default, this library expects a global `fetch` function is defined.
-
-If you want to use a different `fetch` function, you can either polyfill the global:
-
-```ts
-import fetch from 'my-fetch';
+const program = Effect.gen(function* () {
+	const expand = yield* ExpandService
+	const run = yield* expand.batched({ urls: ['https://example.com'] })
+	const final = yield* expand.getBatched(run.id).pipe(
+		Effect.repeat(
+			Schedule.recurUntil(
+				(status: GetBatchedResponse) => status.batchedStatus !== 'RUNNING' && status.batchedStatus !== 'QUEUED',
+			).pipe(Schedule.addDelay(() => Duration.seconds(1))),
+		),
+	)
+	yield* Effect.log(final.results)
+})
 
-globalThis.fetch = fetch;
+NodeRuntime.runMain(program.pipe(Effect.provide(ExpandService.layer({ apiKey: process.env.EXPAND_API_KEY }))))
 ```
 
-Or pass it to the client:
-
-```ts
-import Expand from '@expandai/sdk';
-import fetch from 'my-fetch';
-
-const client = new Expand({ customFetch: fetch });
-```
-
-### Fetch options
-
-If you want to set custom `fetch` options without overriding the `fetch` function, you can provide a `customFetchOptions` object when instantiating the client or making a request. (Request-specific options override client options.)
-
-```ts
-import Expand from '@expandai/sdk';
-
-const client = new Expand({
-  customFetchOptions: {
-    // `RequestInit` options
-  },
-});
-```
-
-#### Configuring proxies
-
-To modify proxy behavior, you can provide custom `customFetchOptions` that add runtime-specific proxy
-options to requests:
-
-<img src="https://raw.githubusercontent.com/stainless-api/sdk-assets/refs/heads/main/node.svg" align="top" width="18" height="21"> **Node** <sup>[[docs](https://github.com/nodejs/undici/blob/main/docs/docs/api/ProxyAgent.md#example---proxyagent-with-fetch)]</sup>
-
-```ts
-import Expand from '@expandai/sdk';
-import * as undici from 'undici';
-
-const proxyAgent = new undici.ProxyAgent('http://localhost:8888');
-const client = new Expand({
-  customFetchOptions: {
-    dispatcher: proxyAgent,
-  },
-});
-```
-
-<img src="https://raw.githubusercontent.com/stainless-api/sdk-assets/refs/heads/main/bun.svg" align="top" width="18" height="21"> **Bun** <sup>[[docs](https://bun.sh/guides/http/proxy)]</sup>
-
-```ts
-import Expand from '@expandai/sdk';
-
-const client = new Expand({
-  customFetchOptions: {
-    proxy: 'http://localhost:8888',
-  },
-});
-```
-
-<img src="https://raw.githubusercontent.com/stainless-api/sdk-assets/refs/heads/main/deno.svg" align="top" width="18" height="21"> **Deno** <sup>[[docs](https://docs.deno.com/api/deno/~/Deno.createHttpClient)]</sup>
-
-```ts
-import Expand from 'npm:@expandai/sdk';
-
-const httpClient = Deno.createHttpClient({ proxy: { url: 'http://localhost:8888' } });
-const client = new Expand({
-  customFetchOptions: {
-    client: httpClient,
-  },
-});
-```
-
-## Frequently Asked Questions
-
-## Semantic versioning
-
-This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:
-
-1. Changes that only affect static types, without breaking runtime behavior.
-2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals.)_
-3. Changes that we do not expect to impact the vast majority of users in practice.
-
-We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.
-
-We are keen for your feedback; please open an [issue](https://www.github.com/expandai/expandai-node/issues) with questions, bugs, or suggestions.
-
-## Requirements
-
-TypeScript >= 4.9 is supported.
-
-The following runtimes are supported:
-
-- Web browsers (Up-to-date Chrome, Firefox, Safari, Edge, and more)
-- Node.js 20 LTS or later ([non-EOL](https://endoflife.date/nodejs)) versions.
-- Deno v1.28.0 or higher.
-- Bun 1.0 or later.
-- Cloudflare Workers.
-- Vercel Edge Runtime.
-- Jest 28 or greater with the `"node"` environment (`"jsdom"` is not supported at this time).
-- Nitro v2.6 or greater.
-
-Note that React Native is not supported at this time.
-
-If you are interested in other runtime environments, please open or upvote an issue on GitHub.
-
-## Contributing
+## License
 
-See [the contributing documentation](./CONTRIBUTING.md).
+[Apache 2.0](./LICENSE)

package/build/dts/Client.d.ts

@@ -0,0 +1,61 @@
+import { type BatchedParams, type BatchedResponse, type ExpandServiceOptions, type FetchJsonParams, type FetchJsonRequestOptions, type FetchJsonResponse, type FetchParams, type FetchRequestOptions, type FetchResponse, type FetchSearchParams, type FetchSearchResponse, type GetBatchedParams, type GetBatchedResponse, type RequestOptions } from './Service.js';
+export type { BatchedParams, BatchedResponse, FetchJsonParams, FetchJsonRequestOptions, FetchJsonResponse, FetchParams, FetchRequestOptions, FetchResponse, FetchSearchParams, FetchSearchResponse, GetBatchedParams, GetBatchedResponse, } from './Service.js';
+/** Options for constructing an {@link ExpandClient}. Same shape as `ExpandServiceOptions`. */
+export type ExpandClientOptions = ExpandServiceOptions;
+/**
+ * Promise-based client for the Expand API. Holds an {@link InternalClient} layer and runs Effects
+ * against it, translating typed failures into the `ExpandClient*Error` hierarchy that async/await
+ * consumers expect.
+ *
+ * @example
+ * ```ts
+ * const client = new ExpandClient({ apiKey: 'sk_...' })
+ * const result = await client.fetch({ url: 'https://example.com' })
+ * ```
+ */
+export declare class ExpandClient {
+    private readonly layer;
+    constructor(options?: ExpandClientOptions);
+    /**
+     * Fetch a URL through the Expand API.
+     *
+     * @throws {ExpandClientApiError} on 4xx/5xx responses
+     * @throws {ExpandClientTimeoutError} when the request exceeds `timeoutMs`
+     * @throws {ExpandClientConnectionError} on network failures
+     * @throws {ExpandClientError} for any other failure
+     */
+    fetch(params: FetchParams, options?: FetchRequestOptions): Promise<FetchResponse>;
+    /**
+     * Fetch a URL through the object-mode endpoint.
+     *
+     * Returns `{ meta, markdown, json }`; use {@link fetch} for the raw markdown document.
+     */
+    fetchJson(params: FetchJsonParams, options?: FetchJsonRequestOptions): Promise<FetchJsonResponse>;
+    /**
+     * Search a previous Fetch response by `snapshotId` without starting a new capture.
+     */
+    fetchSearch(params: FetchSearchParams, options?: RequestOptions): Promise<FetchSearchResponse>;
+    /**
+     * Kick off an asynchronous batched fetch over one or more URLs. Returns a batched-run ID that can
+     * be polled via {@link getBatched}.
+     *
+     * Retries are disabled by default. Pass `{ maxRetries: N }` to opt in.
+     *
+     * @throws {ExpandClientApiError} on 4xx/5xx responses
+     * @throws {ExpandClientTimeoutError} when the request exceeds `timeoutMs`
+     * @throws {ExpandClientConnectionError} on network failures
+     * @throws {ExpandClientError} for any other failure
+     */
+    batched(params: BatchedParams, options?: RequestOptions): Promise<BatchedResponse>;
+    /**
+     * Fetch the status and accumulated results for a batched run previously started by {@link batched}.
+     *
+     * @throws {ExpandClientApiError} on 4xx/5xx responses
+     * @throws {ExpandClientTimeoutError} when the request exceeds `timeoutMs`
+     * @throws {ExpandClientConnectionError} on network failures
+     * @throws {ExpandClientError} for any other failure
+     */
+    getBatched(id: string, options?: GetBatchedParams & RequestOptions): Promise<GetBatchedResponse>;
+    private run;
+}
+//# sourceMappingURL=Client.d.ts.map

package/build/dts/Client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Client.d.ts","sourceRoot":"","sources":["../../src/Client.ts"],"names":[],"mappings":"AAEA,OAAO,EACN,KAAK,aAAa,EAClB,KAAK,eAAe,EAEpB,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,MAAM,cAAc,CAAA;AAErB,YAAY,EACX,aAAa,EACb,eAAe,EACf,eAAe,EACf,uBAAuB,EACvB,iBAAiB,EACjB,WAAW,EACX,mBAAmB,EACnB,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,GAClB,MAAM,cAAc,CAAA;AAErB,8FAA8F;AAC9F,MAAM,MAAM,mBAAmB,GAAG,oBAAoB,CAAA;AAEtD;;;;;;;;;;GAUG;AACH,qBAAa,YAAY;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA6B;gBAEvC,OAAO,GAAE,mBAAwB;IAa7C;;;;;;;OAOG;IACG,KAAK,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,aAAa,CAAC;IAI3F;;;;OAIG;IACG,SAAS,CAAC,MAAM,EAAE,eAAe,EAAE,OAAO,GAAE,uBAA4B,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAI3G;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE,iBAAiB,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAIxG;;;;;;;;;;OAUG;IACG,OAAO,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,eAAe,CAAC;IAI5F;;;;;;;OAOG;IACG,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,gBAAgB,GAAG,cAAmB,GAAG,OAAO,CAAC,kBAAkB,CAAC;YAI5F,GAAG;CAOjB"}

package/build/dts/Error.d.ts

@@ -0,0 +1,90 @@
+import { Schema } from 'effect';
+declare const ExpandSdkError_base: Schema.TaggedErrorClass<ExpandSdkError, "ExpandSdkError", {
+    readonly _tag: Schema.tag<"ExpandSdkError">;
+} & {
+    message: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.Defect>;
+}>;
+/**
+ * Effect-side base error. Schema.TaggedError; Effect consumers receive these in the error channel.
+ */
+export declare class ExpandSdkError extends ExpandSdkError_base {
+    toPublicError(): ExpandClientError;
+}
+declare const ExpandApiError_base: Schema.TaggedErrorClass<ExpandApiError, "ExpandApiError", {
+    readonly _tag: Schema.tag<"ExpandApiError">;
+} & {
+    message: typeof Schema.String;
+    status: typeof Schema.Number;
+    body: Schema.optional<typeof Schema.Unknown>;
+    cause: Schema.optional<typeof Schema.Defect>;
+}>;
+/**
+ * Effect-side error for non-2xx API responses. Inspect `status` and `body` for details.
+ */
+export declare class ExpandApiError extends ExpandApiError_base {
+    toPublicError(): ExpandClientApiError;
+}
+declare const ExpandConnectionError_base: Schema.TaggedErrorClass<ExpandConnectionError, "ExpandConnectionError", {
+    readonly _tag: Schema.tag<"ExpandConnectionError">;
+} & {
+    message: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.Defect>;
+}>;
+/**
+ * Effect-side error when the SDK cannot reach the API (DNS, connection refused, socket reset, etc.).
+ */
+export declare class ExpandConnectionError extends ExpandConnectionError_base {
+    toPublicError(): ExpandClientConnectionError;
+}
+declare const ExpandTimeoutError_base: Schema.TaggedErrorClass<ExpandTimeoutError, "ExpandTimeoutError", {
+    readonly _tag: Schema.tag<"ExpandTimeoutError">;
+} & {
+    message: typeof Schema.String;
+    timeoutMs: typeof Schema.Number;
+    cause: Schema.optional<typeof Schema.Defect>;
+}>;
+/**
+ * Effect-side error when a request exceeds its configured `timeoutMs`.
+ */
+export declare class ExpandTimeoutError extends ExpandTimeoutError_base {
+    toPublicError(): ExpandClientTimeoutError;
+}
+/**
+ * Union of every error the Effect-side `ExpandService` can fail with.
+ */
+export type ExpandError = ExpandSdkError | ExpandApiError | ExpandConnectionError | ExpandTimeoutError;
+/**
+ * Promise-side base class. Catch this to handle any failure thrown by `ExpandClient`.
+ */
+export declare class ExpandClientError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Promise-side error for non-2xx API responses. Inspect `status` and `body` for details.
+ */
+export declare class ExpandClientApiError extends ExpandClientError {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, options: ErrorOptions & {
+        readonly status: number;
+        readonly body?: unknown;
+    });
+}
+/**
+ * Promise-side error when the SDK cannot reach the API (DNS, connection refused, socket reset, etc.).
+ */
+export declare class ExpandClientConnectionError extends ExpandClientError {
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Promise-side error when a request exceeds its configured `timeoutMs`.
+ */
+export declare class ExpandClientTimeoutError extends ExpandClientConnectionError {
+    readonly timeoutMs: number;
+    constructor(message: string, options: ErrorOptions & {
+        readonly timeoutMs: number;
+    });
+}
+export {};
+//# sourceMappingURL=Error.d.ts.map

package/build/dts/Error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Error.d.ts","sourceRoot":"","sources":["../../src/Error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;;;;;;;AAE/B;;GAEG;AACH,qBAAa,cAAe,SAAQ,mBAGlC;IACD,aAAa;CAGb;;;;;;;;;AAED;;GAEG;AACH,qBAAa,cAAe,SAAQ,mBAKlC;IACD,aAAa;CAGb;;;;;;;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,0BAGzC;IACD,aAAa;CAGb;;;;;;;;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,uBAItC;IACD,aAAa;CAGb;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,cAAc,GAAG,cAAc,GAAG,qBAAqB,GAAG,kBAAkB,CAAA;AAEtG;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;gBAC/B,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB;CAIvD;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,iBAAiB;IAC1D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;gBAEV,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG;QAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE;CAMzG;AAED;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,iBAAiB;gBACrD,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB;CAIvD;AAED;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,2BAA2B;IACxE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;gBAEd,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG;QAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;KAAE;CAKnF"}