@tstdl/base 0.85.14 → 0.86.0-beta2

package/api/client/client.js

@@ -1,135 +1,119 @@
-"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);
+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);
         }
-        const request = new import_client.HttpClientRequest({
-          method,
-          url: resource,
-          parameters,
-          body: getRequestBody(requestBody),
-          credentials: endpoint.credentials == true ? "include" : void 0,
-          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
     });
-  }
-  return api;
+    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
+        });
+    }
+    return api;
 }
 function getRequestBody(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 };
+    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 };
 }
 async function getResponseBody(response, schema) {
-  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 });
+    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 });
 }
 function getServerSentEvents(baseUrl, resource, endpoint, parameters) {
-  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));
+    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));
+        }
     }
-  }
-  return new import_server_sent_events.ServerSentEvents(url.toString(), { withCredentials: endpoint.credentials });
+    return new ServerSentEvents(url.toString(), { withCredentials: endpoint.credentials });
 }

package/api/client/index.js

@@ -1,18 +1 @@
-"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);
+export * from './client.js';

package/api/default-error-handlers.js

@@ -1,48 +1,22 @@
-"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
-  };
+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
+    };
 }
-function serializeInnerSchemaError(error) {
-  return {
-    message: error.message,
-    ...serializeSchemaError(error)
-  };
+export function serializeInnerSchemaError(error) {
+    return {
+        message: error.message,
+        ...serializeSchemaError(error)
+    };
 }
-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 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 deserializeInnerSchemaError(data) {
-  return deserializeSchemaError(data.message, data);
+export function deserializeInnerSchemaError(data) {
+    return deserializeSchemaError(data.message, data);
 }

package/api/index.js

@@ -1,20 +1,14 @@
-"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);
+/**
+ * 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';

package/api/response.js

@@ -1,136 +1,112 @@
-"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) {
-  (0, import_type_guards.assertString)(constructor.errorName, "static property 'errorName' missing.");
-  if (errorHandlers.has(constructor.errorName)) {
-    throw new Error(`A handler for ${constructor.errorName} already registered.`);
-  }
-  errorHandlers.set(constructor.errorName, { statusCode, serializer, deserializer });
+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 { assertString, 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) {
+    assertString(constructor.errorName, 'static property \'errorName\' missing.');
+    if (errorHandlers.has(constructor.errorName)) {
+        throw new Error(`A handler for ${constructor.errorName} already registered.`);
+    }
+    errorHandlers.set(constructor.errorName, { statusCode, serializer, deserializer });
 }
-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 hasErrorHandler(constructor) {
+    const name = isFunction(constructor)
+        ? constructor.errorName
+        : isString(constructor)
+            ? constructor
+            : isErrorResponse(constructor)
+                ? constructor.error.name
+                : undefined;
+    return errorHandlers.has(name);
 }
-function getErrorStatusCode(error, defaultStatusCode = 500) {
-  return errorHandlers.get(error.name)?.statusCode ?? defaultStatusCode;
+export function getErrorStatusCode(error, defaultStatusCode = 500) {
+    return errorHandlers.get(error.name)?.statusCode ?? defaultStatusCode;
 }
-function createResultResponse(result) {
-  const response = {
-    result
-  };
-  return response;
+export function createResultResponse(result) {
+    const response = {
+        result
+    };
+    return response;
 }
-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
+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
+                }
+            };
         }
-      };
-    } 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;
 }
-function parseResponse(response) {
-  if (isResultResponse(response)) {
-    return response.result;
-  }
-  if (isErrorResponse(response)) {
-    throw parseErrorResponse(response);
-  }
-  throw new Error("Unsupported response.");
+export function parseResponse(response) {
+    if (isResultResponse(response)) {
+        return response.result;
+    }
+    if (isErrorResponse(response)) {
+        throw parseErrorResponse(response);
+    }
+    throw new Error('Unsupported 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 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 isResultResponse(response) {
-  const hasResult = (0, import_type_guards.isObject)(response) && (0, import_type_guards.isDefined)(response.result);
-  return hasResult;
+export function isResultResponse(response) {
+    const hasResult = isObject(response) && isDefined(response.result);
+    return hasResult;
 }
-function isErrorResponse(response) {
-  const hasError = (0, import_type_guards.isObject)(response) && (0, import_type_guards.isDefined)(response.error);
-  return hasError;
+export function isErrorResponse(response) {
+    const hasError = isObject(response) && isDefined(response.error);
+    return hasError;
 }
-function isResponse(obj) {
-  return isResultResponse(obj) || isErrorResponse(obj);
+export function isResponse(obj) {
+    return (isResultResponse(obj) || isErrorResponse(obj));
 }
-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));
+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));