@shakerquiz/utilities 2.0.0 → 3.0.0

package/source/enumerations/entities/game-status.js

@@ -0,0 +1,130 @@
+import { Role } from './role.js'
+
+export var GameStatus = /** @type {const} */ ({
+  'REJECTED': 'REJECTED',
+  'MODERATION': 'MODERATION',
+  'APPROVED': 'APPROVED',
+  'CLOSED': 'CLOSED',
+  'FORINVITES': 'FORINVITES',
+  'PUBLISHED': 'PUBLISHED',
+  'IS_RESERVE': 'IS_RESERVE',
+  'FINISHED': 'FINISHED',
+  'ARCHIVE': 'ARCHIVE',
+})
+
+export var GameStatuses = Object.values(GameStatus)
+
+export var GameStatusWeight = {
+  [GameStatus.REJECTED]: 0,
+  [GameStatus.MODERATION]: 1,
+  [GameStatus.APPROVED]: 2,
+  [GameStatus.CLOSED]: 3,
+  [GameStatus.FORINVITES]: 4,
+  [GameStatus.PUBLISHED]: 5,
+  [GameStatus.IS_RESERVE]: 6,
+  [GameStatus.FINISHED]: 7,
+  [GameStatus.ARCHIVE]: 8,
+}
+
+export var GameStatusTitle = {
+  [GameStatus.REJECTED]: 'Отклонено',
+  [GameStatus.MODERATION]: 'На проверке',
+  [GameStatus.APPROVED]: 'Одобрено',
+  [GameStatus.CLOSED]: 'Закрыта',
+  [GameStatus.FORINVITES]: 'По приглашению',
+  [GameStatus.PUBLISHED]: 'Опубликовано',
+  [GameStatus.IS_RESERVE]: 'В резерве',
+  [GameStatus.FINISHED]: 'Завершено',
+  [GameStatus.ARCHIVE]: 'В архиве',
+}
+
+export var GameStatusColor = {
+  [GameStatus.REJECTED]: 'danger',
+  [GameStatus.MODERATION]: 'primary',
+  [GameStatus.APPROVED]: 'success',
+  [GameStatus.CLOSED]: 'warning',
+  [GameStatus.FORINVITES]: 'current',
+  [GameStatus.PUBLISHED]: 'secondary',
+  [GameStatus.IS_RESERVE]: 'blue-900',
+  [GameStatus.FINISHED]: 'success',
+  [GameStatus.ARCHIVE]: 'current',
+}
+
+export var GameStatusTextColor = {
+  [GameStatus.REJECTED]: 'text-danger',
+  [GameStatus.MODERATION]: 'text-primary',
+  [GameStatus.APPROVED]: 'text-success',
+  [GameStatus.CLOSED]: 'text-warning',
+  [GameStatus.FORINVITES]: 'text-current',
+  [GameStatus.PUBLISHED]: 'text-secondary',
+  [GameStatus.IS_RESERVE]: 'text-blue-900',
+  [GameStatus.FINISHED]: 'text-success',
+  [GameStatus.ARCHIVE]: 'text-current',
+}
+
+/** @type {Record<GameStatus, Icon>} */
+export var GameStatusIcon = {
+  [GameStatus.REJECTED]: 'hero/outline/x-mark',
+  [GameStatus.MODERATION]: 'hero/outline/clock',
+  [GameStatus.APPROVED]: 'hero/outline/hand-thumb-up',
+  [GameStatus.CLOSED]: 'hero/outline/exclamation-triangle',
+  [GameStatus.FORINVITES]: 'hero/outline/lock-closed',
+  [GameStatus.PUBLISHED]: 'hero/outline/check-circle',
+  [GameStatus.IS_RESERVE]: 'hero/outline/user-plus',
+  [GameStatus.FINISHED]: 'hero/outline/check',
+  [GameStatus.ARCHIVE]: 'hero/outline/archive-box',
+}
+
+/** @type {{ [Key in Role]: Partial<Record<GameStatus, GameStatus[]>> }} */
+export var RoleGameStatusGameStatuses = {
+  [Role.admin]: {},
+
+  [Role.organizer]: {
+    [GameStatus.APPROVED]: [
+      GameStatus.APPROVED,
+      GameStatus.CLOSED,
+      GameStatus.FORINVITES,
+      GameStatus.PUBLISHED,
+      GameStatus.IS_RESERVE,
+      GameStatus.FINISHED,
+      GameStatus.ARCHIVE,
+    ],
+
+    [GameStatus.MODERATION]: [
+      GameStatus.MODERATION,
+    ],
+
+    [GameStatus.REJECTED]: [
+      GameStatus.REJECTED,
+      GameStatus.MODERATION,
+    ],
+  },
+
+  [Role.default]: {},
+}
+
+/** @type {{ [Key in Role]: GameStatus[] }} */
+export var RoleDefaultGameStatuses = {
+  [Role.admin]: [
+    'APPROVED',
+    'ARCHIVE',
+    'CLOSED',
+    'FINISHED',
+    'FORINVITES',
+    'IS_RESERVE',
+    'MODERATION',
+    'PUBLISHED',
+    'REJECTED',
+  ],
+
+  [Role.organizer]: [
+    'ARCHIVE',
+    'CLOSED',
+    'FINISHED',
+    'FORINVITES',
+    'IS_RESERVE',
+    'PUBLISHED',
+  ],
+
+  [Role.default]: [],
+}

