intercom-client 6.0.0-alpha1 → 6.0.0-beta.3

package/README.md

@@ -1,180 +1,286 @@
-# Intercom TypeScript Library
+# Intercom Node API Library
 
-[![fern shield](https://img.shields.io/badge/%F0%9F%8C%BF-SDK%20generated%20by%20Fern-brightgreen)](https://github.com/fern-api/fern)
-[![npm shield](https://img.shields.io/npm/v/intercom-client)](https://www.npmjs.com/package/intercom-client)
+[![NPM version](https://img.shields.io/npm/v/intercom-client.svg)](https://npmjs.org/package/intercom-client) ![npm bundle size](https://img.shields.io/bundlephobia/minzip/intercom-client)
 
-The Intercom TypeScript library provides convenient access to the Intercom API from TypeScript.
+This library provides convenient access to the Intercom REST API from server-side TypeScript or JavaScript.
 
-## V6 Release
+The REST API documentation can be found on [developers.intercom.com](https://developers.intercom.com). The full API of this library can be found in [api.md](api.md).
 
-The Intercom team is excited to announce a new and improved TypeScript SDK, currently available as an `alpha` version. Check out the
-API reference [here](https://github.com/intercom/intercom-node/blob/6.0.0-alpha/reference.md).
-
-During this time, we hope to gather feedback from the Intercom community to help drive the direction of the latest API changes.
-
-Please feel free to leave in any suggestions in our open GitHub discussion to improve the experience for everyone!
+It is generated with [Stainless](https://www.stainlessapi.com/).
 
 ## Installation
 
 ```sh
-npm i -s intercom-client@alpha
+npm install intercom-client@6.0.0-beta.1
 ```
 
 ## Usage
 
-Instantiate and use the client with the following:
+The full API of this library can be found in [api.md](api.md).
 
-```typescript
-import { IntercomClient, Intercom } from "intercom-client";
+<!-- prettier-ignore -->
+```js
+import Intercom from 'intercom-client';
 
-const client = new IntercomClient({ token: "YOUR_TOKEN" });
-await client.articles.create({
-    title: "Thanks for everything",
-    description: "Description of the Article",
-    body: "Body of the Article",
-    author_id: 1295,
-    state: Intercom.CreateArticleRequestState.Published,
+const client = new Intercom({
+  accessToken: process.env['INTERCOM_ACCESS_TOKEN'], // This is the default and can be omitted
+  environment: 'eu', // or 'us' | 'au'; defaults to 'us'
 });
-```
-
-## Request and Response Types
 
-The SDK exports all request and response types as TypeScript interfaces. Simply import them with the
-following namespace:
+async function main() {
+  const adminWithApp = await client.me.retrieve();
 
-```typescript
-import { Intercom } from "intercom-client";
+  console.log(adminWithApp.id);
+}
 
-const request: Intercom.AdminsAwayRequest = {
-    ...
-};
+main();
 ```
 
-## Automatic Pagination
+### Request & Response types
 
-List endpoints are paginated. The SDK provides an iterator so that you
-can simply loop over the items:
+This library includes TypeScript definitions for all request params and response fields. You may import and use them like so:
 
+<!-- prettier-ignore -->
 ```ts
-const result = await client.companies.list();
-for await (const company of result) {
-  console.log(company.id);
+import Intercom from 'intercom-client';
+
+const client = new Intercom({
+  accessToken: process.env['INTERCOM_ACCESS_TOKEN'], // This is the default and can be omitted
+  environment: 'eu', // or 'us' | 'au'; defaults to 'us'
+});
+
+async function main() {
+  const adminWithApp: Intercom.AdminWithApp | null = await client.me.retrieve();
 }
+
+main();
 ```
 
-You can also iterate page-by-page:
+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
-let page = await client.companies.list();
-for (const company of page.data) {
-  console.log(company.id);
+async function main() {
+  const adminWithApp = await client.me.retrieve().catch(async (err) => {
+    if (err instanceof Intercom.APIError) {
+      console.log(err.status); // 400
+      console.log(err.name); // BadRequestError
+      console.log(err.headers); // {server: 'nginx', ...}
+    } else {
+      throw err;
+    }
+  });
 }
+
+main();
 ```
 
-or manually:
+Error codes are as followed:
 
-```ts
-while (page.hasNextPage()) {
-  page = page.getNextPage();
-  // ...
-}
+| 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 Intercom({
+  maxRetries: 0, // default is 2
+});
+
+// Or, configure per-request:
+await client.me.retrieve({
+  maxRetries: 5,
+});
 ```
 
-## Exception Handling
+### Timeouts
 
-When the API returns a non-success status code (4xx or 5xx response), a subclass of the following error
-will be thrown.
+Requests time out after 1 minute by default. You can configure this with a `timeout` option:
 
-```typescript
-import { IntercomError } from "intercom-client";
+<!-- prettier-ignore -->
+```ts
+// Configure the default for all requests:
+const client = new Intercom({
+  timeout: 20 * 1000, // 20 seconds (default is 1 minute)
+});
 
-try {
-    await client.articles.create(...);
-} catch (err) {
-    if (err instanceof IntercomError) {
-        console.log(err.statusCode);
-        console.log(err.message);
-        console.log(err.body);
-    }
-}
+// Override per-request:
+await client.me.retrieve({
+  timeout: 5 * 1000,
+});
 ```
 
-## Advanced
+On timeout, an `APIConnectionTimeoutError` is thrown.
 
-### Retries
+Note that requests which time out will be [retried twice by default](#retries).
 
-The SDK is instrumented with automatic retries with exponential backoff. A request will be retried as long
-as the request is deemed retriable and the number of retry attempts has not grown larger than the configured
-retry limit (default: 2).
+## Advanced Usage
 
-A request is deemed retriable when any of the following HTTP status codes is returned:
+### Accessing raw Response data (e.g., headers)
 
--   [408](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/408) (Timeout)
--   [429](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429) (Too Many Requests)
--   [5XX](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500) (Internal Server Errors)
+The "raw" `Response` returned by `fetch()` can be accessed through the `.asResponse()` method on the `APIPromise` type that all methods return.
 
-Use the `maxRetries` request option to configure this behavior.
+You can also use the `.withResponse()` method to get the raw `Response` along with the parsed data.
+
+<!-- prettier-ignore -->
+```ts
+const client = new Intercom();
 
-```typescript
-const response = await client.articles.create(..., {
-    maxRetries: 0 // override maxRetries at the request level
+const response = await client.me.retrieve().asResponse();
+console.log(response.headers.get('X-My-Header'));
+console.log(response.statusText); // access the underlying Response object
+
+const { data: adminWithApp, response: raw } = await client.me.retrieve().withResponse();
+console.log(raw.headers.get('X-My-Header'));
+console.log(adminWithApp.id);
+```
+
+### 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' },
 });
 ```
 
-### Timeouts
+#### Undocumented request params
 
-The SDK defaults to a 60 second timeout. Use the `timeoutInSeconds` option to configure this behavior.
+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.
 
-```typescript
-const response = await client.articles.create(..., {
-    timeoutInSeconds: 30 // override timeout to 30s
+```ts
+client.foo.create({
+  foo: 'my_param',
+  bar: 12,
+  // @ts-expect-error baz is not yet public
+  baz: 'undocumented option',
 });
 ```
 
-### Aborting Requests
+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
 
-The SDK allows users to abort requests at any point by passing in an abort signal.
+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.
 
-```typescript
-const controller = new AbortController();
-const response = await client.articles.create(..., {
-    abortSignal: controller.signal
+### 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 "Intercom"`:
+
+```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 'intercom-client/shims/web';
+import Intercom from 'intercom-client';
+```
+
+To do the inverse, add `import "intercom-client/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/intercom/intercom-node/tree/v3/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 Intercom from 'intercom-client';
+
+const client = new Intercom({
+  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;
+  },
 });
-controller.abort(); // aborts the request
 ```
 
-### Runtime Compatibility
+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.
 
-The SDK defaults to `node-fetch` but will use the global fetch client if present. The SDK works in the following
-runtimes:
+### Configuring an HTTP(S) Agent (e.g., for proxies)
 
--   Node.js 18+
--   Vercel
--   Cloudflare Workers
--   Deno v1.25+
--   Bun 1.0+
--   React Native
+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.
 
-### Customizing Fetch Client
+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:
 
-The SDK provides a way for your to customize the underlying HTTP client / Fetch function. If you're running in an
-unsupported environment, this provides a way for you to break glass and ensure the SDK works.
+<!-- prettier-ignore -->
+```ts
+import http from 'http';
+import { HttpsProxyAgent } from 'https-proxy-agent';
 
-```typescript
-import { IntercomClient } from "intercom-client";
+// Configure the default for all requests:
+const client = new Intercom({
+  httpAgent: new HttpsProxyAgent(process.env.PROXY_URL),
+});
 
-const client = new IntercomClient({
-    ...
-    fetcher: // provide your implementation here
+// Override per-request:
+await client.me.retrieve({
+  httpAgent: new http.Agent({ keepAlive: false }),
 });
 ```
 
-## Contributing
+## 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/intercom/intercom-node/issues) with questions, bugs, or suggestions.
+
+## Requirements
+
+TypeScript >= 4.5 is supported.
+
+The following runtimes are supported:
 
-While we value open-source contributions to this SDK, this library is generated programmatically.
-Additions made directly to this library would have to be moved over to our generation code,
-otherwise they would be overwritten upon the next generated release. Feel free to open a PR as
-a proof of concept, but know that we will not be able to merge it as-is. We suggest opening
-an issue first to discuss with us!
+Note that React Native is not supported at this time.
 
-On the other hand, contributions to the README are always very welcome!
+If you are interested in other runtime environments, please open or upvote an issue on GitHub.

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?
+
+`intercom-client` 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, `intercom-client` 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 'intercom-client/shims/node'`
+- `import 'intercom-client/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 `intercom-client/_shims/registry`.
+
+Manually importing `intercom-client/shims/node` or `intercom-client/shims/web`, calls `setShims` with the respective runtime shims.
+
+All client code imports shims from `intercom-client/_shims/index`, which:
+
+- checks if shims have been set manually
+- if not, calls `setShims` with the shims from `intercom-client/_shims/auto/runtime`
+- re-exports the installed shims from `intercom-client/_shims/registry`.
+
+`intercom-client/_shims/auto/runtime` exports web runtime shims.
+If the `node` export condition is set, the export map replaces it with `intercom-client/_shims/auto/runtime-node`.
+
+### How it works - Type time
+
+All client code imports shim types from `intercom-client/_shims/index`, which selects the manual types from `intercom-client/_shims/manual-types` if they have been declared, otherwise it exports the auto types from `intercom-client/_shims/auto/types`.
+
+`intercom-client/_shims/manual-types` exports an empty namespace.
+Manually importing `intercom-client/shims/node` or `intercom-client/shims/web` merges declarations into this empty namespace, so they get picked up by `intercom-client/_shims/index`.
+
+`intercom-client/_shims/auto/types` exports web type definitions.
+If the `node` export condition is set, the export map replaces it with `intercom-client/_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

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

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