@stevenkellner/team-conduct-api 1.0.4 → 1.0.5

package/lib/src/types/Invitation.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Invitation = void 0;
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+const Team_1 = require("./Team");
+const Person_1 = require("./Person");
+class Invitation {
+    teamId;
+    personId;
+    constructor(teamId, personId) {
+        this.teamId = teamId;
+        this.personId = personId;
+    }
+    createId() {
+        const hasher = new typescript_common_functionality_1.Sha512();
+        const teamIdBytes = typescript_common_functionality_1.BytesCoder.fromUtf8(this.teamId.guidString);
+        const personIdBytes = typescript_common_functionality_1.BytesCoder.fromUtf8(this.personId.guidString);
+        const hashedInvitationBytes = hasher.hash(new Uint8Array([...teamIdBytes, ...personIdBytes]));
+        const rawId = typescript_common_functionality_1.BytesCoder.toHex(hashedInvitationBytes).slice(0, 12);
+        return new typescript_common_functionality_1.Tagged(rawId, 'invitation');
+    }
+    get flatten() {
+        return {
+            teamId: this.teamId.flatten,
+            personId: this.personId.flatten
+        };
+    }
+}
+exports.Invitation = Invitation;
+(function (Invitation) {
+    let Id;
+    (function (Id) {
+        Id.builder = typescript_common_functionality_1.Tagged.builder('invitation', new typescript_common_functionality_1.ValueTypeBuilder());
+    })(Id = Invitation.Id || (Invitation.Id = {}));
+    class TypeBuilder {
+        build(value) {
+            return new Invitation(Team_1.Team.Id.builder.build(value.teamId), Person_1.Person.Id.builder.build(value.personId));
+        }
+    }
+    Invitation.TypeBuilder = TypeBuilder;
+    Invitation.builder = new TypeBuilder();
+})(Invitation || (exports.Invitation = Invitation = {}));

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

@@ -0,0 +1,17 @@
+import { Flattable, ITypeBuilder } from '@stevenkellner/typescript-common-functionality';
+import { Configuration } from './Configuration';
+export declare class MoneyAmount implements Flattable<MoneyAmount.Flatten> {
+    value: number;
+    subunitValue: number;
+    constructor(value: number, subunitValue: number);
+    static zero(): MoneyAmount;
+    formatted(currency: Configuration.Currency): string;
+    get flatten(): MoneyAmount.Flatten;
+}
+export declare namespace MoneyAmount {
+    type Flatten = number;
+    class TypeBuilder implements ITypeBuilder<Flatten, MoneyAmount> {
+        build(value: Flatten): MoneyAmount;
+    }
+    const builder: TypeBuilder;
+}

package/lib/src/types/MoneyAmount.js

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoneyAmount = void 0;
+const i18n = __importStar(require("i18n"));
+class MoneyAmount {
+    value;
+    subunitValue;
+    constructor(value, subunitValue) {
+        this.value = value;
+        this.subunitValue = subunitValue;
+    }
+    static zero() {
+        return new MoneyAmount(0, 0);
+    }
+    formatted(currency) {
+        const numberFormat = Intl.NumberFormat(i18n.getLocale(), {
+            style: 'currency',
+            currency: currency
+        });
+        return numberFormat.format(this.value + this.subunitValue / 100);
+    }
+    get flatten() {
+        return this.value + this.subunitValue / 100;
+    }
+}
+exports.MoneyAmount = MoneyAmount;
+(function (MoneyAmount) {
+    class TypeBuilder {
+        build(value) {
+            return new MoneyAmount(Math.floor(value), Math.round((value - Math.floor(value)) * 100));
+        }
+    }
+    MoneyAmount.TypeBuilder = TypeBuilder;
+    MoneyAmount.builder = new MoneyAmount.TypeBuilder();
+})(MoneyAmount || (exports.MoneyAmount = MoneyAmount = {}));

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

