@tambo-ai/typescript-sdk 0.31.0

package/README.md

@@ -0,0 +1,434 @@
+# Tambo Typescript API Library
+
+[![NPM version](https://img.shields.io/npm/v/@tambo-ai/typescript-sdk.svg)](https://npmjs.org/package/@tambo-ai/typescript-sdk) ![npm bundle size](https://img.shields.io/bundlephobia/minzip/@tambo-ai/typescript-sdk)
+
+This library provides convenient access to the Tambo AI REST API from server-side TypeScript or JavaScript.
+
+The REST API documentation can be found on [tambo.co](https://tambo.co/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
+
+```sh
+npm install @tambo-ai/typescript-sdk
+```
+
+## Usage
+
+The full API of this library can be found in [api.md](api.md).
+
+<!-- prettier-ignore -->
+```js
+import TamboAI from '@tambo-ai/typescript-sdk';
+
+const client = new TamboAI({
+  apiKey: process.env['TAMBO_API_KEY'], // This is the default and can be omitted
+});
+
+async function main() {
+  const response = await client.components.generate({
+    availableComponents: {
+      foo: {
+        contextTools: [
+          {
+            description: 'description',
+            name: 'name',
+            parameters: [{ description: 'description', isRequired: true, name: 'name', type: 'type' }],
+          },
+        ],
+        description: 'description',
+        name: 'name',
+        props: { foo: 'bar' },
+      },
+    },
+    messageHistory: [{ message: 'message', sender: 'hydra' }],
+  });
+
+  console.log(response.componentName);
+}
+
+main();
+```
+
+### Request & Response types
+
+This library includes TypeScript definitions for all request params and response fields. You may import and use them like so:
+
+<!-- prettier-ignore -->
+```ts
+import TamboAI from '@tambo-ai/typescript-sdk';
+
+const client = new TamboAI({
+  apiKey: process.env['TAMBO_API_KEY'], // This is the default and can be omitted
+});
+
+async function main() {
+  const params: TamboAI.ComponentGenerateParams = {
+    availableComponents: {
+      foo: {
+        contextTools: [
+          {
+            description: 'description',
+            name: 'name',
+            parameters: [{ description: 'description', isRequired: true, name: 'name', type: 'type' }],
+          },
+        ],
+        description: 'description',
+        name: 'name',
+        props: { foo: 'bar' },
+      },
+    },
+    messageHistory: [{ message: 'message', sender: 'hydra' }],
+  };
+  const response: TamboAI.ComponentGenerateResponse = await client.components.generate(params);
+}
+
+main();
+```
+
+Documentation for each method, request param, and response field are available in docstrings and will appear on hover in most modern editors.
+
+## Handling errors
+
+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
+async function main() {
+  const response = await client.components
+    .generate({
+      availableComponents: {
+        foo: {
+          contextTools: [
+            {
+              description: 'description',
+              name: 'name',
+              parameters: [{ description: 'description', isRequired: true, name: 'name', type: 'type' }],
+            },
+          ],
+          description: 'description',
+          name: 'name',
+          props: { foo: 'bar' },
+        },
+      },
+      messageHistory: [{ message: 'message', sender: 'hydra' }],
+    })
+    .catch(async (err) => {
+      if (err instanceof TamboAI.APIError) {
+        console.log(err.status); // 400
+        console.log(err.name); // BadRequestError
+        console.log(err.headers); // {server: 'nginx', ...}
+      } else {
+        throw err;
+      }
+    });
+}
+
+main();
+```
+
+Error codes are as followed:
+
+| 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 0 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 TamboAI({
+  maxRetries: 0, // default is 2
+});
+
+// Or, configure per-request:
+await client.components.generate({ availableComponents: { foo: { contextTools: [{ description: 'description', name: 'name', parameters: [{ description: 'description', isRequired: true, name: 'name', type: 'type' }] }], description: 'description', name: 'name', props: { foo: 'bar' } } }, messageHistory: [{ message: 'message', sender: 'hydra' }] }, {
+  maxRetries: 5,
+});
+```
+
+### Timeouts
+
+Requests time out after 1 minute by default. You can configure this with a `timeout` option:
+
+<!-- prettier-ignore -->
+```ts
+// Configure the default for all requests:
+const client = new TamboAI({
+  timeout: 20 * 1000, // 20 seconds (default is 1 minute)
+});
+
+// Override per-request:
+await client.components.generate({ availableComponents: { foo: { contextTools: [{ description: 'description', name: 'name', parameters: [{ description: 'description', isRequired: true, name: 'name', type: 'type' }] }], description: 'description', name: 'name', props: { foo: 'bar' } } }, messageHistory: [{ message: 'message', sender: 'hydra' }] }, {
+  timeout: 5 * 1000,
+});
+```
+
+On timeout, an `APIConnectionTimeoutError` is thrown.
+
+Note that requests which time out will be [retried twice by default](#retries).
+
+## Auto-pagination
+
+List methods in the TamboAI API are paginated.
+You can use the `for await … of` syntax to iterate through items across all pages:
+
+```ts
+async function fetchAllBetaThreads(params) {
+  const allBetaThreads = [];
+  // Automatically fetches more pages as needed.
+  for await (const thread of client.beta.threads.list('projectId')) {
+    allBetaThreads.push(thread);
+  }
+  return allBetaThreads;
+}
+```
+
+Alternatively, you can request a single page at a time:
+
+```ts
+let page = await client.beta.threads.list('projectId');
+for (const thread of page.items) {
+  console.log(thread);
+}
+
+// Convenience methods are provided for manually paginating:
+while (page.hasNextPage()) {
+  page = await page.getNextPage();
+  // ...
+}
+```
+
+## Advanced Usage
+
+### 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.
+
+You can also use the `.withResponse()` method to get the raw `Response` along with the parsed data.
+
+<!-- prettier-ignore -->
+```ts
+const client = new TamboAI();
+
+const response = await client.components
+  .generate({
+    availableComponents: {
+      foo: {
+        contextTools: [
+          {
+            description: 'description',
+            name: 'name',
+            parameters: [{ description: 'description', isRequired: true, name: 'name', type: 'type' }],
+          },
+        ],
+        description: 'description',
+        name: 'name',
+        props: { foo: 'bar' },
+      },
+    },
+    messageHistory: [{ message: 'message', sender: 'hydra' }],
+  })
+  .asResponse();
+console.log(response.headers.get('X-My-Header'));
+console.log(response.statusText); // access the underlying Response object
+
+const { data: response, response: raw } = await client.components
+  .generate({
+    availableComponents: {
+      foo: {
+        contextTools: [
+          {
+            description: 'description',
+            name: 'name',
+            parameters: [{ description: 'description', isRequired: true, name: 'name', type: 'type' }],
+          },
+        ],
+        description: 'description',
+        name: 'name',
+        props: { foo: 'bar' },
+      },
+    },
+    messageHistory: [{ message: 'message', sender: 'hydra' }],
+  })
+  .withResponse();
+console.log(raw.headers.get('X-My-Header'));
+console.log(response.componentName);
+```
+
+### 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.
+
+#### Undocumented endpoints
+
+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.
+
+```ts
+await client.post('/some/path', {
+  body: { some_prop: 'foo' },
+  query: { some_query_arg: 'bar' },
+});
+```
+
+#### 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.
+
+```ts
+client.foo.create({
+  foo: 'my_param',
+  bar: 12,
+  // @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.
+
+### Customizing the fetch client
+
+By default, this library uses `node-fetch` in Node, and expects a global `fetch` function in other environments.
+
+If you would prefer to use a global, web-standards-compliant `fetch` function even in a Node environment,
+(for example, if you are running Node with `--experimental-fetch` or using NextJS which polyfills with `undici`),
+add the following import before your first import `from "TamboAI"`:
+
+```ts
+// Tell TypeScript and the package to use the global web fetch instead of node-fetch.
+// Note, despite the name, this does not add any polyfills, but expects them to be provided if needed.
+import '@tambo-ai/typescript-sdk/shims/web';
+import TamboAI from '@tambo-ai/typescript-sdk';
+```
+
+To do the inverse, add `import "@tambo-ai/typescript-sdk/shims/node"` (which does import polyfills).
+This can also be useful if you are getting the wrong TypeScript types for `Response` ([more details](https://github.com/tambo-ai/typescript-sdk/tree/main/src/_shims#readme)).
+
+### Logging and middleware
+
+You may also provide a custom `fetch` function when instantiating the client,
+which can be used to inspect or alter the `Request` or `Response` before/after each request:
+
+```ts
+import { fetch } from 'undici'; // as one example
+import TamboAI from '@tambo-ai/typescript-sdk';
+
+const client = new TamboAI({
+  fetch: async (url: RequestInfo, init?: RequestInit): Promise<Response> => {
+    console.log('About to make a request', url, init);
+    const response = await fetch(url, init);
+    console.log('Got response', response);
+    return response;
+  },
+});
+```
+
+Note that if given a `DEBUG=true` environment variable, this library will log all requests and responses automatically.
+This is intended for debugging purposes only and may change in the future without notice.
+
+### Configuring an HTTP(S) Agent (e.g., for proxies)
+
+By default, this library uses a stable agent for all http/https requests to reuse TCP connections, eliminating many TCP & TLS handshakes and shaving around 100ms off most requests.
+
+If you would like to disable or customize this behavior, for example to use the API behind a proxy, you can pass an `httpAgent` which is used for all requests (be they http or https), for example:
+
+<!-- prettier-ignore -->
+```ts
+import http from 'http';
+import { HttpsProxyAgent } from 'https-proxy-agent';
+
+// Configure the default for all requests:
+const client = new TamboAI({
+  httpAgent: new HttpsProxyAgent(process.env.PROXY_URL),
+});
+
+// Override per-request:
+await client.components.generate(
+  {
+    availableComponents: {
+      foo: {
+        contextTools: [
+          {
+            description: 'description',
+            name: 'name',
+            parameters: [{ description: 'description', isRequired: true, name: 'name', type: 'type' }],
+          },
+        ],
+        description: 'description',
+        name: 'name',
+        props: { foo: 'bar' },
+      },
+    },
+    messageHistory: [{ message: 'message', sender: 'hydra' }],
+  },
+  {
+    httpAgent: new http.Agent({ keepAlive: false }),
+  },
+);
+```
+
+## 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/tambo-ai/typescript-sdk/issues) with questions, bugs, or suggestions.
+
+## Requirements
+
+TypeScript >= 4.5 is supported.
+
+The following runtimes are supported:
+
+- Web browsers (Up-to-date Chrome, Firefox, Safari, Edge, and more)
+- Node.js 18 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
+
+See [the contributing documentation](./CONTRIBUTING.md).

package/_shims/MultipartBody.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+export declare class MultipartBody {
+    body: any;
+    constructor(body: any);
+    get [Symbol.toStringTag](): string;
+}
+//# sourceMappingURL=MultipartBody.d.ts.map

package/_shims/MultipartBody.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultipartBody.d.ts","sourceRoot":"","sources":["../src/_shims/MultipartBody.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,aAAa;IACL,IAAI,EAAE,GAAG;gBAAT,IAAI,EAAE,GAAG;IAC5B,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;CACF"}

package/_shims/MultipartBody.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultipartBody = void 0;
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+class MultipartBody {
+    constructor(body) {
+        this.body = body;
+    }
+    get [Symbol.toStringTag]() {
+        return 'MultipartBody';
+    }
+}
+exports.MultipartBody = MultipartBody;
+//# sourceMappingURL=MultipartBody.js.map

package/_shims/MultipartBody.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultipartBody.js","sourceRoot":"","sources":["../src/_shims/MultipartBody.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,MAAa,aAAa;IACxB,YAAmB,IAAS;QAAT,SAAI,GAAJ,IAAI,CAAK;IAAG,CAAC;IAChC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;QACtB,OAAO,eAAe,CAAC;IACzB,CAAC;CACF;AALD,sCAKC"}

package/_shims/MultipartBody.mjs

@@ -0,0 +1,12 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+export class MultipartBody {
+    constructor(body) {
+        this.body = body;
+    }
+    get [Symbol.toStringTag]() {
+        return 'MultipartBody';
+    }
+}
+//# sourceMappingURL=MultipartBody.mjs.map

package/_shims/MultipartBody.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultipartBody.mjs","sourceRoot":"","sources":["../src/_shims/MultipartBody.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,OAAO,aAAa;IACxB,YAAmB,IAAS;QAAT,SAAI,GAAJ,IAAI,CAAK;IAAG,CAAC;IAChC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;QACtB,OAAO,eAAe,CAAC;IACzB,CAAC;CACF"}

package/_shims/README.md

@@ -0,0 +1,46 @@
+# 👋 Wondering what everything in here does?
+
+`@tambo-ai/typescript-sdk` supports a wide variety of runtime environments like Node.js, Deno, Bun, browsers, and various
+edge runtimes, as well as both CommonJS (CJS) and EcmaScript Modules (ESM).
+
+To do this, `@tambo-ai/typescript-sdk` provides shims for either using `node-fetch` when in Node (because `fetch` is still experimental there) or the global `fetch` API built into the environment when not in Node.
+
+It uses [conditional exports](https://nodejs.org/api/packages.html#conditional-exports) to
+automatically select the correct shims for each environment. However, conditional exports are a fairly new
+feature and not supported everywhere. For instance, the TypeScript `"moduleResolution": "node"`
+
+setting doesn't consult the `exports` map, compared to `"moduleResolution": "nodeNext"`, which does.
+Unfortunately that's still the default setting, and it can result in errors like
+getting the wrong raw `Response` type from `.asResponse()`, for example.
+
+The user can work around these issues by manually importing one of:
+
+- `import '@tambo-ai/typescript-sdk/shims/node'`
+- `import '@tambo-ai/typescript-sdk/shims/web'`
+
+All of the code here in `_shims` handles selecting the automatic default shims or manual overrides.
+
+### How it works - Runtime
+
+Runtime shims get installed by calling `setShims` exported by `@tambo-ai/typescript-sdk/_shims/registry`.
+
+Manually importing `@tambo-ai/typescript-sdk/shims/node` or `@tambo-ai/typescript-sdk/shims/web`, calls `setShims` with the respective runtime shims.
+
+All client code imports shims from `@tambo-ai/typescript-sdk/_shims/index`, which:
+
+- checks if shims have been set manually
+- if not, calls `setShims` with the shims from `@tambo-ai/typescript-sdk/_shims/auto/runtime`
+- re-exports the installed shims from `@tambo-ai/typescript-sdk/_shims/registry`.
+
+`@tambo-ai/typescript-sdk/_shims/auto/runtime` exports web runtime shims.
+If the `node` export condition is set, the export map replaces it with `@tambo-ai/typescript-sdk/_shims/auto/runtime-node`.
+
+### How it works - Type time
+
+All client code imports shim types from `@tambo-ai/typescript-sdk/_shims/index`, which selects the manual types from `@tambo-ai/typescript-sdk/_shims/manual-types` if they have been declared, otherwise it exports the auto types from `@tambo-ai/typescript-sdk/_shims/auto/types`.
+
+`@tambo-ai/typescript-sdk/_shims/manual-types` exports an empty namespace.
+Manually importing `@tambo-ai/typescript-sdk/shims/node` or `@tambo-ai/typescript-sdk/shims/web` merges declarations into this empty namespace, so they get picked up by `@tambo-ai/typescript-sdk/_shims/index`.
+
+`@tambo-ai/typescript-sdk/_shims/auto/types` exports web type definitions.
+If the `node` export condition is set, the export map replaces it with `@tambo-ai/typescript-sdk/_shims/auto/types-node`, though TS only picks this up if `"moduleResolution": "nodenext"` or `"moduleResolution": "bundler"`.

package/_shims/auto/runtime-bun.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+export * from "../bun-runtime.js";
+//# sourceMappingURL=runtime-bun.d.ts.map

package/_shims/auto/runtime-bun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-bun.d.ts","sourceRoot":"","sources":["../../src/_shims/auto/runtime-bun.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,gBAAgB,CAAC"}

package/_shims/auto/runtime-bun.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+__exportStar(require("../bun-runtime.js"), exports);
+//# sourceMappingURL=runtime-bun.js.map

package/_shims/auto/runtime-bun.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-bun.js","sourceRoot":"","sources":["../../src/_shims/auto/runtime-bun.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;GAEG;AACH,oDAA+B"}

package/_shims/auto/runtime-bun.mjs

@@ -0,0 +1,2 @@
+export * from "../bun-runtime.mjs";
+//# sourceMappingURL=runtime-bun.mjs.map

package/_shims/auto/runtime-bun.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-bun.mjs","sourceRoot":"","sources":["../../src/_shims/auto/runtime-bun.ts"],"names":[],"mappings":""}

package/_shims/auto/runtime-node.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+export * from "../node-runtime.js";
+//# sourceMappingURL=runtime-node.d.ts.map

package/_shims/auto/runtime-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-node.d.ts","sourceRoot":"","sources":["../../src/_shims/auto/runtime-node.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,iBAAiB,CAAC"}

package/_shims/auto/runtime-node.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+__exportStar(require("../node-runtime.js"), exports);
+//# sourceMappingURL=runtime-node.js.map

package/_shims/auto/runtime-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-node.js","sourceRoot":"","sources":["../../src/_shims/auto/runtime-node.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;GAEG;AACH,qDAAgC"}

package/_shims/auto/runtime-node.mjs

@@ -0,0 +1,2 @@
+export * from "../node-runtime.mjs";
+//# sourceMappingURL=runtime-node.mjs.map

package/_shims/auto/runtime-node.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-node.mjs","sourceRoot":"","sources":["../../src/_shims/auto/runtime-node.ts"],"names":[],"mappings":""}

package/_shims/auto/runtime.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+export * from "../web-runtime.js";
+//# sourceMappingURL=runtime.d.ts.map

package/_shims/auto/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/_shims/auto/runtime.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,gBAAgB,CAAC"}

package/_shims/auto/runtime.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+__exportStar(require("../web-runtime.js"), exports);
+//# sourceMappingURL=runtime.js.map

package/_shims/auto/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../src/_shims/auto/runtime.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA;;GAEG;AACH,oDAA+B"}

package/_shims/auto/runtime.mjs

@@ -0,0 +1,2 @@
+export * from "../web-runtime.mjs";
+//# sourceMappingURL=runtime.mjs.map

package/_shims/auto/runtime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.mjs","sourceRoot":"","sources":["../../src/_shims/auto/runtime.ts"],"names":[],"mappings":""}

package/_shims/auto/types-node.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+export * from "../node-types.js";
+//# sourceMappingURL=types-node.d.ts.map