@stevenkellner/team-conduct-api 1.0.36 → 2.0.1

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

@@ -1,28 +1,69 @@
 import { Flattable, Guid, ITypeBuilder, Tagged } from '@stevenkellner/typescript-common-functionality';
 import { FineAmount } from './FineAmount';
 import { FineTemplateRepetition } from './FineTemplateRepetition';
+/**
+ * Represents a template for creating fines with predefined reason, amount, and optional repetition rules.
+ *
+ * Fine templates allow teams to quickly create recurring or standard fines without entering
+ * the same information repeatedly.
+ */
 export declare class FineTemplate implements Flattable<FineTemplate.Flatten> {
     id: FineTemplate.Id;
     reason: string;
     amount: FineAmount;
     repetition: FineTemplateRepetition | null;
+    /**
+     * Creates a new FineTemplate instance.
+     *
+     * @param id - Unique identifier for the fine template (GUID)
+     * @param reason - The reason or description for the fine
+     * @param amount - The monetary or item-based amount of the fine
+     * @param repetition - Optional repetition rules (null for non-recurring templates)
+     */
     constructor(id: FineTemplate.Id, reason: string, amount: FineAmount, repetition: FineTemplateRepetition | null);
+    /**
+     * Returns the flattened representation for serialization.
+     */
     get flatten(): FineTemplate.Flatten;
 }
 export declare namespace FineTemplate {
+    /**
+     * Tagged GUID type for fine template identifiers.
+     */
     type Id = Tagged<Guid, 'fineTemplate'>;
     namespace Id {
+        /**
+         * Flattened representation of a fine template ID (GUID string).
+         */
         type Flatten = string;
+        /**
+         * Type builder for FineTemplate.Id serialization/deserialization.
+         */
         const builder: Tagged.TypeBuilder<Guid, "fineTemplate">;
     }
+    /**
+     * Flattened representation of a FineTemplate for serialization.
+     */
     type Flatten = {
         id: Id.Flatten;
         reason: string;
         amount: FineAmount.Flatten;
         repetition: FineTemplateRepetition.Flatten | null;
     };
+    /**
+     * Type builder for FineTemplate serialization/deserialization.
+     */
     class TypeBuilder implements ITypeBuilder<Flatten, FineTemplate> {
+        /**
+         * Builds a FineTemplate instance from flattened data.
+         *
+         * @param value - Flattened fine template data
+         * @returns FineTemplate instance
+         */
         build(value: Flatten): FineTemplate;
     }
+    /**
+     * Singleton instance of TypeBuilder for FineTemplate.
+     */
     const builder: TypeBuilder;
 }

package/lib/src/types/FineTemplate.js

@@ -4,17 +4,34 @@ exports.FineTemplate = void 0;
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
 const FineAmount_1 = require("./FineAmount");
 const FineTemplateRepetition_1 = require("./FineTemplateRepetition");