@@ -0,0 +1,28 @@
+import { Dictionary, Flattable, ITypeBuilder, Tagged, ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+export declare class NotificationProperties implements Flattable<NotificationProperties.Flatten> {
+    tokens: Dictionary<NotificationProperties.TokenId, string>;
+    subscriptions: NotificationProperties.Subscription[];
+    constructor(tokens?: Dictionary<NotificationProperties.TokenId, string>, subscriptions?: NotificationProperties.Subscription[]);
+    get flatten(): NotificationProperties.Flatten;
+}
+export declare namespace NotificationProperties {
+    type TokenId = Tagged<string, 'notificationToken'>;
+    namespace TokenId {
+        function create(token: string): TokenId;
+        type Flatten = string;
+        const builder: Tagged.TypeBuilder<string, "notificationToken">;
+    }
+    type Subscription = 'new-fine' | 'fine-reminder' | 'fine-state-change';
+    namespace Subscription {
+        const all: Subscription[];
+        const builder: ValueTypeBuilder<Subscription>;
+    }
+    type Flatten = {
+        tokens: Dictionary.Flatten<string>;
+        subscriptions: Subscription[];
+    };
+    class TypeBuilder implements ITypeBuilder<Flatten, NotificationProperties> {
+        build(value: Flatten): NotificationProperties;
+    }
+    const builder: TypeBuilder;
+}

package/lib/src/types/NotificationProperties.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationProperties = void 0;
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+class NotificationProperties {
+    tokens;
+    subscriptions;
+    constructor(tokens = new typescript_common_functionality_1.Dictionary(NotificationProperties.TokenId.builder), subscriptions = []) {
+        this.tokens = tokens;
+        this.subscriptions = subscriptions;
+    }
+    get flatten() {
+        return {
+            tokens: this.tokens.flatten,
+            subscriptions: this.subscriptions
+        };
+    }
+}
+exports.NotificationProperties = NotificationProperties;
+(function (NotificationProperties) {
+    let TokenId;
+    (function (TokenId) {
+        function create(token) {
+            const hasher = new typescript_common_functionality_1.Sha512();
+            const tokenBytes = typescript_common_functionality_1.BytesCoder.fromUtf8(token);
+            const tokenIdBytes = hasher.hash(tokenBytes);
+            const tokenId = typescript_common_functionality_1.BytesCoder.toHex(tokenIdBytes);
+            const rawId = tokenId.slice(0, 16);
+            return new typescript_common_functionality_1.Tagged(rawId, 'notificationToken');
+        }
+        TokenId.create = create;
+        TokenId.builder = typescript_common_functionality_1.Tagged.builder('notificationToken', new typescript_common_functionality_1.ValueTypeBuilder());
+    })(TokenId = NotificationProperties.TokenId || (NotificationProperties.TokenId = {}));
+    let Subscription;
+    (function (Subscription) {
+        Subscription.all = [
+            'new-fine',
+            'fine-reminder',
+            'fine-state-change'
+        ];
+        Subscription.builder = new typescript_common_functionality_1.ValueTypeBuilder();
+    })(Subscription = NotificationProperties.Subscription || (NotificationProperties.Subscription = {}));
+    class TypeBuilder {
+        build(value) {
+            return new NotificationProperties(typescript_common_functionality_1.Dictionary.builder(TokenId.builder, new typescript_common_functionality_1.ValueTypeBuilder()).build(value.tokens), value.subscriptions);
+        }
+    }
+    NotificationProperties.TypeBuilder = TypeBuilder;
+    NotificationProperties.builder = new TypeBuilder();
+})(NotificationProperties || (exports.NotificationProperties = NotificationProperties = {}));

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

@@ -0,0 +1,6 @@
+import { ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+export type PayedState = 'payed' | 'notPayed';
+export declare namespace PayedState {
+    const all: PayedState[];
+    const builder: ValueTypeBuilder<PayedState>;
+}

package/lib/src/types/PayedState.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PayedState = void 0;
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+var PayedState;
+(function (PayedState) {
+    PayedState.all = ['payed', 'notPayed'];
+    PayedState.builder = new typescript_common_functionality_1.ValueTypeBuilder();
+})(PayedState || (exports.PayedState = PayedState = {}));

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

@@ -0,0 +1,29 @@
+import { PersonPrivateProperties } from './PersonPrivateProperties';
+import { PersonSignInProperties } from './PersonSignInProperties';
+import { Fine } from './Fine';
+import { Flattable, Guid, ITypeBuilder, Tagged } from '@stevenkellner/typescript-common-functionality';
+export declare class Person implements Flattable<Person.Flatten> {
+    id: Person.Id;
+    properties: PersonPrivateProperties;
+    fineIds: Fine.Id[];
+    signInProperties: PersonSignInProperties | null;
+    constructor(id: Person.Id, properties: PersonPrivateProperties, fineIds?: Fine.Id[], signInProperties?: PersonSignInProperties | null);
+    get flatten(): Person.Flatten;
+}
+export declare namespace Person {
+    type Id = Tagged<Guid, 'person'>;
+    namespace Id {
+        type Flatten = string;
+        const builder: Tagged.TypeBuilder<Guid, "person">;
+    }
+    type Flatten = {
+        id: Id.Flatten;
+        properties: PersonPrivateProperties.Flatten;
+        fineIds: Fine.Id.Flatten[];
+        signInProperties: PersonSignInProperties.Flatten | null;
+    };
+    class TypeBuilder implements ITypeBuilder<Flatten, Person> {
+        build(value: Flatten): Person;
+    }
+    const builder: TypeBuilder;
+}

package/lib/src/types/Person.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Person = void 0;
+const PersonPrivateProperties_1 = require("./PersonPrivateProperties");
+const PersonSignInProperties_1 = require("./PersonSignInProperties");
+const Fine_1 = require("./Fine");
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+class Person {
+    id;
+    properties;
+    fineIds;
+    signInProperties;
+    constructor(id, properties, fineIds = [], signInProperties = null) {
+        this.id = id;
+        this.properties = properties;
+        this.fineIds = fineIds;
+        this.signInProperties = signInProperties;
+    }
+    get flatten() {
+        return {
+            id: this.id.flatten,
+            properties: this.properties.flatten,
+            fineIds: this.fineIds.map(fineId => fineId.flatten),
+            signInProperties: this.signInProperties?.flatten ?? null
+        };
+    }
+}
+exports.Person = Person;
+(function (Person) {
+    let Id;
+    (function (Id) {
+        Id.builder = typescript_common_functionality_1.Tagged.builder('person', typescript_common_functionality_1.Guid.builder);
+    })(Id = Person.Id || (Person.Id = {}));
+    class TypeBuilder {
+        build(value) {
+            return new Person(Id.builder.build(value.id), PersonPrivateProperties_1.PersonPrivateProperties.builder.build(value.properties), value.fineIds.map(fineId => Fine_1.Fine.Id.builder.build(fineId)), value.signInProperties ? PersonSignInProperties_1.PersonSignInProperties.builder.build(value.signInProperties) : null);
+        }
+    }
+    Person.TypeBuilder = TypeBuilder;
+    Person.builder = new TypeBuilder();
+})(Person || (exports.Person = Person = {}));

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

@@ -0,0 +1,17 @@
+import { Flattable, ITypeBuilder } from '@stevenkellner/typescript-common-functionality';
+export declare class PersonPrivateProperties implements Flattable<PersonPrivateProperties.Flatten> {
+    firstName: string;
+    lastName: string | null;
+    constructor(firstName: string, lastName: string | null);
+    get flatten(): PersonPrivateProperties.Flatten;
+}
+export declare namespace PersonPrivateProperties {
+    type Flatten = {
+        firstName: string;
+        lastName: string | null;
+    };
+    class TypeBuilder implements ITypeBuilder<Flatten, PersonPrivateProperties> {
+        build(value: Flatten): PersonPrivateProperties;
+    }
+    const builder: TypeBuilder;
+}

package/lib/src/types/PersonPrivateProperties.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersonPrivateProperties = void 0;
+class PersonPrivateProperties {
+    firstName;
+    lastName;
+    constructor(firstName, lastName) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+    get flatten() {
+        return {
+            firstName: this.firstName,
+            lastName: this.lastName
+        };
+    }
+}
+exports.PersonPrivateProperties = PersonPrivateProperties;
+(function (PersonPrivateProperties) {
+    class TypeBuilder {
+        build(value) {
+            return new PersonPrivateProperties(value.firstName, value.lastName);
+        }
+    }
+    PersonPrivateProperties.TypeBuilder = TypeBuilder;
+    PersonPrivateProperties.builder = new TypeBuilder();
+})(PersonPrivateProperties || (exports.PersonPrivateProperties = PersonPrivateProperties = {}));

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

@@ -0,0 +1,24 @@
+import { Flattable, ITypeBuilder, UtcDate } from '@stevenkellner/typescript-common-functionality';
+import { NotificationProperties } from './NotificationProperties';
+import { User } from './User';
+import { UserRole } from './UserRole';
+export declare class PersonSignInProperties implements Flattable<PersonSignInProperties.Flatten> {
+    userId: User.Id;
+    signInDate: UtcDate;
+    notificationProperties: NotificationProperties;
+    roles: UserRole[];
+    constructor(userId: User.Id, signInDate: UtcDate, notificationProperties?: NotificationProperties, roles?: UserRole[]);
+    get flatten(): PersonSignInProperties.Flatten;
+}
+export declare namespace PersonSignInProperties {
+    type Flatten = {
+        userId: User.Id.Flatten;
+        signInDate: UtcDate.Flatten;
+        notificationProperties: NotificationProperties.Flatten;
+        roles: UserRole[];
+    };
+    class TypeBuilder implements ITypeBuilder<Flatten, PersonSignInProperties> {
+        build(value: Flatten): PersonSignInProperties;
+    }
+    const builder: TypeBuilder;
+}

package/lib/src/types/PersonSignInProperties.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersonSignInProperties = void 0;
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+const NotificationProperties_1 = require("./NotificationProperties");
+const User_1 = require("./User");
+class PersonSignInProperties {
+    userId;
+    signInDate;
+    notificationProperties;
+    roles;
+    constructor(userId, signInDate, notificationProperties = new NotificationProperties_1.NotificationProperties(), roles = []) {
+        this.userId = userId;
+        this.signInDate = signInDate;
+        this.notificationProperties = notificationProperties;
+        this.roles = roles;
+    }
+    get flatten() {
+        return {
+            userId: this.userId.flatten,
+            signInDate: this.signInDate.flatten,
+            notificationProperties: this.notificationProperties.flatten,
+            roles: this.roles
+        };
+    }
+}
+exports.PersonSignInProperties = PersonSignInProperties;
+(function (PersonSignInProperties) {
+    class TypeBuilder {
+        build(value) {
+            return new PersonSignInProperties(User_1.User.Id.builder.build(value.userId), typescript_common_functionality_1.UtcDate.builder.build(value.signInDate), NotificationProperties_1.NotificationProperties.builder.build(value.notificationProperties), value.roles);
+        }
+    }
+    PersonSignInProperties.TypeBuilder = TypeBuilder;
+    PersonSignInProperties.builder = new TypeBuilder();
+})(PersonSignInProperties || (exports.PersonSignInProperties = PersonSignInProperties = {}));

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

@@ -0,0 +1,24 @@
+import { Flattable, Guid, ITypeBuilder, Tagged } from '@stevenkellner/typescript-common-functionality';
+export declare class Team implements Flattable<Team.Flatten> {
+    id: Team.Id;
+    name: string;
+    paypalMeLink: string | null;
+    constructor(id: Team.Id, name: string, paypalMeLink: string | null);
+    get flatten(): Team.Flatten;
+}
+export declare namespace Team {
+    type Id = Tagged<Guid, 'team'>;
+    namespace Id {
+        type Flatten = string;
+        const builder: Tagged.TypeBuilder<Guid, "team">;
+    }
+    type Flatten = {
+        id: Id.Flatten;
+        name: string;
+        paypalMeLink: string | null;
+    };
+    class TypeBuilder implements ITypeBuilder<Flatten, Team> {
+        build(value: Flatten): Team;
+    }
+    const builder: TypeBuilder;
+}

package/lib/src/types/Team.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Team = void 0;
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+class Team {
+    id;
+    name;
+    paypalMeLink;
+    constructor(id, name, paypalMeLink) {
+        this.id = id;
+        this.name = name;
+        this.paypalMeLink = paypalMeLink;
+    }
+    get flatten() {
+        return {
+            id: this.id.flatten,
+            name: this.name,
+            paypalMeLink: this.paypalMeLink
+        };
+    }
+}
+exports.Team = Team;
+(function (Team) {
+    let Id;
+    (function (Id) {
+        Id.builder = typescript_common_functionality_1.Tagged.builder('team', typescript_common_functionality_1.Guid.builder);
+    })(Id = Team.Id || (Team.Id = {}));
+    class TypeBuilder {
+        build(value) {
+            return new Team(Id.builder.build(value.id), value.name, value.paypalMeLink);
+        }
+    }
+    Team.TypeBuilder = TypeBuilder;
+    Team.builder = new TypeBuilder();
+})(Team || (exports.Team = Team = {}));

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

@@ -0,0 +1,40 @@
+import { Dictionary, Flattable, ITypeBuilder, Tagged } from '@stevenkellner/typescript-common-functionality';
+import { Team } from './Team';
+import { Person } from './Person';
+export declare class User implements Flattable<User.Flatten> {
+    id: User.Id;
+    teams: Dictionary<Team.Id, User.TeamProperties>;
+    constructor(id: User.Id, teams?: Dictionary<Team.Id, User.TeamProperties>);
+    get flatten(): User.Flatten;
+}
+export declare namespace User {
+    type Id = Tagged<string, 'user'>;
+    namespace Id {
+        type Flatten = string;
+        const builder: Tagged.TypeBuilder<string, "user">;
+    }
+    class TeamProperties implements Flattable<TeamProperties.Flatten> {
+        name: string;
+        personId: Person.Id;
+        constructor(name: string, personId: Person.Id);
+        get flatten(): TeamProperties.Flatten;
+    }
+    namespace TeamProperties {
+        type Flatten = {
+            name: string;
+            personId: Person.Id.Flatten;
+        };
+        class TypeBuilder implements ITypeBuilder<Flatten, TeamProperties> {
+            build(value: Flatten): TeamProperties;
+        }
+        const builder: TypeBuilder;
+    }
+    type Flatten = {
+        id: Id.Flatten;
+        teams: Dictionary.Flatten<TeamProperties>;
+    };
+    class TypeBuilder implements ITypeBuilder<Flatten, User> {
+        build(value: Flatten): User;
+    }
+    const builder: TypeBuilder;
+}

package/lib/src/types/User.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+const Team_1 = require("./Team");
+const Person_1 = require("./Person");
+class User {
+    id;
+    teams;
+    constructor(id, teams = new typescript_common_functionality_1.Dictionary(Team_1.Team.Id.builder)) {
+        this.id = id;
+        this.teams = teams;
+    }
+    get flatten() {
+        return {
+            id: this.id.flatten,
+            teams: this.teams.flatten
+        };
+    }
+}
+exports.User = User;
+(function (User) {
+    let Id;
+    (function (Id) {
+        Id.builder = typescript_common_functionality_1.Tagged.builder('user', new typescript_common_functionality_1.ValueTypeBuilder());
+    })(Id = User.Id || (User.Id = {}));
+    class TeamProperties {
+        name;
+        personId;
+        constructor(name, personId) {
+            this.name = name;
+            this.personId = personId;
+        }
+        get flatten() {
+            return {
+                name: this.name,
+                personId: this.personId.flatten
+            };
+        }
+    }
+    User.TeamProperties = TeamProperties;
+    (function (TeamProperties) {
+        class TypeBuilder {
+            build(value) {
+                return new TeamProperties(value.name, Person_1.Person.Id.builder.build(value.personId));
+            }
+        }
+        TeamProperties.TypeBuilder = TypeBuilder;
+        TeamProperties.builder = new TypeBuilder();
+    })(TeamProperties = User.TeamProperties || (User.TeamProperties = {}));
+    class TypeBuilder {
+        build(value) {
+            return new User(Id.builder.build(value.id), typescript_common_functionality_1.Dictionary.builder(Team_1.Team.Id.builder, User.TeamProperties.builder).build(value.teams));
+        }
+    }
+    User.TypeBuilder = TypeBuilder;
+    User.builder = new TypeBuilder();
+})(User || (exports.User = User = {}));

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

@@ -0,0 +1,6 @@
+import { ValueTypeBuilder } from '@stevenkellner/typescript-common-functionality';
+export type UserRole = 'person-manager' | 'fineTemplate-manager' | 'fine-manager' | 'team-manager';
+export declare namespace UserRole {
+    const all: UserRole[];
+    const builder: ValueTypeBuilder<UserRole>;
+}

package/lib/src/types/UserRole.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserRole = void 0;
+const typescript_common_functionality_1 = require("@stevenkellner/typescript-common-functionality");
+var UserRole;
+(function (UserRole) {
+    UserRole.all = [
+        'person-manager',
+        'fineTemplate-manager',
+        'fine-manager',
+        'team-manager'
+    ];
+    UserRole.builder = new typescript_common_functionality_1.ValueTypeBuilder();
+})(UserRole || (exports.UserRole = UserRole = {}));

package/lib/src/types/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Configuration"), exports);
+__exportStar(require("./Fine"), exports);
+__exportStar(require("./FineAmount"), exports);
+__exportStar(require("./FineTemplate"), exports);
+__exportStar(require("./FineTemplateRepetition"), exports);
+__exportStar(require("./Invitation"), exports);
+__exportStar(require("./MoneyAmount"), exports);
+__exportStar(require("./NotificationProperties"), exports);
+__exportStar(require("./PayedState"), exports);
+__exportStar(require("./Person"), exports);
+__exportStar(require("./PersonPrivateProperties"), exports);
+__exportStar(require("./PersonSignInProperties"), exports);
+__exportStar(require("./Team"), exports);
+__exportStar(require("./User"), exports);
+__exportStar(require("./UserRole"), exports);

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../index.ts","../src/Firestore.ts","../src/FirestoreScheme.ts","../src/checkAuthentication.ts","../src/firebaseFunctionCreators.ts","../src/pushNotification.ts","../src/firebase/FirebaseConfiguration.ts","../src/firebase/Messaging.ts","../src/firebase/index.ts","../src/functions/fine/add.ts","../src/functions/fine/delete.ts","../src/functions/fine/update.ts","../src/functions/fineTemplate/add.ts","../src/functions/fineTemplate/delete.ts","../src/functions/fineTemplate/update.ts","../src/functions/invitation/invite.ts","../src/functions/invitation/register.ts","../src/functions/invitation/withdraw.ts","../src/functions/notification/register.ts","../src/functions/notification/subscribe.ts","../src/functions/paypalMe/edit.ts","../src/functions/person/add.ts","../src/functions/person/delete.ts","../src/functions/person/update.ts","../src/functions/team/new.ts","../src/functions/user/login.ts","../src/functions/user/roleEdit.ts","../src/types/Configuration.ts","../src/types/Fine.ts","../src/types/FineAmount.ts","../src/types/FineTemplate.ts","../src/types/FineTemplateRepetition.ts","../src/types/Invitation.ts","../src/types/MoneyAmount.ts","../src/types/NotificationProperties.ts","../src/types/PayedState.ts","../src/types/Person.ts","../src/types/PersonPrivateProperties.ts","../src/types/PersonSignInProperties.ts","../src/types/Team.ts","../src/types/User.ts","../src/types/UserRole.ts","../src/types/index.ts"],"version":"5.8.3"}

package/package.json

@@ -1,11 +1,14 @@
 {
     "name": "@stevenkellner/team-conduct-api",
-    "version": "1.0.4",
+    "version": "1.0.5",
     "description": "Firebase API for Team Conduct",
     "license": "MIT",
     "author": "Steven Kellner",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",
+    "files": [
+        "lib/**/*"
+    ],
     "scripts": {
         "build": "tsc",
         "rebuild": "tsc --build --force",