@flarehr/superhero-basic-profile 0.1.2217 → 0.1.2219

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

@@ -1,475 +0,0 @@
-import { Union, Record } from "../../fable_modules/fable-library-js.4.20.0/Types.js";
-import { list_type, union_type, anonRecord_type, class_type, int32_type, record_type, option_type, string_type } from "../../fable_modules/fable-library-js.4.20.0/Reflection.js";
-import { AppVersionModule_value, StreamId, StreamIdModule_value } from "../Metadata.jsx";
-import { PartnerId, AccountId as AccountId_1, PartnerIdModule_value, AccountIdModule_value, UtcDateTimeModule_create, UtcDateTimeModule_value } from "../DomainPrimitives.jsx";
-import { CorrelationIdModule_value, CausationIdModule_value, EventIdModule_value, Aggregate$2, AggregateMetadata$1 } from "./CommonTypes.jsx";
-import { ImportEventDomainMetadata, AccountImportsDomainMetadata, AccountImportsData, ImportHistory, ActiveImport, ImportIdModule_create, ImportIdModule_value, FileInfo, Origin, Actor } from "./Types.jsx";
-import { map } from "../../fable_modules/fable-library-js.4.20.0/Option.js";
-import { map as map_1 } from "../../fable_modules/fable-library-js.4.20.0/List.js";
-
-export class UnusedDto extends Record {
-    constructor(Unused) {
-        super();
-        this.Unused = Unused;
-    }
-}
-
-export function UnusedDto_$reflection() {
-    return record_type("Basic.Profile.Domain.Import.Dto.UnusedDto", [], UnusedDto, () => [["Unused", option_type(string_type)]]);
-}
-
-export const UnusedDtoModule_Default = new UnusedDto(undefined);
-
-export class AggregateMetadataDto$1 extends Record {
-    constructor(StreamId, Version, CreatedAt, UpdatedAt, Domain) {
-        super();
-        this.StreamId = StreamId;
-        this.Version = (Version | 0);
-        this.CreatedAt = CreatedAt;
-        this.UpdatedAt = UpdatedAt;
-        this.Domain = Domain;
-    }
-}
-
-export function AggregateMetadataDto$1_$reflection(gen0) {
-    return record_type("Basic.Profile.Domain.Import.Dto.AggregateMetadataDto`1", [gen0], AggregateMetadataDto$1, () => [["StreamId", string_type], ["Version", int32_type], ["CreatedAt", class_type("System.DateTime")], ["UpdatedAt", class_type("System.DateTime")], ["Domain", gen0]]);
-}
-
-export function AggregateMetadataDto_ofDomain(metadataOfDomain, domain) {
-    return new AggregateMetadataDto$1(StreamIdModule_value(domain.StreamId), domain.Version, UtcDateTimeModule_value(domain.CreatedAt), UtcDateTimeModule_value(domain.UpdatedAt), metadataOfDomain(domain.Domain));
-}
-
-export function AggregateMetadataDto_toDomain(metadataToDomain, dto) {
-    return new AggregateMetadata$1(new StreamId(dto.StreamId), dto.Version, UtcDateTimeModule_create(dto.CreatedAt), UtcDateTimeModule_create(dto.UpdatedAt), metadataToDomain(dto.Domain));
-}
-
-export class AggregateDto$2 extends Record {
-    constructor(Data, Metadata) {
-        super();
-        this.Data = Data;
-        this.Metadata = Metadata;
-    }
-}
-
-export function AggregateDto$2_$reflection(gen0, gen1) {
-    return record_type("Basic.Profile.Domain.Import.Dto.AggregateDto`2", [gen0, gen1], AggregateDto$2, () => [["Data", gen0], ["Metadata", AggregateMetadataDto$1_$reflection(gen1)]]);
-}
-
-export function AggregateDto_ofDomain(metadataOfDomain, payloadOfDomain, domain) {
-    return new AggregateDto$2(payloadOfDomain(domain.Data), AggregateMetadataDto_ofDomain(metadataOfDomain, domain.Metadata));
-}
-
-export function AggregateDto_toDomain(metadataToDomain, payloadToDomain, dto) {
-    return new Aggregate$2(payloadToDomain(dto.Data), AggregateMetadataDto_toDomain(metadataToDomain, dto.Metadata));
-}
-
-export class EventMetadataDto$1 extends Record {
-    constructor(StreamId, Version, Timestamp, AppVersion, Domain) {
-        super();
-        this.StreamId = StreamId;
-        this.Version = (Version | 0);
-        this.Timestamp = Timestamp;
-        this.AppVersion = AppVersion;
-        this.Domain = Domain;
-    }
-}
-
-export function EventMetadataDto$1_$reflection(gen0) {
-    return record_type("Basic.Profile.Domain.Import.Dto.EventMetadataDto`1", [gen0], EventMetadataDto$1, () => [["StreamId", string_type], ["Version", int32_type], ["Timestamp", class_type("System.DateTime")], ["AppVersion", string_type], ["Domain", gen0]]);
-}
-
-export function EventMetadataDto_ofDomain(metadataOfDomain, domain) {
-    return new EventMetadataDto$1(StreamIdModule_value(domain.StreamId), domain.Version, UtcDateTimeModule_value(domain.Timestamp), AppVersionModule_value(domain.AppVersion), metadataOfDomain(domain.Domain));
-}
-
-export class EventDto$2 extends Record {
-    constructor(Id, CausationId, CorrelationId, Event$, Metadata) {
-        super();
-        this.Id = Id;
-        this.CausationId = CausationId;
-        this.CorrelationId = CorrelationId;
-        this.Event = Event$;
-        this.Metadata = Metadata;
-    }
-}
-
-export function EventDto$2_$reflection(gen0, gen1) {
-    return record_type("Basic.Profile.Domain.Import.Dto.EventDto`2", [gen0, gen1], EventDto$2, () => [["Id", class_type("System.Guid")], ["CausationId", string_type], ["CorrelationId", string_type], ["Event", gen0], ["Metadata", EventMetadataDto$1_$reflection(gen1)]]);
-}
-
-export function EventDto_ofDomain(metadataOfDomain, payloadOfDomain, domain) {
-    return new EventDto$2(EventIdModule_value(domain.Id), CausationIdModule_value(domain.CausationId), CorrelationIdModule_value(domain.CorrelationId), payloadOfDomain(domain.Payload), EventMetadataDto_ofDomain(metadataOfDomain, domain.Metadata));
-}
-
-export class ActorDto extends Union {
-    constructor(tag, fields) {
-        super();
-        this.tag = tag;
-        this.fields = fields;
-    }
-    cases() {
-        return ["FlareUser", "ApolloImport"];
-    }
-}
-
-export function ActorDto_$reflection() {
-    return union_type("Basic.Profile.Domain.Import.Dto.ActorDto", [], ActorDto, () => [[["Item", anonRecord_type(["Email", string_type], ["Id", string_type], ["Name", string_type])]], []]);
-}
-
-export function ActorDtoModule_ofDomain(_arg) {
-    if (_arg.tag === 1) {
-        return new ActorDto(1, []);
-    }
-    else {
-        return new ActorDto(0, [_arg.fields[0]]);
-    }
-}
-
-export function ActorDtoModule_toDomain(_arg) {
-    if (_arg.tag === 1) {
-        return new Actor(1, []);
-    }
-    else {
-        return new Actor(0, [_arg.fields[0]]);
-    }
-}
-
-export class OriginDto extends Union {
-    constructor(tag, fields) {
-        super();
-        this.tag = tag;
-        this.fields = fields;
-    }
-    cases() {
-        return ["SuperHero", "InternalApi"];
-    }
-}
-
-export function OriginDto_$reflection() {
-    return union_type("Basic.Profile.Domain.Import.Dto.OriginDto", [], OriginDto, () => [[], []]);
-}
-
-export function OriginDtoModule_ofDomain(_arg) {
-    if (_arg.tag === 1) {
-        return new OriginDto(1, []);
-    }
-    else {
-        return new OriginDto(0, []);
-    }
-}
-
-export function OriginDtoModule_toDomain(_arg) {
-    if (_arg.tag === 1) {
-        return new Origin(1, []);
-    }
-    else {
-        return new Origin(0, []);
-    }
-}
-
-export class FileInfoDto extends Record {
-    constructor(Id, Filename) {
-        super();
-        this.Id = Id;
-        this.Filename = Filename;
-    }
-}
-
-export function FileInfoDto_$reflection() {
-    return record_type("Basic.Profile.Domain.Import.Dto.FileInfoDto", [], FileInfoDto, () => [["Id", string_type], ["Filename", string_type]]);
-}
-
-export function FileInfoDtoModule_ofDomain(domain) {
-    return new FileInfoDto(domain.Id, domain.Filename);
-}
-
-export function FileInfoDtoModule_toDomain(domain) {
-    return new FileInfo(domain.Id, domain.Filename);
-}
-
-export class ActiveImportDto extends Record {
-    constructor(ImportId, Origin, Actor, FileInfo, NumberOfRecords, CompletedSuccessfully, CompletedFailed, NextRow, StartTime) {
-        super();
-        this.ImportId = (ImportId | 0);
-        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 ActiveImportDto_$reflection() {
-    return record_type("Basic.Profile.Domain.Import.Dto.ActiveImportDto", [], ActiveImportDto, () => [["ImportId", int32_type], ["Origin", OriginDto_$reflection()], ["Actor", ActorDto_$reflection()], ["FileInfo", FileInfoDto_$reflection()], ["NumberOfRecords", int32_type], ["CompletedSuccessfully", int32_type], ["CompletedFailed", int32_type], ["NextRow", option_type(int32_type)], ["StartTime", class_type("System.DateTime")]]);
-}
-
-export function ActiveImportDtoModule_ofDomain(domain) {
-    return new ActiveImportDto(ImportIdModule_value(domain.ImportId), OriginDtoModule_ofDomain(domain.Origin), ActorDtoModule_ofDomain(domain.Actor), FileInfoDtoModule_ofDomain(domain.FileInfo), domain.NumberOfRecords, domain.CompletedSuccessfully, domain.CompletedFailed, domain.NextRow, UtcDateTimeModule_value(domain.StartTime));
-}
-
-export function ActiveImportDtoModule_toDomain(dto) {
-    return new ActiveImport(ImportIdModule_create(dto.ImportId), OriginDtoModule_toDomain(dto.Origin), ActorDtoModule_toDomain(dto.Actor), FileInfoDtoModule_toDomain(dto.FileInfo), dto.NumberOfRecords, dto.CompletedSuccessfully, dto.CompletedFailed, dto.NextRow, UtcDateTimeModule_create(dto.StartTime));
-}
-
-export class ImportHistoryDto extends Record {
-    constructor(ImportId, Origin, Actor, FileInfo, NumberOfRecords, Succeeded, Failed, StartTime, StopTime) {
-        super();
-        this.ImportId = (ImportId | 0);
-        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 ImportHistoryDto_$reflection() {
-    return record_type("Basic.Profile.Domain.Import.Dto.ImportHistoryDto", [], ImportHistoryDto, () => [["ImportId", int32_type], ["Origin", OriginDto_$reflection()], ["Actor", ActorDto_$reflection()], ["FileInfo", FileInfoDto_$reflection()], ["NumberOfRecords", int32_type], ["Succeeded", int32_type], ["Failed", int32_type], ["StartTime", class_type("System.DateTime")], ["StopTime", class_type("System.DateTime")]]);
-}
-
-export function ImportHistoryDtoModule_ofDomain(domain) {
-    return new ImportHistoryDto(ImportIdModule_value(domain.ImportId), OriginDtoModule_ofDomain(domain.Origin), ActorDtoModule_ofDomain(domain.Actor), FileInfoDtoModule_ofDomain(domain.FileInfo), domain.NumberOfRecords, domain.Succeeded, domain.Failed, UtcDateTimeModule_value(domain.StartTime), UtcDateTimeModule_value(domain.StopTime));
-}
-
-export function ImportHistoryDtoModule_toDomain(dto) {
-    return new ImportHistory(ImportIdModule_create(dto.ImportId), OriginDtoModule_toDomain(dto.Origin), ActorDtoModule_toDomain(dto.Actor), FileInfoDtoModule_toDomain(dto.FileInfo), dto.NumberOfRecords, dto.Succeeded, dto.Failed, UtcDateTimeModule_create(dto.StartTime), UtcDateTimeModule_create(dto.StopTime));
-}
-
-export class AccountImportsDataDto extends Record {
-    constructor(ActiveImport, ImportHistory) {
-        super();
-        this.ActiveImport = ActiveImport;
-        this.ImportHistory = ImportHistory;
-    }
-}
-
-export function AccountImportsDataDto_$reflection() {
-    return record_type("Basic.Profile.Domain.Import.Dto.AccountImportsDataDto", [], AccountImportsDataDto, () => [["ActiveImport", option_type(ActiveImportDto_$reflection())], ["ImportHistory", list_type(ImportHistoryDto_$reflection())]]);
-}
-
-export function AccountImportsDataDtoModule_ofDomain(domain) {
-    return new AccountImportsDataDto(map(ActiveImportDtoModule_ofDomain, domain.ActiveImport), map_1(ImportHistoryDtoModule_ofDomain, domain.ImportHistory));
-}
-
-export function AccountImportsDataDtoModule_toDomain(dto) {
-    return new AccountImportsData(map(ActiveImportDtoModule_toDomain, dto.ActiveImport), map_1(ImportHistoryDtoModule_toDomain, dto.ImportHistory));
-}
-
-export class ImportStartedEventPayloadDto extends Record {
-    constructor(Origin, Actor, FileInfo, TotalRowCount) {
-        super();
-        this.Origin = Origin;
-        this.Actor = Actor;
-        this.FileInfo = FileInfo;
-        this.TotalRowCount = (TotalRowCount | 0);
-    }
-}
-
-export function ImportStartedEventPayloadDto_$reflection() {
-    return record_type("Basic.Profile.Domain.Import.Dto.ImportStartedEventPayloadDto", [], ImportStartedEventPayloadDto, () => [["Origin", OriginDto_$reflection()], ["Actor", ActorDto_$reflection()], ["FileInfo", FileInfoDto_$reflection()], ["TotalRowCount", int32_type]]);
-}
-
-export function ImportStartedEventPayloadDtoModule_ofDomain(domain) {
-    return new ImportStartedEventPayloadDto(OriginDtoModule_ofDomain(domain.Origin), ActorDtoModule_ofDomain(domain.Actor), FileInfoDtoModule_ofDomain(domain.FileInfo), domain.TotalRowCount);
-}
-
-export class RowImportSucceededEventPayloadDto extends Record {
-    constructor(RowId, ProfileId) {
-        super();
-        this.RowId = (RowId | 0);
-        this.ProfileId = ProfileId;
-    }
-}
-
-export function RowImportSucceededEventPayloadDto_$reflection() {
-    return record_type("Basic.Profile.Domain.Import.Dto.RowImportSucceededEventPayloadDto", [], RowImportSucceededEventPayloadDto, () => [["RowId", int32_type], ["ProfileId", string_type]]);
-}
-
-export function RowImportSucceededEventPayloadDtoModule_ofDomain(domain) {
-    return new RowImportSucceededEventPayloadDto(domain.RowId, domain.ProfileId);
-}
-
-export class RowImportFailedEventPayloadDto extends Record {
-    constructor(RowId, Reason) {
-        super();
-        this.RowId = (RowId | 0);
-        this.Reason = Reason;
-    }
-}
-
-export function RowImportFailedEventPayloadDto_$reflection() {
-    return record_type("Basic.Profile.Domain.Import.Dto.RowImportFailedEventPayloadDto", [], RowImportFailedEventPayloadDto, () => [["RowId", int32_type], ["Reason", string_type]]);
-}
-
-export function RowImportFailedEventPayloadDtoModule_ofDomain(domain) {
-    return new RowImportFailedEventPayloadDto(domain.RowId, domain.Reason);
-}
-
-export class ImportEventPayloadDto extends Union {
-    constructor(tag, fields) {
-        super();
-        this.tag = tag;
-        this.fields = fields;
-    }
-    cases() {
-        return ["ImportStarted", "RowImportSucceeded", "RowImportFailed", "ImportComplete"];
-    }
-}
-
-export function ImportEventPayloadDto_$reflection() {
-    return union_type("Basic.Profile.Domain.Import.Dto.ImportEventPayloadDto", [], ImportEventPayloadDto, () => [[["Item", ImportStartedEventPayloadDto_$reflection()]], [["Item", RowImportSucceededEventPayloadDto_$reflection()]], [["Item", RowImportFailedEventPayloadDto_$reflection()]], [["Item", UnusedDto_$reflection()]]]);
-}
-
-export function ImportEventPayloadDtoModule_ofDomain(_arg) {
-    switch (_arg.tag) {
-        case 1:
-            return new ImportEventPayloadDto(1, [RowImportSucceededEventPayloadDtoModule_ofDomain(_arg.fields[0])]);
-        case 2:
-            return new ImportEventPayloadDto(2, [RowImportFailedEventPayloadDtoModule_ofDomain(_arg.fields[0])]);
-        case 3:
-            return new ImportEventPayloadDto(3, [UnusedDtoModule_Default]);
-        default:
-            return new ImportEventPayloadDto(0, [ImportStartedEventPayloadDtoModule_ofDomain(_arg.fields[0])]);
-    }
-}
-
-export class AccountImportsDomainMetadataDto extends Record {
-    constructor(AccountId, PartnerId) {
-        super();
-        this.AccountId = AccountId;
-        this.PartnerId = PartnerId;
-    }
-}
-
-export function AccountImportsDomainMetadataDto_$reflection() {
-    return record_type("Basic.Profile.Domain.Import.Dto.AccountImportsDomainMetadataDto", [], AccountImportsDomainMetadataDto, () => [["AccountId", string_type], ["PartnerId", string_type]]);
-}
-
-export function AccountImportsDomainMetadataDtoModule_ofDomain(domain) {
-    return new AccountImportsDomainMetadataDto(AccountIdModule_value(domain.AccountId), PartnerIdModule_value(domain.PartnerId));
-}
-
-export function AccountImportsDomainMetadataDtoModule_toDomain(dto) {
-    return new AccountImportsDomainMetadata(new AccountId_1(dto.AccountId), new PartnerId(dto.PartnerId));
-}
-
-export class AccountImportsDataVersionedDto extends Union {
-    constructor(tag, fields) {
-        super();
-        this.tag = tag;
-        this.fields = fields;
-    }
-    cases() {
-        return ["V1", "Unused"];
-    }
-}
-
-export function AccountImportsDataVersionedDto_$reflection() {
-    return union_type("Basic.Profile.Domain.Import.Dto.AccountImportsDataVersionedDto", [], AccountImportsDataVersionedDto, () => [[["Item", AccountImportsDataDto_$reflection()]], []]);
-}
-
-export function AccountImportsDataVersionedDtoModule_ofDomain(domain) {
-    return new AccountImportsDataVersionedDto(0, [AccountImportsDataDtoModule_ofDomain(domain)]);
-}
-
-export function AccountImportsDataVersionedDtoModule_toDomain(dto) {
-    if (dto.tag === 1) {
-        throw new Error("Invalid AccountImportsDataVersionedDto");
-    }
-    else {
-        return AccountImportsDataDtoModule_toDomain(dto.fields[0]);
-    }
-}
-
-export const AccountImportsAggregateDtoModule_ofDomain = (domain) => AggregateDto_ofDomain(AccountImportsDomainMetadataDtoModule_ofDomain, AccountImportsDataVersionedDtoModule_ofDomain, domain);
-
-export const AccountImportsAggregateDtoModule_toDomain = (dto) => AggregateDto_toDomain(AccountImportsDomainMetadataDtoModule_toDomain, AccountImportsDataVersionedDtoModule_toDomain, dto);
-
-export class ImportEventDomainMetadataDto extends Record {
-    constructor(AccountId, PartnerId, ImportId) {
-        super();
-        this.AccountId = AccountId;
-        this.PartnerId = PartnerId;
-        this.ImportId = (ImportId | 0);
-    }
-}
-
-export function ImportEventDomainMetadataDto_$reflection() {
-    return record_type("Basic.Profile.Domain.Import.Dto.ImportEventDomainMetadataDto", [], ImportEventDomainMetadataDto, () => [["AccountId", string_type], ["PartnerId", string_type], ["ImportId", int32_type]]);
-}
-
-export function ImportEventDomainMetadataDtoModule_ofDomain(domain) {
-    return new ImportEventDomainMetadataDto(AccountIdModule_value(domain.AccountId), PartnerIdModule_value(domain.PartnerId), ImportIdModule_value(domain.ImportId));
-}
-
-export function ImportEventDomainMetadataDtoModule_toDomain(dto) {
-    return new ImportEventDomainMetadata(new PartnerId(dto.PartnerId), new AccountId_1(dto.AccountId), ImportIdModule_create(dto.ImportId));
-}
-
-export const ImportEventDtoModule_ofDomain = (domain) => EventDto_ofDomain(ImportEventDomainMetadataDtoModule_ofDomain, ImportEventPayloadDtoModule_ofDomain, domain);
-
-export class ValidatedImportAddressDto extends Record {
-    constructor(AddressLine1, AddressLine2, City, State, Postcode, CountryCode) {
-        super();
-        this.AddressLine1 = AddressLine1;
-        this.AddressLine2 = AddressLine2;
-        this.City = City;
-        this.State = State;
-        this.Postcode = Postcode;
-        this.CountryCode = CountryCode;
-    }
-}
-
-export function ValidatedImportAddressDto_$reflection() {
-    return record_type("Basic.Profile.Domain.Import.Dto.ValidatedImportAddressDto", [], ValidatedImportAddressDto, () => [["AddressLine1", string_type], ["AddressLine2", option_type(string_type)], ["City", string_type], ["State", string_type], ["Postcode", string_type], ["CountryCode", string_type]]);
-}
-
-export class ValidatedImportProfileDataDto extends Record {
-    constructor(FirstName, MiddleName, LastName, Email, MobilePhone, ExternalId, Title, Gender, DateOfBirth, Address) {
-        super();
-        this.FirstName = FirstName;
-        this.MiddleName = MiddleName;
-        this.LastName = LastName;
-        this.Email = Email;
-        this.MobilePhone = MobilePhone;
-        this.ExternalId = ExternalId;
-        this.Title = Title;
-        this.Gender = Gender;
-        this.DateOfBirth = DateOfBirth;
-        this.Address = Address;
-    }
-}
-
-export function ValidatedImportProfileDataDto_$reflection() {
-    return record_type("Basic.Profile.Domain.Import.Dto.ValidatedImportProfileDataDto", [], ValidatedImportProfileDataDto, () => [["FirstName", string_type], ["MiddleName", option_type(string_type)], ["LastName", string_type], ["Email", string_type], ["MobilePhone", option_type(string_type)], ["ExternalId", option_type(string_type)], ["Title", option_type(string_type)], ["Gender", option_type(string_type)], ["DateOfBirth", option_type(string_type)], ["Address", option_type(ValidatedImportAddressDto_$reflection())]]);
-}
-
-export class ValidatedImportRowDataDto extends Record {
-    constructor(RowId, Data) {
-        super();
-        this.RowId = (RowId | 0);
-        this.Data = Data;
-    }
-}
-
-export function ValidatedImportRowDataDto_$reflection() {
-    return record_type("Basic.Profile.Domain.Import.Dto.ValidatedImportRowDataDto", [], ValidatedImportRowDataDto, () => [["RowId", int32_type], ["Data", ValidatedImportProfileDataDto_$reflection()]]);
-}
-
-export class ValidatedImportDataDto extends Record {
-    constructor(Data) {
-        super();
-        this.Data = Data;
-    }
-}
-
-export function ValidatedImportDataDto_$reflection() {
-    return record_type("Basic.Profile.Domain.Import.Dto.ValidatedImportDataDto", [], ValidatedImportDataDto, () => [["Data", list_type(ValidatedImportRowDataDto_$reflection())]]);
-}
-