@pristine-ts/networking 0.0.162 → 0.0.166

package/dist/types/models/request.d.ts

@@ -4,30 +4,42 @@ import { RequestInterface } from "@pristine-ts/common";
  * This Request object represents the class used internally that represents a Request.
  */
 export declare class Request implements RequestInterface {
+    /**
+     * The http method of the request.
+     */
     httpMethod: HttpMethod | string;
+    /**
+     * The url of the request.
+     */
     url: string;
+    /**
+     * The headers of the request.
+     */
     headers: {
         [key: string]: string;
     };
+    /**
+     * The body of the request.
+     */
     body: any;
     constructor(requestInterface: RequestInterface);
     /**
      * This method sets a header parameter in the Request.
      *
-     * @param name
-     * @param value
+     * @param name The name of the header.
+     * @param value The value of the header.
      */
     setHeader(name: string, value: string): void;
     /**
      * This method returns whether or not the header exists in the Request.
      *
-     * @param name
+     * @param name The name of the header.
      */
     hasHeader(name: string): boolean;
     /**
      * This method returns the header corresponding to the name or undefined if it doesn't exist.
      *
-     * @param name
+     * @param name The name of the header.
      */
     getHeader(name: string): string | undefined;
 }

package/dist/types/models/response.d.ts

@@ -1,9 +1,24 @@
 import { RequestInterface } from "@pristine-ts/common";
+/**
+ * This Response object represents the class used internally that represents a Response.
+ */
 export declare class Response {
+    /**
+     * The status code of the response. By default we return a 200.
+     */
     status: number;
+    /**
+     * The headers of the response.
+     */
     headers?: {
         [key: string]: string;
     };
+    /**
+     * The body of the response.
+     */
     body?: any;
+    /**
+     * The request that triggered this response.
+     */
     request?: RequestInterface;
 }

package/dist/types/models/route.d.ts

@@ -13,5 +13,9 @@ export declare class Route {
      * This contains the Route context for dynamic usage.
      */
     context?: any;
+    /**
+     * @param controllerInstantiationToken The instantiation token of the controller. Usually this will be the controller's constructor name.
+     * @param methodPropertyKey The name of the method that corresponds to the route in the controller.
+     */
     constructor(controllerInstantiationToken: any, methodPropertyKey: string);
 }

package/dist/types/nodes/method-router.node.d.ts

@@ -4,12 +4,24 @@ import { PathRouterNode } from "./path-router.node";
 import { Route } from "../models/route";
 /**
  * This class represents the Leaf node of the RouteTree.
+ * It will always have a parent node that will be a PathRouterNode.
  */
 export declare class MethodRouterNode extends RouterNode {
     readonly method: HttpMethod | string;
     readonly route: Route;
     readonly levelFromRoot: number;
+    /**
+     * @param parent The parent node of the current node.
+     * @param method The http method of the current method node.
+     * @param route The route associated with the current node.
+     * @param levelFromRoot The depth level from the root node.
+     */
     constructor(parent: PathRouterNode, method: HttpMethod | string, route: Route, levelFromRoot: number);
+    /**
+     * Returns whether or not the node matches.
+     * This verification is made by verify the http method matches with the http method of the current node.
+     * @param method The http method to compare.
+     */
     matches(method: HttpMethod | string): boolean;
     /**
      * A MethodRouterNode is never a catch-all node.
@@ -17,19 +29,20 @@ export declare class MethodRouterNode extends RouterNode {
     isCatchAll(): boolean;
     /**
      * This method adds all the required nodes to match the splitPaths and the method.
-     *
+     * Since a MethodRouterNode is a leaf node, you can't add anything after it, this method therefore doesn't do anything.
      * @param splitPaths
      * @param method
      * @param route
      */
     add(splitPaths: string[], method: HttpMethod | string, route: Route): void;
     /**
-     * This method checks to see if the method matches. If yes,
+     * This method receives an array of path and recursively calls its children if this node matches
+     * the first splitPath. If the node is a MethodRouterNode, it checks to see if the method matches. If yes,
      * it returns itself as the node found. This method should always return a MethodRouterNode. However, Typescript
      * doesn't like these recursive imports so we return the base class
      *
-     * @param splitPaths
-     * @param method
+     * @param splitPaths A list of all the parts of the paths spliced at the forward slashes.
+     * @param method The http method for which to find a node.
      */
     find(splitPaths: string[], method: HttpMethod | string): RouterNode | null;
 }

