agentnetes 0.1.3 → 0.1.4

package/web/.next/node_modules/@vercel/sandbox-458c632d4d217a3e/dist/auth/oauth.js

@@ -0,0 +1,269 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAuth = OAuth;
+exports.isOAuthError = isOAuthError;
+const os_1 = __importDefault(require("os"));
+const zod_1 = require("zod");
+const version_1 = require("../version");
+const USER_AGENT = `${os_1.default.hostname()} @ vercel/sandbox/${version_1.VERSION} node-${process.version} ${os_1.default.platform()} (${os_1.default.arch()})`;
+const ISSUER = new URL("https://vercel.com");
+const CLIENT_ID = "cl_HYyOPBNtFMfHhaUn9L4QPfTZz6TP47bp";
+const AuthorizationServerMetadata = zod_1.z.object({
+    issuer: zod_1.z.string().url(),
+    device_authorization_endpoint: zod_1.z.string().url(),
+    token_endpoint: zod_1.z.string().url(),
+    revocation_endpoint: zod_1.z.string().url(),
+    jwks_uri: zod_1.z.string().url(),
+    introspection_endpoint: zod_1.z.string().url(),
+});
+let _as;
+const DeviceAuthorization = zod_1.z.object({
+    device_code: zod_1.z.string(),
+    user_code: zod_1.z.string(),
+    verification_uri: zod_1.z.string().url(),
+    verification_uri_complete: zod_1.z.string().url(),
+    expires_in: zod_1.z.number(),
+    interval: zod_1.z.number(),
+});
+const IntrospectionResponse = zod_1.z
+    .object({
+    active: zod_1.z.literal(true),
+    client_id: zod_1.z.string(),
+    session_id: zod_1.z.string(),
+})
+    .or(zod_1.z.object({ active: zod_1.z.literal(false) }));
+/**
+ * Returns the Authorization Server Metadata
+ *
+ * @see https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderConfigurationRequest
+ * @see https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderConfigurationResponse
+ */
+async function authorizationServerMetadata() {
+    if (_as)
+        return _as;
+    const response = await fetch(new URL(".well-known/openid-configuration", ISSUER), {
+        headers: { "Content-Type": "application/json", "user-agent": USER_AGENT },
+    });
+    _as = AuthorizationServerMetadata.parse(await response.json());
+    return _as;
+}
+async function OAuth() {
+    const as = await authorizationServerMetadata();
+    return {
+        /**
+         * Perform the Device Authorization Request
+         *
+         * @see https://datatracker.ietf.org/doc/html/rfc8628#section-3.1
+         * @see https://datatracker.ietf.org/doc/html/rfc8628#section-3.2
+         */
+        async deviceAuthorizationRequest() {
+            const response = await fetch(as.device_authorization_endpoint, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    "user-agent": USER_AGENT,
+                },
+                body: new URLSearchParams({
+                    client_id: CLIENT_ID,
+                    scope: "openid offline_access",
+                }),
+            });
+            const json = await response.json();
+            const parsed = DeviceAuthorization.safeParse(json);
+            if (!parsed.success) {
+                throw new OAuthError(`Failed to parse device authorization response: ${parsed.error.message}`, json);
+            }
+            return {
+                device_code: parsed.data.device_code,
+                user_code: parsed.data.user_code,
+                verification_uri: parsed.data.verification_uri,
+                verification_uri_complete: parsed.data.verification_uri_complete,
+                expiresAt: Date.now() + parsed.data.expires_in * 1000,
+                interval: parsed.data.interval,
+            };
+        },
+        /**
+         * Perform the Device Access Token Request
+         *
+         * @see https://datatracker.ietf.org/doc/html/rfc8628#section-3.4
+         */
+        async deviceAccessTokenRequest(device_code) {
+            try {
+                return [
+                    null,
+                    await fetch(as.token_endpoint, {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/x-www-form-urlencoded",
+                            "user-agent": USER_AGENT,
+                        },
+                        body: new URLSearchParams({
+                            client_id: CLIENT_ID,
+                            grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+                            device_code,
+                        }),
+                        signal: AbortSignal.timeout(10 * 1000),
+                    }),
+                ];
+            }
+            catch (error) {
+                if (error instanceof Error)
+                    return [error];
+                return [
+                    new Error("An unknown error occurred. See the logs for details.", {
+                        cause: error,
+                    }),
+                ];
+            }
+        },
+        /**
+         * Process the Token request Response
+         *
+         * @see https://datatracker.ietf.org/doc/html/rfc8628#section-3.5
+         */
+        async processTokenResponse(response) {
+            const json = await response.json();
+            const processed = TokenSet.safeParse(json);
+            if (!processed.success) {
+                return [
+                    new OAuthError(`Failed to parse token response: ${processed.error.message}`, json),
+                ];
+            }
+            return [null, processed.data];
+        },
+        /**
+         * Perform a Token Revocation Request.
+         *
+         * @see https://datatracker.ietf.org/doc/html/rfc7009#section-2.1
+         * @see https://datatracker.ietf.org/doc/html/rfc7009#section-2.2
+         */
+        async revokeToken(token) {
+            const response = await fetch(as.revocation_endpoint, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    "user-agent": USER_AGENT,
+                },
+                body: new URLSearchParams({ token, client_id: CLIENT_ID }),
+            });
+            if (response.ok)
+                return;
+            const json = await response.json();
+            return new OAuthError("Revocation request failed", json);
+        },
+        /**
+         * Perform Refresh Token Request.
+         *
+         * @see https://datatracker.ietf.org/doc/html/rfc6749#section-6
+         */
+        async refreshToken(token) {
+            const response = await fetch(as.token_endpoint, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    "user-agent": USER_AGENT,
+                },
+                body: new URLSearchParams({
+                    client_id: CLIENT_ID,
+                    grant_type: "refresh_token",
+                    refresh_token: token,
+                }),
+            });
+            const [tokensError, tokenSet] = await this.processTokenResponse(response);
+            if (tokensError)
+                throw tokensError;
+            return tokenSet;
+        },
+        /**
+         * Perform Token Introspection Request.
+         *
+         * @see https://datatracker.ietf.org/doc/html/rfc7662#section-2.1
+         */
+        async introspectToken(token) {
+            const response = await fetch(as.introspection_endpoint, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    "user-agent": USER_AGENT,
+                },
+                body: new URLSearchParams({ token }),
+            });
+            const json = await response.json();
+            const processed = IntrospectionResponse.safeParse(json);
+            if (!processed.success) {
+                throw new OAuthError(`Failed to parse introspection response: ${processed.error.message}`, json);
+            }
+            return processed.data;
+        },
+    };
+}
+const TokenSet = zod_1.z.object({
+    /** The access token issued by the authorization server. */
+    access_token: zod_1.z.string(),
+    /** The type of the token issued */
+    token_type: zod_1.z.literal("Bearer"),
+    /** The lifetime in seconds of the access token. */
+    expires_in: zod_1.z.number(),
+    /** The refresh token, which can be used to obtain new access tokens. */
+    refresh_token: zod_1.z.string().optional(),
+    /** The scope of the access token. */
+    scope: zod_1.z.string().optional(),
+});
+const OAuthErrorResponse = zod_1.z.object({
+    error: zod_1.z.enum([
+        "invalid_request",
+        "invalid_client",
+        "invalid_grant",
+        "unauthorized_client",
+        "unsupported_grant_type",
+        "invalid_scope",
+        "server_error",
+        // Device Authorization Response Errors
+        "authorization_pending",
+        "slow_down",
+        "access_denied",
+        "expired_token",
+        // Revocation Response Errors
+        "unsupported_token_type",
+    ]),
+    error_description: zod_1.z.string().optional(),
+    error_uri: zod_1.z.string().optional(),
+});
+function processOAuthErrorResponse(json) {
+    try {
+        return OAuthErrorResponse.parse(json);
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            return new TypeError(`Invalid OAuth error response: ${error.message}`);
+        }
+        return new TypeError("Failed to parse OAuth error response");
+    }
+}
+class OAuthError extends Error {
+    constructor(message, response) {
+        super(message);
+        this.name = "OAuthError";
+        const error = processOAuthErrorResponse(response);
+        if (error instanceof TypeError) {
+            const message = `Unexpected server response: ${JSON.stringify(response)}`;
+            this.cause = new Error(message, { cause: error });
+            this.code = "server_error";
+            return;
+        }
+        let cause = error.error;
+        if (error.error_description)
+            cause += `: ${error.error_description}`;
+        if (error.error_uri)
+            cause += ` (${error.error_uri})`;
+        this.cause = new Error(cause);
+        this.code = error.error;
+    }
+}
+function isOAuthError(error) {
+    return error instanceof OAuthError;
+}
+//# sourceMappingURL=oauth.js.map