package/source/enumerations/entities/password-mode.js

@@ -0,0 +1,40 @@
+export var PasswordMode = /** @type {const} */ ({
+  'known': 'known',
+  'unknown': 'unknown',
+})
+
+export var PasswordModes = Object.values(PasswordMode)
+
+export var PasswordModeTitle = {
+  [PasswordMode.known]: 'Назначен',
+  [PasswordMode.unknown]: 'Неизвестно',
+}
+
+export var PasswordModeWeight = {
+  [PasswordMode.known]: 0,
+  [PasswordMode.unknown]: 1,
+}
+
+/**
+ * @param {keyof typeof PasswordMode} value
+ */
+var getter = value =>
+  value in PasswordMode
+    ? value
+    : PasswordMode['unknown']
+
+export var getPasswordMode = value => {
+  if (value === null)
+    return getter(undefined)
+
+  switch (typeof value) {
+    case 'string':
+      return getter(value)
+
+    case 'object':
+      return getter(value?.mode)
+
+    default:
+      return getter(undefined)
+  }
+}

package/source/enumerations/entities/registration-attribute.js

@@ -0,0 +1,83 @@
+import { getTag } from '../../functions/tag.js'
+
+export var RegistrationAttribute = /** @type {const} */ ({
+  'Alone': 'Alone',
+  'Newcomer': 'Newcomer',
+  'Birthday': 'Birthday',
+  'Public': 'Public',
+})
+
+export var RegistrationAttributes = Object.values(RegistrationAttribute)
+
+export var RegistrationAttributeWeight = {
+  [RegistrationAttribute.Alone]: 0,
+  [RegistrationAttribute.Newcomer]: 1,
+  [RegistrationAttribute.Birthday]: 2,
+  [RegistrationAttribute.Public]: 3,
+}
+
+export var RegistrationAttributeTitle = {
+  [RegistrationAttribute.Alone]: 'Без команды',
+  [RegistrationAttribute.Newcomer]: 'Новичок',
+  [RegistrationAttribute.Birthday]: 'День рождения',
+  [RegistrationAttribute.Public]: 'Принимаем людей',
+}
+
+/** @type {Record<RegistrationAttribute, Icon>} */
+export var RegistrationAttributeIcon = {
+  [RegistrationAttribute.Alone]: 'hero/outline/user',
+  [RegistrationAttribute.Newcomer]: 'hero/outline/sparkles',
+  [RegistrationAttribute.Birthday]: 'hero/outline/cake',
+  [RegistrationAttribute.Public]: 'hero/outline/user-plus',
+}
+
+export var RegistrationAttributeEmoji = {
+  [RegistrationAttribute.Alone]: '👤',
+  [RegistrationAttribute.Newcomer]: '✨',
+  [RegistrationAttribute.Birthday]: '🎂',
+  [RegistrationAttribute.Public]: '🫂',
+}
+
+export var RegistrationAttributeRegistrationProperty = /** @type {const} */ ({
+  [RegistrationAttribute.Alone]: 'is_alone',
+  [RegistrationAttribute.Newcomer]: 'is_first',
+  [RegistrationAttribute.Birthday]: 'is_birthday',
+  [RegistrationAttribute.Public]: 'is_extensible',
+})
+
+export var RegistrationAttributeRegistrationProperties = Object.values(RegistrationAttributeRegistrationProperty)
+
+export var RegistrationPropertyRegistrationAttribute = {
+  [RegistrationAttributeRegistrationProperty[RegistrationAttribute.Alone]]: RegistrationAttribute.Alone,
+  [RegistrationAttributeRegistrationProperty[RegistrationAttribute.Newcomer]]: RegistrationAttribute.Newcomer,
+  [RegistrationAttributeRegistrationProperty[RegistrationAttribute.Birthday]]: RegistrationAttribute.Birthday,
+  [RegistrationAttributeRegistrationProperty[RegistrationAttribute.Public]]: RegistrationAttribute.Public,
+}
+
+/**
+ * @param {RegistrationAttribute[] | Partial<Pick<RegistrationTable, 'is_alone' | 'is_birthday' | 'is_extensible' | 'is_first'>>} value
+ */
+export var getRegistrationAttributes = value => {
+  switch (getTag(value)) {
+    case 'Object':
+      return RegistrationAttributeRegistrationProperties
+        .map(property => value[property] ? RegistrationPropertyRegistrationAttribute[property] : '')
+        .filter(Boolean)
+
+    case 'Array':
+      if (!value.every(attribute => RegistrationAttributes.includes(attribute)))
+        throw TypeError(
+          `[Function: getRegistrationAttributes] Parameter 'value': '${value}' of type 'Array' must include only members of 'RegistrationAttributes'.`,
+        )
+
+      return value.reduce((attributes, attribute) => {
+        attributes[RegistrationAttributeRegistrationProperty[attribute]] = true
+        return attributes
+      }, {})
+
+    default:
+      throw TypeError(
+        `[Function: getRegistrationAttributes] Parameter 'value': '${value}' must be of types: 'Object', 'Array'.`,
+      )
+  }
+}