+/**
+ * Represents a template for creating fines with predefined reason, amount, and optional repetition rules.
+ *
+ * Fine templates allow teams to quickly create recurring or standard fines without entering
+ * the same information repeatedly.
+ */
 class FineTemplate {
     id;
     reason;
     amount;
     repetition;
+    /**
+     * Creates a new FineTemplate instance.
+     *
+     * @param id - Unique identifier for the fine template (GUID)
+     * @param reason - The reason or description for the fine
+     * @param amount - The monetary or item-based amount of the fine
+     * @param repetition - Optional repetition rules (null for non-recurring templates)
+     */
     constructor(id, reason, amount, repetition) {
         this.id = id;
         this.reason = reason;
         this.amount = amount;
         this.repetition = repetition;
     }
+    /**
+     * Returns the flattened representation for serialization.
+     */
     get flatten() {
         return {
             id: this.id.flatten,
@@ -28,13 +45,28 @@ exports.FineTemplate = FineTemplate;
 (function (FineTemplate) {
     let Id;
     (function (Id) {
+        /**
+         * Type builder for FineTemplate.Id serialization/deserialization.
+         */
         Id.builder = typescript_common_functionality_1.Tagged.builder('fineTemplate', typescript_common_functionality_1.Guid.builder);
     })(Id = FineTemplate.Id || (FineTemplate.Id = {}));
+    /**
+     * Type builder for FineTemplate serialization/deserialization.
+     */
     class TypeBuilder {
+        /**
+         * Builds a FineTemplate instance from flattened data.
+         *
+         * @param value - Flattened fine template data
+         * @returns FineTemplate instance
+         */
         build(value) {
             return new FineTemplate(Id.builder.build(value.id), value.reason, FineAmount_1.FineAmount.builder.build(value.amount), value.repetition === null ? null : FineTemplateRepetition_1.FineTemplateRepetition.builder.build(value.repetition));
         }
     }
     FineTemplate.TypeBuilder = TypeBuilder;
+    /**
+     * Singleton instance of TypeBuilder for FineTemplate.
+     */
     FineTemplate.builder = new TypeBuilder();
 })(FineTemplate || (exports.FineTemplate = FineTemplate = {}));

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

@@ -1,25 +1,87 @@
 import { Flattable, ITypeBuilder, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+import { Locale } from './Locale';
+/**
+ * Represents how a fine template repeats over time.
+ *
+ * Defines the repetition unit (minute, day, item, count) and optional maximum count for repetitions.
+ */
 export declare class FineTemplateRepetition implements Flattable<FineTemplateRepetition.Flatten> {
     item: FineTemplateRepetition.Item;
     maxCount: number | null;
+    /**
+     * Creates a new FineTemplateRepetition instance.
+     *
+     * @param item - The repetition unit type (minute, day, item, count)
+     * @param maxCount - Optional maximum number of repetitions (null for unlimited)
+     */
     constructor(item: FineTemplateRepetition.Item, maxCount: number | null);
-    formatted(count: number): string;
-    formattedWithoutCount(count: number): string;
+    /**
+     * Returns a localized formatted string including the count value.
+     *
+     * @param count - The number of repetitions
+     * @param locale - The locale to use for formatting
+     * @returns Formatted string (e.g., "every 5 minutes")
+     */
+    formatted(count: number, locale: Locale): string;
+    /**
+     * Returns a localized formatted string without explicitly showing the count.
+     *
+     * @param count - The number of repetitions
+     * @param locale - The locale to use for formatting
+     * @returns Formatted string without count display
+     */
+    formattedWithoutCount(count: number, locale: Locale): string;
+    /**
+     * Returns the flattened representation for serialization.
+     */
     get flatten(): FineTemplateRepetition.Flatten;
 }
 export declare namespace FineTemplateRepetition {
-    type Item = 'minute' | 'day' | 'item' | 'count';
-    namespace Item {
-        const all: Item[];
-        function formatted(item: Item): string;
-        const builder: ValueTypeBuilder<Item>;
+    const repetitionItems: readonly ["minute", "day", "item", "count"];
+    /**
+     * Repetition unit type: 'minute', 'day', 'item', or 'count'.
+     */
+    export type Item = typeof repetitionItems[number];
+    export namespace Item {
+        /**
+         * Array containing all possible repetition item types.
+         */
+        const all: readonly Item[];
+        /**
+         * Returns the localized name for a repetition item type.
+         *
+         * @param item - The repetition item type
+         * @param locale - The locale to use for formatting
+         * @returns Localized name string
+         */
+        function formatted(item: Item, locale: Locale): string;
+        /**
+         * Type builder for Item serialization/deserialization.
+         */
+        const builder: ValueTypeBuilder<"item" | "minute" | "day" | "count">;
     }
-    type Flatten = {
+    /**
+     * Flattened representation of FineTemplateRepetition for serialization.
+     */
+    export type Flatten = {
         item: Item;
         maxCount: number | null;
     };
-    class TypeBuilder implements ITypeBuilder<Flatten, FineTemplateRepetition> {
+    /**
+     * Type builder for FineTemplateRepetition serialization/deserialization.
+     */
+    export class TypeBuilder implements ITypeBuilder<Flatten, FineTemplateRepetition> {
+        /**
+         * Builds a FineTemplateRepetition instance from flattened data.
+         *
+         * @param flatten - Flattened repetition data
+         * @returns FineTemplateRepetition instance
+         */
         build(flatten: Flatten): FineTemplateRepetition;
     }
-    const builder: TypeBuilder;
+    /**
+     * Singleton instance of TypeBuilder for FineTemplateRepetition.
+     */
+    export const builder: TypeBuilder;
+    export {};
 }

package/lib/src/types/FineTemplateRepetition.js

@@ -3,19 +3,47 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FineTemplateRepetition = void 0;
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
 const Localization_1 = require("./Localization");
+/**
+ * Represents how a fine template repeats over time.
+ *
+ * Defines the repetition unit (minute, day, item, count) and optional maximum count for repetitions.
+ */
 class FineTemplateRepetition {
     item;
     maxCount;
+    /**
+     * Creates a new FineTemplateRepetition instance.
+     *
+     * @param item - The repetition unit type (minute, day, item, count)
+     * @param maxCount - Optional maximum number of repetitions (null for unlimited)
+     */
     constructor(item, maxCount) {
         this.item = item;
         this.maxCount = maxCount;
     }
-    formatted(count) {
-        return Localization_1.Localization.shared.fineTemplateRepetition.item[this.item].withCount.value(count);
+    /**
+     * Returns a localized formatted string including the count value.
+     *
+     * @param count - The number of repetitions
+     * @param locale - The locale to use for formatting
+     * @returns Formatted string (e.g., "every 5 minutes")
+     */
+    formatted(count, locale) {
+        return Localization_1.Localization.shared(locale).fineTemplateRepetition.item[this.item].withCount.value(count);
     }
-    formattedWithoutCount(count) {
-        return Localization_1.Localization.shared.fineTemplateRepetition.item[this.item].withoutCount.value(count);
+    /**
+     * Returns a localized formatted string without explicitly showing the count.
+     *
+     * @param count - The number of repetitions
+     * @param locale - The locale to use for formatting
+     * @returns Formatted string without count display
+     */
+    formattedWithoutCount(count, locale) {
+        return Localization_1.Localization.shared(locale).fineTemplateRepetition.item[this.item].withoutCount.value(count);
     }
+    /**
+     * Returns the flattened representation for serialization.
+     */
     get flatten() {
         return {
             item: this.item,
@@ -25,25 +53,51 @@ class FineTemplateRepetition {
 }
 exports.FineTemplateRepetition = FineTemplateRepetition;
 (function (FineTemplateRepetition) {
+    const repetitionItems = [
+        'minute',
+        'day',
+        'item',
+        'count'
+    ];
     let Item;
     (function (Item) {
-        Item.all = [
-            'minute',
-            'day',
-            'item',
-            'count'
-        ];
-        function formatted(item) {
-            return Localization_1.Localization.shared.fineTemplateRepetition.item[item].name.value();
+        /**
+         * Array containing all possible repetition item types.
+         */
+        Item.all = repetitionItems;
+        /**
+         * Returns the localized name for a repetition item type.
+         *
+         * @param item - The repetition item type
+         * @param locale - The locale to use for formatting
+         * @returns Localized name string
+         */
+        function formatted(item, locale) {
+            return Localization_1.Localization.shared(locale).fineTemplateRepetition.item[item].name.value();
         }
         Item.formatted = formatted;
+        /**
+         * Type builder for Item serialization/deserialization.
+         */
         Item.builder = new typescript_common_functionality_1.ValueTypeBuilder();
     })(Item = FineTemplateRepetition.Item || (FineTemplateRepetition.Item = {}));
+    /**
+     * Type builder for FineTemplateRepetition serialization/deserialization.
+     */
     class TypeBuilder {
+        /**
+         * Builds a FineTemplateRepetition instance from flattened data.
+         *
+         * @param flatten - Flattened repetition data
+         * @returns FineTemplateRepetition instance
+         */
         build(flatten) {
             return new FineTemplateRepetition(flatten.item, flatten.maxCount);
         }
     }
     FineTemplateRepetition.TypeBuilder = TypeBuilder;
+    /**
+     * Singleton instance of TypeBuilder for FineTemplateRepetition.
+     */
     FineTemplateRepetition.builder = new TypeBuilder();
 })(FineTemplateRepetition || (exports.FineTemplateRepetition = FineTemplateRepetition = {}));

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

@@ -1,25 +1,73 @@
 import { Flattable, ITypeBuilder, Tagged } from '@stevenkellner/typescript-common-functionality';
 import { Team } from './Team';
 import { Person } from './Person';
+/**
+ * Represents an invitation to join a team.
+ *
+ * An invitation can be team-wide (personId is null) or specific to a person.
+ * The invitation ID is generated by hashing the team ID and optional person ID.
+ */
 export declare class Invitation implements Flattable<Invitation.Flatten> {
     teamId: Team.Id;
     personId: Person.Id | null;
+    /**
+     * Creates a new Invitation instance.
+     *
+     * @param teamId - The ID of the team for the invitation
+     * @param personId - Optional person ID for person-specific invitations (null for team-wide invitations)
+     */
     constructor(teamId: Team.Id, personId: Person.Id | null);
+    /**
+     * Creates a unique invitation ID by hashing the team ID and optional person ID.
+     *
+     * Uses SHA-512 hashing and takes the first 12 characters of the hex representation.
+     * Team-wide invitations (personId null) hash only the team ID.
+     * Person-specific invitations hash both team ID and person ID concatenated.
+     *
+     * @returns Tagged invitation ID string (12 hex characters)
+     */
     createId(): Invitation.Id;
+    /**
+     * Returns the flattened representation for serialization.
+     */
     get flatten(): Invitation.Flatten;
 }
 export declare namespace Invitation {
+    /**
+     * Tagged string type for invitation identifiers (12 hex characters).
+     */
     type Id = Tagged<string, 'invitation'>;
     namespace Id {
+        /**
+         * Flattened representation of an invitation ID (string).
+         */
         type Flatten = string;
+        /**
+         * Type builder for Invitation.Id serialization/deserialization.
+         */
         const builder: Tagged.TypeBuilder<string, "invitation">;
     }
+    /**
+     * Flattened representation of an Invitation for serialization.
+     */
     type Flatten = {
         teamId: Team.Id.Flatten;
         personId: Person.Id.Flatten | null;
     };
+    /**
+     * Type builder for Invitation serialization/deserialization.
+     */
     class TypeBuilder implements ITypeBuilder<Flatten, Invitation> {
+        /**
+         * Builds an Invitation instance from flattened data.
+         *
+         * @param value - Flattened invitation data
+         * @returns Invitation instance
+         */
         build(value: Flatten): Invitation;
     }
+    /**
+     * Singleton instance of TypeBuilder for Invitation.
+     */
     const builder: TypeBuilder;
 }

package/lib/src/types/Invitation.js

@@ -4,13 +4,34 @@ exports.Invitation = void 0;
 const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
 const Team_1 = require("./Team");
 const Person_1 = require("./Person");
+/**
+ * Represents an invitation to join a team.
+ *
+ * An invitation can be team-wide (personId is null) or specific to a person.
+ * The invitation ID is generated by hashing the team ID and optional person ID.
+ */
 class Invitation {
     teamId;
     personId;
+    /**
+     * Creates a new Invitation instance.
+     *
+     * @param teamId - The ID of the team for the invitation
+     * @param personId - Optional person ID for person-specific invitations (null for team-wide invitations)
+     */
     constructor(teamId, personId) {
         this.teamId = teamId;
         this.personId = personId;
     }
+    /**
+     * Creates a unique invitation ID by hashing the team ID and optional person ID.
+     *
+     * Uses SHA-512 hashing and takes the first 12 characters of the hex representation.
+     * Team-wide invitations (personId null) hash only the team ID.
+     * Person-specific invitations hash both team ID and person ID concatenated.
+     *
+     * @returns Tagged invitation ID string (12 hex characters)
+     */
     createId() {
         const hasher = new typescript_common_functionality_1.Sha512();
         const teamIdBytes = typescript_common_functionality_1.BytesCoder.fromUtf8(this.teamId.guidString);
@@ -23,6 +44,9 @@ class Invitation {
         const rawId = typescript_common_functionality_1.BytesCoder.toHex(hashedInvitationBytes).slice(0, 12);
         return new typescript_common_functionality_1.Tagged(rawId, 'invitation');
     }
+    /**
+     * Returns the flattened representation for serialization.
+     */
     get flatten() {
         return {
             teamId: this.teamId.flatten,
@@ -34,13 +58,28 @@ exports.Invitation = Invitation;
 (function (Invitation) {
     let Id;
     (function (Id) {
+        /**
+         * Type builder for Invitation.Id serialization/deserialization.
+         */
         Id.builder = typescript_common_functionality_1.Tagged.builder('invitation', new typescript_common_functionality_1.ValueTypeBuilder());
     })(Id = Invitation.Id || (Invitation.Id = {}));
+    /**
+     * Type builder for Invitation serialization/deserialization.
+     */
     class TypeBuilder {
+        /**
+         * Builds an Invitation instance from flattened data.
+         *
+         * @param value - Flattened invitation data
+         * @returns Invitation instance
+         */
         build(value) {
             return new Invitation(Team_1.Team.Id.builder.build(value.teamId), new typescript_common_functionality_1.OptionalTypeBuilder(Person_1.Person.Id.builder).build(value.personId));
         }
     }
     Invitation.TypeBuilder = TypeBuilder;
+    /**
+     * Singleton instance of TypeBuilder for Invitation.
+     */
     Invitation.builder = new TypeBuilder();
 })(Invitation || (exports.Invitation = Invitation = {}));

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

@@ -0,0 +1,16 @@
+import { ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+import { localizations } from './Localization';
+/**
+ * Supported locale types, derived from available localizations.
+ */
+export type Locale = keyof typeof localizations;
+export declare namespace Locale {
+    /**
+     * Array of all available locales.
+     */
+    const all: Locale[];
+    /**
+     * Builder for constructing Locale values.
+     */
+    const builder: ValueTypeBuilder<"en" | "de">;
+}

package/lib/src/types/Locale.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Locale = void 0;
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+const Localization_1 = require("./Localization");
+var Locale;
+(function (Locale) {
+    /**
+     * Array of all available locales.
+     */
+    Locale.all = (0, typescript_common_functionality_1.keys)(Localization_1.localizations);
+    /**
+     * Builder for constructing Locale values.
+     */
+    Locale.builder = new typescript_common_functionality_1.ValueTypeBuilder();
+})(Locale || (exports.Locale = Locale = {}));