package/web/.next/node_modules/@vercel/sandbox-458c632d4d217a3e/dist/auth/poll-for-token.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pollForToken = pollForToken;
+const promises_1 = require("node:timers/promises");
+const file_1 = require("./file");
+const oauth_1 = require("./oauth");
+async function* pollForToken({ request, oauth, }) {
+    const controller = new AbortController();
+    try {
+        let intervalMs = request.interval * 1000;
+        while (Date.now() < request.expiresAt) {
+            const [tokenResponseError, tokenResponse] = await oauth.deviceAccessTokenRequest(request.device_code);
+            if (tokenResponseError) {
+                // 2x backoff on connection timeouts per spec https://datatracker.ietf.org/doc/html/rfc8628#section-3.5
+                if (tokenResponseError.message.includes("timeout")) {
+                    intervalMs *= 2;
+                    yield { _tag: "Timeout", newInterval: intervalMs };
+                    await (0, promises_1.setTimeout)(intervalMs, { signal: controller.signal });
+                    continue;
+                }
+                yield { _tag: "Error", error: tokenResponseError };
+                return;
+            }
+            yield {
+                _tag: "Response",
+                response: tokenResponse.clone(),
+            };
+            const [tokensError, tokens] = await oauth.processTokenResponse(tokenResponse);
+            if ((0, oauth_1.isOAuthError)(tokensError)) {
+                const { code } = tokensError;
+                switch (code) {
+                    case "authorization_pending":
+                        await (0, promises_1.setTimeout)(intervalMs, { signal: controller.signal });
+                        continue;
+                    case "slow_down":
+                        intervalMs += 5 * 1000;
+                        yield { _tag: "SlowDown", newInterval: intervalMs };
+                        await (0, promises_1.setTimeout)(intervalMs, { signal: controller.signal });
+                        continue;
+                    default:
+                        yield { _tag: "Error", error: tokensError.cause };
+                        return;
+                }
+            }
+            if (tokensError) {
+                yield { _tag: "Error", error: tokensError };
+                return;
+            }
+            (0, file_1.updateAuthConfig)({
+                token: tokens.access_token,
+                expiresAt: new Date(Date.now() + tokens.expires_in * 1000),
+                refreshToken: tokens.refresh_token,
+            });
+            return;
+        }
+        yield {
+            _tag: "Error",
+            error: new Error("Timed out waiting for authentication. Please try again."),
+        };
+        return;
+    }
+    finally {
+        controller.abort();
+    }
+}
+//# sourceMappingURL=poll-for-token.js.map

