@dereekb/model 13.0.0 → 13.0.1

package/index.cjs.js

@@ -3,10 +3,7 @@
 var util = require('@dereekb/util');
 var classTransformer = require('class-transformer');
 var classValidator = require('class-validator');
-require('core-js/modules/es.iterator.constructor.js');
-require('core-js/modules/es.iterator.map.js');
-require('core-js/modules/es.map.get-or-insert.js');
-require('core-js/modules/es.map.get-or-insert-computed.js');
+var makeError = require('make-error');
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -48,37 +45,67 @@ const ADDRESS_STATE_CODE_MAX_LENGTH = 2;
 const ADDRESS_ZIP_MAX_LENGTH = 11;
 const ADDRESS_COUNTRY_MAX_LENGTH = 80;
 class AbstractUnitedStatesAddressWithoutStateParams {
-  constructor() {
-    this.line1 = void 0;
-    this.line2 = void 0;
-    this.city = void 0;
-    this.zip = void 0;
-  }
-}
-__decorate([classTransformer.Expose(), classValidator.IsString(), classValidator.IsNotEmpty(), classValidator.MaxLength(ADDRESS_LINE_MAX_LENGTH), __metadata("design:type", String)], AbstractUnitedStatesAddressWithoutStateParams.prototype, "line1", void 0);
-__decorate([classTransformer.Expose(), classValidator.IsOptional(), classValidator.IsString(), classValidator.MaxLength(ADDRESS_LINE_MAX_LENGTH), __metadata("design:type", String)], AbstractUnitedStatesAddressWithoutStateParams.prototype, "line2", void 0);
-__decorate([classTransformer.Expose(), classValidator.IsString(), classValidator.IsNotEmpty(), classValidator.MaxLength(ADDRESS_CITY_MAX_LENGTH), __metadata("design:type", String)], AbstractUnitedStatesAddressWithoutStateParams.prototype, "city", void 0);
-__decorate([classTransformer.Expose(), classValidator.IsString(), classValidator.IsNotEmpty(), classValidator.Matches(util.ZIP_CODE_STRING_REGEX), classValidator.MaxLength(ADDRESS_ZIP_MAX_LENGTH), __metadata("design:type", String)], AbstractUnitedStatesAddressWithoutStateParams.prototype, "zip", void 0);
+    line1;
+    line2;
+    city;
+    zip;
+}
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsString(),
+    classValidator.IsNotEmpty(),
+    classValidator.MaxLength(ADDRESS_LINE_MAX_LENGTH),
+    __metadata("design:type", String)
+], AbstractUnitedStatesAddressWithoutStateParams.prototype, "line1", void 0);
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsOptional(),
+    classValidator.IsString(),
+    classValidator.MaxLength(ADDRESS_LINE_MAX_LENGTH),
+    __metadata("design:type", String)
+], AbstractUnitedStatesAddressWithoutStateParams.prototype, "line2", void 0);
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsString(),
+    classValidator.IsNotEmpty(),
+    classValidator.MaxLength(ADDRESS_CITY_MAX_LENGTH),
+    __metadata("design:type", String)
+], AbstractUnitedStatesAddressWithoutStateParams.prototype, "city", void 0);
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsString(),
+    classValidator.IsNotEmpty(),
+    classValidator.Matches(util.ZIP_CODE_STRING_REGEX),
+    classValidator.MaxLength(ADDRESS_ZIP_MAX_LENGTH),
+    __metadata("design:type", String)
+], AbstractUnitedStatesAddressWithoutStateParams.prototype, "zip", void 0);
 /**
  * UnitedStatesAddress that enforces a StateCode for the state value.
  */
 class UnitedStatesAddressWithStateCodeParams extends AbstractUnitedStatesAddressWithoutStateParams {
-  constructor(...args) {
-    super(...args);
-    this.state = void 0;
-  }
-}
-__decorate([classTransformer.Expose(), classValidator.IsString(), classValidator.Matches(util.US_STATE_CODE_STRING_REGEX), classValidator.MinLength(ADDRESS_STATE_CODE_MAX_LENGTH), classValidator.MaxLength(ADDRESS_STATE_CODE_MAX_LENGTH), __metadata("design:type", String)], UnitedStatesAddressWithStateCodeParams.prototype, "state", void 0);
+    state;
+}
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsString(),
+    classValidator.Matches(util.US_STATE_CODE_STRING_REGEX),
+    classValidator.MinLength(ADDRESS_STATE_CODE_MAX_LENGTH),
+    classValidator.MaxLength(ADDRESS_STATE_CODE_MAX_LENGTH),
+    __metadata("design:type", String)
+], UnitedStatesAddressWithStateCodeParams.prototype, "state", void 0);
 /**
  * UnitedStatesAddress that enforces a State for the state value.
  */
 class UnitedStatesAddressWithStateStringParams extends AbstractUnitedStatesAddressWithoutStateParams {
-  constructor(...args) {
-    super(...args);
-    this.state = void 0;
-  }
-}
-__decorate([classTransformer.Expose(), classValidator.IsString(), classValidator.IsNotEmpty(), classValidator.MaxLength(ADDRESS_STATE_MAX_LENGTH), __metadata("design:type", String)], UnitedStatesAddressWithStateStringParams.prototype, "state", void 0);
+    state;
+}
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsString(),
+    classValidator.IsNotEmpty(),
+    classValidator.MaxLength(ADDRESS_STATE_MAX_LENGTH),
+    __metadata("design:type", String)
+], UnitedStatesAddressWithStateStringParams.prototype, "state", void 0);
 
 const UNKNOWN_WEBSITE_LINK_TYPE = 'u';
 /**
@@ -90,24 +117,37 @@ const WEBSITE_LINK_TYPE_MAX_LENGTH = 32;
  */
 const WEBSITE_LINK_TYPE_REGEX = /^[a-zA-Z0-9]{1,32}$/;
 function isValidWebsiteLinkType(input) {
-  return WEBSITE_LINK_TYPE_REGEX.test(input);
+    return WEBSITE_LINK_TYPE_REGEX.test(input);
 }
 /**
  * Default max length of WebsiteLink's data string.
  */
 const WEBSITE_LINK_ENCODED_DATA_MAX_LENGTH = 1000;
 class WebsiteLink {
-  constructor(template) {
-    this.t = void 0;
-    this.d = void 0;
-    if (template != null) {
-      this.t = template.t;
-      this.d = template.d;
+    t;
+    d;
+    constructor(template) {
+        if (template != null) {
+            this.t = template.t;
+            this.d = template.d;
+        }
     }
-  }
 }
-__decorate([classTransformer.Expose(), classValidator.IsString(), classValidator.IsNotEmpty(), classValidator.Matches(WEBSITE_LINK_TYPE_REGEX), classValidator.MaxLength(WEBSITE_LINK_TYPE_MAX_LENGTH), __metadata("design:type", String)], WebsiteLink.prototype, "t", void 0);
-__decorate([classTransformer.Expose(), classValidator.IsString(), classValidator.IsNotEmpty(), classValidator.MaxLength(WEBSITE_LINK_ENCODED_DATA_MAX_LENGTH), __metadata("design:type", String)], WebsiteLink.prototype, "d", void 0);
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsString(),
+    classValidator.IsNotEmpty(),
+    classValidator.Matches(WEBSITE_LINK_TYPE_REGEX),
+    classValidator.MaxLength(WEBSITE_LINK_TYPE_MAX_LENGTH),
+    __metadata("design:type", String)
+], WebsiteLink.prototype, "t", void 0);
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsString(),
+    classValidator.IsNotEmpty(),
+    classValidator.MaxLength(WEBSITE_LINK_ENCODED_DATA_MAX_LENGTH),
+    __metadata("design:type", String)
+], WebsiteLink.prototype, "d", void 0);
 
 /**
  * Max length of WebsiteLink's data type.
@@ -135,47 +175,73 @@ const WEBSITE_FILE_LINK_NAME_MAX_LENGTH = 128;
 const WEBSITE_FILE_LINK_DATA_MAX_LENGTH = WEBSITE_LINK_ENCODED_DATA_MAX_LENGTH - 3 - WEBSITE_FILE_LINK_TYPE_MAX_LENGTH - WEBSITE_FILE_LINK_MIME_TYPE_MAX_LENGTH - WEBSITE_FILE_LINK_NAME_MAX_LENGTH;
 const WEBSITE_FILE_LINK_DATA_REGEX = /^[^|]+$/;
 class WebsiteFileLink {
-  constructor(template) {
-    this.type = void 0;
-    this.mime = void 0;
-    this.name = void 0;
-    this.data = void 0;
-    if (template != null) {
-      this.type = template.type;
-      this.mime = template.mime;
-      this.name = template.name;
-      this.data = template.data;
+    type;
+    mime;
+    name;
+    data;
+    constructor(template) {
+        if (template != null) {
+            this.type = template.type;
+            this.mime = template.mime;
+            this.name = template.name;
+            this.data = template.data;
+        }
     }
-  }
 }
-__decorate([classTransformer.Expose(), classValidator.IsOptional(), classValidator.IsString(), classValidator.Matches(WEBSITE_FILE_LINK_TYPE_REGEX), classValidator.MaxLength(WEBSITE_LINK_TYPE_MAX_LENGTH), __metadata("design:type", String)], WebsiteFileLink.prototype, "type", void 0);
-__decorate([classTransformer.Expose(), classValidator.IsOptional(), classValidator.IsString(), classValidator.Matches(WEBSITE_FILE_LINK_MIME_TYPE_REGEX), classValidator.MaxLength(WEBSITE_FILE_LINK_MIME_TYPE_MAX_LENGTH), __metadata("design:type", String)], WebsiteFileLink.prototype, "mime", void 0);
-__decorate([classTransformer.Expose(), classValidator.IsOptional(), classValidator.IsString(), classValidator.MaxLength(WEBSITE_FILE_LINK_NAME_MAX_LENGTH), __metadata("design:type", String)], WebsiteFileLink.prototype, "name", void 0);
-__decorate([classValidator.IsString(), classValidator.IsNotEmpty(), classValidator.Matches(WEBSITE_FILE_LINK_DATA_REGEX), classValidator.MaxLength(WEBSITE_FILE_LINK_DATA_MAX_LENGTH), __metadata("design:type", String)], WebsiteFileLink.prototype, "data", void 0);
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsOptional(),
+    classValidator.IsString(),
+    classValidator.Matches(WEBSITE_FILE_LINK_TYPE_REGEX),
+    classValidator.MaxLength(WEBSITE_LINK_TYPE_MAX_LENGTH),
+    __metadata("design:type", String)
+], WebsiteFileLink.prototype, "type", void 0);
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsOptional(),
+    classValidator.IsString(),
+    classValidator.Matches(WEBSITE_FILE_LINK_MIME_TYPE_REGEX),
+    classValidator.MaxLength(WEBSITE_FILE_LINK_MIME_TYPE_MAX_LENGTH),
+    __metadata("design:type", String)
+], WebsiteFileLink.prototype, "mime", void 0);
+__decorate([
+    classTransformer.Expose(),
+    classValidator.IsOptional(),
+    classValidator.IsString(),
+    classValidator.MaxLength(WEBSITE_FILE_LINK_NAME_MAX_LENGTH),
+    __metadata("design:type", String)
+], WebsiteFileLink.prototype, "name", void 0);
+__decorate([
+    classValidator.IsString(),
+    classValidator.IsNotEmpty(),
+    classValidator.Matches(WEBSITE_FILE_LINK_DATA_REGEX),
+    classValidator.MaxLength(WEBSITE_FILE_LINK_DATA_MAX_LENGTH),
+    __metadata("design:type", String)
+], WebsiteFileLink.prototype, "data", void 0);
 const WEBSITE_FILE_LINK_WEBSITE_LINK_TYPE = 'f';
 function websiteFileLinkToWebsiteLink(input) {
-  return {
-    t: WEBSITE_FILE_LINK_WEBSITE_LINK_TYPE,
-    d: encodeWebsiteFileLinkToWebsiteLinkEncodedData(input)
-  };
+    return {
+        t: WEBSITE_FILE_LINK_WEBSITE_LINK_TYPE,
+        d: encodeWebsiteFileLinkToWebsiteLinkEncodedData(input)
+    };
 }
 function websiteLinkToWebsiteLinkFile(input) {
-  const encodedData = input.d;
-  return decodeWebsiteLinkEncodedDataToWebsiteFileLink(encodedData);
+    const encodedData = input.d;
+    return decodeWebsiteLinkEncodedDataToWebsiteFileLink(encodedData);
 }
 const WEBSITE_FILE_LINK_ENCODE_SEPARATOR = '|';
 function encodeWebsiteFileLinkToWebsiteLinkEncodedData(input) {
-  const encoded = [input.type, input.mime, input.data, input.name].map(x => x || '').join(WEBSITE_FILE_LINK_ENCODE_SEPARATOR);
-  return encoded;
+    const encoded = [input.type, input.mime, input.data, input.name].map((x) => x || '').join(WEBSITE_FILE_LINK_ENCODE_SEPARATOR);
+    return encoded;
 }
 function decodeWebsiteLinkEncodedDataToWebsiteFileLink(input) {
-  const [type, mime, data, name] = util.splitJoinRemainder(input, WEBSITE_FILE_LINK_ENCODE_SEPARATOR, 4);
-  return util.filterFalsyAndEmptyValues({
-    type,
-    mime,
-    name,
-    data
-  });
+    const [type, mime, data, name] = util.splitJoinRemainder(input, WEBSITE_FILE_LINK_ENCODE_SEPARATOR, 4);
+    return util.filterFalsyAndEmptyValues({
+        type,
+        mime,
+        name,
+        data
+    });
 }
 
 /**
@@ -185,193 +251,194 @@ function decodeWebsiteLinkEncodedDataToWebsiteFileLink(input) {
  * - https://facebook.com/facebook
  */
 const WEBSITE_LINK_ISOLATE_BASE_URL_PROFILE_ID = util.isolateWebsitePathFunction({
-  isolatePathComponents: 0,
-  removeTrailingSlash: true,
-  removeQueryParameters: true
+    isolatePathComponents: 0,
+    removeTrailingSlash: true,
+    removeQueryParameters: true
 });
 function usernameFromUsernameOrWebsiteWithBaseUrlUsername(input, prefix) {
-  const username = util.toRelativeSlashPathStartType(WEBSITE_LINK_ISOLATE_BASE_URL_PROFILE_ID(usernameOrWebsiteUrlToWebsiteUrl(input)));
-  if (prefix) {
-    return util.addPrefix(prefix, username);
-  } else {
-    return username;
-  }
+    const username = util.toRelativeSlashPathStartType(WEBSITE_LINK_ISOLATE_BASE_URL_PROFILE_ID(usernameOrWebsiteUrlToWebsiteUrl(input)));
+    if (prefix) {
+        return util.addPrefix(prefix, username);
+    }
+    else {
+        return username;
+    }
 }
 function usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, isolateFn) {
-  return util.toRelativeSlashPathStartType(isolateFn(usernameOrWebsiteUrlToWebsiteUrl(input)));
+    return util.toRelativeSlashPathStartType(isolateFn(usernameOrWebsiteUrlToWebsiteUrl(input)));
 }
 function usernameOrWebsiteUrlToWebsiteUrl(input) {
-  return util.hasWebsiteDomain(input) ? input : util.toAbsoluteSlashPathStartType(util.removeHttpFromUrl(input));
+    return util.hasWebsiteDomain(input) ? input : util.toAbsoluteSlashPathStartType(util.removeHttpFromUrl(input));
 }
 // MARK: Website
 const WEBSITE_URL_WEBSITE_LINK_TYPE = 'w';
 function websiteUrlToWebsiteLink(input) {
-  return {
-    t: WEBSITE_URL_WEBSITE_LINK_TYPE,
-    d: util.removeHttpFromUrl(input) // website urls are stored as-is without http/https
-  };
+    return {
+        t: WEBSITE_URL_WEBSITE_LINK_TYPE,
+        d: util.removeHttpFromUrl(input) // website urls are stored as-is without http/https
+    };
 }
 // MARK: Email
 const EMAIL_URL_WEBSITE_LINK_TYPE = 'e';
 function emailAddressToWebsiteLink(input) {
-  return {
-    t: EMAIL_URL_WEBSITE_LINK_TYPE,
-    d: input
-  };
+    return {
+        t: EMAIL_URL_WEBSITE_LINK_TYPE,
+        d: input
+    };
 }
 // MARK: Phone
 const PHONE_URL_WEBSITE_LINK_TYPE = 'p';
 function phoneNumberToWebsiteLink(input) {
-  return {
-    t: PHONE_URL_WEBSITE_LINK_TYPE,
-    d: input
-  };
+    return {
+        t: PHONE_URL_WEBSITE_LINK_TYPE,
+        d: input
+    };
 }
 // MARK: Facebook
 const FACEBOOK_BASE_URL = `https://www.facebook.com`;
 const FACEBOOK_WEBSITE_LINK_TYPE = 'fb';
 function facebookProfileUrlToWebsiteLink(input) {
-  return {
-    t: FACEBOOK_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
-  };
+    return {
+        t: FACEBOOK_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
+    };
 }
 function facebookProfileUrl(profileId) {
-  return `${FACEBOOK_BASE_URL}/${profileId}`;
+    return `${FACEBOOK_BASE_URL}/${profileId}`;
 }
 // MARK: Instagram
 const INSTAGRAM_BASE_URL = `https://www.instagram.com`;
 const INSTAGRAM_WEBSITE_LINK_TYPE = 'ig';
 function instagramProfileUrlToWebsiteLink(input) {
-  return {
-    t: INSTAGRAM_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
-  };
+    return {
+        t: INSTAGRAM_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
+    };
 }
 function instagramProfileUrl(profileId) {
-  return `${INSTAGRAM_BASE_URL}/${profileId}`;
+    return `${INSTAGRAM_BASE_URL}/${profileId}`;
 }
 // MARK: Twitter
 const TWITTER_BASE_URL = `https://www.twitter.com`;
 const TWITTER_WEBSITE_LINK_TYPE = 'tw';
 function twitterProfileUrlToWebsiteLink(input) {
-  return {
-    t: TWITTER_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
-  };
+    return {
+        t: TWITTER_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
+    };
 }
 function twitterProfileUrl(profileId) {
-  return `${TWITTER_BASE_URL}/${profileId}`;
+    return `${TWITTER_BASE_URL}/${profileId}`;
 }
 // MARK: Tiktok
 const TIKTOK_BASE_URL = `https://tiktok.com`;
 const TIKTOK_USERNAME_PREFIX = '@';
 const TIKTOK_WEBSITE_LINK_TYPE = 'tt';
 function tiktokProfileUrlToWebsiteLink(input) {
-  return {
-    t: TIKTOK_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input, TIKTOK_USERNAME_PREFIX)
-  };
+    return {
+        t: TIKTOK_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input, TIKTOK_USERNAME_PREFIX)
+    };
 }
 function tiktokProfileUrl(profileId) {
-  return `${TIKTOK_BASE_URL}/@${profileId}`;
+    return `${TIKTOK_BASE_URL}/@${profileId}`;
 }
 // MARK: Snapchat
 const SNAPCHAT_BASE_URL = `https://snapchat.com`;
 const SNAPCHAT_WEBSITE_LINK_TYPE = 'sc';
 const SNAPCHAT_WEBSITE_LINK_ISOLATE_PROFILE_ID = util.isolateWebsitePathFunction({
-  ignoredBasePath: 'add',
-  isolatePathComponents: 0,
-  removeTrailingSlash: true,
-  removeQueryParameters: true
+    ignoredBasePath: 'add',
+    isolatePathComponents: 0,
+    removeTrailingSlash: true,
+    removeQueryParameters: true
 });
 function snapchatProfileUrlToWebsiteLink(input) {
-  return {
-    t: SNAPCHAT_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, SNAPCHAT_WEBSITE_LINK_ISOLATE_PROFILE_ID)
-  };
+    return {
+        t: SNAPCHAT_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, SNAPCHAT_WEBSITE_LINK_ISOLATE_PROFILE_ID)
+    };
 }
 function snapchatProfileUrl(profileId) {
-  return `${SNAPCHAT_BASE_URL}/add/${profileId}`;
+    return `${SNAPCHAT_BASE_URL}/add/${profileId}`;
 }
 // MARK: YouTube
 const YOUTUBE_BASE_URL = `https://youtube.com`;
 const YOUTUBE_WEBSITE_LINK_TYPE = 'yt';
 const YOUTUBE_WEBSITE_LINK_ISOLATE_PROFILE_ID = util.isolateWebsitePathFunction({
-  ignoredBasePath: 'c',
-  isolatePathComponents: 0,
-  removeTrailingSlash: true,
-  removeQueryParameters: true
+    ignoredBasePath: 'c',
+    isolatePathComponents: 0,
+    removeTrailingSlash: true,
+    removeQueryParameters: true
 });
 function youtubeProfileUrlToWebsiteLink(input) {
-  return {
-    t: YOUTUBE_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, YOUTUBE_WEBSITE_LINK_ISOLATE_PROFILE_ID)
-  };
+    return {
+        t: YOUTUBE_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, YOUTUBE_WEBSITE_LINK_ISOLATE_PROFILE_ID)
+    };
 }
 function youtubeProfileUrl(profileId) {
-  return `${YOUTUBE_BASE_URL}/c/${profileId}`;
+    return `${YOUTUBE_BASE_URL}/c/${profileId}`;
 }
 // MARK: PayPal
 const PAYPAL_BASE_URL = `https://paypal.me`;
 const PAYPAL_WEBSITE_LINK_TYPE = 'pp';
 function paypalProfileUrlToWebsiteLink(input) {
-  return {
-    t: PAYPAL_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
-  };
+    return {
+        t: PAYPAL_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input)
+    };
 }
 function paypalProfileUrl(profileId) {
-  return `${PAYPAL_BASE_URL}/${profileId}`;
+    return `${PAYPAL_BASE_URL}/${profileId}`;
 }
 // MARK: Cashapp
 const CASHAPP_BASE_URL = `https://cash.app`;
 const CASHAPP_USERNAME_PREFIX = '$';
 const CASHAPP_WEBSITE_LINK_TYPE = 'ca';
 function cashappProfileUrlToWebsiteLink(input) {
-  return {
-    t: CASHAPP_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input, CASHAPP_USERNAME_PREFIX)
-  };
+    return {
+        t: CASHAPP_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithBaseUrlUsername(input, CASHAPP_USERNAME_PREFIX)
+    };
 }
 function cashappProfileUrl(profileId) {
-  return `${CASHAPP_BASE_URL}/$${profileId}`;
+    return `${CASHAPP_BASE_URL}/$${profileId}`;
 }
 // MARK: Venmo
 const VENMO_BASE_URL = `https://account.venmo.com`;
 const VENMO_WEBSITE_LINK_TYPE = 'vn';
 const VENMO_WEBSITE_LINK_ISOLATE_PROFILE_ID = util.isolateWebsitePathFunction({
-  ignoredBasePath: 'u',
-  isolatePathComponents: 0,
-  removeTrailingSlash: true,
-  removeQueryParameters: true
+    ignoredBasePath: 'u',
+    isolatePathComponents: 0,
+    removeTrailingSlash: true,
+    removeQueryParameters: true
 });
 function venmoProfileUrlToWebsiteLink(input) {
-  return {
-    t: VENMO_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, VENMO_WEBSITE_LINK_ISOLATE_PROFILE_ID)
-  };
+    return {
+        t: VENMO_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, VENMO_WEBSITE_LINK_ISOLATE_PROFILE_ID)
+    };
 }
 function venmoProfileUrl(profileId) {
-  return `${VENMO_BASE_URL}/u/${profileId}`;
+    return `${VENMO_BASE_URL}/u/${profileId}`;
 }
 // MARK: Spotify
 const SPOTIFY_BASE_URL = `https://open.spotify.com/`;
 const SPOTIFY_WEBSITE_LINK_TYPE = 'sp';
 const SPOTIFY_WEBSITE_LINK_ISOLATE_PROFILE_ID = util.isolateWebsitePathFunction({
-  ignoredBasePath: 'user',
-  isolatePathComponents: 0,
-  removeTrailingSlash: true,
-  removeQueryParameters: true
+    ignoredBasePath: 'user',
+    isolatePathComponents: 0,
+    removeTrailingSlash: true,
+    removeQueryParameters: true
 });
 function spotifyProfileUrlToWebsiteLink(input) {
-  return {
-    t: SPOTIFY_WEBSITE_LINK_TYPE,
-    d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, SPOTIFY_WEBSITE_LINK_ISOLATE_PROFILE_ID)
-  };
+    return {
+        t: SPOTIFY_WEBSITE_LINK_TYPE,
+        d: usernameFromUsernameOrWebsiteWithOneOffBaseUrlUsername(input, SPOTIFY_WEBSITE_LINK_ISOLATE_PROFILE_ID)
+    };
 }
 function spotifyProfileUrl(profileId) {
-  return `${SPOTIFY_BASE_URL}/user/${profileId}`;
+    return `${SPOTIFY_BASE_URL}/user/${profileId}`;
 }
 
 const GRANTED_SYS_ADMIN_ROLE_KEY = 'sysadmin';
