@thisisagile/easy-domain 15.29.3

package/README.md

@@ -0,0 +1,282 @@
+ # easy
+ The easiest framework to build robust and stable microservices in TypeScript on node.js.
+
+<a href="https://www.npmjs.com/package/@thisisagile/easy" target="_blank"><img src="https://img.shields.io/npm/v/@thisisagile/easy.svg" alt="npm version" /></a>
+<a href="https://www.npmjs.com/package/@thisisagile/easy" target="_blank"><img src="https://img.shields.io/npm/dm/@thisisagile/easy.svg" alt="npm downloads" /></a>
+<a href="https://github.com/thisisagile/easy/actions?query=workflow%3A%22pipeline%22"><img src="https://github.com/thisisagile/easy/workflows/pipeline/badge.svg?branch=main" alt="pipeline status" /></a>
+<a href="https://sonarcloud.io/dashboard?id=thisisagile_easy" target="_blank"><img src="https://sonarcloud.io/api/project_badges/measure?project=thisisagile_easy&metric=alert_status" alt="quality gate" /></a>
+<a href="https://github.com/semantic-release/semantic-release" target="_blank"><img src="https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg" alt="semantic-release" /></a>
+<a href="https://sonarcloud.io/dashboard?id=thisisagile_easy" target="_blank"><img src="https://sonarcloud.io/api/project_badges/measure?project=thisisagile_easy&metric=coverage" alt="coverage" /></a>
+
+## Note
+The **easy** framework captures the best practices we (the contributors) have built up while implementing microservices architectures at a diverse range of clients in Typescript, running on node.js and deployed on Amazon, Google Cloud and even on Windows Server. The companies that contribute / have contributed include a well-known Dutch insurance company, an insurance software vendor, an IoT scale-up, a software vendor in logistics and an online e-commerce company. From those practices, the **easy** framework grows step-by-step. 
+
+The **easy** framework already works fine in many situations. However, it also continuously improves and grows. It is a work-in-progress, including its documentation. Being a framework, it probably not always perfectly fits your situation. Therefore, we aim to implement **easy** so that it is straightforward, simple to use, standardized, and open to extensions. 
+
+## Welcome!
+The **easy** framework is a straightforward, smart library for building domain-driven microservice architectures, implementing a simple evolutionary architecture. This library is distilled from projects where the teams I've worked with built platforms based on a simple, common architecture where each service centers around a small part of the platform domain.
+
+This framework will include best and foremost simple practices to support building microservices, based on the following software architecture and patterns:
+
+## Architecture
+Microservices built with **easy** have a four layered architecture: *services*, *process*, *domain*, *data*. Each of the layers serves a single purpose and follows clear patterns and communications:
+
+- *Services*. This layer contains resource classes, which handle requests to the microservice's endpoints.
+- *Process*. This second layer contains use cases, which handle all process logic of the microservice.
+- *Domain*. At the heart of each microservice lies its domain, which consists of entities, values objects, enumerations and structs. To approach the objects in the domain, this layer also contains repositories. 
+- *Data*. The bottom layer of each microservice contains gateways, that allow the microservice to interact with its outside world, such as relational databases, no-sql databases, file storage or other services.
+
+The **easy** framework supports this architecture by supplying root classes (or layer supertypes) for each of the types describe above. The repository `easy-test` contains utilities to assist you with testing **easy** specific constructs, such as `toMatchText` or `toMatchPath` for checking paths in uri's. The repository `easy-sample` contains examples of microservices built with the **easy** framework.
+
+## Root
+At the root of each microservice built using **easy**, there is a class that inherits from `Service`. These are used to initiate the service, set the `port` at which it runs,  register all resource classes, and start the service. An example services class is the one below for a movie service.
+
+    SampleService.Movie
+      .with(MoviesResource, MovieResource)
+      .atPort(9001)
+      .start();
+
+This movie service registers two resources, `MoviesResource` and `MovieResource`, each of which handle endpoints. The service listens at port `9001`.
+
+In general, you will not build a single microservice, but rather a collection of microservices, each responsible for a distinct part of the complete business domain. In that case, it can be useful to build a root class for your services, such as the `SampleService` class below. 
+
+    class SampleService extends Service {
+      static readonly Movie = new SampleService('movie');
+      pre = () => [correlation];
+      post = () => [error, notFound];
+    }
+
+The `SampleService` inherits directly from the `Service` layer supertype from **easy**. The methods `pre()` and `post()` can be used to register middleware (by default **easy** uses express as its web server). However, this can easily be changed if you require so. The middlewares `correlation`, `error` and `notFound` are also provided by **easy**.  
+
+## Services
+The services layer has resource as the layer supertype, to model the API exposed.
+
+## Process
+The process layer contains use cases, that model your process.
+
+## Domain
+In the domain layer there are supertypes to model the domain, such as entities, records, value objects and enumerations.
+The domain layer also knows the repository layer supertype, for handling instances of entities and structs.
+
+### Entities
+Using **easy**, your entities, as described in domain driven design, inherit from the `Entity` class. This gives your entities identity. The default implementation of `Entity` provides a generated `id` property (it's a UUID by default). 
+
+All classes that inherit from `Record` or `Entity` will have an internal object called `state`. Normally, the state of an object is passed to it during construction. Using this internal object `state` allows for easy mapping of the content of an entity, which is usually JSON, to its properties. We prefer to keep our entities immutable. Properties therefore can be readonly. An update to an object is considered a state change and should therefore always return a new instance of the entity, instead of modifying the state of the current instance.
+
+An example of an entity is the `Movie` class below. Here the content of the object comes from an external service (called OMDb), and is mapped to the actual properties of the `Movie` class.
+
+    export class Movie extends Entity {
+        @required() readonly id = this.state.imdbID as Id;
+        @required() readonly title = this.state.Title as string;
+        @required() readonly year = this.state.Year as number;
+        readonly poster = this.state.Poster as string;
+        
+        update = (add?: Json): Movie => new Movie(this.toJSON(add));
+    }
+
+Some properties of `Movie` have decorators, such as `@required`. These decorators can be used to validate the object, using the separate `validate()` function. 
+
+### Enumerables
+Most modern programming languages support the use of enumerables. The goal of enumerables is to allow only a limited set of values to be chosen for a particular property or passed as a parameter of a function, or its return type. Although this seems trivial, there are some drawbacks to using enumerables. 
+
+First, in most languages, you can not inherit from enumerables. As a result, if you define an enumerable in a library, and would like to add values to it in another repository, this is not possible. If you would, as we do in **easy** support a list of scopes, we could have created an enumerable `Scope`, with the scopes we see. However, if you use **easy** and would like to add your own scopes, this is not possible with a default enumerable.
+
+Secondly, in most languages (Java not included), enumerations only have two properties, the name and the index of its items. If you want to have some more properties on you enumerations, or add some behavior, an enumerable is not your best bet.
+
+Thirdly, and perhaps the most dangerous one, if you persist your enumerables to a storage facility (a database for instance), enumerations are usually stored using their index. This makes the data hard to interpret. After all, what does scope `2` really mean? But even worse, if you would add more items to your enumerable later on, the index of the items might alter, and hence the stored data gets a different meaning, often without noticing.
+
+Therefore, **easy** provides an `Enum` class, which is both extendable and allows you to define meaningful identifiers for your items, and also add additional properties. And still, the behaviour of enumerables created using the `Enum` class, is comparable to traditional enumerables. Here's the `UseCase` enumerable from **easy** as an example.
+
+    export class UseCase extends Enum {
+      constructor(readonly scope: Scope, name: string, id: string = text(name).kebab) {
+        super(name, id);
+      }
+
+      static readonly Main = new UseCase(Scope.Basic, "Main");
+      static readonly Login = new UseCase(Scope.Auth, "Login");
+      static readonly Logout = new UseCase(Scope.Auth, "Logout");
+      static readonly ForgotPassword = new UseCase(Scope.Auth, "Forgot password");
+      static readonly ChangePassword = new UseCase(Scope.Auth, "Change password");
+    }
+
+The class `UseCase` has five items, such as `UseCase.Main` or `UseCase.ChangePassword`. The constructor has an additional property `scope`, which the `Enum` class does not have, but it calls on the constructor of its superclass to actual make it work. All instances of `Enum` have a property `id`, which is used to store the enums, when used as property on entities, or for comparison.
+
+### Value objects
+When we are not so much interested in the identity of objects, as with entities, but are merely interested in the values of the object, we use value objects. A nice useful definition of value objects is presented by Eric Evens in his seminal book *Domain Driven Design*.
+
+> An object that represents a descriptive aspect of the domain with no conceptual identity is called a Value Object. Value Objects are instantiated to represent elements of the design that we care about only for what they are, not who or which they are.
+
+The nice thing about value objects is that you can define them once, and then use everywhere, usually as the types of properties of entities, or even of other value objects. Straightforward examples of value objects are `Email`, and `Address`. The nice thing about value objects is that checking its validity is done at the value object itself, so reusing them does not result in validations being re-implemented everywhere. 
+
+In **easy** we have defined two base classes to implement your value objects. For single valued objects, such as `Email`, we use the base class `Value`. For value objects that have multiple properties, such as `Address` or `Money`, we tend to inherit from the base class `Struct`. Classes that derive from `Value` or `Struct` can be easily validated using the `validate()` function.
+
+### Value
+Values are single property objects that are immutable and give meaning to that single property. If you take a string `john.doe@example.com`. This string is a valid string and any validation on whether this string is an email or not needs to be done externally. 
+
+However, if you would create an `Email` value object, the validation can be implemented internally, and the `Email` class can then be reused everywhere emails are needed.
+    
+    class Email extends Value<string> {
+        get isValid(): boolean {
+            return validator.isEmail(this.value);
+        }
+    }
+
+You can now use the above `Email` class as the type of email properties in an entity or struct to make sure that this property is a valid email.
+
+#### DateTime
+DateTime is a value object that takes either a Date object, RFC-3339 formatted string, or a number representing Epoch in milliseconds. The json is always an RFC-3339 formatted string. [luxon](https://moment.github.io/luxon/#/) is used internally.
+
+A few examples of DateTime:
+
+    new DateTime().toJSON() // returns the date formatted as 2021-03-25T08:39:44.000Z
+    new DateTime(new Date()).toJSON() // same as above
+    DateTime.now.toJSON() // same as above
+    new DateTime(1617288152000).toJSON() // returns 2021-04-01T14:42:32.000Z
+
+## Validation
+All **easy** microservices evolve around their part of the total business domain you are implementing. Quite usually, in its domain layer, a microservice contains an *aggregate*. In domain-driven design an aggregate maps to a part of the domain that is persisted together. In a relational database, this is usually guarded with a transaction. In a document database, such as MongoDB, this is more often a single serialized `Json` object.
+
+To assure that such an aggregate is valid, when persisted, it is validated, usually starting from the *aggregate root*. In most cases, the aggregate root is the entity that is also the resource that requests are about, and in most often it is also the name of the microservice itself.
+
+### Validate
+The **easy** framework supplies a nice and easy mechanism for validating instances of the microservice's aggregate. We supply to easy-to-use functions, named `validate(subject?: unknown): Results` and `validateReject = <T>(subject?: T): Promise<T>`. Although you can pass any object to these functions, in general, you will pass the aggregate root as an argument.
+
+    validate = (dev: Developer): Results => validate(dev);
+
+The `validate()` function will validate its `subject`, and recursively the subjects properties. The outcome of this validation is always a `Results` object, with a list of shortcomings (in its `results` property) of the subject. The `Results` object also has a property `isValid`, which is set to `true` if the subject is valid, or to `false` when it is not.
+
+The `validate()` validates the following:
+
+- First it will check if the object you are validating is actually defined. If not, validation fails.
+- On value objects (objects that inherit from the `Value` class), it will check the `isValid` property. Therefore, `isValid` is a suitable location for implementing your value objects validity.
+- On enumerations (objects inheriting from the `Enum` class), it will also check the `isValid` property. However, usually, if enumerations are creating through their `byId()` function, if they are not valid, then `byId()` will have returned `undefined`.
+
+### Constraints
+The easiest way to validate objects is to use constraints. By adding constraints, as decorators, to the properties and functions on the object you would like to validate, these properties and functions will be checked when the object is validated through calling `validate(myObject)`. **easy** comes with a variety of ready-to-use constraints, but it is also easy (no pun intended) to add your own.
+
+Below is a typical example of an entity, which derives from the `Entity` class in **easy**. It has a number of properties, which are pre-filled with values from the internal state (in `state`) of the entity. As you can see, several of these properties have constraint decorators, such as `@required()`, `@valid()` and `@lt()`. As you can see, properties may have multiple constraints. 
+
+    export class Product extends Entity {
+        @required() readonly name: string = this.state.name;
+        @required() readonly erpId: Id = this.state.erpId;
+        readonly suppliers: List<Id> = toList(this.state.suppliers);
+        @valid() readonly ean: Ean = new Ean(this.state.ean);
+        @valid() readonly type: ProductType = ProductType.byId(this.state.type);
+        readonly brand: string = this.state.brand;
+        @gt(0) @lt(100) readonly weight: number = this.state.weight;
+        @gt(0, 'Current value {this.height} for height is insufficient.') readonly height: number = this.state.height;
+        @gt(0) readonly width: number = this.state.width;
+        
+        update = (add: Json): Product => new Product(this.merge(add));
+    }
+
+When an instance of the `Product` class is validated, through `validate(myProduct)`, all constraint decorators will be checked.
+If one or more constraints fail, the object is considered as invalid. The outcome of `validate()` will contain a `Results` object that has a list of `Result` objects (consisting of `message`, `location` and `domain`). Each failed constrained will have added a `Result` to the list.
+
+Each constraint in **easy** comes with a pre-defined and templated message. However, if needed, you can specify your own messages by adding them to the decorators you use. In the example above, we have added a custom message to the `height` property.
+
+### Custom constraints
+It is quite easy to create your own custom constraints. Below is an example of a custom constraint `is42`.
+
+    const is42 = (message?: Text): PropertyDecorator => constraint(v => v === 42, message ?? "Property {property} should have value '42' instead of '{actual}'.");
+
+This custom constraint makes use of the `constraint()` function in **easy**. The first parameter for your constraint is a function that returns true or false. When you use your new constraint, as a decorator on a property, the `validate()` function will pick it up automatically. If your constraint fails, the message will be added to the results. 
+
+After creating your custom constraint, you can add them to your classes, like in the example below. 
+
+    class Person extends Struct {
+        @valid() readonly age: Age = new Age(this.state.age);
+        @is42('Value for real age must be 42, not {actual}.') readonly realAge: number = this.state.age;
+    }
+
+P.S. If you create custom constraints that might be helpful for other developers, don't hesitate to do a pull request on **easy**.
+
+## Data
+Microservices can use data from a variety of sources, transform and process that data, and expose that to their users through their own API. In the different microservices architecture implementations we've seen data for instance come from:
+
+- a variety of relational databases, such as SQL Server, MySQL, or PostgreSQL.
+- a variety of non-relational databases, quite often MongoDB.
+- file systems.
+- systems the organization owns. such as HR, marketing, ERP or CMS.
+- other microservices, internal to the own organization.
+- other microservices, implemented with **easy** too.
+- other services, external to the own organization.
+- systems running in the cloud, such as SalesForce, Office365.
+- identity access platforms, often in the cloud.
+- last but not least, data could even be fixed in the service itself, as a JSON array for instance.
+
+### Gateways
+The data layer in an **easy** microservice provide the service with gateways to all these possible sources. It is the responsibility of the classes in the data layer to fetch and deliver data from outside to the microservices. Depending on the type of the source, **easy** provides a number of gateways, which all implement the `Gateway` interface:
+
+- `InMemoryGateway` (formerly `CollectionGateway`). Used to provide data which is statically stored inside the services, e.g. in a JSON array.
+- `RouteGateway`. This allows services to talk to other API's, using a predefined URI. This gateway is often used for talking to other **easy** services, which provide a similar experience and API.
+- `MappedRouteGateway`. It allows services to talk to other API's, similar to the `RouteGateway`, but with the ability to map the incoming data (in JSON format) to an internally preferred format. This mapping is based on an instance of the `Map` class.
+- `TableGateway`. This allows to get data (in JSON format) from a relational database. It uses a `QueryProvider` to connect to a specific relational database. We're currently adding providers for SQL Server, MySQL, and PostgreSQL. It uses a `Table` to map the incoming data to the format internal to the service.
+- `CollectionGateway` (formerly `MongoGateway`). It allows to get data (in JSON format) from a document database, for now MongoDB. It uses the `MongoProvider` to connect to the database. It uses a `Collection` to map the incoming data to the format internal to the service.
+ 
+### The `Map`, `Table`, and `Collection` mappings 
+Because data in existing databases rarely supplies the format you need in your service, you can define a `Map` (for other services), a `Table` (for relational databases), or a `Collection` (for MongoDB) to contain all mappings that transform the incoming data to the service internal format, as below.
+
+    export class ErpProductView extends Table {
+        readonly db = MyDatabase.Erp;
+        readonly id = this.prop('id', { convert: toId.fromLegacyId });
+        readonly brandId = this.prop('brandId', { convert: toId.fromLegacyId });
+
+        toString(): string {
+            return 'mover_product_view';
+        }
+    }
+
+The `Map` and `Table` classes have a property called `db` that represents the database to connect to. This is usually an instance of the `Database` enumeration, which in its turn defines the database (and its provider) to connect to, as in the example below.
+
+    export class MyDatabase extends Database {
+        static readonly Erp = new Database('openerp', PostgreSqlProvider);
+        static readonly Cms = new Database('cms', MySqlProvider);
+    }
+
+Next, the `Map`, `Table` and `Collection` classes, describe a list of properties that you would want mapped in the incoming JSON. Properties in the incoming JSON that are not described here are copied automatically. Properties can use converters, e.g. to converter from number to string and vice versa. Converters are bi-directional, as data that needs to go from the service to storage is mapped back to the database specific format too. 
+
+## Handling exceptions in services
+During the execution of a request, lots of things can go wrong. Here as some common failures that occur when you try to reach an endpoint, and how **easy** normally responds, and where and how such failures are handled in a typical **easy** microservices:
+
+* For starters, you might not reach the endpoint, because you've typed in the wrong URL. If this happens, and you still reach your microservice, **easy** handles this in the `NotFoundHandler`, which is plugged-in by default.
+* If you are not allowed to execute an endpoint, for instance because it is secured with one of the security decorators in **easy**, such as `@requires.useCase()`, `@requires.Scope()` or `@requires.token`, the endpoint will not execute, and you will receive a 403. In this case the middleware from the `SecurityHandler` already breaks the loop, and the code in you microservices is not executed at all.
+* All other failures are handled by the `ErrorHandler`, and can result in any custom HTTP status code, most likely a 400, or a 500. In case the caller makes a mistake, the code should come from the 400 range, in cases the microservice makes the mistake, the code comes from the 500 range.
+
+## Utilities
+Additionally, this library contains utility classes for standardizing e.g. uri's, and ids, constructors, lists, queries, and errors. Quite often these are constructed as monads, which renders robust code.
+
+### When
+The `When` class is a utility that is usually exposed through the `when()` function. It is one of many monads we use in **easy** to make code more robust, and easier to read. It can be used to make validations in promises a little easier such as the following example.
+
+    update = (json: Json): Promise<T> =>
+    this.gateway
+    .byId(json.id as Id)
+    .then(j => when(j).not.isDefined.reject(Exception.DoesNotExist))
+    .then(j => new this.ctor(j).update(json))
+    .then(i => when(i).not.isValid.reject())
+    .then(i => this.gateway.update(toJson(i)))
+    .then(j => new this.ctor(j));
+
+The `reject()` method is used to reject the chain, so it will not execute any of its following statements. The `reject()` method accept any error type. A special case is made for `when().not.isValid`. This statement validates the subject of the `when`, and reject with the results (an instance of `Results`) if no parameter is passed to `reject()`.
+
+## Authentication and Authorization
+Access to endpoints is configured using the `@requires` decorator group. If multiple decorators are added, all conditions must be met to access the endpoint. A resource class (which is the main entry to an **easy** service) with security decorators is shown in the following example.
+
+    @route(ProductUri.Products)
+    export class ProductsResource {
+      constructor(readonly manage = new ManageProduct()) {}
+
+      @get()
+      @requires.useCase(UseCase.ViewProduct)
+      search = (req: Req): Promise<List<Product>> => this.manage.search(req.q);
+
+      @post()
+      @requires.useCase(UseCase.ManageProduct)
+      add = (req: Req): Promise<Product> => this.manage.add(req.body as Json);
+    }
+
+The `@requires` decorator group also contains `@requires.labCoat()` this decorator can be added to endpoints you only want to be available on your development environment, for example a `delete`.
+
+To use these decorators, the generic `security` middleware must be loaded first. In most cases, it should be added to the `pre` list of handlers of a service.
+The security middleware takes an optional configuration object, which is documented [in code](packages/easy-express/src/express/SecurityHandler.ts).

package/dist/chunk-3N5M6QHW.mjs

@@ -0,0 +1,132 @@
+// src/enums/Currency.ts
+import { Enum } from "@thisisagile/easy";
+var Currency = class _Currency extends Enum {
+  constructor(id, name, digits, code) {
+    super(name, id, code);
+    this.digits = digits;
+  }
+  static EUR = new _Currency("EUR", "Euro", 2, "\u20AC");
+  static USD = new _Currency("USD", "US Dollar", 2, "$");
+  static AED = new _Currency("AED", "United Arab Emirates Dirham", 2, "AED");
+  static AFN = new _Currency("AFN", "Afghan Afghani", 0, "Af");
+  static ALL = new _Currency("ALL", "Albanian Lek", 0, "ALL");
+  static AMD = new _Currency("AMD", "Armenian Dram", 0, "AMD");
+  static ARS = new _Currency("ARS", "Argentine Peso", 2, "AR$");
+  static AUD = new _Currency("AUD", "Australian Dollar", 2, "AU$");
+  static AZN = new _Currency("AZN", "Azerbaijani Manat", 2, "man.");
+  static BAM = new _Currency("BAM", "Bosnia-Herzegovina Convertible Mark", 2, "KM");
+  static BDT = new _Currency("BDT", "Bangladeshi Taka", 2, "Tk");
+  static BGN = new _Currency("BGN", "Bulgarian Lev", 2, "BGN");
+  static BHD = new _Currency("BHD", "Bahraini Dinar", 3, "BD");
+  static BIF = new _Currency("BIF", "Burundian Franc", 0, "FBu");
+  static BND = new _Currency("BND", "Brunei Dollar", 2, "BN$");
+  static BOB = new _Currency("BOB", "Bolivian Boliviano", 2, "Bs");
+  static BRL = new _Currency("BRL", "Brazilian Real", 2, "R$");
+  static BWP = new _Currency("BWP", "Botswanan Pula", 2, "BWP");
+  static BYN = new _Currency("BYN", "Belarusian Ruble", 2, "Br");
+  static BZD = new _Currency("BZD", "Belize Dollar", 2, "BZ$");
+  static CAD = new _Currency("CAD", "Canadian Dollar", 2, "CA$");
+  static CDF = new _Currency("CDF", "Congolese Franc", 2, "CDF");
+  static CHF = new _Currency("CHF", "Swiss Franc", 2, "CHF");
+  static CLP = new _Currency("CLP", "Chilean Peso", 0, "CL$");
+  static CNY = new _Currency("CNY", "Chinese Yuan", 2, "CN\xA5");
+  static COP = new _Currency("COP", "Colombian Peso", 0, "CO$");
+  static CRC = new _Currency("CRC", "Costa Rican Col\xF3n", 0, "\u20A1");
+  static CVE = new _Currency("CVE", "Cape Verdean Escudo", 2, "CV$");
+  static CZK = new _Currency("CZK", "Czech Republic Koruna", 2, "K\u010D");
+  static DJF = new _Currency("DJF", "Djiboutian Franc", 0, "Fdj");
+  static DKK = new _Currency("DKK", "Danish Krone", 2, "Dkr");
+  static DOP = new _Currency("DOP", "Dominican Peso", 2, "RD$");
+  static DZD = new _Currency("DZD", "Algerian Dinar", 2, "DA");
+  static EEK = new _Currency("EEK", "Estonian Kroon", 2, "Ekr");
+  static EGP = new _Currency("EGP", "Egyptian Pound", 2, "EGP");
+  static ERN = new _Currency("ERN", "Eritrean Nakfa", 2, "Nfk");
+  static ETB = new _Currency("ETB", "Ethiopian Birr", 2, "Br");
+  static GBP = new _Currency("GBP", "British Pound Sterling", 2, "\xA3");
+  static GEL = new _Currency("GEL", "Georgian Lari", 2, "GEL");
+  static GHS = new _Currency("GHS", "Ghanaian Cedi", 2, "GH\u20B5");
+  static GNF = new _Currency("GNF", "Guinean Franc", 0, "FG");
+  static GTQ = new _Currency("GTQ", "Guatemalan Quetzal", 2, "GTQ");
+  static HKD = new _Currency("HKD", "Hong Kong Dollar", 2, "HK$");
+  static HNL = new _Currency("HNL", "Honduran Lempira", 2, "HNL");
+  static HRK = new _Currency("HRK", "Croatian Kuna", 2, "kn");
+  static HUF = new _Currency("HUF", "Hungarian Forint", 0, "Ft");
+  static IDR = new _Currency("IDR", "Indonesian Rupiah", 0, "Rp");
+  static ILS = new _Currency("ILS", "Israeli New Sheqel", 2, "\u20AA");
+  static INR = new _Currency("INR", "Indian Rupee", 2, "Rs");
+  static IQD = new _Currency("IQD", "Iraqi Dinar", 0, "IQD");
+  static IRR = new _Currency("IRR", "Iranian Rial", 0, "IRR");
+  static ISK = new _Currency("ISK", "Icelandic Kr\xF3na", 0, "Ikr");
+  static JMD = new _Currency("JMD", "Jamaican Dollar", 2, "J$");
+  static JOD = new _Currency("JOD", "Jordanian Dinar", 3, "JD");
+  static JPY = new _Currency("JPY", "Japanese Yen", 0, "\xA5");
+  static KES = new _Currency("KES", "Kenyan Shilling", 2, "Ksh");
+  static KHR = new _Currency("KHR", "Cambodian Riel", 2, "KHR");
+  static KMF = new _Currency("KMF", "Comorian Franc", 0, "CF");
+  static KRW = new _Currency("KRW", "South Korean Won", 0, "\u20A9");
+  static KWD = new _Currency("KWD", "Kuwaiti Dinar", 3, "KD");
+  static KZT = new _Currency("KZT", "Kazakhstani Tenge", 2, "KZT");
+  static LBP = new _Currency("LBP", "Lebanese Pound", 0, "L.L.");
+  static LKR = new _Currency("LKR", "Sri Lankan Rupee", 2, "SLRs");
+  static LTL = new _Currency("LTL", "Lithuanian Litas", 2, "Lt");
+  static LVL = new _Currency("LVL", "Latvian Lats", 2, "Ls");
+  static LYD = new _Currency("LYD", "Libyan Dinar", 3, "LD");
+  static MAD = new _Currency("MAD", "Moroccan Dirham", 2, "MAD");
+  static MDL = new _Currency("MDL", "Moldovan Leu", 2, "MDL");
+  static MGA = new _Currency("MGA", "Malagasy Ariary", 0, "MGA");
+  static MKD = new _Currency("MKD", "Macedonian Denar", 2, "MKD");
+  static MMK = new _Currency("MMK", "Myanma Kyat", 0, "MMK");
+  static MOP = new _Currency("MOP", "Macanese Pataca", 2, "MOP$");
+  static MUR = new _Currency("MUR", "Mauritian Rupee", 0, "MURs");
+  static MXN = new _Currency("MXN", "Mexican Peso", 2, "MX$");
+  static MYR = new _Currency("MYR", "Malaysian Ringgit", 2, "RM");
+  static MZN = new _Currency("MZN", "Mozambican Metical", 2, "MTn");
+  static NAD = new _Currency("NAD", "Namibian Dollar", 2, "N$");
+  static NGN = new _Currency("NGN", "Nigerian Naira", 2, "\u20A6");
+  static NIO = new _Currency("NIO", "Nicaraguan C\xF3rdoba", 2, "C$");
+  static NOK = new _Currency("NOK", "Norwegian Krone", 2, "Nkr");
+  static NPR = new _Currency("NPR", "Nepalese Rupee", 2, "NPRs");
+  static NZD = new _Currency("NZD", "New Zealand Dollar", 2, "NZ$");
+  static OMR = new _Currency("OMR", "Omani Rial", 3, "OMR");
+  static PAB = new _Currency("PAB", "Panamanian Balboa", 2, "B/.");
+  static PEN = new _Currency("PEN", "Peruvian Nuevo Sol", 2, "S/.");
+  static PHP = new _Currency("PHP", "Philippine Peso", 2, "\u20B1");
+  static PKR = new _Currency("PKR", "Pakistani Rupee", 0, "PKRs");
+  static PLN = new _Currency("PLN", "Polish Zloty", 2, "z\u0142");
+  static PYG = new _Currency("PYG", "Paraguayan Guarani", 0, "\u20B2");
+  static QAR = new _Currency("QAR", "Qatari Rial", 2, "QR");
+  static RON = new _Currency("RON", "Romanian Leu", 2, "RON");
+  static RSD = new _Currency("RSD", "Serbian Dinar", 0, "din.");
+  static RUB = new _Currency("RUB", "Russian Ruble", 2, "RUB");
+  static RWF = new _Currency("RWF", "Rwandan Franc", 0, "RWF");
+  static SAR = new _Currency("SAR", "Saudi Riyal", 2, "SR");
+  static SDG = new _Currency("SDG", "Sudanese Pound", 2, "SDG");
+  static SEK = new _Currency("SEK", "Swedish Krona", 2, "Skr");
+  static SGD = new _Currency("SGD", "Singapore Dollar", 2, "S$");
+  static SOS = new _Currency("SOS", "Somali Shilling", 0, "Ssh");
+  static SYP = new _Currency("SYP", "Syrian Pound", 0, "SY\xA3");
+  static THB = new _Currency("THB", "Thai Baht", 2, "\u0E3F");
+  static TND = new _Currency("TND", "Tunisian Dinar", 3, "DT");
+  static TOP = new _Currency("TOP", "Tongan Pa\u02BBanga", 2, "T$");
+  static TRY = new _Currency("TRY", "Turkish Lira", 2, "TL");
+  static TTD = new _Currency("TTD", "Trinidad and Tobago Dollar", 2, "TT$");
+  static TWD = new _Currency("TWD", "New Taiwan Dollar", 2, "NT$");
+  static TZS = new _Currency("TZS", "Tanzanian Shilling", 0, "TSh");
+  static UAH = new _Currency("UAH", "Ukrainian Hryvnia", 2, "\u20B4");
+  static UGX = new _Currency("UGX", "Ugandan Shilling", 0, "USh");
+  static UYU = new _Currency("UYU", "Uruguayan Peso", 2, "$U");
+  static UZS = new _Currency("UZS", "Uzbekistan Som", 0, "UZS");
+  static VEF = new _Currency("VEF", "Venezuelan Bol\xEDvar", 2, "Bs.F.");
+  static VND = new _Currency("VND", "Vietnamese Dong", 0, "\u20AB");
+  static XAF = new _Currency("XAF", "CFA Franc BEAC", 0, "FCFA");
+  static XOF = new _Currency("XOF", "CFA Franc BCEAO", 0, "CFA");
+  static YER = new _Currency("YER", "Yemeni Rial", 0, "YR");
+  static ZAR = new _Currency("ZAR", "South African Rand", 2, "R");
+  static ZMK = new _Currency("ZMK", "Zambian Kwacha", 0, "ZK");
+  static ZWL = new _Currency("ZWL", "Zimbabwean Dollar", 0, "ZWL$");
+};
+
+export {
+  Currency
+};
+//# sourceMappingURL=chunk-3N5M6QHW.mjs.map

package/dist/chunk-3N5M6QHW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/enums/Currency.ts"],"sourcesContent":["import { Enum } from '@thisisagile/easy';\n\nexport class Currency extends Enum {\n  constructor(\n    id: string,\n    name: string,\n    readonly digits: number,\n    code: string\n  ) {\n    super(name, id, code);\n  }\n  static readonly EUR = new Currency('EUR', 'Euro', 2, '€');\n  static readonly USD = new Currency('USD', 'US Dollar', 2, '$');\n  static readonly AED = new Currency('AED', 'United Arab Emirates Dirham', 2, 'AED');\n  static readonly AFN = new Currency('AFN', 'Afghan Afghani', 0, 'Af');\n  static readonly ALL = new Currency('ALL', 'Albanian Lek', 0, 'ALL');\n  static readonly AMD = new Currency('AMD', 'Armenian Dram', 0, 'AMD');\n  static readonly ARS = new Currency('ARS', 'Argentine Peso', 2, 'AR$');\n  static readonly AUD = new Currency('AUD', 'Australian Dollar', 2, 'AU$');\n  static readonly AZN = new Currency('AZN', 'Azerbaijani Manat', 2, 'man.');\n  static readonly BAM = new Currency('BAM', 'Bosnia-Herzegovina Convertible Mark', 2, 'KM');\n  static readonly BDT = new Currency('BDT', 'Bangladeshi Taka', 2, 'Tk');\n  static readonly BGN = new Currency('BGN', 'Bulgarian Lev', 2, 'BGN');\n  static readonly BHD = new Currency('BHD', 'Bahraini Dinar', 3, 'BD');\n  static readonly BIF = new Currency('BIF', 'Burundian Franc', 0, 'FBu');\n  static readonly BND = new Currency('BND', 'Brunei Dollar', 2, 'BN$');\n  static readonly BOB = new Currency('BOB', 'Bolivian Boliviano', 2, 'Bs');\n  static readonly BRL = new Currency('BRL', 'Brazilian Real', 2, 'R$');\n  static readonly BWP = new Currency('BWP', 'Botswanan Pula', 2, 'BWP');\n  static readonly BYN = new Currency('BYN', 'Belarusian Ruble', 2, 'Br');\n  static readonly BZD = new Currency('BZD', 'Belize Dollar', 2, 'BZ$');\n  static readonly CAD = new Currency('CAD', 'Canadian Dollar', 2, 'CA$');\n  static readonly CDF = new Currency('CDF', 'Congolese Franc', 2, 'CDF');\n  static readonly CHF = new Currency('CHF', 'Swiss Franc', 2, 'CHF');\n  static readonly CLP = new Currency('CLP', 'Chilean Peso', 0, 'CL$');\n  static readonly CNY = new Currency('CNY', 'Chinese Yuan', 2, 'CN¥');\n  static readonly COP = new Currency('COP', 'Colombian Peso', 0, 'CO$');\n  static readonly CRC = new Currency('CRC', 'Costa Rican Colón', 0, '₡');\n  static readonly CVE = new Currency('CVE', 'Cape Verdean Escudo', 2, 'CV$');\n  static readonly CZK = new Currency('CZK', 'Czech Republic Koruna', 2, 'Kč');\n  static readonly DJF = new Currency('DJF', 'Djiboutian Franc', 0, 'Fdj');\n  static readonly DKK = new Currency('DKK', 'Danish Krone', 2, 'Dkr');\n  static readonly DOP = new Currency('DOP', 'Dominican Peso', 2, 'RD$');\n  static readonly DZD = new Currency('DZD', 'Algerian Dinar', 2, 'DA');\n  static readonly EEK = new Currency('EEK', 'Estonian Kroon', 2, 'Ekr');\n  static readonly EGP = new Currency('EGP', 'Egyptian Pound', 2, 'EGP');\n  static readonly ERN = new Currency('ERN', 'Eritrean Nakfa', 2, 'Nfk');\n  static readonly ETB = new Currency('ETB', 'Ethiopian Birr', 2, 'Br');\n  static readonly GBP = new Currency('GBP', 'British Pound Sterling', 2, '£');\n  static readonly GEL = new Currency('GEL', 'Georgian Lari', 2, 'GEL');\n  static readonly GHS = new Currency('GHS', 'Ghanaian Cedi', 2, 'GH₵');\n  static readonly GNF = new Currency('GNF', 'Guinean Franc', 0, 'FG');\n  static readonly GTQ = new Currency('GTQ', 'Guatemalan Quetzal', 2, 'GTQ');\n  static readonly HKD = new Currency('HKD', 'Hong Kong Dollar', 2, 'HK$');\n  static readonly HNL = new Currency('HNL', 'Honduran Lempira', 2, 'HNL');\n  static readonly HRK = new Currency('HRK', 'Croatian Kuna', 2, 'kn');\n  static readonly HUF = new Currency('HUF', 'Hungarian Forint', 0, 'Ft');\n  static readonly IDR = new Currency('IDR', 'Indonesian Rupiah', 0, 'Rp');\n  static readonly ILS = new Currency('ILS', 'Israeli New Sheqel', 2, '₪');\n  static readonly INR = new Currency('INR', 'Indian Rupee', 2, 'Rs');\n  static readonly IQD = new Currency('IQD', 'Iraqi Dinar', 0, 'IQD');\n  static readonly IRR = new Currency('IRR', 'Iranian Rial', 0, 'IRR');\n  static readonly ISK = new Currency('ISK', 'Icelandic Króna', 0, 'Ikr');\n  static readonly JMD = new Currency('JMD', 'Jamaican Dollar', 2, 'J$');\n  static readonly JOD = new Currency('JOD', 'Jordanian Dinar', 3, 'JD');\n  static readonly JPY = new Currency('JPY', 'Japanese Yen', 0, '¥');\n  static readonly KES = new Currency('KES', 'Kenyan Shilling', 2, 'Ksh');\n  static readonly KHR = new Currency('KHR', 'Cambodian Riel', 2, 'KHR');\n  static readonly KMF = new Currency('KMF', 'Comorian Franc', 0, 'CF');\n  static readonly KRW = new Currency('KRW', 'South Korean Won', 0, '₩');\n  static readonly KWD = new Currency('KWD', 'Kuwaiti Dinar', 3, 'KD');\n  static readonly KZT = new Currency('KZT', 'Kazakhstani Tenge', 2, 'KZT');\n  static readonly LBP = new Currency('LBP', 'Lebanese Pound', 0, 'L.L.');\n  static readonly LKR = new Currency('LKR', 'Sri Lankan Rupee', 2, 'SLRs');\n  static readonly LTL = new Currency('LTL', 'Lithuanian Litas', 2, 'Lt');\n  static readonly LVL = new Currency('LVL', 'Latvian Lats', 2, 'Ls');\n  static readonly LYD = new Currency('LYD', 'Libyan Dinar', 3, 'LD');\n  static readonly MAD = new Currency('MAD', 'Moroccan Dirham', 2, 'MAD');\n  static readonly MDL = new Currency('MDL', 'Moldovan Leu', 2, 'MDL');\n  static readonly MGA = new Currency('MGA', 'Malagasy Ariary', 0, 'MGA');\n  static readonly MKD = new Currency('MKD', 'Macedonian Denar', 2, 'MKD');\n  static readonly MMK = new Currency('MMK', 'Myanma Kyat', 0, 'MMK');\n  static readonly MOP = new Currency('MOP', 'Macanese Pataca', 2, 'MOP$');\n  static readonly MUR = new Currency('MUR', 'Mauritian Rupee', 0, 'MURs');\n  static readonly MXN = new Currency('MXN', 'Mexican Peso', 2, 'MX$');\n  static readonly MYR = new Currency('MYR', 'Malaysian Ringgit', 2, 'RM');\n  static readonly MZN = new Currency('MZN', 'Mozambican Metical', 2, 'MTn');\n  static readonly NAD = new Currency('NAD', 'Namibian Dollar', 2, 'N$');\n  static readonly NGN = new Currency('NGN', 'Nigerian Naira', 2, '₦');\n  static readonly NIO = new Currency('NIO', 'Nicaraguan Córdoba', 2, 'C$');\n  static readonly NOK = new Currency('NOK', 'Norwegian Krone', 2, 'Nkr');\n  static readonly NPR = new Currency('NPR', 'Nepalese Rupee', 2, 'NPRs');\n  static readonly NZD = new Currency('NZD', 'New Zealand Dollar', 2, 'NZ$');\n  static readonly OMR = new Currency('OMR', 'Omani Rial', 3, 'OMR');\n  static readonly PAB = new Currency('PAB', 'Panamanian Balboa', 2, 'B/.');\n  static readonly PEN = new Currency('PEN', 'Peruvian Nuevo Sol', 2, 'S/.');\n  static readonly PHP = new Currency('PHP', 'Philippine Peso', 2, '₱');\n  static readonly PKR = new Currency('PKR', 'Pakistani Rupee', 0, 'PKRs');\n  static readonly PLN = new Currency('PLN', 'Polish Zloty', 2, 'zł');\n  static readonly PYG = new Currency('PYG', 'Paraguayan Guarani', 0, '₲');\n  static readonly QAR = new Currency('QAR', 'Qatari Rial', 2, 'QR');\n  static readonly RON = new Currency('RON', 'Romanian Leu', 2, 'RON');\n  static readonly RSD = new Currency('RSD', 'Serbian Dinar', 0, 'din.');\n  static readonly RUB = new Currency('RUB', 'Russian Ruble', 2, 'RUB');\n  static readonly RWF = new Currency('RWF', 'Rwandan Franc', 0, 'RWF');\n  static readonly SAR = new Currency('SAR', 'Saudi Riyal', 2, 'SR');\n  static readonly SDG = new Currency('SDG', 'Sudanese Pound', 2, 'SDG');\n  static readonly SEK = new Currency('SEK', 'Swedish Krona', 2, 'Skr');\n  static readonly SGD = new Currency('SGD', 'Singapore Dollar', 2, 'S$');\n  static readonly SOS = new Currency('SOS', 'Somali Shilling', 0, 'Ssh');\n  static readonly SYP = new Currency('SYP', 'Syrian Pound', 0, 'SY£');\n  static readonly THB = new Currency('THB', 'Thai Baht', 2, '฿');\n  static readonly TND = new Currency('TND', 'Tunisian Dinar', 3, 'DT');\n  static readonly TOP = new Currency('TOP', 'Tongan Paʻanga', 2, 'T$');\n  static readonly TRY = new Currency('TRY', 'Turkish Lira', 2, 'TL');\n  static readonly TTD = new Currency('TTD', 'Trinidad and Tobago Dollar', 2, 'TT$');\n  static readonly TWD = new Currency('TWD', 'New Taiwan Dollar', 2, 'NT$');\n  static readonly TZS = new Currency('TZS', 'Tanzanian Shilling', 0, 'TSh');\n  static readonly UAH = new Currency('UAH', 'Ukrainian Hryvnia', 2, '₴');\n  static readonly UGX = new Currency('UGX', 'Ugandan Shilling', 0, 'USh');\n  static readonly UYU = new Currency('UYU', 'Uruguayan Peso', 2, '$U');\n  static readonly UZS = new Currency('UZS', 'Uzbekistan Som', 0, 'UZS');\n  static readonly VEF = new Currency('VEF', 'Venezuelan Bolívar', 2, 'Bs.F.');\n  static readonly VND = new Currency('VND', 'Vietnamese Dong', 0, '₫');\n  static readonly XAF = new Currency('XAF', 'CFA Franc BEAC', 0, 'FCFA');\n  static readonly XOF = new Currency('XOF', 'CFA Franc BCEAO', 0, 'CFA');\n  static readonly YER = new Currency('YER', 'Yemeni Rial', 0, 'YR');\n  static readonly ZAR = new Currency('ZAR', 'South African Rand', 2, 'R');\n  static readonly ZMK = new Currency('ZMK', 'Zambian Kwacha', 0, 'ZK');\n  static readonly ZWL = new Currency('ZWL', 'Zimbabwean Dollar', 0, 'ZWL$');\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-CKW4QYDN.mjs

@@ -0,0 +1,16 @@
+// src/enums/UnitOfWeight.ts
+import { Enum } from "@thisisagile/easy";
+var UnitOfWeight = class _UnitOfWeight extends Enum {
+  constructor(name, id, gMultiplier) {
+    super(name, id);
+    this.gMultiplier = gMultiplier;
+  }
+  static MG = new _UnitOfWeight("MilliGram", "mg", 1e-3);
+  static G = new _UnitOfWeight("Gram", "g", 1);
+  static KG = new _UnitOfWeight("Kilogram", "kg", 1e3);
+};
+
+export {
+  UnitOfWeight
+};
+//# sourceMappingURL=chunk-CKW4QYDN.mjs.map

package/dist/chunk-CKW4QYDN.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/enums/UnitOfWeight.ts"],"sourcesContent":["import { Enum } from '@thisisagile/easy';\n\nexport class UnitOfWeight extends Enum {\n  static readonly MG = new UnitOfWeight('MilliGram', 'mg', 0.001);\n  static readonly G = new UnitOfWeight('Gram', 'g', 1);\n  static readonly KG = new UnitOfWeight('Kilogram', 'kg', 1000);\n\n  constructor(\n    name: string,\n    id: string,\n    readonly gMultiplier: number\n  ) {\n    super(name, id);\n  }\n}\n"],"mappings":";AAAA,SAAS,YAAY;AAEd,IAAM,eAAN,MAAM,sBAAqB,KAAK;AAAA,EAKrC,YACE,MACA,IACS,aACT;AACA,UAAM,MAAM,EAAE;AAFL;AAAA,EAGX;AAAA,EAVA,OAAgB,KAAK,IAAI,cAAa,aAAa,MAAM,IAAK;AAAA,EAC9D,OAAgB,IAAI,IAAI,cAAa,QAAQ,KAAK,CAAC;AAAA,EACnD,OAAgB,KAAK,IAAI,cAAa,YAAY,MAAM,GAAI;AAS9D;","names":[]}

package/dist/chunk-H2VHSGNX.mjs

@@ -0,0 +1,35 @@
+import {
+  UnitOfMeasurement
+} from "./chunk-XBORRJ6W.mjs";
+import {
+  __decorateClass
+} from "./chunk-RDITZTSA.mjs";
+
+// src/structs/Dimension.ts
+import { Struct, required } from "@thisisagile/easy";
+var _Dimension = class _Dimension extends Struct {
+  value = this.state.value;
+  uom = UnitOfMeasurement.byId(this.state.uom, UnitOfMeasurement.MM);
+  static with = (value, uom = UnitOfMeasurement.MM) => new _Dimension({ value, uom });
+  /**
+   @deprecated use inMilliMeters getter instead
+   */
+  sizeInMM() {
+    return this.inMilliMeters;
+  }
+  get inMilliMeters() {
+    return this.value * this.uom.mmMultiplier;
+  }
+  gte(dim) {
+    return this.inMilliMeters >= dim.inMilliMeters;
+  }
+};
+__decorateClass([
+  required()
+], _Dimension.prototype, "value", 2);
+var Dimension = _Dimension;
+
+export {
+  Dimension
+};
+//# sourceMappingURL=chunk-H2VHSGNX.mjs.map

package/dist/chunk-H2VHSGNX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/structs/Dimension.ts"],"sourcesContent":["import { Struct, required } from '@thisisagile/easy';\nimport { UnitOfMeasurement } from '../enums/UnitOfMeasurement';\n\nexport class Dimension extends Struct {\n  @required() readonly value = this.state.value as number;\n  readonly uom = UnitOfMeasurement.byId<UnitOfMeasurement>(this.state.uom, UnitOfMeasurement.MM);\n\n  static with = (value: number, uom: UnitOfMeasurement = UnitOfMeasurement.MM) => new Dimension({ value, uom });\n\n  /**\n   @deprecated use inMilliMeters getter instead\n   */\n  sizeInMM(): number {\n    return this.inMilliMeters;\n  }\n\n  get inMilliMeters(): number {\n    return this.value * this.uom.mmMultiplier;\n  }\n\n  gte(dim: Dimension): boolean {\n    return this.inMilliMeters >= dim.inMilliMeters;\n  }\n}\n"],"mappings":";;;;;;;;AAAA,SAAS,QAAQ,gBAAgB;AAG1B,IAAM,aAAN,MAAM,mBAAkB,OAAO;AAAA,EACf,QAAQ,KAAK,MAAM;AAAA,EAC/B,MAAM,kBAAkB,KAAwB,KAAK,MAAM,KAAK,kBAAkB,EAAE;AAAA,EAE7F,OAAO,OAAO,CAAC,OAAe,MAAyB,kBAAkB,OAAO,IAAI,WAAU,EAAE,OAAO,IAAI,CAAC;AAAA;AAAA;AAAA;AAAA,EAK5G,WAAmB;AACjB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAI,gBAAwB;AAC1B,WAAO,KAAK,QAAQ,KAAK,IAAI;AAAA,EAC/B;AAAA,EAEA,IAAI,KAAyB;AAC3B,WAAO,KAAK,iBAAiB,IAAI;AAAA,EACnC;AACF;AAnBuB;AAAA,EAApB,SAAS;AAAA,GADC,WACU;AADhB,IAAM,YAAN;","names":[]}