@stevenkellner/team-conduct-api 1.0.36 → 2.0.1

package/lib/src/types/Configuration.js

@@ -1,15 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Configuration = void 0;
-const Localization_1 = require("./Localization");
-const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+/**
+ * Represents the configuration settings that will be passed to the functions parameters.
+ * Contains currency and locale preferences.
+ */
 class Configuration {
     currency;
     locale;
+    /**
+     * Creates a new Configuration instance.
+     * @param currency - The currency to use for monetary values (EUR, USD, ...)
+     * @param locale - The locale for localization (language/region)
+     */
     constructor(currency, locale) {
         this.currency = currency;
         this.locale = locale;
     }
+    /**
+     * Returns the flattened representation of the configuration.
+     * @returns The flattened configuration object
+     */
     get flatten() {
         return {
             currency: this.currency,
@@ -19,21 +30,22 @@ class Configuration {
 }
 exports.Configuration = Configuration;
 (function (Configuration) {
-    let Currency;
-    (function (Currency) {
-        Currency.all = ['EUR', 'USD'];
-        Currency.builder = new typescript_common_functionality_1.ValueTypeBuilder();
-    })(Currency = Configuration.Currency || (Configuration.Currency = {}));
-    let Locale;
-    (function (Locale) {
-        Locale.all = (0, typescript_common_functionality_1.keys)(Localization_1.localizations);
-        Locale.builder = new typescript_common_functionality_1.ValueTypeBuilder();
-    })(Locale = Configuration.Locale || (Configuration.Locale = {}));
+    /**
+     * TypeBuilder for constructing Configuration instances from flattened data.
+     */
     class TypeBuilder {
+        /**
+         * Builds a Configuration instance from flattened data.
+         * @param flatten - The flattened configuration data
+         * @returns A new Configuration instance
+         */
         build(flatten) {
             return new Configuration(flatten.currency, flatten.locale);
         }
     }
     Configuration.TypeBuilder = TypeBuilder;
+    /**
+     * Singleton builder instance for Configuration.
+     */
     Configuration.builder = new TypeBuilder();
 })(Configuration || (exports.Configuration = Configuration = {}));

package/lib/src/types/Currency.d.ts

@@ -0,0 +1,20 @@
+import { ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+/**
+ * Array of all available currencies.
+ */
+declare const currencies: readonly ["EUR", "USD"];
+/**
+ * Supported currency types.
+ */
+export type Currency = typeof currencies[number];
+export declare namespace Currency {
+    /**
+     * Array of all available currencies.
+     */
+    const all: readonly Currency[];
+    /**
+     * Builder for constructing Currency values.
+     */
+    const builder: ValueTypeBuilder<"EUR" | "USD">;
+}
+export {};

package/lib/src/types/Currency.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Currency = void 0;
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+/**
+ * Array of all available currencies.
+ */
+const currencies = ['EUR', 'USD'];
+var Currency;
+(function (Currency) {
+    /**
+     * Array of all available currencies.
+     */
+    Currency.all = currencies;
+    /**
+     * Builder for constructing Currency values.
+     */
+    Currency.builder = new typescript_common_functionality_1.ValueTypeBuilder();
+})(Currency || (exports.Currency = Currency = {}));

package/lib/src/types/Fine.d.ts

@@ -1,21 +1,50 @@
 import { Flattable, Guid, ITypeBuilder, Tagged, UtcDate } from '@stevenkellner/typescript-common-functionality';
 import { FineAmount } from './FineAmount';
 import { PayedState } from './PayedState';
+/**
+ * Represents a fine assigned to a person in a team.
+ *
+ * Contains information about the fine's payment status, date, reason, and monetary amount.
+ */
 export declare class Fine implements Flattable<Fine.Flatten> {
     id: Fine.Id;
     payedState: PayedState;
     date: UtcDate;
     reason: string;
     amount: FineAmount;
+    /**
+     * Creates a new Fine instance.
+     *
+     * @param id - Unique identifier for the fine (GUID)
+     * @param payedState - Payment status ('payed' or 'notPayed')
+     * @param date - Date when the fine was issued
+     * @param reason - Description or reason for the fine
+     * @param amount - Monetary amount of the fine
+     */
     constructor(id: Fine.Id, payedState: PayedState, date: UtcDate, reason: string, amount: FineAmount);
+    /**
+     * Returns the flattened representation for serialization.
+     */
     get flatten(): Fine.Flatten;
 }
 export declare namespace Fine {
+    /**
+     * Tagged GUID type for fine identifiers.
+     */
     type Id = Tagged<Guid, 'fine'>;
     namespace Id {
+        /**
+         * Flattened representation of a fine ID (GUID string).
+         */
         type Flatten = string;
+        /**
+         * Type builder for Fine.Id serialization/deserialization.
+         */
         const builder: Tagged.TypeBuilder<Guid, "fine">;
     }
+    /**
+     * Flattened representation of a Fine for serialization.
+     */
     type Flatten = {
         id: Id.Flatten;
         payedState: PayedState;
@@ -23,8 +52,20 @@ export declare namespace Fine {
         reason: string;
         amount: FineAmount.Flatten;
     };
+    /**
+     * Type builder for Fine serialization/deserialization.
+     */
     class TypeBuilder implements ITypeBuilder<Flatten, Fine> {
+        /**
+         * Builds a Fine instance from flattened data.
+         *
+         * @param value - Flattened fine data
+         * @returns Fine instance
+         */
         build(value: Flatten): Fine;
     }
+    /**
+     * Singleton instance of TypeBuilder for Fine.
+     */
     const builder: TypeBuilder;
 }

package/lib/src/types/Fine.js

@@ -3,12 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Fine = void 0;
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
 const FineAmount_1 = require("./FineAmount");
+/**
+ * Represents a fine assigned to a person in a team.
+ *
+ * Contains information about the fine's payment status, date, reason, and monetary amount.
+ */
 class Fine {
     id;
     payedState;
     date;
     reason;
     amount;
+    /**
+     * Creates a new Fine instance.
+     *
+     * @param id - Unique identifier for the fine (GUID)
+     * @param payedState - Payment status ('payed' or 'notPayed')
+     * @param date - Date when the fine was issued
+     * @param reason - Description or reason for the fine
+     * @param amount - Monetary amount of the fine
+     */
     constructor(id, payedState, date, reason, amount) {
         this.id = id;
         this.payedState = payedState;
@@ -16,6 +30,9 @@ class Fine {
         this.reason = reason;
         this.amount = amount;
     }
+    /**
+     * Returns the flattened representation for serialization.
+     */
     get flatten() {
         return {
             id: this.id.flatten,
@@ -30,13 +47,28 @@ exports.Fine = Fine;
 (function (Fine) {
     let Id;
     (function (Id) {
+        /**
+         * Type builder for Fine.Id serialization/deserialization.
+         */
         Id.builder = typescript_common_functionality_1.Tagged.builder('fine', typescript_common_functionality_1.Guid.builder);
     })(Id = Fine.Id || (Fine.Id = {}));
+    /**
+     * Type builder for Fine serialization/deserialization.
+     */
     class TypeBuilder {
+        /**
+         * Builds a Fine instance from flattened data.
+         *
+         * @param value - Flattened fine data
+         * @returns Fine instance
+         */
         build(value) {
             return new Fine(Id.builder.build(value.id), value.payedState, typescript_common_functionality_1.UtcDate.builder.build(value.date), value.reason, FineAmount_1.FineAmount.builder.build(value.amount));
         }
     }
     Fine.TypeBuilder = TypeBuilder;
+    /**
+     * Singleton instance of TypeBuilder for Fine.
+     */
     Fine.builder = new TypeBuilder();
 })(Fine || (exports.Fine = Fine = {}));

package/lib/src/types/FineAmount.d.ts

@@ -1,56 +1,207 @@
 import { Flattable, ITypeBuilder } from '@stevenkellner/typescript-common-functionality';
 import { MoneyAmount } from './MoneyAmount';
 import { Configuration } from './Configuration';
+import { Locale } from './Locale';
+/**
+ * Represents the amount of a fine, either as a monetary value or as items.
+ *
+ * Can be either FineAmount.Money (e.g., $10) or FineAmount.Item (e.g., 2 crates of beer).
+ */
 export type FineAmount = FineAmount.Money | FineAmount.Item;
 export declare namespace FineAmount {
+    /**
+     * Represents a fine amount as a monetary value.
+     */
     class Money implements Flattable<Money.Flatten> {
         amount: MoneyAmount;
+        /**
+         * Creates a new Money fine amount.
+         *
+         * @param amount - The monetary amount
+         */
         constructor(amount: MoneyAmount);
+        /**
+         * Returns a formatted string representation of the amount.
+         *
+         * @param configuration - Configuration containing currency and locale
+         * @returns Formatted currency string (e.g., "$10.50")
+         */
         formatted(configuration: Configuration): string;
+        /**
+         * Returns a new Money instance with the amount multiplied by a factor.
+         *
+         * @param factor - The multiplication factor
+         * @returns New Money instance with multiplied amount
+         */
         multiplied(factor: number): Money;
+        /**
+         * Returns the flattened representation for serialization.
+         */
         get flatten(): Money.Flatten;
     }
     namespace Money {
+        /**
+         * Flattened representation of Money for serialization.
+         */
         type Flatten = {
             type: 'money';
             amount: MoneyAmount.Flatten;
         };
+        /**
+         * Type builder for Money serialization/deserialization.
+         */
         class TypeBuilder implements ITypeBuilder<Flatten, Money> {
+            /**
+             * Builds a Money instance from flattened data.
+             *
+             * @param value - Flattened money data
+             * @returns Money instance
+             */
             build(value: Flatten): Money;
         }
+        /**
+         * Singleton instance of TypeBuilder for Money.
+         */
         const builder: TypeBuilder;
     }
+    /**
+     * Represents a fine amount as a quantity of items.
+     */
     class Item implements Flattable<Item.Flatten> {
         item: Item.Type;
         count: number;
+        /**
+         * Creates a new Item fine amount.
+         *
+         * @param item - The item type (e.g., 'crateOfBeer')
+         * @param count - The number of items
+         */
         constructor(item: Item.Type, count: number);
-        formatted(): string;
-        formattedWithoutCount(): string;
+        /**
+         * Returns a formatted string representation including count.
+         *
+         * @param locale - The locale for formatting
+         * @returns Formatted string (e.g., "2 crates of beer")
+         */
+        formatted(locale: Locale): string;
+        /**
+         * Returns a formatted string representation including count.
+         *
+         * @param configuration - Configuration containing locale
+         * @returns Formatted string (e.g., "2 crates of beer")
+         */
+        formatted(configuration: Configuration): string;
+        /**
+         * Returns a formatted string representation without explicitly showing count.
+         *
+         * @param locale - The locale for formatting
+         * @returns Formatted string without count display
+         */
+        formattedWithoutCount(locale: Locale): string;
+        /**
+         * Returns a new Item instance with the count multiplied by a factor.
+         *
+         * @param factor - The multiplication factor
+         * @returns New Item instance with multiplied count
+         */
         multiplied(factor: number): Item;
+        /**
+         * Returns the flattened representation for serialization.
+         */
         get flatten(): Item.Flatten;
     }
     namespace Item {
-        type Type = 'crateOfBeer';
-        namespace Type {
-            const all: Type[];
-            function formatted(type: Type): string;
+        const itemTypes: readonly ["crateOfBeer"];
+        /**
+         * Item type: currently only 'crateOfBeer'.
+         */
+        export type Type = typeof itemTypes[number];
+        export namespace Type {
+            /**
+             * Array containing all possible item types.
+             */
+            const all: readonly Type[];
+            /**
+             * Returns the localized name for an item type.
+             *
+             * @param type - The item type
+             * @param locale - The locale to use for formatting
+             * @returns Localized item name
+             */
+            function formatted(type: Type, locale: Locale): string;
         }
-        type Flatten = {
+        /**
+         * Flattened representation of Item for serialization.
+         */
+        export type Flatten = {
             type: 'item';
             item: Item.Type;
             count: number;
         };
-        class TypeBuilder implements ITypeBuilder<Flatten, Item> {
+        /**
+         * Type builder for Item serialization/deserialization.
+         */
+        export class TypeBuilder implements ITypeBuilder<Flatten, Item> {
+            /**
+             * Builds an Item instance from flattened data.
+             *
+             * @param value - Flattened item data
+             * @returns Item instance
+             */
             build(value: Flatten): Item;
         }
-        const builder: TypeBuilder;
+        /**
+         * Singleton instance of TypeBuilder for Item.
+         */
+        export const builder: TypeBuilder;
+        export {};
     }
+    /**
+     * Creates a Money fine amount.
+     *
+     * @param MoneyAmount - The monetary amount
+     * @returns Money instance
+     */
     function money(MoneyAmount: MoneyAmount): Money;
+    /**
+     * Creates an Item fine amount.
+     *
+     * @param item - The item type
+     * @param count - The number of items
+     * @returns Item instance
+     */
     function item(item: Item.Type, count: number): Item;
+    /**
+     * Compares two fine amounts and returns their relative ordering.
+     *
+     * Money amounts are considered greater than Item amounts.
+     * Within the same type, values are compared numerically.
+     *
+     * @param lhs - First fine amount to compare
+     * @param rhs - Second fine amount to compare
+     * @returns 'less' if lhs < rhs, 'equal' if lhs === rhs, 'greater' if lhs > rhs
+     */
     function compare(lhs: FineAmount, rhs: FineAmount): 'less' | 'equal' | 'greater';
+    /**
+     * Flattened representation of FineAmount (union of Money.Flatten and Item.Flatten).
+     */
     type Flatten = Money.Flatten | Item.Flatten;
+    /**
+     * Type builder for FineAmount serialization/deserialization.
+     */
     class TypeBuilder implements ITypeBuilder<Flatten, FineAmount> {
+        /**
+         * Builds a FineAmount instance from flattened data.
+         *
+         * Determines the type based on the 'type' discriminator field.
+         *
+         * @param value - Flattened fine amount data
+         * @returns FineAmount instance (Money or Item)
+         */
         build(value: Flatten): FineAmount;
     }
+    /**
+     * Singleton instance of TypeBuilder for FineAmount.
+     */
     const builder: TypeBuilder;
 }

package/lib/src/types/FineAmount.js

@@ -2,20 +2,44 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FineAmount = void 0;
 const MoneyAmount_1 = require("./MoneyAmount");
+const Configuration_1 = require("./Configuration");
 const Localization_1 = require("./Localization");
 var FineAmount;
 (function (FineAmount) {
+    /**
+     * Represents a fine amount as a monetary value.
+     */
     class Money {
         amount;
+        /**
+         * Creates a new Money fine amount.
+         *
+         * @param amount - The monetary amount
+         */
         constructor(amount) {
             this.amount = amount;
         }
+        /**
+         * Returns a formatted string representation of the amount.
+         *
+         * @param configuration - Configuration containing currency and locale
+         * @returns Formatted currency string (e.g., "$10.50")
+         */
         formatted(configuration) {
             return this.amount.formatted(configuration.currency, configuration);
         }
+        /**
+         * Returns a new Money instance with the amount multiplied by a factor.
+         *
+         * @param factor - The multiplication factor
+         * @returns New Money instance with multiplied amount
+         */
         multiplied(factor) {
             return new Money(this.amount.multiplied(factor));
         }
+        /**
+         * Returns the flattened representation for serialization.
+         */
         get flatten() {
             return {
                 type: 'money',
@@ -25,30 +49,67 @@ var FineAmount;
     }
     FineAmount.Money = Money;
     (function (Money) {
+        /**
+         * Type builder for Money serialization/deserialization.
+         */
         class TypeBuilder {
+            /**
+             * Builds a Money instance from flattened data.
+             *
+             * @param value - Flattened money data
+             * @returns Money instance
+             */
             build(value) {
                 return new Money(MoneyAmount_1.MoneyAmount.builder.build(value.amount));
             }
         }
         Money.TypeBuilder = TypeBuilder;
+        /**
+         * Singleton instance of TypeBuilder for Money.
+         */
         Money.builder = new TypeBuilder();
     })(Money = FineAmount.Money || (FineAmount.Money = {}));
+    /**
+     * Represents a fine amount as a quantity of items.
+     */
     class Item {
         item;
         count;
+        /**
+         * Creates a new Item fine amount.
+         *
+         * @param item - The item type (e.g., 'crateOfBeer')
+         * @param count - The number of items
+         */
         constructor(item, count) {
             this.item = item;
             this.count = count;
         }
-        formatted() {
-            return Localization_1.Localization.shared.fineAmount.item.type[this.item].withCount.value(this.count);
+        formatted(configurationOrLocale) {
+            const locale = configurationOrLocale instanceof Configuration_1.Configuration ? configurationOrLocale.locale : configurationOrLocale;
+            return Localization_1.Localization.shared(locale).fineAmount.item.type[this.item].withCount.value(this.count);
         }
-        formattedWithoutCount() {
-            return Localization_1.Localization.shared.fineAmount.item.type[this.item].withoutCount.value(this.count);
+        /**
+         * Returns a formatted string representation without explicitly showing count.
+         *
+         * @param locale - The locale for formatting
+         * @returns Formatted string without count display
+         */
+        formattedWithoutCount(locale) {
+            return Localization_1.Localization.shared(locale).fineAmount.item.type[this.item].withoutCount.value(this.count);
         }
+        /**
+         * Returns a new Item instance with the count multiplied by a factor.
+         *
+         * @param factor - The multiplication factor
+         * @returns New Item instance with multiplied count
+         */
         multiplied(factor) {
             return new Item(this.item, this.count * factor);
         }
+        /**
+         * Returns the flattened representation for serialization.
+         */
         get flatten() {
             return {
                 type: 'item',
@@ -59,30 +120,76 @@ var FineAmount;
     }
     FineAmount.Item = Item;
     (function (Item) {
+        const itemTypes = ['crateOfBeer'];
         let Type;
         (function (Type) {
-            Type.all = ['crateOfBeer'];
-            function formatted(type) {
-                return Localization_1.Localization.shared.fineAmount.item.type[type].name.value();
+            /**
+             * Array containing all possible item types.
+             */
+            Type.all = itemTypes;
+            /**
+             * Returns the localized name for an item type.
+             *
+             * @param type - The item type
+             * @param locale - The locale to use for formatting
+             * @returns Localized item name
+             */
+            function formatted(type, locale) {
+                return Localization_1.Localization.shared(locale).fineAmount.item.type[type].name.value();
             }
             Type.formatted = formatted;
         })(Type = Item.Type || (Item.Type = {}));
+        /**
+         * Type builder for Item serialization/deserialization.
+         */
         class TypeBuilder {
+            /**
+             * Builds an Item instance from flattened data.
+             *
+             * @param value - Flattened item data
+             * @returns Item instance
+             */
             build(value) {
                 return new Item(value.item, value.count);
             }
         }
         Item.TypeBuilder = TypeBuilder;
+        /**
+         * Singleton instance of TypeBuilder for Item.
+         */
         Item.builder = new TypeBuilder();
     })(Item = FineAmount.Item || (FineAmount.Item = {}));
+    /**
+     * Creates a Money fine amount.
+     *
+     * @param MoneyAmount - The monetary amount
+     * @returns Money instance
+     */
     function money(MoneyAmount) {
         return new Money(MoneyAmount);
     }
     FineAmount.money = money;
+    /**
+     * Creates an Item fine amount.
+     *
+     * @param item - The item type
+     * @param count - The number of items
+     * @returns Item instance
+     */
     function item(item, count) {
         return new Item(item, count);
     }
     FineAmount.item = item;
+    /**
+     * Compares two fine amounts and returns their relative ordering.
+     *
+     * Money amounts are considered greater than Item amounts.
+     * Within the same type, values are compared numerically.
+     *
+     * @param lhs - First fine amount to compare
+     * @param rhs - Second fine amount to compare
+     * @returns 'less' if lhs < rhs, 'equal' if lhs === rhs, 'greater' if lhs > rhs
+     */
     function compare(lhs, rhs) {
         if (lhs instanceof Money) {
             if (!(rhs instanceof Money))
@@ -102,7 +209,18 @@ var FineAmount;
         return 'equal';
     }
     FineAmount.compare = compare;
+    /**
+     * Type builder for FineAmount serialization/deserialization.
+     */
     class TypeBuilder {
+        /**
+         * Builds a FineAmount instance from flattened data.
+         *
+         * Determines the type based on the 'type' discriminator field.
+         *
+         * @param value - Flattened fine amount data
+         * @returns FineAmount instance (Money or Item)
+         */
         build(value) {
             switch (value.type) {
                 case 'money':
@@ -113,5 +231,8 @@ var FineAmount;
         }
     }
     FineAmount.TypeBuilder = TypeBuilder;
+    /**
+     * Singleton instance of TypeBuilder for FineAmount.
+     */
     FineAmount.builder = new TypeBuilder();
 })(FineAmount || (exports.FineAmount = FineAmount = {}));