@@ -384,7 +451,7 @@ const GRANTED_ADMIN_ROLE_KEY = 'admin';
  * @returns
  */
 function isGrantedAdminLevelRole(role) {
-  return role === GRANTED_ADMIN_ROLE_KEY || role === GRANTED_OWNER_ROLE_KEY;
+    return role === GRANTED_ADMIN_ROLE_KEY || role === GRANTED_OWNER_ROLE_KEY;
 }
 const GRANTED_READ_ROLE_KEY = 'read';
 const GRANTED_UPDATE_ROLE_KEY = 'update';
@@ -392,20 +459,20 @@ const GRANTED_DELETE_ROLE_KEY = 'delete';
 const FULL_ACCESS_ROLE_KEY = '__FULL__';
 const NO_ACCESS_ROLE_KEY = '__EMPTY__';
 function noAccessRoleMap() {
-  return {
-    [NO_ACCESS_ROLE_KEY]: true
-  };
+    return {
+        [NO_ACCESS_ROLE_KEY]: true
+    };
 }
 function isNoAccessRoleMap(input) {
-  return input[NO_ACCESS_ROLE_KEY] === true;
+    return input[NO_ACCESS_ROLE_KEY] === true;
 }
 function fullAccessRoleMap() {
-  return {
-    [FULL_ACCESS_ROLE_KEY]: true
-  };
+    return {
+        [FULL_ACCESS_ROLE_KEY]: true
+    };
 }
 function isFullAccessRoleMap(input) {
-  return input[FULL_ACCESS_ROLE_KEY] === true;
+    return input[FULL_ACCESS_ROLE_KEY] === true;
 }
 /**
  * Creates a GrantedRoleMapReader.
@@ -414,61 +481,63 @@ function isFullAccessRoleMap(input) {
  * @returns
  */
 function grantedRoleMapReader(map) {
-  return new GrantedRoleMapReaderInstance(map);
+    return new GrantedRoleMapReaderInstance(map);
 }
 class GrantedRoleMapReaderInstance {
-  constructor(map) {
-    this._map = void 0;
-    this._map = map;
-  }
-  hasNoAccess() {
-    return this._map[NO_ACCESS_ROLE_KEY];
-  }
-  truthMap(input) {
-    const result = {};
-    util.forEachKeyValue(input, {
-      forEach: ([role, value]) => {
-        if (this.hasRole(role)) {
-          result[role] = value;
-        }
-      }
-    });
-    return result;
-  }
-  hasRole(role) {
-    return this.hasRoles('any', role);
-  }
-  hasRoles(setIncludes, inputRoles) {
-    if (this._map[FULL_ACCESS_ROLE_KEY]) {
-      return true;
-    } else {
-      return this.containsRoles(setIncludes, inputRoles);
+    _map;
+    constructor(map) {
+        this._map = map;
     }
-  }
-  containsRoles(setIncludes, inputRoles) {
-    const roles = util.iterableToArray(inputRoles);
-    if (setIncludes === 'any') {
-      return this.containsAnyRole(roles);
-    } else {
-      return this.containsEachRole(roles);
+    hasNoAccess() {
+        return this._map[NO_ACCESS_ROLE_KEY];
     }
-  }
-  containsAnyRole(roles) {
-    for (const role of roles) {
-      if (this._map[role]) {
-        return true;
-      }
+    truthMap(input) {
+        const result = {};
+        util.forEachKeyValue(input, {
+            forEach: ([role, value]) => {
+                if (this.hasRole(role)) {
+                    result[role] = value;
+                }
+            }
+        });
+        return result;
+    }
+    hasRole(role) {
+        return this.hasRoles('any', role);
+    }
+    hasRoles(setIncludes, inputRoles) {
+        if (this._map[FULL_ACCESS_ROLE_KEY]) {
+            return true;
+        }
+        else {
+            return this.containsRoles(setIncludes, inputRoles);
+        }
     }
-    return false;
-  }
-  containsEachRole(roles) {
-    for (const role of roles) {
-      if (!this._map[role]) {
+    containsRoles(setIncludes, inputRoles) {
+        const roles = util.iterableToArray(inputRoles);
+        if (setIncludes === 'any') {
+            return this.containsAnyRole(roles);
+        }
+        else {
+            return this.containsEachRole(roles);
+        }
+    }
+    containsAnyRole(roles) {
+        for (const role of roles) {
+            if (this._map[role]) {
+                return true;
+            }
+        }
         return false;
-      }
     }
-    return true;
-  }
+    containsEachRole(roles) {
+        for (const role of roles) {
+            if (!this._map[role]) {
+                return false;
+            }
+        }
+        return true;
+    }
 }
 /**
  * Converts the input array of roles to a GrantedRoleKeysMap.
@@ -477,74 +546,77 @@ class GrantedRoleMapReaderInstance {
  * @returns
  */
 function grantedRoleKeysMapFromArray(roles, value = true) {
-  return util.arrayToObject(roles, x => x, () => value);
+    return util.arrayToObject(roles, (x) => x, () => value);
 }
 
 function noAccessContextGrantedModelRoles(context, data) {
-  return contextGrantedModelRoles(context, data, noAccessRoleMap());
+    return contextGrantedModelRoles(context, data, noAccessRoleMap());
 }
 function fullAccessGrantedModelRoles(context, data) {
-  return contextGrantedModelRoles(context, data, fullAccessRoleMap());
+    return contextGrantedModelRoles(context, data, fullAccessRoleMap());
 }
 function contextGrantedModelRoles(context, data, roles) {
-  return {
-    data,
-    context,
-    roleMap: roles
-  };
+    return {
+        data,
+        context,
+        roleMap: roles
+    };
 }
 
 /**
  * Abstract ModelPermissionService implementation.
  */
 class AbstractModelPermissionService {
-  constructor(modelLoader) {
-    this._modelLoader = void 0;
-    this._modelLoader = modelLoader;
-  }
-  get modelLoader() {
-    return this._modelLoader;
-  }
-  async roleMapForKeyContext(key, context) {
-    const model = await this.modelLoader.loadModelForKey(key, context);
-    let result;
-    if (model != null) {
-      result = await this.roleMapForModelContext(model, context);
-    } else {
-      result = noAccessContextGrantedModelRoles(context);
+    _modelLoader;
+    constructor(modelLoader) {
+        this._modelLoader = modelLoader;
     }
-    return result;
-  }
-  async roleMapForModelContext(model, context) {
-    const output = await this.outputForModel(model, context);
-    let result;
-    if (output != null && this.isUsableOutputForRoles(output, context)) {
-      result = await this.getRoleMapForOutput(output, context, model);
-    } else {
-      result = noAccessContextGrantedModelRoles(context, output);
+    get modelLoader() {
+        return this._modelLoader;
+    }
+    async roleMapForKeyContext(key, context) {
+        const model = await this.modelLoader.loadModelForKey(key, context);
+        let result;
+        if (model != null) {
+            result = await this.roleMapForModelContext(model, context);
+        }
+        else {
+            result = noAccessContextGrantedModelRoles(context);
+        }
+        return result;
+    }
+    async roleMapForModelContext(model, context) {
+        const output = await this.outputForModel(model, context);
+        let result;
+        if (output != null && this.isUsableOutputForRoles(output, context)) {
+            result = await this.getRoleMapForOutput(output, context, model);
+        }
+        else {
+            result = noAccessContextGrantedModelRoles(context, output);
+        }
+        return result;
+    }
+    async getRoleMapForOutput(output, context, model) {
+        const roleMap = await this.roleMapForModel(output, context, model);
+        return contextGrantedModelRoles(context, output, roleMap);
+    }
+    isUsableOutputForRoles(output, context) {
+        return true; // can override in parent functions to further filter roles.
     }
-    return result;
-  }
-  async getRoleMapForOutput(output, context, model) {
-    const roleMap = await this.roleMapForModel(output, context, model);
-    return contextGrantedModelRoles(context, output, roleMap);
-  }
-  isUsableOutputForRoles(output, context) {
-    return true; // can override in parent functions to further filter roles.
-  }
 }
 
 function syncEntityCommonTypeIdPairFactory(commonType) {
-  return input => {
-    if (typeof input === 'string') {
-      return {
-        commonType,
-        commonId: input
-      };
-    } else {
-      return input;
-    }
-  };
+    return (input) => {
+        if (typeof input === 'string') {
+            return {
+                commonType,
+                commonId: input
+            };
+        }
+        else {
+            return input;
+        }
+    };
 }
 /**
  * Creates a SyncEntityFactory.
@@ -553,496 +625,323 @@ function syncEntityCommonTypeIdPairFactory(commonType) {
  * @returns
  */
 function syncEntityFactory(config) {
-  const {
-    idFactory: inputIdFactory,
-    sourceInfo
-  } = config;
-  const idFactory = inputIdFactory ?? util.MAP_IDENTITY;
-  return input => {
-    const {
-      commonType,
-      commonId
-    } = input;
-    const id = idFactory(commonId);
-    return {
-      commonType,
-      commonId,
-      id,
-      sourceInfo
+    const { idFactory: inputIdFactory, sourceInfo } = config;
+    const idFactory = inputIdFactory ?? util.MAP_IDENTITY;
+    return (input) => {
+        const { commonType, commonId } = input;
+        const id = idFactory(commonId);
+        return {
+            commonType,
+            commonId,
+            id,
+            sourceInfo
+        };
     };
-  };
 }
 
-var makeError = {exports: {}};
-
-(function (module, exports$1) {
-
-	// ===================================================================
-
-	var construct = typeof Reflect !== "undefined" ? Reflect.construct : undefined;
-	var defineProperty = Object.defineProperty;
-
-	// -------------------------------------------------------------------
-
-	var captureStackTrace = Error.captureStackTrace;
-	if (captureStackTrace === undefined) {
-	  captureStackTrace = function captureStackTrace(error) {
-	    var container = new Error();
-
-	    defineProperty(error, "stack", {
-	      configurable: true,
-	      get: function getStack() {
-	        var stack = container.stack;
-
-	        // Replace property with value for faster future accesses.
-	        defineProperty(this, "stack", {
-	          configurable: true,
-	          value: stack,
-	          writable: true,
-	        });
-
-	        return stack;
-	      },
-	      set: function setStack(stack) {
-	        defineProperty(error, "stack", {
-	          configurable: true,
-	          value: stack,
-	          writable: true,
-	        });
-	      },
-	    });
-	  };
-	}
-
-	// -------------------------------------------------------------------
-
-	function BaseError(message) {
-	  if (message !== undefined) {
-	    defineProperty(this, "message", {
-	      configurable: true,
-	      value: message,
-	      writable: true,
-	    });
-	  }
-
-	  var cname = this.constructor.name;
-	  if (cname !== undefined && cname !== this.name) {
-	    defineProperty(this, "name", {
-	      configurable: true,
-	      value: cname,
-	      writable: true,
-	    });
-	  }
-
-	  captureStackTrace(this, this.constructor);
-	}
-
-	BaseError.prototype = Object.create(Error.prototype, {
-	  // See: https://github.com/JsCommunity/make-error/issues/4
-	  constructor: {
-	    configurable: true,
-	    value: BaseError,
-	    writable: true,
-	  },
-	});
-
-	// -------------------------------------------------------------------
-
-	// Sets the name of a function if possible (depends of the JS engine).
-	var setFunctionName = (function() {
-	  function setFunctionName(fn, name) {
-	    return defineProperty(fn, "name", {
-	      configurable: true,
-	      value: name,
-	    });
-	  }
-	  try {
-	    var f = function() {};
-	    setFunctionName(f, "foo");
-	    if (f.name === "foo") {
-	      return setFunctionName;
-	    }
-	  } catch (_) {}
-	})();
-
-	// -------------------------------------------------------------------
-
-	function makeError(constructor, super_) {
-	  if (super_ == null || super_ === Error) {
-	    super_ = BaseError;
-	  } else if (typeof super_ !== "function") {
-	    throw new TypeError("super_ should be a function");
-	  }
-
-	  var name;
-	  if (typeof constructor === "string") {
-	    name = constructor;
-	    constructor =
-	      construct !== undefined
-	        ? function() {
-	            return construct(super_, arguments, this.constructor);
-	          }
-	        : function() {
-	            super_.apply(this, arguments);
-	          };
-
-	    // If the name can be set, do it once and for all.
-	    if (setFunctionName !== undefined) {
-	      setFunctionName(constructor, name);
-	      name = undefined;
-	    }
-	  } else if (typeof constructor !== "function") {
-	    throw new TypeError("constructor should be either a string or a function");
-	  }
-
-	  // Also register the super constructor also as `constructor.super_` just
-	  // like Node's `util.inherits()`.
-	  //
-	  // eslint-disable-next-line dot-notation
-	  constructor.super_ = constructor["super"] = super_;
-
-	  var properties = {
-	    constructor: {
-	      configurable: true,
-	      value: constructor,
-	      writable: true,
-	    },
-	  };
-
-	  // If the name could not be set on the constructor, set it on the
-	  // prototype.
-	  if (name !== undefined) {
-	    properties.name = {
-	      configurable: true,
-	      value: name,
-	      writable: true,
-	    };
-	  }
-	  constructor.prototype = Object.create(super_.prototype, properties);
-
-	  return constructor;
-	}
-	exports$1 = module.exports = makeError;
-	exports$1.BaseError = BaseError; 
-} (makeError, makeError.exports));
-
-var makeErrorExports = makeError.exports;
-
 /**
  * Error thrown when the common type is not known/registered.
  */
-class UnregisteredSyncEntityCommonTypeError extends makeErrorExports.BaseError {
-  constructor(commonType) {
-    super(`The common type "${commonType}" is not registered.`);
-    this.commonType = void 0;
-    this.commonType = commonType;
-  }
+class UnregisteredSyncEntityCommonTypeError extends makeError.BaseError {
+    commonType;
+    constructor(commonType) {
+        super(`The common type "${commonType}" is not registered.`);
+        this.commonType = commonType;
+    }
 }
 /**
  * Error thrown when no primary sync source is found for an entity.
  */
-class NoPrimarySyncSourceError extends makeErrorExports.BaseError {
-  constructor(entity) {
-    super(`No primary sync source found for entity "${entity.commonType}:${entity.commonId}".`);
-    this.entity = void 0;
-    this.entity = entity;
-  }
+class NoPrimarySyncSourceError extends makeError.BaseError {
+    entity;
+    constructor(entity) {
+        super(`No primary sync source found for entity "${entity.commonType}:${entity.commonId}".`);
+        this.entity = entity;
+    }
 }
 /**
  * Error thrown when multiple primary sync sources are found for an entity.
  */
-class MultiplePrimarySyncSourceError extends makeErrorExports.BaseError {
-  constructor(entity) {
-    super(`Multiple primary sync sources found for entity "${entity.commonType}:${entity.commonId}".`);
-    this.entity = void 0;
-    this.entity = entity;
-  }
+class MultiplePrimarySyncSourceError extends makeError.BaseError {
+    entity;
+    constructor(entity) {
+        super(`Multiple primary sync sources found for entity "${entity.commonType}:${entity.commonId}".`);
+        this.entity = entity;
+    }
 }
 /**
  * Error thrown when a synchronization fails for an entity.
  */
-class SynchronizationFailedError extends makeErrorExports.BaseError {
-  constructor(entity, error) {
-    super(`Synchronization failed for entity "${entity.commonType}:${entity.commonId}". Error: ${error}`);
-    this.entity = void 0;
-    this.error = void 0;
-    this.entity = entity;
-    this.error = error;
-  }
+class SynchronizationFailedError extends makeError.BaseError {
+    entity;
+    error;
+    constructor(entity, error) {
+        super(`Synchronization failed for entity "${entity.commonType}:${entity.commonId}". Error: ${error}`);
+        this.entity = entity;
+        this.error = error;
+    }
 }
 
 function syncEntitySynchronizer(config) {
-  const map = new Map(config.commonTypeSynchronizers.map(x => [x.commonType, x]));
-  const commonTypes = Array.from(map.keys());
-  const commonTypeSynchronizer = input => {
-    const synchronizer = map.get(input);
-    if (!synchronizer) {
-      throw new UnregisteredSyncEntityCommonTypeError(input);
-    }
-    return synchronizer;
-  };
-  return {
-    commonTypes,
-    commonTypeSynchronizer,
-    synchronizeInstance: input => {
-      const synchronizer = commonTypeSynchronizer(input.commonType);
-      return synchronizer.synchronizeInstance(input);
-    }
-  };
+    const map = new Map(config.commonTypeSynchronizers.map((x) => [x.commonType, x]));
+    const commonTypes = Array.from(map.keys());
+    const commonTypeSynchronizer = (input) => {
+        const synchronizer = map.get(input);
+        if (!synchronizer) {
+            throw new UnregisteredSyncEntityCommonTypeError(input);
+        }
+        return synchronizer;
+    };
+    return {
+        commonTypes,
+        commonTypeSynchronizer,
+        synchronizeInstance: (input) => {
+            const synchronizer = commonTypeSynchronizer(input.commonType);
+            return synchronizer.synchronizeInstance(input);
+        }
+    };
 }
 
 function basicSyncEntityCommonTypeSynchronizerInstanceFactory(config) {
-  const {
-    commonType,
-    sources,
-    entitySourceContextLoader,
-    dynamicSources = false
-  } = config;
-  const syncEntityCommonTypeIdPairForType = syncEntityCommonTypeIdPairFactory(commonType);
-  const sourcesByContextType = util.makeValuesGroupMap(sources, x => x.contextType);
-  const allGlobalSources = sourcesByContextType.get('global') ?? [];
-  const allContextSources = sourcesByContextType.get('context') ?? [];
-  /**
-   * Loads the relevant sources for the given entity and context.
-   *
-   * @param entitySourceContext The contextual information for the entity.
-   * @returns The relevant sources for the entity.
-   */
-  function loadSources(entityCommonTypeIdPair, entitySourceContext) {
-    const {
-      globalSources,
-      contextSources
-    } = entitySourceContext;
-    // load/filter global sources
-    const globalMap = new Map(globalSources.map(x => {
-      let sourceId;
-      let flowType;
-      if (typeof x === 'string') {
-        sourceId = x;
-        flowType = 'unset';
-      } else {
-        sourceId = x.sourceId;
-        flowType = x.flowType;
-      }
-      return [sourceId, {
-        sourceId,
-        flowType
-      }];
-    }));
-    const relevantGlobalSources = util.filterMaybeArrayValues(allGlobalSources.map(x => {
-      const sourceContext = globalMap.get(x.info.id);
-      let result;
-      if (sourceContext != null) {
-        result = {
-          entityCommonTypeIdPair,
-          flowType: sourceContext.flowType ?? x.defaultFlowType ?? 'unset',
-          source: x
-        };
-      }
-      return result;
-    }));
-    // load/filter context sources
-    const contextMap = new Map(contextSources.map(x => [x.sourceId, x]));
-    const relevantContextSources = util.filterMaybeArrayValues(allContextSources.map(x => {
-      const sourceContext = contextMap.get(x.info.id);
-      let result;
-      if (sourceContext != null) {
-        const flowType = sourceContext.flowType ?? x.defaultFlowType ?? 'unset';
-        result = {
-          entityCommonTypeIdPair,
-          flowType,
-          source: x,
-          context: sourceContext
-        };
-      }
-      return result;
-    }));
-    const allSources = [...relevantGlobalSources, ...relevantContextSources];
-    // sort by order, with primary first
-    allSources.sort(util.sortByNumberFunction(x => {
-      let result;
-      switch (x.flowType) {
-        case 'primary':
-          result = 1;
-          break;
-        case 'secondary':
-          result = 2;
-          break;
-        case 'unset':
-        default:
-          result = 3;
-          break;
-      }
-      return result;
-    }));
-    return allSources;
-  }
-  const synchronizeInstance = async input => {
-    const syncEntityCommonTypeIdPair = syncEntityCommonTypeIdPairForType(input);
-    const _loadRelevantSources = async () => {
-      const entitySourceContext = await entitySourceContextLoader(syncEntityCommonTypeIdPair);
-      const relevantSources = loadSources(syncEntityCommonTypeIdPair, entitySourceContext);
-      return relevantSources;
-    };
-    let loadRelevantSources;
-    if (dynamicSources) {
-      // if dynamic, reload each time and do not cache
-      loadRelevantSources = _loadRelevantSources;
-    } else {
-      // if not dynamic, make a cached getter
-      loadRelevantSources = util.cachedGetter(_loadRelevantSources);
-    }
+    const { commonType, sources, entitySourceContextLoader, dynamicSources = false } = config;
+    const syncEntityCommonTypeIdPairForType = syncEntityCommonTypeIdPairFactory(commonType);
+    const sourcesByContextType = util.makeValuesGroupMap(sources, (x) => x.contextType);
+    const allGlobalSources = sourcesByContextType.get('global') ?? [];
+    const allContextSources = sourcesByContextType.get('context') ?? [];
     /**
-     * Performs the synchonization
+     * Loads the relevant sources for the given entity and context.
+     *
+     * @param entitySourceContext The contextual information for the entity.
+     * @returns The relevant sources for the entity.
      */
-    const synchronize = async context => {
-      const relevantSources = await loadRelevantSources();
-      const syncEntityInstances = await Promise.all(relevantSources.map(x => x.source.syncEntityInstance(x).then(y => [x, y])));
-      const sourcesByFlowType = util.makeValuesGroupMap(syncEntityInstances, x => x[0].flowType);
-      const primarySources = sourcesByFlowType.get('primary') ?? [];
-      const secondarySources = sourcesByFlowType.get('secondary') ?? [];
-      const replicaSources = sourcesByFlowType.get('replica') ?? [];
-      // assert primary sources count
-      switch (primarySources.length) {
-        case 0:
-          throw new NoPrimarySyncSourceError(syncEntityCommonTypeIdPair);
-        case 1:
-          break;
-        default:
-          throw new MultiplePrimarySyncSourceError(syncEntityCommonTypeIdPair);
-      }
-      function synchronizeInstance(source, deleted) {
-        const [input, sourceInstance] = source;
-        const promise = deleted ? sourceInstance.synchronizeDelete() : sourceInstance.synchronize();
-        return promise.catch(error => {
-          const errorResult = {
-            type: 'error',
-            error,
-            entity: {
-              ...syncEntityCommonTypeIdPair,
-              sourceInfo: input.source.info,
-              id: ''
+    function loadSources(entityCommonTypeIdPair, entitySourceContext) {
+        const { globalSources, contextSources } = entitySourceContext;
+        // load/filter global sources
+        const globalMap = new Map(globalSources.map((x) => {
+            let sourceId;
+            let flowType;
+            if (typeof x === 'string') {
+                sourceId = x;
+                flowType = 'unset';
             }
-          };
-          return errorResult;
-        });
-      }
-      async function performSynchronizationOfSources(input) {
-        const {
-          secondaryFlaggedDelete
-        } = input;
-        let result;
-        // synchronize the primary source
-        const primarySource = primarySources[0];
-        const primarySyncResult = await synchronizeInstance(primarySource, secondaryFlaggedDelete ?? false);
-        const synchronizedEntityResults = [primarySyncResult];
-        let primaryFlaggedDelete = false;
-        switch (primarySyncResult.type) {
-          case 'deleted':
-            primaryFlaggedDelete = true;
-            break;
-          case 'failed':
-          case 'error':
-            throw new SynchronizationFailedError(syncEntityCommonTypeIdPair, primarySyncResult.error);
-        }
-        // synchronize all secondary sources, one after the other. If any secondary source returns deleted and the primary source was not flagged as deleted, then the synchronization will be restarted.
-        for (const secondarySource of secondarySources) {
-          const secondarySyncResult = await synchronizeInstance(secondarySource, primaryFlaggedDelete);
-          synchronizedEntityResults.push(secondarySyncResult);
-          switch (secondarySyncResult.type) {
-            case 'deleted':
-              if (primaryFlaggedDelete === false) {
-                break;
-              }
-              break;
-            case 'failed':
-            case 'error':
-              throw new SynchronizationFailedError(syncEntityCommonTypeIdPair, secondarySyncResult.error);
-          }
+            else {
+                sourceId = x.sourceId;
+                flowType = x.flowType;
+            }
+            return [sourceId, { sourceId, flowType }];
+        }));
+        const relevantGlobalSources = util.filterMaybeArrayValues(allGlobalSources.map((x) => {
+            const sourceContext = globalMap.get(x.info.id);
+            let result;
+            if (sourceContext != null) {
+                result = {
+                    entityCommonTypeIdPair,
+                    flowType: sourceContext.flowType ?? x.defaultFlowType ?? 'unset',
+                    source: x
+                };
+            }
+            return result;
+        }));
+        // load/filter context sources
+        const contextMap = new Map(contextSources.map((x) => [x.sourceId, x]));
+        const relevantContextSources = util.filterMaybeArrayValues(allContextSources.map((x) => {
+            const sourceContext = contextMap.get(x.info.id);
+            let result;
+            if (sourceContext != null) {
+                const flowType = sourceContext.flowType ?? x.defaultFlowType ?? 'unset';
+                result = {
+                    entityCommonTypeIdPair,
+                    flowType,
+                    source: x,
+                    context: sourceContext
+                };
+            }
+            return result;
+        }));
+        const allSources = [...relevantGlobalSources, ...relevantContextSources];
+        // sort by order, with primary first
+        allSources.sort(util.sortByNumberFunction((x) => {
+            let result;
+            switch (x.flowType) {
+                case 'primary':
+                    result = 1;
+                    break;
+                case 'secondary':
+                    result = 2;
+                    break;
+                case 'unset':
+                default:
+                    result = 3;
+                    break;
+            }
+            return result;
+        }));
+        return allSources;
+    }
+    const synchronizeInstance = async (input) => {
+        const syncEntityCommonTypeIdPair = syncEntityCommonTypeIdPairForType(input);
+        const _loadRelevantSources = async () => {
+            const entitySourceContext = await entitySourceContextLoader(syncEntityCommonTypeIdPair);
+            const relevantSources = loadSources(syncEntityCommonTypeIdPair, entitySourceContext);
+            return relevantSources;
+        };
+        let loadRelevantSources;
+        if (dynamicSources) {
+            // if dynamic, reload each time and do not cache
+            loadRelevantSources = _loadRelevantSources;
         }
-        // if result was already set, then it was completed in a recursive result
-        if (result == null) {
-          // synchronize all replica sources concurrently
-          const replicaTaskResults = await util.performAsyncTasks(replicaSources, x => synchronizeInstance(x, primaryFlaggedDelete), {
-            sequential: false,
-            maxParallelTasks: 3
-          });
-          // add all the results
-          util.pushArrayItemsIntoArray(synchronizedEntityResults, replicaTaskResults.results.map(x => x[1]));
-          // compute final result
-          result = {
-            synchronizedEntityResults
-          };
+        else {
+            // if not dynamic, make a cached getter
+            loadRelevantSources = util.cachedGetter(_loadRelevantSources);
         }
-        return result;
-      }
-      const result = await performSynchronizationOfSources({
-        });
-      return {
-        targetPair: syncEntityCommonTypeIdPair,
-        entitiesSynchronized: result.synchronizedEntityResults
-      };
+        /**
+         * Performs the synchonization
+         */
+        const synchronize = async (context) => {
+            const relevantSources = await loadRelevantSources();
+            const syncEntityInstances = await Promise.all(relevantSources.map((x) => x.source.syncEntityInstance(x).then((y) => [x, y])));
+            const sourcesByFlowType = util.makeValuesGroupMap(syncEntityInstances, (x) => x[0].flowType);
+            const primarySources = sourcesByFlowType.get('primary') ?? [];
+            const secondarySources = sourcesByFlowType.get('secondary') ?? [];
+            const replicaSources = sourcesByFlowType.get('replica') ?? [];
+            // assert primary sources count
+            switch (primarySources.length) {
+                case 0:
+                    throw new NoPrimarySyncSourceError(syncEntityCommonTypeIdPair);
+                case 1:
+                    break;
+                default:
+                    throw new MultiplePrimarySyncSourceError(syncEntityCommonTypeIdPair);
+            }
+            function synchronizeInstance(source, deleted) {
+                const [input, sourceInstance] = source;
+                const promise = deleted ? sourceInstance.synchronizeDelete() : sourceInstance.synchronize();
+                return promise.catch((error) => {
+                    const errorResult = {
+                        type: 'error',
+                        error,
+                        entity: {
+                            ...syncEntityCommonTypeIdPair,
+                            sourceInfo: input.source.info,
+                            id: ''
+                        }
+                    };
+                    return errorResult;
+                });
+            }
+            async function performSynchronizationOfSources(input) {
+                const { secondaryFlaggedDelete } = input;
+                let result;
+                // synchronize the primary source
+                const primarySource = primarySources[0];
+                const primarySyncResult = await synchronizeInstance(primarySource, secondaryFlaggedDelete ?? false);
+                const synchronizedEntityResults = [primarySyncResult];
+                let primaryFlaggedDelete = false;
+                switch (primarySyncResult.type) {
+                    case 'deleted':
+                        primaryFlaggedDelete = true;
+                        break;
+                    case 'failed':
+                    case 'error':
+                        throw new SynchronizationFailedError(syncEntityCommonTypeIdPair, primarySyncResult.error);
+                }
+                // synchronize all secondary sources, one after the other. If any secondary source returns deleted and the primary source was not flagged as deleted, then the synchronization will be restarted.
+                for (const secondarySource of secondarySources) {
+                    const secondarySyncResult = await synchronizeInstance(secondarySource, primaryFlaggedDelete);
+                    synchronizedEntityResults.push(secondarySyncResult);
+                    switch (secondarySyncResult.type) {
+                        case 'deleted':
+                            if (primaryFlaggedDelete === false) {
+                                break;
+                            }
+                            break;
+                        case 'failed':
+                        case 'error':
+                            throw new SynchronizationFailedError(syncEntityCommonTypeIdPair, secondarySyncResult.error);
+                    }
+                }
+                // if result was already set, then it was completed in a recursive result
+                if (result == null) {
+                    // synchronize all replica sources concurrently
+                    const replicaTaskResults = await util.performAsyncTasks(replicaSources, (x) => synchronizeInstance(x, primaryFlaggedDelete), {
+                        sequential: false,
+                        maxParallelTasks: 3
+                    });
+                    // add all the results
+                    util.pushArrayItemsIntoArray(synchronizedEntityResults, replicaTaskResults.results.map((x) => x[1]));
+                    // compute final result
+                    result = {
+                        synchronizedEntityResults
+                    };
+                }
+                return result;
+            }
+            const result = await performSynchronizationOfSources({ });
+            return {
+                targetPair: syncEntityCommonTypeIdPair,
+                entitiesSynchronized: result.synchronizedEntityResults
+            };
+        };
+        const instance = {
+            entityPair: syncEntityCommonTypeIdPair,
+            synchronize
+        };
+        return instance;
     };
-    const instance = {
-      entityPair: syncEntityCommonTypeIdPair,
-      synchronize
+    const result = {
+        commonType,
+        synchronizeInstance
     };
-    return instance;
-  };
-  const result = {
-    commonType,
-    synchronizeInstance
-  };
-  return result;
+    return result;
 }
 
 // MARK: String
 function transformStringToBoolean(defaultValue) {
-  return params => util.stringToBoolean(params.value, defaultValue);
+    return (params) => util.stringToBoolean(params.value, defaultValue);
 }
 // MARK: Comma Separated Values
 function transformCommaSeparatedValueToArray(mapFn) {
-  return params => {
-    let result;
-    if (params.value) {
-      if (Array.isArray(params.value)) {
-        result = params.value;
-      } else {
-        result = util.splitCommaSeparatedString(params.value, mapFn);
-      }
-    }
-    return result;
-  };
+    return (params) => {
+        let result;
+        if (params.value) {
+            if (Array.isArray(params.value)) {
+                result = params.value;
+            }
+            else {
+                result = util.splitCommaSeparatedString(params.value, mapFn);
+            }
+        }
+        return result;
+    };
 }
-const transformCommaSeparatedNumberValueToArray = transformCommaSeparatedValueToArray(x => Number(x));
-const transformCommaSeparatedStringValueToArray = transformCommaSeparatedValueToArray(x => x);
+const transformCommaSeparatedNumberValueToArray = transformCommaSeparatedValueToArray((x) => Number(x));
+const transformCommaSeparatedStringValueToArray = transformCommaSeparatedValueToArray((x) => x);
 
 // MARK: Transform Annotations
 function TransformCommaSeparatedValueToArray(mapFn) {
-  return classTransformer.Transform(transformCommaSeparatedValueToArray(mapFn));
+    return classTransformer.Transform(transformCommaSeparatedValueToArray(mapFn));
 }
 const TransformCommaSeparatedStringValueToArray = () => classTransformer.Transform(transformCommaSeparatedStringValueToArray);
 const TransformCommaSeparatedNumberValueToArray = () => classTransformer.Transform(transformCommaSeparatedNumberValueToArray);
 const TransformStringValueToBoolean = () => classTransformer.Transform(transformStringToBoolean());
 
 function transformAndValidateObject(config) {
-  const transformToResult = transformAndValidateObjectResult(config);
-  const {
-    handleValidationError
-  } = config;
-  return (input, context) => transformToResult(input, context).then(async x => {
-    const object = x.object;
-    let result;
-    if (x.success) {
-      result = x.result;
-    } else {
-      result = await handleValidationError(x.validationErrors);
-    }
-    return {
-      object,
-      result
-    };
-  });
+    const transformToResult = transformAndValidateObjectResult(config);
+    const { handleValidationError } = config;
+    return (input, context) => transformToResult(input, context).then(async (x) => {
+        const object = x.object;
+        let result;
+        if (x.success) {
+            result = x.result;
+        }
+        else {
+            result = await handleValidationError(x.validationErrors);
+        }
+        return {
+            object,
+            result
+        };
+    });
 }
 /**
  * Creates a new TransformAndValidateObjectFactory.
@@ -1051,21 +950,17 @@ function transformAndValidateObject(config) {
  * @returns
  */
 function transformAndValidateObjectFactory(defaults) {
-  const {
-    handleValidationError: defaultHandleValidationError,
-    optionsForContext,
-    defaultValidationOptions
-  } = defaults;
-  return (classType, fn, handleValidationError) => {
-    const config = {
-      classType,
-      fn,
-      handleValidationError: handleValidationError ?? defaultHandleValidationError,
-      optionsForContext,
-      defaultValidationOptions
+    const { handleValidationError: defaultHandleValidationError, optionsForContext, defaultValidationOptions } = defaults;
+    return (classType, fn, handleValidationError) => {
+        const config = {
+            classType,
+            fn,
+            handleValidationError: handleValidationError ?? defaultHandleValidationError,
+            optionsForContext,
+            defaultValidationOptions
+        };
+        return transformAndValidateObject(config);
     };
-    return transformAndValidateObject(config);
-  };
 }
 /**
  * Factory function that wraps the input class type and handler function to first transform the input object to a the given class, and then validate it.
@@ -1075,134 +970,113 @@ function transformAndValidateObjectFactory(defaults) {
  * @returns
  */
 function transformAndValidateObjectResult(config) {
-  const {
-    defaultValidationOptions,
-    classType,
-    fn,
-    optionsForContext: inputOptionsForContext
-  } = config;
-  const optionsForContext = inputOptionsForContext ?? (() => ({}));
-  return async (input, context) => {
-    const {
-      transform: transformOptions,
-      validate: validateOptions
-    } = optionsForContext(context);
-    const object = classTransformer.plainToInstance(classType, input, {
-      ...transformOptions,
-      // Note: Each variable on the target class must be marked with the @Expose() annotation.
-      excludeExtraneousValues: true
-    });
-    const validationErrors = await classValidator.validate(object, {
-      forbidUnknownValues: false,
-      // allow classes without annotations by default
-      ...defaultValidationOptions,
-      ...validateOptions
-    });
-    if (validationErrors.length) {
-      return {
-        object,
-        validationErrors,
-        success: false
-      };
-    } else {
-      const result = await fn(object);
-      return {
-        object,
-        result,
-        success: true
-      };
-    }
-  };
+    const { defaultValidationOptions, classType, fn, optionsForContext: inputOptionsForContext } = config;
+    const optionsForContext = inputOptionsForContext ?? (() => ({}));
+    return async (input, context) => {
+        const { transform: transformOptions, validate: validateOptions } = optionsForContext(context);
+        const object = classTransformer.plainToInstance(classType, input, {
+            ...transformOptions,
+            // Note: Each variable on the target class must be marked with the @Expose() annotation.
+            excludeExtraneousValues: true
+        });
+        const validationErrors = await classValidator.validate(object, {
+            forbidUnknownValues: false, // allow classes without annotations by default
+            ...defaultValidationOptions,
+            ...validateOptions
+        });
+        if (validationErrors.length) {
+            return { object, validationErrors, success: false };
+        }
+        else {
+            const result = await fn(object);
+            return { object, result, success: true };
+        }
+    };
 }
 
 function transformAndValidateFunctionResultFactory(defaults) {
-  return toTransformAndValidateFunctionResultFactory(transformAndValidateObjectFactory(defaults));
+    return toTransformAndValidateFunctionResultFactory(transformAndValidateObjectFactory(defaults));
 }
 function toTransformAndValidateFunctionResultFactory(transformAndValidateObjectFactory) {
-  return (classType, fn, handleValidationError) => {
-    const transformAndValidateObjectFn = transformAndValidateObjectFactory(classType, fn, handleValidationError);
-    return (input, context) => {
-      return toTransformAndValidateFunctionResult(transformAndValidateObjectFn(input, context));
+    return (classType, fn, handleValidationError) => {
+        const transformAndValidateObjectFn = transformAndValidateObjectFactory(classType, fn, handleValidationError);
+        return (input, context) => {
+            return toTransformAndValidateFunctionResult(transformAndValidateObjectFn(input, context));
+        };
     };
-  };
 }
 function toTransformAndValidateFunctionResult(objectOutput) {
-  return util.mapPromiseOrValue(objectOutput, x => {
-    const {
-      object,
-      result
-    } = x;
-    const fnResult = result;
-    fnResult.params = object;
-    return fnResult;
-  });
+    return util.mapPromiseOrValue(objectOutput, (x) => {
+        const { object, result } = x;
+        const fnResult = result;
+        fnResult.params = object;
+        return fnResult;
+    });
 }
 
 function transformAndValidateResultFactory(defaults) {
-  const factory = transformAndValidateObjectFactory(defaults);
-  return (classType, fn, handleValidationError) => {
-    const transformAndValidateObjectFn = factory(classType, fn, handleValidationError);
-    return async (input, context) => {
-      const {
-        result
-      } = await transformAndValidateObjectFn(input, context);
-      return result;
+    const factory = transformAndValidateObjectFactory(defaults);
+    return (classType, fn, handleValidationError) => {
+        const transformAndValidateObjectFn = factory(classType, fn, handleValidationError);
+        return async (input, context) => {
+            const { result } = await transformAndValidateObjectFn(input, context);
+            return result;
+        };
     };
-  };
 }
 
 /**
  * isISO8601DayString validator
  */
 function IsISO8601DayString(validationOptions) {
-  return function (object, propertyName) {
-    classValidator.registerDecorator({
-      name: 'isISO8601DayString',
-      target: object.constructor,
-      propertyName: propertyName,
-      options: validationOptions,
-      validator: {
-        validate: util.isISO8601DayString,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a ISO8601DayString.`, validationOptions)
-      }
-    });
-  };
+    return function (object, propertyName) {
+        classValidator.registerDecorator({
+            name: 'isISO8601DayString',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate: util.isISO8601DayString,
+                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a ISO8601DayString.`, validationOptions)
+            }
+        });
+    };
 }
 
 /**
  * isMinuteOfDay validator
  */
 function IsMinuteOfDay(validationOptions) {
-  return function (object, propertyName) {
-    classValidator.registerDecorator({
-      name: 'isMinuteOfDay',
-      target: object.constructor,
-      propertyName: propertyName,
-      options: validationOptions,
-      validator: {
-        validate: util.isMinuteOfDay,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a valid minute of the day.`, validationOptions)
-      }
-    });
-  };
+    return function (object, propertyName) {
+        classValidator.registerDecorator({
+            name: 'isMinuteOfDay',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate: util.isMinuteOfDay,
+                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a valid minute of the day.`, validationOptions)
+            }
+        });
+    };
 }
 
 /**
  * isE164PhoneNumber validator that does not allowed extensions.
  */
 function IsE164PhoneNumber(validationOptions) {
-  return function (object, propertyName) {
-    classValidator.registerDecorator({
-      name: 'isE164PhoneNumber',
-      target: object.constructor,
-      propertyName: propertyName,
-      options: validationOptions,
-      validator: {
-        validate: x => util.isE164PhoneNumber(x, false),
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a E164PhoneNumber with no extension.`, validationOptions)
-      }
-    });
-  };
+    return function (object, propertyName) {
+        classValidator.registerDecorator({
+            name: 'isE164PhoneNumber',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate: (x) => util.isE164PhoneNumber(x, false),
+                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a E164PhoneNumber with no extension.`, validationOptions)
+            }
+        });
+    };
 }
 /**
  * isE164PhoneNumber validator that allows extensions.
@@ -1211,18 +1085,18 @@ function IsE164PhoneNumber(validationOptions) {
  * @returns
  */
 function IsE164PhoneNumberWithOptionalExtension(validationOptions) {
-  return function (object, propertyName) {
-    classValidator.registerDecorator({
-      name: 'isE164PhoneNumber',
-      target: object.constructor,
-      propertyName: propertyName,
-      options: validationOptions,
-      validator: {
-        validate: x => util.isE164PhoneNumber(x, true),
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not an E164PhoneNumber or has an invalid extension.`, validationOptions)
-      }
-    });
-  };
+    return function (object, propertyName) {
+        classValidator.registerDecorator({
+            name: 'isE164PhoneNumber',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate: (x) => util.isE164PhoneNumber(x, true),
+                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not an E164PhoneNumber or has an invalid extension.`, validationOptions)
+            }
+        });
+    };
 }
 /**
  * isE164PhoneNumberWithExtension validator
@@ -1231,72 +1105,72 @@ function IsE164PhoneNumberWithOptionalExtension(validationOptions) {
  * @returns
  */
 function IsE164PhoneNumberWithExtension(validationOptions) {
-  return function (object, propertyName) {
-    classValidator.registerDecorator({
-      name: 'isE164PhoneNumberWithExtension',
-      target: object.constructor,
-      propertyName: propertyName,
-      options: validationOptions,
-      validator: {
-        validate: util.isE164PhoneNumberWithExtension,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a E164PhoneNumberWithExtension.`, validationOptions)
-      }
-    });
-  };
+    return function (object, propertyName) {
+        classValidator.registerDecorator({
+            name: 'isE164PhoneNumberWithExtension',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate: util.isE164PhoneNumberWithExtension,
+                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a E164PhoneNumberWithExtension.`, validationOptions)
+            }
+        });
+    };
 }
 
 /**
  * isUniqueKeyedFunction validator
  */
 function IsUniqueKeyed(readKey, validationOptions) {
-  const isUniqueKeyed = util.isUniqueKeyedFunction(readKey);
-  return function (object, propertyName) {
-    classValidator.registerDecorator({
-      name: 'isUniqueKeyed',
-      target: object.constructor,
-      propertyName: propertyName,
-      options: validationOptions,
-      validator: {
-        validate: isUniqueKeyed,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value has one or more values with the same key. Keys must be unique.`, validationOptions)
-      }
-    });
-  };
+    const isUniqueKeyed = util.isUniqueKeyedFunction(readKey);
+    return function (object, propertyName) {
+        classValidator.registerDecorator({
+            name: 'isUniqueKeyed',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate: isUniqueKeyed,
+                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value has one or more values with the same key. Keys must be unique.`, validationOptions)
+            }
+        });
+    };
 }
 
 /**
  * isWebsiteUrl validator
  */
 function IsWebsiteUrl(validationOptions) {
-  return function (object, propertyName) {
-    classValidator.registerDecorator({
-      name: 'isWebsiteUrl',
-      target: object.constructor,
-      propertyName: propertyName,
-      options: validationOptions,
-      validator: {
-        validate: util.isWebsiteUrl,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a valid website url.`, validationOptions)
-      }
-    });
-  };
+    return function (object, propertyName) {
+        classValidator.registerDecorator({
+            name: 'isWebsiteUrl',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate: util.isWebsiteUrl,
+                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a valid website url.`, validationOptions)
+            }
+        });
+    };
 }
 /**
  * isWebsiteUrlWithPrefix validator
  */
 function IsWebsiteUrlWithPrefix(validationOptions) {
-  return function (object, propertyName) {
-    classValidator.registerDecorator({
-      name: 'isWebsiteUrlWithPrefix',
-      target: object.constructor,
-      propertyName: propertyName,
-      options: validationOptions,
-      validator: {
-        validate: util.isWebsiteUrlWithPrefix,
-        defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a valid website url that starts with a http/https prefix.`, validationOptions)
-      }
-    });
-  };
+    return function (object, propertyName) {
+        classValidator.registerDecorator({
+            name: 'isWebsiteUrlWithPrefix',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate: util.isWebsiteUrlWithPrefix,
+                defaultMessage: classValidator.buildMessage((eachPrefix, args) => eachPrefix + `$property value of "${args?.value}" is not a valid website url that starts with a http/https prefix.`, validationOptions)
+            }
+        });
+    };
 }
 
 exports.ADDRESS_CITY_MAX_LENGTH = ADDRESS_CITY_MAX_LENGTH;