package/web/.next/node_modules/@vercel/sandbox-458c632d4d217a3e/dist/auth/project.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferScope = inferScope;
+exports.selectTeam = selectTeam;
+const zod_1 = require("zod");
+const api_1 = require("./api");
+const error_1 = require("./error");
+const linked_project_1 = require("./linked-project");
+const TeamsSchema = zod_1.z.object({
+    teams: zod_1.z
+        .array(zod_1.z.object({
+        slug: zod_1.z.string(),
+    }))
+        .min(1, `No teams found. Please create a team first.`),
+});
+const DEFAULT_PROJECT_NAME = "vercel-sandbox-default-project";
+/**
+ * Resolves the team and project scope for sandbox operations.
+ *
+ * First checks for a locally linked project in `.vercel/project.json`.
+ * If found, uses the `projectId` and `orgId` from there.
+ *
+ * Otherwise, if `teamId` is not provided, selects the first available team for the account.
+ * Ensures a default project exists within the team, creating it if necessary.
+ *
+ * @param opts.token - Vercel API authentication token.
+ * @param opts.teamId - Optional team slug. If omitted, the first team is selected.
+ * @param opts.cwd - Optional directory to search for `.vercel/project.json`. Defaults to `process.cwd()`.
+ * @returns The resolved scope with `projectId`, `teamId`, and whether the project was `created`.
+ *
+ * @throws {NotOk} If the API returns an error other than 404 when checking the project.
+ * @throws {ZodError} If no teams exist for the account.
+ *
+ * @example
+ * ```ts
+ * const scope = await inferScope({ token: "vercel_..." });
+ * // => { projectId: "vercel-sandbox-default-project", teamId: "my-team", created: false }
+ * ```
+ */
+async function inferScope(opts) {
+    const linkedProject = await (0, linked_project_1.readLinkedProject)(opts.cwd ?? process.cwd());
+    if (linkedProject) {
+        return { ...linkedProject, created: false };
+    }
+    const teamId = opts.teamId ?? (await selectTeam(opts.token));
+    let created = false;
+    try {
+        await (0, api_1.fetchApi)({
+            token: opts.token,
+            endpoint: `/v2/projects/${encodeURIComponent(DEFAULT_PROJECT_NAME)}?slug=${encodeURIComponent(teamId)}`,
+        });
+    }
+    catch (e) {
+        if (!(e instanceof error_1.NotOk) || e.response.statusCode !== 404) {
+            throw e;
+        }
+        await (0, api_1.fetchApi)({
+            token: opts.token,
+            endpoint: `/v11/projects?slug=${encodeURIComponent(teamId)}`,
+            method: "POST",
+            body: JSON.stringify({
+                name: DEFAULT_PROJECT_NAME,
+            }),
+        });
+        created = true;
+    }
+    return { projectId: DEFAULT_PROJECT_NAME, teamId, created };
+}
+/**
+ * Selects a team for the current token by querying the Teams API and
+ * returning the slug of the first team in the result set.
+ *
+ * @param token - Authentication token used to call the Vercel API.
+ * @returns A promise that resolves to the first team's slug.
+ */
+async function selectTeam(token) {
+    const { teams: [team], } = await (0, api_1.fetchApi)({ token, endpoint: "/v2/teams?limit=1" }).then(TeamsSchema.parse);
+    return team.slug;
+}
+//# sourceMappingURL=project.js.map