package/dist/types/nodes/path-router.node.d.ts

@@ -6,13 +6,17 @@ import { Route } from "../models/route";
  */
 export declare class PathRouterNode extends RouterNode {
     readonly path: string;
+    /**
+     * @param path The path associated with the current node.
+     * @param parent The parent node of the current node.
+     */
     constructor(path: string, parent?: PathRouterNode);
     /**
      * This method adds all the required nodes to match the splitPaths and the method.
      *
-     * @param splitPaths
-     * @param method
-     * @param route
+     * @param splitPaths A list of all the parts of the paths spliced at the forward slashes.
+     * @param method The http method for this route.
+     * @param route The route.
      */
     add(splitPaths: string[], method: HttpMethod | string, route: Route, levelFromRoot: number): void;
     /**
@@ -21,14 +25,14 @@ export declare class PathRouterNode extends RouterNode {
      * it returns itself as the node found. This method should always return a MethodRouterNode. However, Typescript
      * doesn't like these recursive imports so we return the base class
      *
-     * @param splitPaths
-     * @param method
+     * @param splitPaths A list of all the parts of the paths spliced at the forward slashes.
+     * @param method The http method for which to find a node.
      */
     find(splitPaths: string[], method: HttpMethod | string): RouterNode | null;
     /**
      * This httpMethod navigates the tree upwards and returns all the routeParameters
      *
-     * @param splitPaths
+     * @param splitPaths A list of all the parts of the paths spliced at the forward slashes.
      */
     getRouteParameters(splitPaths: string[]): {
         [key: string]: string;
@@ -38,7 +42,7 @@ export declare class PathRouterNode extends RouterNode {
      */
     isCatchAll(): boolean;
     /**
-     * This method returns whether or not this pathRouterNode represents a route parameter, e.g.: /{id} or :id
+     * This method returns whether or not this pathRouterNode represents a route parameter, e.g.: /{id} or /:id
      */
     isRouteParameter(): boolean;
     /**

package/dist/types/nodes/router.node.d.ts

@@ -20,7 +20,7 @@ export declare abstract class RouterNode {
     /**
      * This method adds all the required nodes to match the splitPaths and the method.
      *
-     * @param splitPaths
+     * @param splitPaths A list of all the parts of the paths spliced at the forward slashes.
      * @param method
      * @param route
      * @param levelFromRoot This parameter represents the number of level from the root. The root is at 0.
@@ -32,8 +32,8 @@ export declare abstract class RouterNode {
      * it returns itself as the node found. This method should always return a MethodRouterNode. However, Typescript
      * doesn't like these recursive imports so we return the base class
      *
-     * @param splitPaths
-     * @param method
+     * @param splitPaths A list of all the parts of the paths spliced at the forward slashes.
+     * @param method The http method for which to find a node.
      */
     abstract find(splitPaths: string[], method: HttpMethod | string): RouterNode | null;
     /**

package/dist/types/resolvers/body-parameter-decorator.resolver.d.ts

@@ -2,9 +2,29 @@ import "reflect-metadata";
 import { ControllerMethodParameterDecoratorResolverInterface } from "../interfaces/controller-method-parameter-decorator-resolver.interface";
 import { Request } from "../models/request";
 import { IdentityInterface } from "@pristine-ts/common";
+import { ParameterDecoratorInterface } from "../interfaces/parameter-decorator.interface";
+import { BodyParameterDecoratorInterface } from "../interfaces/body-parameter-decorator.interface";
+/**
+ * The BodyParameterDecoratorResolver resolves the value of the body of the request so that it can be injected it into the
+ * parameter of the route of the controller that was annotated with the @body decorator.
+ * It is tagged as an MethodParameterDecoratorResolver so it can be automatically injected with the all the other MethodParameterDecoratorResolvers.
+ */
 export declare class BodyParameterDecoratorResolver implements ControllerMethodParameterDecoratorResolverInterface {
-    resolve(methodArgument: any, request: Request, routeParameters: {
+    /**
+     * Resolves the value of the body of the request.
+     * The router than injects that value into the parameter of the controller method.
+     * @param methodArgument The method argument created by the decorator.
+     * @param request The request
+     * @param routeParameters The router parameters
+     * @param identity The identity making the request
+     */
+    resolve(methodArgument: BodyParameterDecoratorInterface, request: Request, routeParameters: {
         [p: string]: string;
     }, identity?: IdentityInterface): Promise<any>;
-    supports(methodArgument: any): boolean;
+    /**
+     * Returns whether or not the resolver support such a method argument.
+     * Usually we will check the methodArgument.type field to determine if it is a supported type.
+     * @param methodArgument
+     */
+    supports(methodArgument: ParameterDecoratorInterface): boolean;
 }

package/dist/types/resolvers/controller-method-parameter-decorator.resolver.d.ts

@@ -2,9 +2,23 @@ import { IdentityInterface } from "@pristine-ts/common";
 import { ControllerMethodParameterDecoratorResolverInterface } from "../interfaces/controller-method-parameter-decorator-resolver.interface";
 import { Request } from "../models/request";
 import { ParameterDecoratorInterface } from "../interfaces/parameter-decorator.interface";
+/**
+ * This service calls the resolvers to resolve the value to be injected in the parameter of a method.
+ */
 export declare class ControllerMethodParameterDecoratorResolver {
     private readonly methodParameterDecoratorResolvers;
+    /**
+     * This service calls the resolvers to resolve the value to be injected in the parameter of a method.
+     * @param methodParameterDecoratorResolvers The parameter decorator resolvers. All services with the tag ServiceDefinitionTagEnum.MethodParameterDecoratorResolver will be automatically injected here.
+     */
     constructor(methodParameterDecoratorResolvers: ControllerMethodParameterDecoratorResolverInterface[]);
+    /**
+     * This method calls the parameter decorator resolver that supports the type of the decorator and resolves the value to be injected in the parameter.
+     * @param methodArgument The method argument created by the decorator.
+     * @param request The request
+     * @param routeParameters The router parameters
+     * @param identity The identity making the request
+     */
     resolve(methodArgument: ParameterDecoratorInterface, request: Request, routeParameters: {
         [key: string]: string;
     }, identity?: IdentityInterface): Promise<any>;

package/dist/types/resolvers/headers-parameter-decorator.resolver.d.ts

@@ -2,9 +2,29 @@ import "reflect-metadata";
 import { ControllerMethodParameterDecoratorResolverInterface } from "../interfaces/controller-method-parameter-decorator-resolver.interface";
 import { Request } from "../models/request";
 import { IdentityInterface } from "@pristine-ts/common";
+import { ParameterDecoratorInterface } from "../interfaces/parameter-decorator.interface";
+import { HeadersParameterDecoratorInterface } from "../interfaces/headers-parameter-decorator.interface";
+/**
+ * The HeadersParameterDecoratorResolver resolves the value of the headers of the request so that it can be injected it into the
+ * parameter of the route of the controller that was annotated with the @headers decorator.
+ * It is tagged as an MethodParameterDecoratorResolver so it can be automatically injected with the all the other MethodParameterDecoratorResolvers.
+ */
 export declare class HeadersParameterDecoratorResolver implements ControllerMethodParameterDecoratorResolverInterface {
-    resolve(methodArgument: any, request: Request, routeParameters: {
+    /**
+     * Resolves the value of the headers of the request.
+     * The router than injects that value into the parameter of the controller method.
+     * @param methodArgument The method argument created by the decorator.
+     * @param request The request
+     * @param routeParameters The router parameters
+     * @param identity The identity making the request
+     */
+    resolve(methodArgument: HeadersParameterDecoratorInterface, request: Request, routeParameters: {
         [p: string]: string;
     }, identity?: IdentityInterface): Promise<any>;
-    supports(methodArgument: any): boolean;
+    /**
+     * Returns whether or not the resolver support such a method argument.
+     * Usually we will check the methodArgument.type field to determine if it is a supported type.
+     * @param methodArgument
+     */
+    supports(methodArgument: ParameterDecoratorInterface): boolean;
 }

package/dist/types/resolvers/identity-parameter-decorator.resolver.d.ts

@@ -2,9 +2,29 @@ import "reflect-metadata";
 import { ControllerMethodParameterDecoratorResolverInterface } from "../interfaces/controller-method-parameter-decorator-resolver.interface";
 import { Request } from "../models/request";
 import { IdentityInterface } from "@pristine-ts/common";
+import { ParameterDecoratorInterface } from "../interfaces/parameter-decorator.interface";
+import { IdentityParameterDecoratorInterface } from "../interfaces/identity-parameteter-decorator.interface";
+/**
+ * The IdentityParameterDecoratorResolver resolves the value of the identity (parsed by the authenticator) of the request
+ * so that it can be injected it into the parameter of the route of the controller that was annotated with the @identity decorator.
+ * It is tagged as an MethodParameterDecoratorResolver so it can be automatically injected with the all the other MethodParameterDecoratorResolvers.
+ */
 export declare class IdentityParameterDecoratorResolver implements ControllerMethodParameterDecoratorResolverInterface {
-    resolve(methodArgument: any, request: Request, routeParameters: {
+    /**
+     * Resolves the value of the identity of the request.
+     * The router than injects that value into the parameter of the controller method.
+     * @param methodArgument The method argument created by the decorator.
+     * @param request The request
+     * @param routeParameters The router parameters
+     * @param identity The identity making the request
+     */
+    resolve(methodArgument: IdentityParameterDecoratorInterface, request: Request, routeParameters: {
         [p: string]: string;
     }, identity?: IdentityInterface): Promise<any>;
-    supports(methodArgument: any): boolean;
+    /**
+     * Returns whether or not the resolver support such a method argument.
+     * Usually we will check the methodArgument.type field to determine if it is a supported type.
+     * @param methodArgument
+     */
+    supports(methodArgument: ParameterDecoratorInterface): boolean;
 }

package/dist/types/resolvers/query-parameter-decorator.resolver.d.ts

@@ -1,9 +1,30 @@
 import { ControllerMethodParameterDecoratorResolverInterface } from "../interfaces/controller-method-parameter-decorator-resolver.interface";
 import { Request } from "../models/request";
 import { IdentityInterface } from "@pristine-ts/common";
+import { ParameterDecoratorInterface } from "../interfaces/parameter-decorator.interface";
+import { QueryParameterDecoratorInterface } from "../interfaces/query-parameter-decorator.interface";
+/**
+ * The QueryParameterDecoratorResolver resolves the value of the query parameter with the name passed to the decorator
+ * of the request so that it can be injected it into the parameter of the route of the controller that was annotated
+ * with the @queryParameter decorator.
+ * It is tagged as an MethodParameterDecoratorResolver so it can be automatically injected with the all the other MethodParameterDecoratorResolvers.
+ */
 export declare class QueryParameterDecoratorResolver implements ControllerMethodParameterDecoratorResolverInterface {
-    resolve(methodArgument: any, request: Request, routeParameters: {
+    /**
+     * Resolves the value of the query parameter with the specified name of the request.
+     * The router than injects that value into the parameter of the controller method.
+     * @param methodArgument The method argument created by the decorator including the query parameter name.
+     * @param request The request
+     * @param routeParameters The router parameters
+     * @param identity The identity making the request
+     */
+    resolve(methodArgument: QueryParameterDecoratorInterface, request: Request, routeParameters: {
         [p: string]: string;
     }, identity?: IdentityInterface): Promise<any>;
-    supports(methodArgument: any): boolean;
+    /**
+     * Returns whether or not the resolver support such a method argument.
+     * Usually we will check the methodArgument.type field to determine if it is a supported type.
+     * @param methodArgument
+     */
+    supports(methodArgument: ParameterDecoratorInterface): boolean;
 }

package/dist/types/resolvers/query-parameters-decorator.resolver.d.ts

@@ -1,9 +1,29 @@
 import { ControllerMethodParameterDecoratorResolverInterface } from "../interfaces/controller-method-parameter-decorator-resolver.interface";
 import { Request } from "../models/request";
 import { IdentityInterface } from "@pristine-ts/common";
+import { ParameterDecoratorInterface } from "../interfaces/parameter-decorator.interface";
+import { QueryParametersDecoratorInterface } from "../interfaces/query-parameters-decorator.interface";
+/**
+ * The QueryParametersDecoratorResolver resolves the value (a  map) of the query parameters of the request so that it can be injected it into the
+ * parameter of the route of the controller that was annotated with the @queryParameters decorator.
+ * It is tagged as an MethodParameterDecoratorResolver so it can be automatically injected with the all the other MethodParameterDecoratorResolvers.
+ */
 export declare class QueryParametersDecoratorResolver implements ControllerMethodParameterDecoratorResolverInterface {
-    resolve(methodArgument: any, request: Request, routeParameters: {
+    /**
+     * Resolves the value of all the query parameters of the request.
+     * The router than injects that value into the parameter of the controller method.
+     * @param methodArgument The method argument created by the decorator.
+     * @param request The request
+     * @param routeParameters The router parameters
+     * @param identity The identity making the request
+     */
+    resolve(methodArgument: QueryParametersDecoratorInterface, request: Request, routeParameters: {
         [p: string]: string;
     }, identity?: IdentityInterface): Promise<any>;
-    supports(methodArgument: any): boolean;
+    /**
+     * Returns whether or not the resolver support such a method argument.
+     * Usually we will check the methodArgument.type field to determine if it is a supported type.
+     * @param methodArgument
+     */
+    supports(methodArgument: ParameterDecoratorInterface): boolean;
 }

package/dist/types/resolvers/request-parameter-decorator.resolver.d.ts

@@ -2,9 +2,29 @@ import "reflect-metadata";
 import { ControllerMethodParameterDecoratorResolverInterface } from "../interfaces/controller-method-parameter-decorator-resolver.interface";
 import { Request } from "../models/request";
 import { IdentityInterface } from "@pristine-ts/common";
+import { RequestParameterDecoratorInterface } from "../interfaces/request-parameter-decorator.interface";
+import { ParameterDecoratorInterface } from "../interfaces/parameter-decorator.interface";
+/**
+ * The RequestParameterDecoratorResolver resolves the value of the whole request so that it can be injected it into the
+ * parameter of the route of the controller that was annotated with the @request decorator.
+ * It is tagged as an MethodParameterDecoratorResolver so it can be automatically injected with the all the other MethodParameterDecoratorResolvers.
+ */
 export declare class RequestParameterDecoratorResolver implements ControllerMethodParameterDecoratorResolverInterface {
-    resolve(methodArgument: any, request: Request, routeParameters: {
+    /**
+     * Resolves the value of the whole request.
+     * The router than injects that value into the parameter of the controller method.
+     * @param methodArgument The method argument created by the decorator.
+     * @param request The request
+     * @param routeParameters The router parameters
+     * @param identity The identity making the request
+     */
+    resolve(methodArgument: RequestParameterDecoratorInterface, request: Request, routeParameters: {
         [p: string]: string;
     }, identity?: IdentityInterface): Promise<any>;
-    supports(methodArgument: any): boolean;
+    /**
+     * Returns whether or not the resolver support such a method argument.
+     * Usually we will check the methodArgument.type field to determine if it is a supported type.
+     * @param methodArgument
+     */
+    supports(methodArgument: ParameterDecoratorInterface): boolean;
 }

package/dist/types/resolvers/route-parameter-decorator.resolver.d.ts

@@ -1,9 +1,29 @@
 import { ControllerMethodParameterDecoratorResolverInterface } from "../interfaces/controller-method-parameter-decorator-resolver.interface";
 import { Request } from "../models/request";
 import { IdentityInterface } from "@pristine-ts/common";
+import { RouteParameterDecoratorInterface } from "../interfaces/route-parameter-decorator.interface";
+import { ParameterDecoratorInterface } from "../interfaces/parameter-decorator.interface";
+/**
+ * The RouteParameterDecoratorResolver resolves the value of the route parameter specified of the request so that it can be injected it into the
+ * parameter of the route of the controller that was annotated with the @routeParameter decorator.
+ * It is tagged as an MethodParameterDecoratorResolver so it can be automatically injected with the all the other MethodParameterDecoratorResolvers.
+ */
 export declare class RouteParameterDecoratorResolver implements ControllerMethodParameterDecoratorResolverInterface {
-    resolve(methodArgument: any, request: Request, routeParameters: {
+    /**
+     * Resolves the value of the the route parameter with the specified name of the request.
+     * The router than injects that value into the parameter of the controller method.
+     * @param methodArgument The method argument created by the decorator, including the name of the parameter to resolve.
+     * @param request The request
+     * @param routeParameters The router parameters
+     * @param identity The identity making the request
+     */
+    resolve(methodArgument: RouteParameterDecoratorInterface, request: Request, routeParameters: {
         [p: string]: string;
     }, identity?: IdentityInterface): Promise<any>;
-    supports(methodArgument: any): boolean;
+    /**
+     * Returns whether or not the resolver support such a method argument.
+     * Usually we will check the methodArgument.type field to determine if it is a supported type.
+     * @param methodArgument
+     */
+    supports(methodArgument: ParameterDecoratorInterface): boolean;
 }

package/dist/types/router.d.ts

@@ -7,15 +7,25 @@ import { ControllerMethodParameterDecoratorResolver } from "./resolvers/controll
 import { HttpMethod } from "@pristine-ts/common";
 import { AuthenticationManagerInterface, AuthorizerManagerInterface } from "@pristine-ts/security";
 import { LogHandlerInterface } from "@pristine-ts/logging";
-import { TracingManagerInterface } from "@pristine-ts/telemetry";
+/**
+ * The router service is the service that creates the routing tree from the controllers.
+ * It also executes a request properly by routing it to the intended controller and returns the response.
+ */
 export declare class Router implements RouterInterface {
     private readonly loghandler;
     private readonly controllerMethodParameterDecoratorResolver;
     private readonly authorizerManager;
     private readonly authenticationManager;
-    private readonly tracingManager;
     private root;
-    constructor(loghandler: LogHandlerInterface, controllerMethodParameterDecoratorResolver: ControllerMethodParameterDecoratorResolver, authorizerManager: AuthorizerManagerInterface, authenticationManager: AuthenticationManagerInterface, tracingManager: TracingManagerInterface);
+    /**
+     * The router service is the service that creates the routing tree from the controllers.
+     * It also executes a request properly by routing it to the intended controller and returns the response.
+     * @param loghandler The log handler
+     * @param controllerMethodParameterDecoratorResolver The controller method parameter decorator resolver used to resolve the values.
+     * @param authorizerManager The authorizer manager to validate authorization.
+     * @param authenticationManager The authentication manager to validate authentication.
+     */
+    constructor(loghandler: LogHandlerInterface, controllerMethodParameterDecoratorResolver: ControllerMethodParameterDecoratorResolver, authorizerManager: AuthorizerManagerInterface, authenticationManager: AuthenticationManagerInterface);
     /**
      * This method registers a Route into the Route Tree maintained by the router.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pristine-ts/networking",
-  "version": "0.0.162",
+  "version": "0.0.166",
   "description": "",
   "module": "dist/lib/esm/networking.module.js",
   "main": "dist/lib/cjs/networking.module.js",
@@ -19,9 +19,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@pristine-ts/common": "^0.0.162",
-    "@pristine-ts/security": "^0.0.162",
-    "@pristine-ts/telemetry": "^0.0.162",
+    "@pristine-ts/common": "^0.0.166",
+    "@pristine-ts/security": "^0.0.166",
+    "@pristine-ts/telemetry": "^0.0.166",
     "url-parse": "^1.4.7"
   },
   "jest": {
@@ -58,5 +58,5 @@
       "src/*.{js,ts}"
     ]
   },
-  "gitHead": "3e5edd96d10fe71784bccf975ee9c0170bce566c"
+  "gitHead": "c452544a69d17814c83d6a99a4fd788fdaa0daff"
 }

package/dist/lib/cjs/enums/enums.js

@@ -1 +0,0 @@
-//# sourceMappingURL=enums.js.map

package/dist/lib/cjs/enums/enums.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"enums.js","sourceRoot":"","sources":["../../../../src/enums/enums.ts"],"names":[],"mappings":""}

package/dist/lib/cjs/models/error-response-body.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorResponseBody = void 0;
-class ErrorResponseBody {
-}
-exports.ErrorResponseBody = ErrorResponseBody;
-//# sourceMappingURL=error-response-body.js.map

package/dist/lib/cjs/models/error-response-body.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-response-body.js","sourceRoot":"","sources":["../../../../src/models/error-response-body.ts"],"names":[],"mappings":";;;AAAA,MAAa,iBAAiB;CAG7B;AAHD,8CAGC"}

package/dist/lib/esm/enums/enums.js

@@ -1 +0,0 @@
-//# sourceMappingURL=enums.js.map

package/dist/lib/esm/enums/enums.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"enums.js","sourceRoot":"","sources":["../../../../src/enums/enums.ts"],"names":[],"mappings":""}

package/dist/lib/esm/models/error-response-body.js

@@ -1,3 +0,0 @@
-export class ErrorResponseBody {
-}
-//# sourceMappingURL=error-response-body.js.map

package/dist/lib/esm/models/error-response-body.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-response-body.js","sourceRoot":"","sources":["../../../../src/models/error-response-body.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,iBAAiB;CAG7B"}

package/dist/types/models/error-response-body.d.ts

@@ -1,4 +0,0 @@
-export declare class ErrorResponseBody {
-    message: string;
-    errors?: any[];
-}