package/source/enumerations/entities/registration-channel.js

@@ -0,0 +1,26 @@
+export var RegistrationChannel = /** @type {const} */ ({
+  'vkontakte': 'vkontakte',
+  'telegramBot': 'telegramBot',
+  'email': 'email',
+})
+
+export var RegistrationChannels = Object.values(RegistrationChannel)
+
+export var RegistrationChannelWeight = {
+  [RegistrationChannel.vkontakte]: 0,
+  [RegistrationChannel.telegramBot]: 1,
+  [RegistrationChannel.email]: 2,
+}
+
+export var RegistationChannelTitle = {
+  [RegistrationChannel.vkontakte]: 'Вконтакте',
+  [RegistrationChannel.telegramBot]: 'Телеграм',
+  [RegistrationChannel.email]: 'Электронная почта',
+}
+
+/** @type {Record<RegistrationChannel, Icon>} */
+export var RegistationChannelIcon = {
+  [RegistrationChannel.vkontakte]: 'brand/solid/vk',
+  [RegistrationChannel.telegramBot]: 'brand/solid/telegram',
+  [RegistrationChannel.email]: 'hero/solid/at-symbol',
+}

package/source/enumerations/entities/registration-lineup.js

@@ -0,0 +1,75 @@
+export var RegistrationLineup = /** @type {const} */ ({
+  'Main': 'Main',
+  'Reserve': 'Reserve',
+})
+
+export var RegistrationLineups = Object.values(RegistrationLineup)
+
+/** @type {Record<RegistrationLineup, number>} */
+export var RegistrationLineupWeight = {
+  [RegistrationLineup.Main]: 0,
+  [RegistrationLineup.Reserve]: 1,
+}
+
+/** @type {Record<RegistrationLineup, string>} */
+export var RegistrationLineupTitle = {
+  [RegistrationLineup.Main]: 'Основа',
+  [RegistrationLineup.Reserve]: 'Резерв',
+}
+
+/** @type {Record<RegistrationLineup, Icon>} */
+export var RegistrationLineupIcon = {
+  [RegistrationLineup.Main]: 'hero/outline/user-circle',
+  [RegistrationLineup.Reserve]: 'hero/outline/pause-circle',
+}
+
+/** @type {Record<RegistrationLineup, string>} */
+export var RegistrationLineupEmoji = {
+  [RegistrationLineup.Main]: '🟢',
+  [RegistrationLineup.Reserve]: '🟡',
+}
+
+/** @type {Record<RegistrationLineup, string>} */
+export var RegistrationLineupColor = {
+  [RegistrationLineup.Main]: 'text-primary',
+  [RegistrationLineup.Reserve]: 'text-secondary',
+}
+
+/** @type {Record<RegistrationLineup, Pick<RegistrationTable, 'is_reserve'>>} */
+export var RegistrationLineupShape = {
+  [RegistrationLineup.Main]: {
+    is_reserve: false,
+  },
+
+  [RegistrationLineup.Reserve]: {
+    is_reserve: true,
+  },
+}
+
+/**
+ * @param {RegistrationLineup | typeof RegistrationLineupShape[RegistrationLineup]} value
+ */
+export var getRegistrationLineup = value => {
+  switch (typeof value) {
+    case 'object':
+      let found = Object
+        .entries(RegistrationLineupShape)
+        .find(([, object]) => object.is_reserve === value.is_reserve)
+        ?.at(0)
+
+      if (!RegistrationLineups.includes(found))
+        throw TypeError(
+          `[Function: getRegistrationLineup] Parameter 'found': '${found}' must be a member of 'Lineups'.`,
+        )
+
+      return found
+
+    case 'string':
+      if (!RegistrationLineups.includes(value))
+        throw TypeError(
+          `[Function: getRegistrationLineup] Parameter 'value': '${value}' must be a member of 'Lineups'.`,
+        )
+
+      return RegistrationLineupShape[value]
+  }
+}

