@flarehr/superhero-basic-profile 0.1.2215 → 0.1.2217

package/dist/Basic.Profile.Domain/Import/Types.jsx

@@ -0,0 +1,405 @@
+import { Record, Union } from "../../fable_modules/fable-library-js.4.20.0/Types.js";
+import { list_type, option_type, record_type, anonRecord_type, string_type, union_type, int32_type } from "../../fable_modules/fable-library-js.4.20.0/Reflection.js";
+import { max } from "../../fable_modules/fable-library-js.4.20.0/Double.js";
+import { tryFind, cons, map, empty, fold } from "../../fable_modules/fable-library-js.4.20.0/List.js";
+import { tryLast } from "../../fable_modules/fable-library-js.4.20.0/Seq.js";
+import { split } from "../../fable_modules/fable-library-js.4.20.0/String.js";
+import { FSharpChoice$3 } from "../../fable_modules/fable-library-js.4.20.0/Choice.js";
+import { UtcDateTime_$reflection, AccountId_$reflection, PartnerId_$reflection } from "../DomainPrimitives.jsx";
+import { equals } from "../../fable_modules/fable-library-js.4.20.0/Util.js";
+import { FSharpResult$2 } from "../../fable_modules/fable-library-js.4.20.0/Result.js";
+
+export class ImportId extends Union {
+    constructor(Item) {
+        super();
+        this.tag = 0;
+        this.fields = [Item];
+    }
+    cases() {
+        return ["ImportId"];
+    }
+}
+
+export function ImportId_$reflection() {
+    return union_type("Basic.Profile.Domain.Import.Types.ImportId", [], ImportId, () => [[["Item", int32_type]]]);
+}
+
+export function ImportIdModule_init() {
+    return new ImportId(1);
+}
+
+export function ImportIdModule_create(id) {
+    return new ImportId(id);
+}
+
+export function ImportIdModule_value(_arg) {
+    return _arg.fields[0];
+}
+
+export function ImportIdModule_increment(_arg) {
+    return new ImportId(_arg.fields[0] + 1);
+}
+
+export function ImportIdModule_max(_arg, _arg_1) {
+    return new ImportId(max(_arg.fields[0], _arg_1.fields[0]));
+}
+
+export const ImportIdModule_nextOrDefault = (arg) => ImportIdModule_increment(((list) => fold(ImportIdModule_max, new ImportId(0), list))(arg));
+
+export const $007CImportId$007C = ImportIdModule_value;
+
+export class Actor extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["FlareUser", "ApolloImport"];
+    }
+}
+
+export function Actor_$reflection() {
+    return union_type("Basic.Profile.Domain.Import.Types.Actor", [], Actor, () => [[["Item", anonRecord_type(["Email", string_type], ["Id", string_type], ["Name", string_type])]], []]);
+}
+
+export class Origin extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["SuperHero", "InternalApi"];
+    }
+}
+
+export function Origin_$reflection() {
+    return union_type("Basic.Profile.Domain.Import.Types.Origin", [], Origin, () => [[], []]);
+}
+
+export class FileInfo extends Record {
+    constructor(Id, Filename) {
+        super();
+        this.Id = Id;
+        this.Filename = Filename;
+    }
+}
+
+export function FileInfo_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Types.FileInfo", [], FileInfo, () => [["Id", string_type], ["Filename", string_type]]);
+}
+
+export function FileInfoModule_$007CCSV$007CJSON$007CUnknown$007C(fileInfo) {
+    const extensionOption = tryLast(split(fileInfo.Filename, ["."], undefined, 0));
+    if (extensionOption != null) {
+        const extension = extensionOption;
+        const matchValue = extension.toUpperCase();
+        switch (matchValue) {
+            case "CSV":
+                return new FSharpChoice$3(0, [undefined]);
+            case "JSON":
+                return new FSharpChoice$3(1, [undefined]);
+            default:
+                return new FSharpChoice$3(2, [undefined]);
+        }
+    }
+    else {
+        return new FSharpChoice$3(2, [undefined]);
+    }
+}
+
+export class ImportStartedEventPayload extends Record {
+    constructor(Origin, Actor, FileInfo, TotalRowCount) {
+        super();
+        this.Origin = Origin;
+        this.Actor = Actor;
+        this.FileInfo = FileInfo;
+        this.TotalRowCount = (TotalRowCount | 0);
+    }
+}
+
+export function ImportStartedEventPayload_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Types.ImportStartedEventPayload", [], ImportStartedEventPayload, () => [["Origin", Origin_$reflection()], ["Actor", Actor_$reflection()], ["FileInfo", FileInfo_$reflection()], ["TotalRowCount", int32_type]]);
+}
+
+export class RowImportSucceededEventPayload extends Record {
+    constructor(RowId, ProfileId) {
+        super();
+        this.RowId = (RowId | 0);
+        this.ProfileId = ProfileId;
+    }
+}
+
+export function RowImportSucceededEventPayload_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Types.RowImportSucceededEventPayload", [], RowImportSucceededEventPayload, () => [["RowId", int32_type], ["ProfileId", string_type]]);
+}
+
+export class RowImportFailedEventPayload extends Record {
+    constructor(RowId, Reason) {
+        super();
+        this.RowId = (RowId | 0);
+        this.Reason = Reason;
+    }
+}
+
+export function RowImportFailedEventPayload_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Types.RowImportFailedEventPayload", [], RowImportFailedEventPayload, () => [["RowId", int32_type], ["Reason", string_type]]);
+}
+
+export class ImportFailedEventPayload extends Record {
+    constructor(Reason) {
+        super();
+        this.Reason = Reason;
+    }
+}
+
+export function ImportFailedEventPayload_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Types.ImportFailedEventPayload", [], ImportFailedEventPayload, () => [["Reason", string_type]]);
+}
+
+export class ImportEventPayload extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["ImportStarted", "RowImportSucceeded", "RowImportFailed", "ImportComplete"];
+    }
+}
+
+export function ImportEventPayload_$reflection() {
+    return union_type("Basic.Profile.Domain.Import.Types.ImportEventPayload", [], ImportEventPayload, () => [[["Item", ImportStartedEventPayload_$reflection()]], [["Item", RowImportSucceededEventPayload_$reflection()]], [["Item", RowImportFailedEventPayload_$reflection()]], []]);
+}
+
+export class ImportEventDomainMetadata extends Record {
+    constructor(PartnerId, AccountId, ImportId) {
+        super();
+        this.PartnerId = PartnerId;
+        this.AccountId = AccountId;
+        this.ImportId = ImportId;
+    }
+}
+
+export function ImportEventDomainMetadata_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Types.ImportEventDomainMetadata", [], ImportEventDomainMetadata, () => [["PartnerId", PartnerId_$reflection()], ["AccountId", AccountId_$reflection()], ["ImportId", ImportId_$reflection()]]);
+}
+
+export class ActiveImport extends Record {
+    constructor(ImportId, Origin, Actor, FileInfo, NumberOfRecords, CompletedSuccessfully, CompletedFailed, NextRow, StartTime) {
+        super();
+        this.ImportId = ImportId;
+        this.Origin = Origin;
+        this.Actor = Actor;
+        this.FileInfo = FileInfo;
+        this.NumberOfRecords = (NumberOfRecords | 0);
+        this.CompletedSuccessfully = (CompletedSuccessfully | 0);
+        this.CompletedFailed = (CompletedFailed | 0);
+        this.NextRow = NextRow;
+        this.StartTime = StartTime;
+    }
+}
+
+export function ActiveImport_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Types.ActiveImport", [], ActiveImport, () => [["ImportId", ImportId_$reflection()], ["Origin", Origin_$reflection()], ["Actor", Actor_$reflection()], ["FileInfo", FileInfo_$reflection()], ["NumberOfRecords", int32_type], ["CompletedSuccessfully", int32_type], ["CompletedFailed", int32_type], ["NextRow", option_type(int32_type)], ["StartTime", UtcDateTime_$reflection()]]);
+}
+
+export function ActiveImportModule_create(cmd, importId, timestamp) {
+    let activePatternResult;
+    return new ActiveImport(importId, cmd.Origin, cmd.Actor, cmd.FileInfo, cmd.TotalRowCount, 0, 0, (activePatternResult = FileInfoModule_$007CCSV$007CJSON$007CUnknown$007C(cmd.FileInfo), (activePatternResult.tag === 1) ? 0 : ((activePatternResult.tag === 2) ? 0 : 2)), timestamp);
+}
+
+export function ActiveImportModule_importsRemaining(i) {
+    return i.NumberOfRecords - (i.CompletedSuccessfully + i.CompletedFailed);
+}
+
+export class ImportHistory extends Record {
+    constructor(ImportId, Origin, Actor, FileInfo, NumberOfRecords, Succeeded, Failed, StartTime, StopTime) {
+        super();
+        this.ImportId = ImportId;
+        this.Origin = Origin;
+        this.Actor = Actor;
+        this.FileInfo = FileInfo;
+        this.NumberOfRecords = (NumberOfRecords | 0);
+        this.Succeeded = (Succeeded | 0);
+        this.Failed = (Failed | 0);
+        this.StartTime = StartTime;
+        this.StopTime = StopTime;
+    }
+}
+
+export function ImportHistory_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Types.ImportHistory", [], ImportHistory, () => [["ImportId", ImportId_$reflection()], ["Origin", Origin_$reflection()], ["Actor", Actor_$reflection()], ["FileInfo", FileInfo_$reflection()], ["NumberOfRecords", int32_type], ["Succeeded", int32_type], ["Failed", int32_type], ["StartTime", UtcDateTime_$reflection()], ["StopTime", UtcDateTime_$reflection()]]);
+}
+
+export class ImportStatus extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Active", "Complete"];
+    }
+}
+
+export function ImportStatus_$reflection() {
+    return union_type("Basic.Profile.Domain.Import.Types.ImportStatus", [], ImportStatus, () => [[["Item", ActiveImport_$reflection()]], [["Item", ImportHistory_$reflection()]]]);
+}
+
+export class AccountImportsData extends Record {
+    constructor(ActiveImport, ImportHistory) {
+        super();
+        this.ActiveImport = ActiveImport;
+        this.ImportHistory = ImportHistory;
+    }
+}
+
+export function AccountImportsData_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Types.AccountImportsData", [], AccountImportsData, () => [["ActiveImport", option_type(ActiveImport_$reflection())], ["ImportHistory", list_type(ImportHistory_$reflection())]]);
+}
+
+export function AccountImportData_init() {
+    return new AccountImportsData(undefined, empty());
+}
+
+export function AccountImportData_hasActiveImport(account) {
+    return account.ActiveImport != null;
+}
+
+export function AccountImportData_getNextImportId(account) {
+    const matchValue = account.ActiveImport;
+    if (matchValue == null) {
+        return ImportIdModule_nextOrDefault(map((i_1) => i_1.ImportId, account.ImportHistory));
+    }
+    else {
+        return ImportIdModule_increment(matchValue.ImportId);
+    }
+}
+
+export function AccountImportData_getActiveImportId(account) {
+    const input_1 = account.ActiveImport;
+    if (input_1 == null) {
+        return undefined;
+    }
+    else {
+        return input_1.ImportId;
+    }
+}
+
+export function AccountImportData_getActiveImportById(account, importId) {
+    const matchValue = account.ActiveImport;
+    let matchResult, i_1;
+    if (matchValue == null) {
+        matchResult = 1;
+    }
+    else if (equals(matchValue.ImportId, importId)) {
+        matchResult = 0;
+        i_1 = matchValue;
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return i_1;
+        default:
+            return undefined;
+    }
+}
+
+export function AccountImportData_completeActiveImport(timestamp, account, invalidActiveImportIdError, importId) {
+    const matchValue = account.ActiveImport;
+    let matchResult, i_1;
+    if (matchValue == null) {
+        matchResult = 1;
+    }
+    else if (equals(matchValue.ImportId, importId)) {
+        matchResult = 0;
+        i_1 = matchValue;
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new FSharpResult$2(0, [new AccountImportsData(undefined, cons(new ImportHistory(i_1.ImportId, i_1.Origin, i_1.Actor, i_1.FileInfo, i_1.NumberOfRecords, i_1.CompletedSuccessfully, i_1.CompletedFailed, i_1.StartTime, timestamp), account.ImportHistory))]);
+        default:
+            return new FSharpResult$2(1, [invalidActiveImportIdError]);
+    }
+}
+
+export function AccountImportData_tryAddActiveImport(account, activeImportExistsError, import$) {
+    if (account.ActiveImport == null) {
+        return new FSharpResult$2(0, [new AccountImportsData(import$, account.ImportHistory)]);
+    }
+    else {
+        return new FSharpResult$2(1, [activeImportExistsError]);
+    }
+}
+
+export function AccountImportData_tryUpdateActiveImport(account, invalidActiveImportIdError, updatedImport) {
+    const matchValue = account.ActiveImport;
+    let matchResult, current_1, updated_1;
+    if (matchValue == null) {
+        matchResult = 1;
+    }
+    else if (equals(matchValue.ImportId, updatedImport.ImportId)) {
+        matchResult = 0;
+        current_1 = matchValue;
+        updated_1 = updatedImport;
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new FSharpResult$2(0, [new AccountImportsData(updatedImport, account.ImportHistory)]);
+        default:
+            return new FSharpResult$2(1, [invalidActiveImportIdError]);
+    }
+}
+
+export function AccountImportData_tryGetImport(accountImportsData, importId) {
+    const matchValue = accountImportsData.ActiveImport;
+    let matchResult, activeImport_1;
+    if (matchValue != null) {
+        if (equals(matchValue.ImportId, importId)) {
+            matchResult = 0;
+            activeImport_1 = matchValue;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return new ImportStatus(0, [activeImport_1]);
+        default: {
+            const matchValue_1 = tryFind((i) => equals(i.ImportId, importId), accountImportsData.ImportHistory);
+            if (matchValue_1 == null) {
+                return undefined;
+            }
+            else {
+                return new ImportStatus(1, [matchValue_1]);
+            }
+        }
+    }
+}
+
+export class AccountImportsDomainMetadata extends Record {
+    constructor(AccountId, PartnerId) {
+        super();
+        this.AccountId = AccountId;
+        this.PartnerId = PartnerId;
+    }
+}
+
+export function AccountImportsDomainMetadata_$reflection() {
+    return record_type("Basic.Profile.Domain.Import.Types.AccountImportsDomainMetadata", [], AccountImportsDomainMetadata, () => [["AccountId", AccountId_$reflection()], ["PartnerId", PartnerId_$reflection()]]);
+}
+

package/dist/Basic.Profile.Domain/JwtPayload.jsx

@@ -0,0 +1,44 @@
+import { Union } from "../fable_modules/fable-library-js.4.20.0/Types.js";
+import { union_type, class_type, obj_type, string_type } from "../fable_modules/fable-library-js.4.20.0/Reflection.js";
+import { FSharpResult$2 } from "../fable_modules/fable-library-js.4.20.0/Result.js";
+import { item } from "../fable_modules/fable-library-js.4.20.0/Array.js";
+import { split } from "../fable_modules/fable-library-js.4.20.0/String.js";
+import { get_UTF8 } from "../fable_modules/fable-library-js.4.20.0/Encoding.js";
+
+export class JwtPayload extends Union {
+    constructor(Item) {
+        super();
+        this.tag = 0;
+        this.fields = [Item];
+    }
+    cases() {
+        return ["JwtPayload"];
+    }
+}
+
+export function JwtPayload_$reflection() {
+    return union_type("Basic.Profile.Domain.JwtPayload", [], JwtPayload, () => [[["Item", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, obj_type])]]]);
+}
+
+function JwtPayloadModule_fromJson(str) {
+    return FSharp_Json_Json_deserializeEx(FSharp_Json_JsonConfig_create_Z5CD7C433(undefined, undefined, undefined, FSharp_Json_Json_lowerCamelCase, true), str);
+}
+
+export function JwtPayloadModule_fromToken(token) {
+    let bytes, objectArg;
+    try {
+        return new FSharpResult$2(0, [new JwtPayload(JwtPayloadModule_fromJson((bytes = Microsoft_AspNetCore_WebUtilities_WebEncoders_Base64UrlDecode_Z721C83C5(item(1, split(token, ["."], undefined, 0))), (objectArg = get_UTF8(), objectArg.getString(bytes)))))]);
+    }
+    catch (matchValue) {
+        return new FSharpResult$2(1, ["Invalid token"]);
+    }
+}
+
+export function JwtPayloadModule_value(_arg) {
+    return _arg.fields[0];
+}
+
+export function JwtPayloadModule_create(claims) {
+    return new JwtPayload(claims);
+}
+

