@tstdl/base 0.83.0-beta2 → 0.83.0-beta3

package/api/client/client.js

@@ -1,120 +1,135 @@
-import { container } from '../../container/index.js';
-import { HttpClient, HttpClientRequest } from '../../http/client/index.js';
-import { normalizeSingleHttpValue } from '../../http/types.js';
-import { Schema } from '../../schema/index.js';
-import { ServerSentEvents } from '../../sse/server-sent-events.js';
-import { toArray } from '../../utils/array/array.js';
-import { objectEntries } from '../../utils/object/object.js';
-import { toTitleCase } from '../../utils/string/title-case.js';
-import { isArray, isBlob, isDefined, isObject, isReadableStream, isString, isUint8Array, isUndefined } from '../../utils/type-guards.js';
-import { buildUrl } from '../../utils/url-builder.js';
-import { normalizedApiDefinitionEndpointsEntries } from '../types.js';
-import { getFullApiEndpointResource } from '../utils.js';
-export const httpClientSymbol = Symbol('ApiTransport');
-export const apiDefinitionSymbol = Symbol('ApiDefinition');
-// eslint-disable-next-line max-lines-per-function
-export function compileClient(definition, options = {}) {
-    const { resource: path, endpoints } = definition;
-    const constructedApiName = toTitleCase(path[0] ?? '');
-    const apiName = `${constructedApiName}ApiClient`;
-    const api = {
-        [apiName]: class {
-            [httpClientSymbol];
-            [apiDefinitionSymbol];
-            constructor(httpClientOrOptions) {
-                this[httpClientSymbol] = (httpClientOrOptions instanceof HttpClient) ? httpClientOrOptions : container.resolve(HttpClient, httpClientOrOptions);
-                this[apiDefinitionSymbol] = definition;
-            }
-        }
-    }[apiName];
-    container.registerSingleton(api, {
-        useFactory: (argument, context) => {
-            const httpClient = (argument instanceof HttpClient) ? argument : context.resolve(HttpClient, argument ?? options.defaultHttpClientOptions);
-            return new api(httpClient);
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+__export(client_exports, {
+  apiDefinitionSymbol: () => apiDefinitionSymbol,
+  compileClient: () => compileClient,
+  httpClientSymbol: () => httpClientSymbol
+});
+module.exports = __toCommonJS(client_exports);
+var import_container = require("../../container/index.js");
+var import_client = require("../../http/client/index.js");
+var import_types = require("../../http/types.js");
+var import_schema = require("../../schema/index.js");
+var import_server_sent_events = require("../../sse/server-sent-events.js");
+var import_array = require("../../utils/array/array.js");
+var import_object = require("../../utils/object/object.js");
+var import_title_case = require("../../utils/string/title-case.js");
+var import_type_guards = require("../../utils/type-guards.js");
+var import_url_builder = require("../../utils/url-builder.js");
+var import_types2 = require("../types.js");
+var import_utils = require("../utils.js");
+const httpClientSymbol = Symbol("ApiTransport");
+const apiDefinitionSymbol = Symbol("ApiDefinition");
+function compileClient(definition, options = {}) {
+  const { resource: path, endpoints } = definition;
+  const constructedApiName = (0, import_title_case.toTitleCase)(path[0] ?? "");
+  const apiName = `${constructedApiName}ApiClient`;
+  const api = {
+    [apiName]: class {
+      [httpClientSymbol];
+      [apiDefinitionSymbol];
+      constructor(httpClientOrOptions) {
+        this[httpClientSymbol] = httpClientOrOptions instanceof import_client.HttpClient ? httpClientOrOptions : import_container.container.resolve(import_client.HttpClient, httpClientOrOptions);
+        this[apiDefinitionSymbol] = definition;
+      }
+    }
+  }[apiName];
+  import_container.container.registerSingleton(api, {
+    useFactory: (argument, context) => {
+      const httpClient = argument instanceof import_client.HttpClient ? argument : context.resolve(import_client.HttpClient, argument ?? options.defaultHttpClientOptions);
+      return new api(httpClient);
+    }
+  });
+  const endpointsEntries = (0, import_types2.normalizedApiDefinitionEndpointsEntries)(endpoints);
+  for (const [name, endpoint] of endpointsEntries) {
+    const methods = (0, import_type_guards.isArray)(endpoint.method) ? endpoint.method : [endpoint.method ?? "GET"];
+    const resource = (0, import_utils.getFullApiEndpointResource)({ api: definition, endpoint, defaultPrefix: options.prefix });
+    const hasGet = methods.includes("GET");
+    const fallbackMethod = methods.filter((method) => method != "GET")[0] ?? "GET";
+    const apiEndpointFunction = {
+      async [name](parameters, requestBody) {
+        const context = { endpoint };
+        const method = hasGet && (0, import_type_guards.isUndefined)(parameters) ? "GET" : fallbackMethod;
+        if (endpoint.result == import_server_sent_events.ServerSentEvents) {
+          if ((0, import_type_guards.isDefined)(requestBody)) {
+            throw new Error("Body not supported for Server Sent Events.");
+          }
+          return getServerSentEvents(this[httpClientSymbol].options.baseUrl, resource, endpoint, parameters);
         }
-    });
-    const endpointsEntries = normalizedApiDefinitionEndpointsEntries(endpoints);
-    for (const [name, endpoint] of endpointsEntries) {
-        const methods = isArray(endpoint.method) ? endpoint.method : [endpoint.method ?? 'GET'];
-        const resource = getFullApiEndpointResource({ api: definition, endpoint, defaultPrefix: options.prefix });
-        const hasGet = methods.includes('GET');
-        const fallbackMethod = methods.filter((method) => method != 'GET')[0] ?? 'GET';
-        const apiEndpointFunction = {
-            async [name](parameters, requestBody) {
-                const context = { endpoint };
-                const method = (hasGet && isUndefined(parameters)) ? 'GET' : fallbackMethod;
-                if (endpoint.result == ServerSentEvents) {
-                    if (isDefined(requestBody)) {
-                        throw new Error('Body not supported for Server Sent Events.');
-                    }
-                    return getServerSentEvents(this[httpClientSymbol].options.baseUrl, resource, endpoint, parameters);
-                }
-                const request = new HttpClientRequest({
-                    method,
-                    url: resource,
-                    parameters,
-                    body: getRequestBody(requestBody),
-                    credentials: (endpoint.credentials == true) ? 'include' : undefined,
-                    context
-                });
-                const response = await this[httpClientSymbol].rawRequest(request);
-                return getResponseBody(response, endpoint.result);
-            }
-        }[name];
-        Object.defineProperty(api.prototype, name, {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: apiEndpointFunction
+        const request = new import_client.HttpClientRequest({
+          method,
+          url: resource,
+          parameters,
+          body: getRequestBody(requestBody),
+          credentials: endpoint.credentials == true ? "include" : void 0,
+          context
         });
-    }
-    return api;
+        const response = await this[httpClientSymbol].rawRequest(request);
+        return getResponseBody(response, endpoint.result);
+      }
+    }[name];
+    Object.defineProperty(api.prototype, name, {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: apiEndpointFunction
+    });
+  }
+  return api;
 }
 function getRequestBody(body) {
-    if (isUndefined(body)) {
-        return undefined;
-    }
-    if (isUint8Array(body)) {
-        return { buffer: body };
-    }
-    if (isReadableStream(body)) {
-        return { stream: body };
-    }
-    if (isBlob(body)) {
-        return { blob: body };
-    }
-    if (isString(body)) {
-        return { text: body };
-    }
-    return { json: body };
+  if ((0, import_type_guards.isUndefined)(body)) {
+    return void 0;
+  }
+  if ((0, import_type_guards.isUint8Array)(body)) {
+    return { buffer: body };
+  }
+  if ((0, import_type_guards.isReadableStream)(body)) {
+    return { stream: body };
+  }
+  if ((0, import_type_guards.isBlob)(body)) {
+    return { blob: body };
+  }
+  if ((0, import_type_guards.isString)(body)) {
+    return { text: body };
+  }
+  return { json: body };
 }
 async function getResponseBody(response, schema) {
-    if (isUndefined(schema)) {
-        response.close();
-        return undefined;
-    }
-    const body = response.hasBody
-        ? (schema == ReadableStream)
-            ? response.body.readAsBinaryStream()
-            : (schema == Uint8Array)
-                ? await response.body.readAsBuffer()
-                : (schema == String)
-                    ? await response.body.readAsText()
-                    : await response.body.read()
-        : undefined;
-    return Schema.parse(schema, body, { mask: true });
+  if ((0, import_type_guards.isUndefined)(schema)) {
+    response.close();
+    return void 0;
+  }
+  const body = response.hasBody ? schema == ReadableStream ? response.body.readAsBinaryStream() : schema == Uint8Array ? await response.body.readAsBuffer() : schema == String ? await response.body.readAsText() : await response.body.read() : void 0;
+  return import_schema.Schema.parse(schema, body, { mask: true });
 }
 function getServerSentEvents(baseUrl, resource, endpoint, parameters) {
-    const { parsedUrl, parametersRest } = buildUrl(resource, parameters, { arraySeparator: ',' });
-    const url = new URL(parsedUrl, baseUrl);
-    for (const [parameter, value] of objectEntries(parametersRest)) {
-        for (const val of toArray(value)) {
-            if (isUndefined(val) || isObject(val)) {
-                continue;
-            }
-            url.searchParams.append(parameter, normalizeSingleHttpValue(val));
-        }
+  const { parsedUrl, parametersRest } = (0, import_url_builder.buildUrl)(resource, parameters, { arraySeparator: "," });
+  const url = new URL(parsedUrl, baseUrl);
+  for (const [parameter, value] of (0, import_object.objectEntries)(parametersRest)) {
+    for (const val of (0, import_array.toArray)(value)) {
+      if ((0, import_type_guards.isUndefined)(val) || (0, import_type_guards.isObject)(val)) {
+        continue;
+      }
+      url.searchParams.append(parameter, (0, import_types.normalizeSingleHttpValue)(val));
     }
-    return new ServerSentEvents(url.toString(), { withCredentials: endpoint.credentials });
+  }
+  return new import_server_sent_events.ServerSentEvents(url.toString(), { withCredentials: endpoint.credentials });
 }
-//# sourceMappingURL=client.js.map

package/api/client/index.js

@@ -1,2 +1,18 @@
-export * from './client.js';
-//# sourceMappingURL=index.js.map
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+module.exports = __toCommonJS(client_exports);
+__reExport(client_exports, require("./client.js"), module.exports);

package/api/default-error-handlers.js

@@ -1,23 +1,48 @@
-import { SchemaError } from '../schema/index.js';
-import { isArray, isDefined } from '../utils/type-guards.js';
-export function serializeSchemaError(error) {
-    return {
-        path: error.path,
-        details: error.details,
-        inner: isDefined(error.inner) ? isArray(error.inner) ? error.inner.map(serializeInnerSchemaError) : serializeInnerSchemaError(error.inner) : undefined
-    };
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var default_error_handlers_exports = {};
+__export(default_error_handlers_exports, {
+  deserializeInnerSchemaError: () => deserializeInnerSchemaError,
+  deserializeSchemaError: () => deserializeSchemaError,
+  serializeInnerSchemaError: () => serializeInnerSchemaError,
+  serializeSchemaError: () => serializeSchemaError
+});
+module.exports = __toCommonJS(default_error_handlers_exports);
+var import_schema = require("../schema/index.js");
+var import_type_guards = require("../utils/type-guards.js");
+function serializeSchemaError(error) {
+  return {
+    path: error.path,
+    details: error.details,
+    inner: (0, import_type_guards.isDefined)(error.inner) ? (0, import_type_guards.isArray)(error.inner) ? error.inner.map(serializeInnerSchemaError) : serializeInnerSchemaError(error.inner) : void 0
+  };
 }
-export function serializeInnerSchemaError(error) {
-    return {
-        message: error.message,
-        ...serializeSchemaError(error)
-    };
+function serializeInnerSchemaError(error) {
+  return {
+    message: error.message,
+    ...serializeSchemaError(error)
+  };
 }
-export function deserializeSchemaError(message, data) {
-    const inner = isDefined(data.inner) ? isArray(data.inner) ? data.inner.map(deserializeInnerSchemaError) : deserializeInnerSchemaError(data.inner) : undefined;
-    return new SchemaError(message, { path: data.path, details: data.details, inner });
+function deserializeSchemaError(message, data) {
+  const inner = (0, import_type_guards.isDefined)(data.inner) ? (0, import_type_guards.isArray)(data.inner) ? data.inner.map(deserializeInnerSchemaError) : deserializeInnerSchemaError(data.inner) : void 0;
+  return new import_schema.SchemaError(message, { path: data.path, details: data.details, inner });
 }
-export function deserializeInnerSchemaError(data) {
-    return deserializeSchemaError(data.message, data);
+function deserializeInnerSchemaError(data) {
+  return deserializeSchemaError(data.message, data);
 }
-//# sourceMappingURL=default-error-handlers.js.map

package/api/index.js

@@ -1,15 +1,20 @@
-/**
- * Module for creating and consuming HTTP apis with built-in support for validation and error handling.
- *
- * This module contains types and functions to define and register apis and error handlers.
- *
- * Consumers of these definitions are [client](api_client.html) and [server](api_server.html).
- *
- * A basic example with a working minimal api server and client can be found in `source/examples/api/basic-overview.ts`
- *
- * @module
- */
-export * from './default-error-handlers.js';
-export * from './response.js';
-export * from './types.js';
-//# sourceMappingURL=index.js.map
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_exports = {};
+module.exports = __toCommonJS(api_exports);
+__reExport(api_exports, require("./default-error-handlers.js"), module.exports);
+__reExport(api_exports, require("./response.js"), module.exports);
+__reExport(api_exports, require("./types.js"), module.exports);

package/api/response.js

@@ -1,112 +1,135 @@
-import { SecretRequirementsError } from '../authentication/errors/secret-requirements.error.js';
-import { SchemaError } from '../schema/schema.error.js';
-import { ApiError, BadRequestError, ForbiddenError, InvalidTokenError, MaxBytesExceededError, MethodNotAllowedError, NotFoundError, NotImplementedError, NotSupportedError, UnauthorizedError, UnsupportedMediaTypeError } from '../error/index.js';
-import { isDefined, isFunction, isObject, isString } from '../utils/type-guards.js';
-import { deserializeSchemaError, serializeSchemaError } from './default-error-handlers.js';
-const errorHandlers = new Map();
-export function registerErrorHandler(constructor, statusCode, serializer, deserializer) {
-    if (errorHandlers.has(constructor.errorName)) {
-        throw new Error(`A handler for ${constructor.errorName} already registered.`);
-    }
-    errorHandlers.set(constructor.errorName, { statusCode, serializer, deserializer });
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var response_exports = {};
+__export(response_exports, {
+  createErrorResponse: () => createErrorResponse,
+  createResultResponse: () => createResultResponse,
+  getErrorStatusCode: () => getErrorStatusCode,
+  hasErrorHandler: () => hasErrorHandler,
+  isErrorResponse: () => isErrorResponse,
+  isResponse: () => isResponse,
+  isResultResponse: () => isResultResponse,
+  parseErrorResponse: () => parseErrorResponse,
+  parseResponse: () => parseResponse,
+  registerErrorHandler: () => registerErrorHandler
+});
+module.exports = __toCommonJS(response_exports);
+var import_secret_requirements_error = require("../authentication/errors/secret-requirements.error.js");
+var import_schema_error = require("../schema/schema.error.js");
+var import_error = require("../error/index.js");
+var import_type_guards = require("../utils/type-guards.js");
+var import_default_error_handlers = require("./default-error-handlers.js");
+const errorHandlers = /* @__PURE__ */ new Map();
+function registerErrorHandler(constructor, statusCode, serializer, deserializer) {
+  if (errorHandlers.has(constructor.errorName)) {
+    throw new Error(`A handler for ${constructor.errorName} already registered.`);
+  }
+  errorHandlers.set(constructor.errorName, { statusCode, serializer, deserializer });
 }
-export function hasErrorHandler(constructor) {
-    const name = isFunction(constructor)
-        ? constructor.errorName
-        : isString(constructor)
-            ? constructor
-            : isErrorResponse(constructor)
-                ? constructor.error.name
-                : undefined;
-    return errorHandlers.has(name);
+function hasErrorHandler(constructor) {
+  const name = (0, import_type_guards.isFunction)(constructor) ? constructor.errorName : (0, import_type_guards.isString)(constructor) ? constructor : isErrorResponse(constructor) ? constructor.error.name : void 0;
+  return errorHandlers.has(name);
 }
-export function getErrorStatusCode(error, defaultStatusCode = 500) {
-    return errorHandlers.get(error.name)?.statusCode ?? defaultStatusCode;
+function getErrorStatusCode(error, defaultStatusCode = 500) {
+  return errorHandlers.get(error.name)?.statusCode ?? defaultStatusCode;
 }
-export function createResultResponse(result) {
-    const response = {
-        result
-    };
-    return response;
+function createResultResponse(result) {
+  const response = {
+    result
+  };
+  return response;
 }
-export function createErrorResponse(errorOrName, message = '', details) {
-    let response;
-    if (errorOrName instanceof Error) {
-        const handler = errorHandlers.get(errorOrName.name);
-        if (handler != undefined) {
-            const data = handler.serializer(errorOrName);
-            response = {
-                error: {
-                    name: errorOrName.name,
-                    message: errorOrName.message,
-                    details,
-                    data
-                }
-            };
+function createErrorResponse(errorOrName, message = "", details) {
+  let response;
+  if (errorOrName instanceof Error) {
+    const handler = errorHandlers.get(errorOrName.name);
+    if (handler != void 0) {
+      const data = handler.serializer(errorOrName);
+      response = {
+        error: {
+          name: errorOrName.name,
+          message: errorOrName.message,
+          details,
+          data
         }
-        else {
-            response = {
-                error: {
-                    name: errorOrName.name,
-                    message: errorOrName.message,
-                    details
-                }
-            };
+      };
+    } else {
+      response = {
+        error: {
+          name: errorOrName.name,
+          message: errorOrName.message,
+          details
         }
+      };
     }
-    else {
-        response = {
-            error: {
-                name: errorOrName,
-                message,
-                details
-            }
-        };
-    }
-    return response;
+  } else {
+    response = {
+      error: {
+        name: errorOrName,
+        message,
+        details
+      }
+    };
+  }
+  return response;
 }
-export function parseResponse(response) {
-    if (isResultResponse(response)) {
-        return response.result;
-    }
-    if (isErrorResponse(response)) {
-        throw parseErrorResponse(response);
-    }
-    throw new Error('Unsupported response.');
+function parseResponse(response) {
+  if (isResultResponse(response)) {
+    return response.result;
+  }
+  if (isErrorResponse(response)) {
+    throw parseErrorResponse(response);
+  }
+  throw new Error("Unsupported response.");
 }
-export function parseErrorResponse(response, fallbackToGenericApiError = true) {
-    const handler = errorHandlers.get(response.error.name);
-    if (handler != undefined) {
-        const error = handler.deserializer(response.error.data, response.error);
-        return error;
-    }
-    if (!fallbackToGenericApiError) {
-        return undefined;
-    }
-    return new ApiError(response);
+function parseErrorResponse(response, fallbackToGenericApiError = true) {
+  const handler = errorHandlers.get(response.error.name);
+  if (handler != void 0) {
+    const error = handler.deserializer(response.error.data, response.error);
+    return error;
+  }
+  if (!fallbackToGenericApiError) {
+    return void 0;
+  }
+  return new import_error.ApiError(response);
 }
-export function isResultResponse(response) {
-    const hasResult = isObject(response) && isDefined(response.result);
-    return hasResult;
+function isResultResponse(response) {
+  const hasResult = (0, import_type_guards.isObject)(response) && (0, import_type_guards.isDefined)(response.result);
+  return hasResult;
 }
-export function isErrorResponse(response) {
-    const hasError = isObject(response) && isDefined(response.error);
-    return hasError;
+function isErrorResponse(response) {
+  const hasError = (0, import_type_guards.isObject)(response) && (0, import_type_guards.isDefined)(response.error);
+  return hasError;
 }
-export function isResponse(obj) {
-    return (isResultResponse(obj) || isErrorResponse(obj));
+function isResponse(obj) {
+  return isResultResponse(obj) || isErrorResponse(obj);
 }
-registerErrorHandler(ApiError, 400, ({ response }) => response, (response) => new ApiError(response));
-registerErrorHandler(BadRequestError, 400, () => undefined, (_, error) => new BadRequestError(error.message));
-registerErrorHandler(ForbiddenError, 403, () => undefined, (_, error) => new ForbiddenError(error.message));
-registerErrorHandler(InvalidTokenError, 401, () => undefined, (_, error) => new InvalidTokenError(error.message));
-registerErrorHandler(MaxBytesExceededError, 400, () => undefined, (_, error) => new MaxBytesExceededError(error.message));
-registerErrorHandler(NotFoundError, 404, () => undefined, (_, error) => new NotFoundError(error.message));
-registerErrorHandler(NotImplementedError, 501, () => undefined, (_, error) => new NotImplementedError(error.message));
-registerErrorHandler(NotSupportedError, 400, () => undefined, (_, error) => new NotSupportedError(error.message));
-registerErrorHandler(UnauthorizedError, 401, () => undefined, (_, error) => new UnauthorizedError(error.message));
-registerErrorHandler(MethodNotAllowedError, 405, () => undefined, (_, error) => new MethodNotAllowedError(error.message));
-registerErrorHandler(UnsupportedMediaTypeError, 415, () => undefined, (_, error) => new UnsupportedMediaTypeError(error.message));
-registerErrorHandler(SchemaError, 400, serializeSchemaError, (data, error) => deserializeSchemaError(error.message, data));
-registerErrorHandler(SecretRequirementsError, 403, () => undefined, (_, error) => new SecretRequirementsError(error.message));
-//# sourceMappingURL=response.js.map
+registerErrorHandler(import_error.ApiError, 400, ({ response }) => response, (response) => new import_error.ApiError(response));
+registerErrorHandler(import_error.BadRequestError, 400, () => void 0, (_, error) => new import_error.BadRequestError(error.message));
+registerErrorHandler(import_error.ForbiddenError, 403, () => void 0, (_, error) => new import_error.ForbiddenError(error.message));
+registerErrorHandler(import_error.InvalidTokenError, 401, () => void 0, (_, error) => new import_error.InvalidTokenError(error.message));
+registerErrorHandler(import_error.MaxBytesExceededError, 400, () => void 0, (_, error) => new import_error.MaxBytesExceededError(error.message));
+registerErrorHandler(import_error.NotFoundError, 404, () => void 0, (_, error) => new import_error.NotFoundError(error.message));
+registerErrorHandler(import_error.NotImplementedError, 501, () => void 0, (_, error) => new import_error.NotImplementedError(error.message));
+registerErrorHandler(import_error.NotSupportedError, 400, () => void 0, (_, error) => new import_error.NotSupportedError(error.message));
+registerErrorHandler(import_error.UnauthorizedError, 401, () => void 0, (_, error) => new import_error.UnauthorizedError(error.message));
+registerErrorHandler(import_error.MethodNotAllowedError, 405, () => void 0, (_, error) => new import_error.MethodNotAllowedError(error.message));
+registerErrorHandler(import_error.UnsupportedMediaTypeError, 415, () => void 0, (_, error) => new import_error.UnsupportedMediaTypeError(error.message));
+registerErrorHandler(import_schema_error.SchemaError, 400, import_default_error_handlers.serializeSchemaError, (data, error) => (0, import_default_error_handlers.deserializeSchemaError)(error.message, data));
+registerErrorHandler(import_secret_requirements_error.SecretRequirementsError, 403, () => void 0, (_, error) => new import_secret_requirements_error.SecretRequirementsError(error.message));