package/source/enumerations/entities/registration-mailing.js

@@ -0,0 +1,24 @@
+export var RegistrationMailing = /** @type {const} */ ({
+  'Idle': 'Idle',
+  'Pending': 'Pending',
+  'Delivered': 'Delivered',
+  'Failed': 'Failed',
+})
+
+export var RegistrationMailings = Object.values(RegistrationMailing)
+
+/** @type {Record<RegistrationMailing, number>} */
+export var RegistrationMailingWeight = {
+  [RegistrationMailing.Idle]: 0,
+  [RegistrationMailing.Pending]: 1,
+  [RegistrationMailing.Delivered]: 2,
+  [RegistrationMailing.Failed]: 3,
+}
+
+/** @type {Record<RegistrationMailing, string>} */
+export var RegistrationMailingColor = {
+  [RegistrationMailing.Idle]: 'default',
+  [RegistrationMailing.Pending]: 'warning',
+  [RegistrationMailing.Delivered]: 'success',
+  [RegistrationMailing.Failed]: 'danger',
+}

package/source/enumerations/entities/registration-status.js

@@ -0,0 +1,89 @@
+export var RegistrationStatus = /** @type {const} */ ({
+  'Confirmed': 'Confirmed',
+  'Created': 'Created',
+  'Cancelled': 'Cancelled',
+})
+
+export var RegistrationStatuses = Object.values(RegistrationStatus)
+
+export var RegistrationStatusWeight = {
+  [RegistrationStatus.Confirmed]: 0,
+  [RegistrationStatus.Created]: 1,
+  [RegistrationStatus.Cancelled]: 2,
+}
+
+export var RegistrationStatusTitle = {
+  [RegistrationStatus.Confirmed]: 'Подтверждена',
+  [RegistrationStatus.Created]: 'Создана',
+  [RegistrationStatus.Cancelled]: 'Отменена',
+}
+
+/** @type {Record<RegistrationStatus, Icon>} */
+export var RegistrationStatusIcon = {
+  [RegistrationStatus.Confirmed]: 'hero/outline/check-circle',
+  [RegistrationStatus.Created]: 'hero/outline/check',
+  [RegistrationStatus.Cancelled]: 'hero/outline/x-mark',
+}
+
+/** @type {Record<RegistrationStatus, Icon>} */
+export var RegistrationStatusEmoji = {
+  [RegistrationStatus.Confirmed]: '✅',
+  [RegistrationStatus.Created]: '📝',
+  [RegistrationStatus.Cancelled]: '❌',
+}
+
+/** @type {Record<RegistrationStatus, string>} */
+export var RegistrationStatusColor = {
+  [RegistrationStatus.Confirmed]: 'text-success',
+  [RegistrationStatus.Created]: 'text-default-700',
+  [RegistrationStatus.Cancelled]: 'text-danger',
+}
+
+/** @type {Record<RegistrationStatus, Pick<RegistrationTable, 'is_canceled' | 'is_confirm'>>} */
+export var RegistrationStatusShape = {
+  [RegistrationStatus.Confirmed]: {
+    is_canceled: false,
+    is_confirm: true,
+  },
+
+  [RegistrationStatus.Created]: {
+    is_canceled: false,
+    is_confirm: false,
+  },
+
+  [RegistrationStatus.Cancelled]: {
+    is_canceled: true,
+    is_confirm: false,
+  },
+}
+
+/**
+ * @param {RegistrationStatus | typeof RegistrationStatusShape[RegistrationStatus]} value
+ */
+export var getRegistrationStatus = value => {
+  switch (typeof value) {
+    case 'object':
+      let found = Object
+        .entries(RegistrationStatusShape)
+        .find(([, object]) =>
+          object.is_canceled === value.is_canceled
+          && object.is_confirm === value.is_confirm
+        )
+        ?.at(0)
+
+      if (!RegistrationStatuses.includes(found))
+        throw TypeError(
+          `[Function: getRegistrationStatus] Parameter 'found': '${found}' must be a member of 'RegistrationStatuses'.`,
+        )
+
+      return found
+
+    case 'string':
+      if (!RegistrationStatuses.includes(value))
+        throw TypeError(
+          `[Function: getRegistrationStatus] Parameter 'value': '${value}' must be a member of 'RegistrationStatuses'.`,
+        )
+
+      return RegistrationStatusShape[value]
+  }
+}