package/dist/Basic.Profile.Domain/Metadata.jsx

@@ -0,0 +1,257 @@
+import { Record, Union } from "../fable_modules/fable-library-js.4.20.0/Types.js";
+import { option_type, anonRecord_type, record_type, class_type, int32_type, union_type, string_type } from "../fable_modules/fable-library-js.4.20.0/Reflection.js";
+import { newGuid } from "../fable_modules/fable-library-js.4.20.0/Guid.js";
+import { printf, toText } from "../fable_modules/fable-library-js.4.20.0/String.js";
+import { PartnerId_$reflection, AccountId_$reflection, Email_$reflection, ProfileId_$reflection } from "./DomainPrimitives.jsx";
+
+export function incrementVersion(delta, version) {
+    return (version + delta) + 1;
+}
+
+export class AppVersion extends Union {
+    constructor(Item) {
+        super();
+        this.tag = 0;
+        this.fields = [Item];
+    }
+    cases() {
+        return ["AppVersion"];
+    }
+}
+
+export function AppVersion_$reflection() {
+    return union_type("MetadataTypes.AppVersion", [], AppVersion, () => [[["Item", string_type]]]);
+}
+
+export function AppVersionModule_value(_arg) {
+    return _arg.fields[0];
+}
+
+export class StreamId extends Union {
+    constructor(Item) {
+        super();
+        this.tag = 0;
+        this.fields = [Item];
+    }
+    cases() {
+        return ["StreamId"];
+    }
+}
+
+export function StreamId_$reflection() {
+    return union_type("MetadataTypes.StreamId", [], StreamId, () => [[["Item", string_type]]]);
+}
+
+export function StreamIdModule_create() {
+    let arg, copyOfStruct;
+    return new StreamId((arg = ((copyOfStruct = newGuid(), copyOfStruct)).toLocaleUpperCase(), toText(printf("AP-%s"))(arg)));
+}
+
+export function StreamIdModule_value(_arg) {
+    return _arg.fields[0];
+}
+
+export class Metadata extends Record {
+    constructor(StreamId, Version, Timestamp) {
+        super();
+        this.StreamId = StreamId;
+        this.Version = (Version | 0);
+        this.Timestamp = Timestamp;
+    }
+}
+
+export function Metadata_$reflection() {
+    return record_type("MetadataTypes.Metadata", [], Metadata, () => [["StreamId", StreamId_$reflection()], ["Version", int32_type], ["Timestamp", class_type("System.DateTime")]]);
+}
+
+export class AdminName extends Union {
+    constructor(Item) {
+        super();
+        this.tag = 0;
+        this.fields = [Item];
+    }
+    cases() {
+        return ["AdminName"];
+    }
+}
+
+export function AdminName_$reflection() {
+    return union_type("MetadataTypes.AdminName", [], AdminName, () => [[["Item", string_type]]]);
+}
+
+export function AdminNameModule_value(_arg) {
+    return _arg.fields[0];
+}
+
+export class InternalOperationType extends Union {
+    constructor() {
+        super();
+        this.tag = 0;
+        this.fields = [];
+    }
+    cases() {
+        return ["MessageQueue"];
+    }
+}
+
+export function InternalOperationType_$reflection() {
+    return union_type("MetadataTypes.InternalOperationType", [], InternalOperationType, () => [[]]);
+}
+
+export class AdminOperationType extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Direct", "Bulk"];
+    }
+}
+
+export function AdminOperationType_$reflection() {
+    return union_type("MetadataTypes.AdminOperationType", [], AdminOperationType, () => [[], []]);
+}
+
+export class SelfOperationType extends Union {
+    constructor() {
+        super();
+        this.tag = 0;
+        this.fields = [];
+    }
+    cases() {
+        return ["Workflow"];
+    }
+}
+
+export function SelfOperationType_$reflection() {
+    return union_type("MetadataTypes.SelfOperationType", [], SelfOperationType, () => [[]]);
+}
+
+export class Source extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["ExternalApi", "InternalApi", "Self", "FlareAdmin", "SuperheroAdmin", "InternalOperation"];
+    }
+}
+
+export function Source_$reflection() {
+    return union_type("MetadataTypes.Source", [], Source, () => [[], [], [["Item", SelfOperationType_$reflection()]], [["Item", anonRecord_type(["Operation", AdminOperationType_$reflection()], ["ProfileId", ProfileId_$reflection()])]], [["Item", anonRecord_type(["AdminName", AdminName_$reflection()], ["Email", Email_$reflection()])]], [["Item", InternalOperationType_$reflection()]]]);
+}
+
+export class DomainMetadata extends Record {
+    constructor(AccountId, PartnerId, Source) {
+        super();
+        this.AccountId = AccountId;
+        this.PartnerId = PartnerId;
+        this.Source = Source;
+    }
+}
+
+export function DomainMetadata_$reflection() {
+    return record_type("MetadataTypes.DomainMetadata", [], DomainMetadata, () => [["AccountId", AccountId_$reflection()], ["PartnerId", PartnerId_$reflection()], ["Source", Source_$reflection()]]);
+}
+
+export function DomainMetadataModule_forFlareAdmin(actorProfileId, accountId, partnerId, operationType) {
+    return new DomainMetadata(accountId, partnerId, new Source(3, [{
+        Operation: operationType,
+        ProfileId: actorProfileId,
+    }]));
+}
+
+export function DomainMetadataModule_forExternalApi(accountId, partnerId) {
+    return new DomainMetadata(accountId, partnerId, new Source(0, []));
+}
+
+export function DomainMetadataModule_forSelf(accountId, partnerId) {
+    return new DomainMetadata(accountId, partnerId, new Source(2, [new SelfOperationType()]));
+}
+
+export function DomainMetadataModule_forInternalMessageQueue(accountId, partnerId) {
+    return new DomainMetadata(accountId, partnerId, new Source(5, [new InternalOperationType()]));
+}
+
+export class ProfileEventMetadata extends Record {
+    constructor(StreamId, Version, Timestamp, Domain) {
+        super();
+        this.StreamId = StreamId;
+        this.Version = (Version | 0);
+        this.Timestamp = Timestamp;
+        this.Domain = Domain;
+    }
+}
+
+export function ProfileEventMetadata_$reflection() {
+    return record_type("MetadataTypes.ProfileEventMetadata", [], ProfileEventMetadata, () => [["StreamId", StreamId_$reflection()], ["Version", int32_type], ["Timestamp", class_type("System.DateTime")], ["Domain", option_type(DomainMetadata_$reflection())]]);
+}
+
+export function ProfileEventMetadataModule_create(streamId, version, timestamp) {
+    return new ProfileEventMetadata(streamId, version, timestamp, undefined);
+}
+
+export function ProfileEventMetadataModule_incrementVersion(delta, m) {
+    return new ProfileEventMetadata(m.StreamId, incrementVersion(delta, m.Version), m.Timestamp, m.Domain);
+}
+
+export function ProfileEventMetadataModule_toAggregateMetaData(eventMetadata) {
+    return new Metadata(eventMetadata.StreamId, eventMetadata.Version, eventMetadata.Timestamp);
+}
+
+export class ProfileCommandMetadata extends Record {
+    constructor(StreamId, Version, Timestamp, Domain) {
+        super();
+        this.StreamId = StreamId;
+        this.Version = (Version | 0);
+        this.Timestamp = Timestamp;
+        this.Domain = Domain;
+    }
+}
+
+export function ProfileCommandMetadata_$reflection() {
+    return record_type("MetadataTypes.ProfileCommandMetadata", [], ProfileCommandMetadata, () => [["StreamId", StreamId_$reflection()], ["Version", int32_type], ["Timestamp", class_type("System.DateTime")], ["Domain", option_type(DomainMetadata_$reflection())]]);
+}
+
+export function CommandMetadata_create(streamId, version, timestamp, domainData) {
+    return new ProfileCommandMetadata(streamId, version, timestamp, domainData);
+}
+
+export function CommandMetadata_createNew(timestamp, domainData) {
+    return CommandMetadata_create(StreamIdModule_create(), 0, timestamp, domainData);
+}
+
+export function CommandMetadata_incrementVersion(delta, m) {
+    return new ProfileCommandMetadata(m.StreamId, incrementVersion(delta, m.Version), m.Timestamp, m.Domain);
+}
+
+export function CommandMetadata_withTimestamp(timestamp, metadata) {
+    return new ProfileCommandMetadata(metadata.StreamId, metadata.Version, timestamp, metadata.Domain);
+}
+
+export function CommandMetadata_toEventMetadata(metadata) {
+    return new ProfileEventMetadata(metadata.StreamId, metadata.Version, metadata.Timestamp, metadata.Domain);
+}
+
+export function MetadataModule_create(streamId, version, timestamp) {
+    return new Metadata(streamId, version, timestamp);
+}
+
+export function MetadataModule_createNew(timestamp) {
+    return MetadataModule_create(StreamIdModule_create(), 0, timestamp);
+}
+
+export function MetadataModule_incrementVersion(delta, m) {
+    return new Metadata(m.StreamId, incrementVersion(delta, m.Version), m.Timestamp);
+}
+
+export function MetadataModule_withTimestamp(timestamp, metadata) {
+    return new Metadata(metadata.StreamId, metadata.Version, timestamp);
+}
+
+export function MetadataModule_toCommandMetadata(metadata, domainMetadata) {
+    return new ProfileCommandMetadata(metadata.StreamId, metadata.Version, metadata.Timestamp, domainMetadata);
+}
+