package/web/.next/node_modules/@vercel/sandbox-458c632d4d217a3e/dist/auth/zod.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.json = void 0;
+const zod_1 = require("zod");
+/**
+ * A Zod codec that serializes and deserializes JSON strings.
+ */
+exports.json = zod_1.z.string().transform((jsonString, ctx) => {
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch (err) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Invalid JSON: ${err.message}`,
+        });
+        return zod_1.z.NEVER;
+    }
+});
+//# sourceMappingURL=zod.js.map

package/web/.next/node_modules/@vercel/sandbox-458c632d4d217a3e/dist/command.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandFinished = exports.Command = void 0;
+const resolveSignal_1 = require("./utils/resolveSignal");
+/**
+ * A command executed in a Sandbox.
+ *
+ * For detached commands, you can {@link wait} to get a {@link CommandFinished} instance
+ * with the populated exit code. For non-detached commands, {@link Sandbox.runCommand}
+ * automatically waits and returns a {@link CommandFinished} instance.
+ *
+ * You can iterate over command output with {@link logs}.
+ *
+ * @see {@link Sandbox.runCommand} to start a command.
+ *
+ * @hideconstructor
+ */
+class Command {
+    /**
+     * ID of the command execution.
+     */
+    get cmdId() {
+        return this.cmd.id;
+    }
+    get cwd() {
+        return this.cmd.cwd;
+    }
+    get startedAt() {
+        return this.cmd.startedAt;
+    }
+    /**
+     * @param params - Object containing the client, sandbox ID, and command ID.
+     * @param params.client - API client used to interact with the backend.
+     * @param params.sandboxId - The ID of the sandbox where the command is running.
+     * @param params.cmdId - The ID of the command execution.
+     */
+    constructor({ client, sandboxId, cmd, }) {
+        this.outputCache = null;
+        this.client = client;
+        this.sandboxId = sandboxId;
+        this.cmd = cmd;
+        this.exitCode = cmd.exitCode ?? null;
+    }
+    /**
+     * Iterate over the output of this command.
+     *
+     * ```
+     * for await (const log of cmd.logs()) {
+     *   if (log.stream === "stdout") {
+     *     process.stdout.write(log.data);
+     *   } else {
+     *     process.stderr.write(log.data);
+     *   }
+     * }
+     * ```
+     *
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel log streaming.
+     * @returns An async iterable of log entries from the command output.
+     *
+     * @see {@link Command.stdout}, {@link Command.stderr}, and {@link Command.output}
+     * to access output as a string.
+     */
+    logs(opts) {
+        return this.client.getLogs({
+            sandboxId: this.sandboxId,
+            cmdId: this.cmd.id,
+            signal: opts?.signal,
+        });
+    }
+    /**
+     * Wait for a command to exit and populate its exit code.
+     *
+     * This method is useful for detached commands where you need to wait
+     * for completion. For non-detached commands, {@link Sandbox.runCommand}
+     * automatically waits and returns a {@link CommandFinished} instance.
+     *
+     * ```
+     * const detachedCmd = await sandbox.runCommand({ cmd: 'sleep', args: ['5'], detached: true });
+     * const result = await detachedCmd.wait();
+     * if (result.exitCode !== 0) {
+     *   console.error("Something went wrong...")
+     * }
+     * ```
+     *
+     * @param params - Optional parameters.
+     * @param params.signal - An AbortSignal to cancel waiting.
+     * @returns A {@link CommandFinished} instance with populated exit code.
+     */
+    async wait(params) {
+        params?.signal?.throwIfAborted();
+        const command = await this.client.getCommand({
+            sandboxId: this.sandboxId,
+            cmdId: this.cmd.id,
+            wait: true,
+            signal: params?.signal,
+        });
+        return new CommandFinished({
+            client: this.client,
+            sandboxId: this.sandboxId,
+            cmd: command.json.command,
+            exitCode: command.json.command.exitCode,
+        });
+    }
+    /**
+     * Get cached output, fetching logs only once and reusing for concurrent calls.
+     * This prevents race conditions when stdout() and stderr() are called in parallel.
+     */
+    async getCachedOutput(opts) {
+        if (!this.outputCache) {
+            this.outputCache = (async () => {
+                try {
+                    let stdout = "";
+                    let stderr = "";
+                    let both = "";
+                    for await (const log of this.logs({ signal: opts?.signal })) {
+                        both += log.data;
+                        if (log.stream === "stdout") {
+                            stdout += log.data;
+                        }
+                        else {
+                            stderr += log.data;
+                        }
+                    }
+                    return { stdout, stderr, both };
+                }
+                catch (err) {
+                    // Clear the promise so future calls can retry
+                    this.outputCache = null;
+                    throw err;
+                }
+            })();
+        }
+        return this.outputCache;
+    }
+    /**
+     * Get the output of `stdout`, `stderr`, or both as a string.
+     *
+     * NOTE: This may throw string conversion errors if the command does
+     * not output valid Unicode.
+     *
+     * @param stream - The output stream to read: "stdout", "stderr", or "both".
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel output streaming.
+     * @returns The output of the specified stream(s) as a string.
+     */
+    async output(stream = "both", opts) {
+        const cached = await this.getCachedOutput(opts);
+        return cached[stream];
+    }
+    /**
+     * Get the output of `stdout` as a string.
+     *
+     * NOTE: This may throw string conversion errors if the command does
+     * not output valid Unicode.
+     *
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel output streaming.
+     * @returns The standard output of the command.
+     */
+    async stdout(opts) {
+        return this.output("stdout", opts);
+    }
+    /**
+     * Get the output of `stderr` as a string.
+     *
+     * NOTE: This may throw string conversion errors if the command does
+     * not output valid Unicode.
+     *
+     * @param opts - Optional parameters.
+     * @param opts.signal - An AbortSignal to cancel output streaming.
+     * @returns The standard error output of the command.
+     */
+    async stderr(opts) {
+        return this.output("stderr", opts);
+    }
+    /**
+     * Kill a running command in a sandbox.
+     *
+     * @param signal - The signal to send the running process. Defaults to SIGTERM.
+     * @param opts - Optional parameters.
+     * @param opts.abortSignal - An AbortSignal to cancel the kill operation.
+     * @returns Promise<void>.
+     */
+    async kill(signal, opts) {
+        await this.client.killCommand({
+            sandboxId: this.sandboxId,
+            commandId: this.cmd.id,
+            signal: (0, resolveSignal_1.resolveSignal)(signal ?? "SIGTERM"),
+            abortSignal: opts?.abortSignal,
+        });
+    }
+}
+exports.Command = Command;
+/**
+ * A command that has finished executing.
+ *
+ * The exit code is immediately available and populated upon creation.
+ * Unlike {@link Command}, you don't need to call wait() - the command
+ * has already completed execution.
+ *
+ * @hideconstructor
+ */
+class CommandFinished extends Command {
+    /**
+     * @param params - Object containing client, sandbox ID, command ID, and exit code.
+     * @param params.client - API client used to interact with the backend.
+     * @param params.sandboxId - The ID of the sandbox where the command ran.
+     * @param params.cmdId - The ID of the command execution.
+     * @param params.exitCode - The exit code of the completed command.
+     */
+    constructor(params) {
+        super({ ...params });
+        this.exitCode = params.exitCode;
+    }
+    /**
+     * The wait method is not needed for CommandFinished instances since
+     * the command has already completed and exitCode is populated.
+     *
+     * @deprecated This method is redundant for CommandFinished instances.
+     * The exitCode is already available.
+     * @returns This CommandFinished instance.
+     */
+    async wait() {
+        return this;
+    }
+}
+exports.CommandFinished = CommandFinished;
+//# sourceMappingURL=command.js.map

package/web/.next/node_modules/@vercel/sandbox-458c632d4d217a3e/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIError = exports.StreamError = exports.CommandFinished = exports.Command = exports.Snapshot = exports.Sandbox = void 0;
+var sandbox_1 = require("./sandbox");
+Object.defineProperty(exports, "Sandbox", { enumerable: true, get: function () { return sandbox_1.Sandbox; } });
+var snapshot_1 = require("./snapshot");
+Object.defineProperty(exports, "Snapshot", { enumerable: true, get: function () { return snapshot_1.Snapshot; } });
+var command_1 = require("./command");
+Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return command_1.Command; } });
+Object.defineProperty(exports, "CommandFinished", { enumerable: true, get: function () { return command_1.CommandFinished; } });
+var api_error_1 = require("./api-client/api-error");
+Object.defineProperty(exports, "StreamError", { enumerable: true, get: function () { return api_error_1.StreamError; } });
+var api_error_2 = require("./api-client/api-error");
+Object.defineProperty(exports, "APIError", { enumerable: true, get: function () { return api_error_2.APIError; } });
+//# sourceMappingURL=index.js.map