package/source/enumerations/entities/role-mode.js

@@ -0,0 +1,40 @@
+export var RoleMode = /** @type {const} */ ({
+  'known': 'known',
+  'unknown': 'unknown',
+})
+
+export var RoleModes = Object.values(RoleMode)
+
+export var RoleModeTitle = {
+  [RoleMode.known]: 'Любая',
+  [RoleMode.unknown]: 'Не назначено',
+}
+
+export var RoleModeWeight = {
+  [RoleMode.known]: 0,
+  [RoleMode.unknown]: 1,
+}
+
+/**
+ * @param {keyof typeof RoleMode} value
+ */
+var getter = value =>
+  value in RoleMode
+    ? value
+    : RoleMode['unknown']
+
+export var getRoleMode = value => {
+  if (value === null)
+    return getter(undefined)
+
+  switch (typeof value) {
+    case 'string':
+      return getter(value)
+
+    case 'object':
+      return getter(value?.mode)
+
+    default:
+      return getter(undefined)
+  }
+}

package/source/enumerations/entities/role.js

@@ -0,0 +1,82 @@
+export var Role = /** @type {const} */ ({
+  'admin': 'admin',
+  'organizer': 'organizer',
+  'captain': 'captain',
+  'player': 'player',
+  'user': 'user',
+  'manager': 'manager',
+  'default': 'default',
+})
+
+export var Roles = Object.values(Role)
+
+export var RoleWeight = {
+  [Role.admin]: 0,
+  [Role.organizer]: 1,
+  [Role.captain]: 2,
+  [Role.player]: 3,
+  [Role.user]: 4,
+  [Role.manager]: 5,
+  [Role.default]: 6,
+}
+
+export var RoleTitle = {
+  [Role.admin]: 'Админ',
+  [Role.organizer]: 'Организатор',
+  [Role.captain]: 'Капитан',
+  [Role.player]: 'Игрок',
+  [Role.user]: 'Пользователь',
+  [Role.manager]: 'Менеджер',
+  [Role.default]: 'Неавторизован',
+}
+
+export var RoleActionTitle = {
+  [Role.admin]: 'Сделать админом',
+  [Role.organizer]: 'Сделать организатором',
+  [Role.captain]: 'Сделать капитаном',
+  [Role.player]: 'Сделать игрокок',
+  [Role.user]: 'Сделать пользователем',
+  [Role.manager]: 'Сделать менеджером',
+  [Role.default]: 'Сделать неавторизованым',
+}
+
+export var RoleActionDescription = {
+  [Role.admin]: 'Назначить роль: Админ',
+  [Role.organizer]: 'Назначить роль: Организатор',
+  [Role.captain]: 'Назначить роль: Капитан',
+  [Role.player]: 'Назначить роль: Игрок',
+  [Role.user]: 'Назначить роль: Пользователь',
+  [Role.manager]: 'Назначить роль: Менеджер',
+  [Role.default]: 'Назначить роль: Неавторизован',
+}
+
+export var RoleColor = {
+  [Role.admin]: 'danger',
+  [Role.organizer]: 'warning',
+  [Role.captain]: 'primary',
+  [Role.player]: 'secondary',
+  [Role.user]: 'default',
+  [Role.manager]: 'default',
+  [Role.default]: 'default',
+}
+
+export var RoleTextColor = {
+  [Role.admin]: 'text-danger',
+  [Role.organizer]: 'text-warning',
+  [Role.captain]: 'text-primary',
+  [Role.player]: 'text-secondary',
+  [Role.user]: 'text-default',
+  [Role.manager]: 'text-default',
+  [Role.default]: 'text-default',
+}
+
+/** @type {Record<Role, Icon>} */
+export var RoleIcon = {
+  [Role.admin]: 'hero/outline/user',
+  [Role.organizer]: 'hero/outline/user',
+  [Role.captain]: 'hero/outline/user',
+  [Role.player]: 'hero/outline/user',
+  [Role.user]: 'hero/outline/user',
+  [Role.manager]: 'hero/outline/user',
+  [Role.default]: 'hero/outline/user',
+}

package/source/enumerations/entities/venue/audience.js

@@ -0,0 +1,100 @@
+export var VenueAudience = /** @type {const} */ ({
+  'Any': 'Any',
+  'All': 'All',
+  'Restricted': 'Restricted',
+  'Unknown': 'Unknown',
+})
+
+export var VenueAudiences = [
+  VenueAudience['Any'],
+  VenueAudience['All'],
+  VenueAudience['Restricted'],
+  VenueAudience['Unknown'],
+]
+
+export var PersistedVenueAudiences = [
+  VenueAudience['All'],
+  VenueAudience['Restricted'],
+]
+
+var VenueAudienceShape = {
+  [VenueAudience['All']]: {
+    is_adult: false,
+  },
+
+  [VenueAudience['Restricted']]: {
+    is_adult: true,
+  },
+
+  [VenueAudience['Unknown']]: {
+    is_adult: null,
+  },
+}
+
+var VenueAudienceShapes = Object.entries(VenueAudienceShape)
+
+export var VenueAudienceTitle = {
+  [VenueAudience['Any']]: 'Любая',
+  [VenueAudience['All']]: 'Открытая',
+  [VenueAudience['Restricted']]: 'Закрытая',
+  [VenueAudience['Unknown']]: 'Неизвестно',
+}
+
+export var VenueAudienceIcon = {
+  [VenueAudience['Any']]: 'hero/outline/square-2-stack',
+  [VenueAudience['All']]: 'hero/outline/lock-open',
+  [VenueAudience['Restricted']]: 'hero/outline/lock-closed',
+  [VenueAudience['Unknown']]: 'hero/outline/no-symbol',
+}
+
+/**
+ * @returns {keyof typeof VenueAudience}
+ */
+var fromString = value =>
+  value in VenueAudience
+    ? value
+    : VenueAudience['Unknown']
+
+/**
+ * @returns {keyof typeof VenueAudience}
+ */
+var fromObject = value =>
+  VenueAudienceShapes
+    .find(([, shape]) => shape.is_adult === value?.is_adult)
+    ?.at(0)
+    ?? VenueAudience['Unknown']
+
+/**
+ * @returns {typeof VenueAudienceShape[keyof typeof VenueAudienceShape]}
+ */
+var toObject = value =>
+  VenueAudienceShapes
+    .find(([venueAudience, shape]) => venueAudience === value)
+    ?.at(1)
+    ?? VenueAudienceShape[VenueAudience['Unknown']]
+
+/**
+ * @returns {keyof typeof VenueAudience}
+ */
+export var inferVenueAudience = value => {
+  switch (typeof value) {
+    case 'string':
+      return fromString(value)
+
+    case 'object':
+      return fromObject(value)
+
+    default:
+      return VenueAudience['Unknown']
+  }
+}
+
+export var inferVenueAudienceShape = value => {
+  switch (typeof value) {
+    case 'string':
+      return toObject(value)
+
+    default:
+      return VenueAudienceShape[VenueAudience['Unknown']]
+  }
+}