@stacksjs/commerce 0.70.55 → 0.70.56

package/src/gift-cards/fetch.ts

@@ -1,431 +0,0 @@
-import type { GiftCardStats } from '../types'
-import type { StacksExpressionBuilder } from '@stacksjs/database'
-import { db, sql } from '@stacksjs/database'
-import { formatDate, toTimestamp } from '@stacksjs/orm'
-import { aggregateStats } from '../utils/typed-stats'
-type GiftCardJsonResponse = ModelRow<typeof GiftCard>
-
-/**
- * Fetch all gift cards from the database
- */
-export async function fetchAll(): Promise<GiftCardJsonResponse[]> {
-  const giftCards = await db
-    .selectFrom('gift_cards')
-    .selectAll()
-    .execute()
-
-  return giftCards as GiftCardJsonResponse[]
-}
-
-/**
- * Fetch a gift card by ID
- */
-export async function fetchById(id: number): Promise<GiftCardJsonResponse | undefined> {
-  return await db
-    .selectFrom('gift_cards')
-    .where('id', '=', id)
-    .selectAll()
-    .executeTakeFirst() as GiftCardJsonResponse | undefined
-}
-
-/**
- * Fetch a gift card by code
- */
-export async function fetchByCode(code: string): Promise<GiftCardJsonResponse | undefined> {
-  return await db
-    .selectFrom('gift_cards')
-    .where('code', '=', code)
-    .selectAll()
-    .executeTakeFirst() as GiftCardJsonResponse | undefined
-}
-
-/**
- * Fetch active gift cards (is_active = true and not expired)
- */
-export async function fetchActive(): Promise<GiftCardJsonResponse[]> {
-  const giftCards = await db
-    .selectFrom('gift_cards')
-    .where('is_active', '=', true)
-    .selectAll()
-    .execute()
-
-  return giftCards as GiftCardJsonResponse[]
-}
-
-/**
- * Get gift card statistics
- */
-export async function fetchStats(): Promise<GiftCardStats> {
-  // Total gift cards
-  const { count: totalCount } = await aggregateStats('gift_cards', { count: { kind: 'count' } })
-
-  // Active gift cards
-  const currentDate = toTimestamp(new Date())
-
-  // bun-query-builder doesn't expose a typed `eb.or([...])` helper, so the
-  // OR-with-NULL filter still uses the untyped expression-builder form.
-  // The boundary `as any` is localized; the result row uses the typed helper.
-  const activeGiftCards = await db
-    .selectFrom('gift_cards')
-    .where('is_active', '=', true)
-    .where('status', '=', 'ACTIVE')
-    .where(((eb: StacksExpressionBuilder) => eb.or([
-      eb('expiry_date', '>=', currentDate),
-      eb('expiry_date', 'is', null),
-    ])) as any)
-    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
-    .executeTakeFirst() as { count: number } | undefined
-
-  // Gift cards by status
-  const giftCardsByStatus = await db
-    .selectFrom('gift_cards')
-    .select(['status', (eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')] as any)
-    .groupBy('status')
-    .execute() as { status: string, count: number }[]
-
-  // Balance distribution: each bucket needs a custom raw fraction filter, so
-  // these stay as direct queries — but we use the typed helper for the
-  // `count(id)` expression to avoid the `as any` chain on the result.
-  const { count: lowBalanceCount } = await aggregateStats('gift_cards', { count: { kind: 'count' } }, qb =>
-    qb.where(((eb: StacksExpressionBuilder) => sql`${eb.ref('current_balance')} / ${eb.ref('initial_balance')} < 0.25`) as any))
-
-  const { count: mediumBalanceCount } = await aggregateStats('gift_cards', { count: { kind: 'count' } }, qb =>
-    qb.where(((eb: StacksExpressionBuilder) => sql`${eb.ref('current_balance')} / ${eb.ref('initial_balance')} >= 0.25 AND ${eb.ref('current_balance')} / ${eb.ref('initial_balance')} <= 0.75`) as any))
-
-  const { count: highBalanceCount } = await aggregateStats('gift_cards', { count: { kind: 'count' } }, qb =>
-    qb.where(((eb: StacksExpressionBuilder) => sql`${eb.ref('current_balance')} / ${eb.ref('initial_balance')} > 0.75`) as any))
-
-  // Expiring soon gift cards (next 30 days)
-  const thirtyDaysFromNow = new Date()
-  thirtyDaysFromNow.setDate(thirtyDaysFromNow.getDate() + 30)
-
-  const expiringGiftCards = await db
-    .selectFrom('gift_cards')
-    .where('is_active', '=', true)
-    .where('status', '=', 'ACTIVE')
-    .where('expiry_date', '<=', toTimestamp(thirtyDaysFromNow))
-    .where('expiry_date', '>=', currentDate)
-    .selectAll()
-    .limit(5)
-    .execute()
-
-  // Recently used gift cards
-  const recentlyUsedGiftCards = await db
-    .selectFrom('gift_cards')
-    .where('last_used_date', 'is not', null)
-    .selectAll()
-    .limit(5)
-    .execute()
-
-  return {
-    total: totalCount,
-    active: Number(activeGiftCards?.count || 0),
-    by_status: giftCardsByStatus.map((item: { status: string, count: number }) => ({
-      status: item.status,
-      count: Number(item.count),
-    })),
-    by_balance: {
-      low: lowBalanceCount,
-      medium: mediumBalanceCount,
-      high: highBalanceCount,
-    },
-    expiring_soon: expiringGiftCards as GiftCardJsonResponse[],
-    recently_used: recentlyUsedGiftCards as GiftCardJsonResponse[],
-  }
-}
-
-/**
- * Check gift card balance by code
- */
-export async function checkBalance(code: string): Promise<{ valid: boolean, balance?: number, currency?: string, message?: string }> {
-  const giftCard = await fetchByCode(code)
-
-  if (!giftCard) {
-    return { valid: false, message: 'Gift card not found' }
-  }
-
-  if (!giftCard.isActive || giftCard.status !== 'ACTIVE') {
-    return {
-      valid: false,
-      balance: giftCard.currentBalance,
-      currency: giftCard.currency,
-      message: `Gift card is ${giftCard.status.toLowerCase()}`,
-    }
-  }
-
-  // Check if expired
-  if (giftCard.expiryDate) {
-    const expiryDate = new Date(giftCard.expiryDate)
-    const currentDate = new Date()
-
-    if (expiryDate < currentDate) {
-      return {
-        valid: false,
-        balance: giftCard.currentBalance,
-        currency: giftCard.currency,
-        message: 'Gift card has expired',
-      }
-    }
-  }
-
-  return {
-    valid: true,
-    balance: giftCard.currentBalance,
-    currency: giftCard.currency,
-  }
-}
-
-/**
- * Compare active gift cards between different time periods
- * @param daysRange Number of days to look back (7, 30, 60, etc.)
- */
-export async function compareActiveGiftCards(_daysRange: number = 30): Promise<{
-  current_period: number
-  previous_period: number
-  difference: number
-  percentage_change: number
-  days_range: number
-}> {
-  const today = new Date()
-
-  // Current period (last N days)
-  const currentPeriodStart = new Date(today)
-  currentPeriodStart.setDate(today.getDate() - _daysRange)
-
-  // Previous period (N days before the current period)
-  const previousPeriodEnd = new Date(currentPeriodStart)
-  previousPeriodEnd.setDate(previousPeriodEnd.getDate() - 1)
-
-  const previousPeriodStart = new Date(previousPeriodEnd)
-  previousPeriodStart.setDate(previousPeriodEnd.getDate() - _daysRange)
-
-  // Get active gift cards for current period
-  const currentPeriodActive = await db
-    .selectFrom('gift_cards')
-    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
-    .where('is_active', '=', true)
-    .where('status', '=', 'ACTIVE')
-    .where(((eb: StacksExpressionBuilder) => eb.or([
-      eb('expiry_date', '>=', toTimestamp(today)),
-      eb('expiry_date', 'is', null),
-    ])) as any)
-    .where('created_at', '>=', formatDate(currentPeriodStart))
-    .where('created_at', '<=', formatDate(today))
-    .executeTakeFirst() as { count: number } | undefined
-
-  // Get active gift cards for previous period
-  const previousPeriodActive = await db
-    .selectFrom('gift_cards')
-    .select(((eb: StacksExpressionBuilder) => eb.fn.count('id').as('count')) as any)
-    .where('is_active', '=', true)
-    .where('status', '=', 'ACTIVE')
-    .where(((eb: StacksExpressionBuilder) => eb.or([
-      eb('expiry_date', '>=', toTimestamp(previousPeriodStart)),
-      eb('expiry_date', 'is', null),
-    ])) as any)
-    .where('created_at', '>=', formatDate(previousPeriodStart))
-    .where('created_at', '<=', formatDate(previousPeriodEnd))
-    .executeTakeFirst() as { count: number } | undefined
-
-  const currentCount = Number(currentPeriodActive?.count || 0)
-  const previousCount = Number(previousPeriodActive?.count || 0)
-  const difference = currentCount - previousCount
-
-  // Calculate percentage change, handling division by zero
-  const percentageChange = previousCount !== 0
-    ? (difference / previousCount) * 100
-    : (currentCount > 0 ? 100 : 0)
-
-  return {
-    current_period: currentCount,
-    previous_period: previousCount,
-    difference,
-    percentage_change: percentageChange,
-    days_range: _daysRange,
-  }
-}
-
-/**
- * Calculate gift card balances and initial values for different time periods
- * with clear increase/decrease indicators
- * @param daysRange Number of days to look back (7, 30, 60, etc.)
- */
-export async function calculateGiftCardValues(_daysRange: number = 30): Promise<{
-  current_period: {
-    total_initial_value: number
-    total_remaining_balance: number
-    utilization_rate: number
-    card_count: number
-    average_initial_value: number
-    average_remaining_balance: number
-  }
-  previous_period: {
-    total_initial_value: number
-    total_remaining_balance: number
-    utilization_rate: number
-    card_count: number
-  }
-  comparison: {
-    initial_value: {
-      difference: number
-      percentage: number
-      is_increase: boolean
-    }
-    balance: {
-      difference: number
-      percentage: number
-      is_increase: boolean
-    }
-    card_count: {
-      difference: number
-      percentage: number
-      is_increase: boolean
-    }
-  }
-  days_range: number
-}> {
-  const today = new Date()
-
-  // Current period (last N days)
-  const currentPeriodStart = new Date(today)
-  currentPeriodStart.setDate(today.getDate() - _daysRange)
-
-  // Previous period (N days before the current period)
-  const previousPeriodEnd = new Date(currentPeriodStart)
-  previousPeriodEnd.setDate(previousPeriodEnd.getDate() - 1)
-
-  const previousPeriodStart = new Date(previousPeriodEnd)
-  previousPeriodStart.setDate(previousPeriodEnd.getDate() - _daysRange)
-
-  // Get values for current period
-  const currentPeriodValues = await db
-    .selectFrom('gift_cards')
-    .select(((eb: StacksExpressionBuilder) => [
-      eb.fn.sum('initial_balance').as('total_initial'),
-      eb.fn.sum('current_balance').as('total_balance'),
-      eb.fn.count('id').as('card_count'),
-    ]) as any)
-    .where('is_active', '=', true)
-    .where('status', '=', 'ACTIVE')
-    .where(((eb: StacksExpressionBuilder) => eb.or([
-      eb('expiry_date', '>=', toTimestamp(today)),
-      eb('expiry_date', 'is', null),
-    ])) as any)
-    .where('created_at', '>=', formatDate(currentPeriodStart))
-    .where('created_at', '<=', formatDate(today))
-    .executeTakeFirst() as { total_initial: number, total_balance: number, card_count: number } | undefined
-
-  // Get values for previous period
-  const previousPeriodValues = await db
-    .selectFrom('gift_cards')
-    .select(((eb: StacksExpressionBuilder) => [
-      eb.fn.sum('initial_balance').as('total_initial'),
-      eb.fn.sum('current_balance').as('total_balance'),
-      eb.fn.count('id').as('card_count'),
-    ]) as any)
-    .where('is_active', '=', true)
-    .where('status', '=', 'ACTIVE')
-    .where(((eb: StacksExpressionBuilder) => eb.or([
-      eb('expiry_date', '>=', toTimestamp(previousPeriodStart)),
-      eb('expiry_date', 'is', null),
-    ])) as any)
-    .where('created_at', '>=', formatDate(previousPeriodStart))
-    .where('created_at', '<=', formatDate(previousPeriodEnd))
-    .executeTakeFirst() as { total_initial: number, total_balance: number, card_count: number } | undefined
-
-  // Calculate values for current period
-  const currentInitialValue = Number(currentPeriodValues?.total_initial || 0)
-  const currentBalance = Number(currentPeriodValues?.total_balance || 0)
-  const currentCardCount = Number(currentPeriodValues?.card_count || 0)
-
-  // Calculate values for previous period
-  const previousInitialValue = Number(previousPeriodValues?.total_initial || 0)
-  const previousBalance = Number(previousPeriodValues?.total_balance || 0)
-  const previousCardCount = Number(previousPeriodValues?.card_count || 0)
-
-  // Calculate utilization rates (percentage of gift card value that has been spent)
-  const currentUtilizationRate = currentInitialValue > 0
-    ? ((currentInitialValue - currentBalance) / currentInitialValue) * 100
-    : 0
-
-  const previousUtilizationRate = previousInitialValue > 0
-    ? ((previousInitialValue - previousBalance) / previousInitialValue) * 100
-    : 0
-
-  // Calculate averages
-  const currentAverageInitial = currentCardCount > 0 ? currentInitialValue / currentCardCount : 0
-  const currentAverageBalance = currentCardCount > 0 ? currentBalance / currentCardCount : 0
-
-  // Calculate differences
-  const initialValueDifference = currentInitialValue - previousInitialValue
-  const balanceDifference = currentBalance - previousBalance
-  const cardCountDifference = currentCardCount - previousCardCount
-
-  // Calculate percentage changes
-  const initialValuePercentageChange = previousInitialValue !== 0
-    ? (initialValueDifference / previousInitialValue) * 100
-    : (currentInitialValue > 0 ? 100 : 0)
-
-  const balancePercentageChange = previousBalance !== 0
-    ? (balanceDifference / previousBalance) * 100
-    : (currentBalance > 0 ? 100 : 0)
-
-  const cardCountPercentageChange = previousCardCount !== 0
-    ? (cardCountDifference / previousCardCount) * 100
-    : (currentCardCount > 0 ? 100 : 0)
-
-  return {
-    current_period: {
-      total_initial_value: currentInitialValue,
-      total_remaining_balance: currentBalance,
-      utilization_rate: currentUtilizationRate,
-      card_count: currentCardCount,
-      average_initial_value: currentAverageInitial,
-      average_remaining_balance: currentAverageBalance,
-    },
-    previous_period: {
-      total_initial_value: previousInitialValue,
-      total_remaining_balance: previousBalance,
-      utilization_rate: previousUtilizationRate,
-      card_count: previousCardCount,
-    },
-    comparison: {
-      initial_value: {
-        difference: initialValueDifference,
-        percentage: Math.abs(initialValuePercentageChange),
-        is_increase: initialValueDifference >= 0,
-      },
-      balance: {
-        difference: balanceDifference,
-        percentage: Math.abs(balancePercentageChange),
-        is_increase: balanceDifference >= 0,
-      },
-      card_count: {
-        difference: cardCountDifference,
-        percentage: Math.abs(cardCountPercentageChange),
-        is_increase: cardCountDifference >= 0,
-      },
-    },
-    days_range: _daysRange,
-  }
-}
-
-/**
- * Get total value of all gift cards
- */
-export async function fetchTotalValue(): Promise<{
-  total_value: number
-}> {
-  const { total_value } = await aggregateStats('gift_cards', { total_value: { kind: 'sum', column: 'initial_balance' } })
-  return { total_value }
-}
-
-/**
- * Get total current balance of all gift cards
- */
-export async function fetchTotalCurrentBalance(): Promise<{
-  total_balance: number
-}> {
-  const { total_balance } = await aggregateStats('gift_cards', { total_balance: { kind: 'sum', column: 'current_balance' } })
-  return { total_balance }
-}

package/src/gift-cards/index.ts

@@ -1,26 +0,0 @@
-export {
-  bulkDestroy,
-  destroy,
-} from './destroy'
-
-export {
-  calculateGiftCardValues,
-  checkBalance,
-  compareActiveGiftCards,
-  fetchActive,
-  fetchAll,
-  fetchByCode,
-  fetchById,
-  fetchStats,
-  fetchTotalCurrentBalance,
-  fetchTotalValue,
-} from './fetch'
-
-export {
-  store,
-} from './store'
-
-export {
-  update,
-  updateBalance,
-} from './update'

package/src/gift-cards/store.ts

@@ -1,56 +0,0 @@
-type GiftCardJsonResponse = ModelRow<typeof GiftCard>
-type NewGiftCard = NewModelData<typeof GiftCard>
-import { randomUUIDv7 } from 'bun'
-import { db } from '@stacksjs/database'
-import { HttpError } from '@stacksjs/error-handling'
-import { isUniqueViolation } from '@stacksjs/orm'
-
-/**
- * Create a new gift card
- *
- * @param data The gift card data to store
- * @returns The newly created gift card record
- */
-export async function store(data: NewGiftCard): Promise<GiftCardJsonResponse | undefined> {
-  const d = data as Record<string, unknown>
-  const giftCardData = {
-    ...data,
-    current_balance: d.current_balance ?? d.initial_balance,
-    status: data.status || 'ACTIVE',
-    is_active: d.is_active ?? true,
-    uuid: randomUUIDv7(),
-  }
-
-  try {
-    // Insert the gift card record
-    const createdGiftCard = await db
-      .insertInto('gift_cards')
-      .values(giftCardData)
-      .executeTakeFirst()
-
-    const insertId = Number(createdGiftCard.insertId) || Number(createdGiftCard.numInsertedOrUpdatedRows)
-
-    // If insert was successful, retrieve the newly created gift card
-    if (insertId) {
-      const giftCard = await db
-        .selectFrom('gift_cards')
-        .where('id', '=', insertId)
-        .selectAll()
-        .executeTakeFirst()
-
-      return giftCard as GiftCardJsonResponse
-    }
-
-    return undefined
-  }
-  catch (error) {
-    if (error instanceof HttpError)
-      throw error
-    // Cross-dialect duplicate detection (#1957).
-    if (isUniqueViolation(error))
-      throw new HttpError(409, 'A gift card with this code already exists')
-    if (error instanceof Error)
-      throw new Error(`Failed to create gift card: ${error.message}`)
-    throw error
-  }
-}

package/src/gift-cards/update.ts

@@ -1,102 +0,0 @@
-import type { StacksExpressionBuilder } from '@stacksjs/database'
-import { db } from '@stacksjs/database'
-import { HttpError } from '@stacksjs/error-handling'
-import { formatDate, isUniqueViolation } from '@stacksjs/orm'
-type GiftCardJsonResponse = ModelRow<typeof GiftCard>
-type GiftCardUpdate = UpdateModelData<typeof GiftCard>
-import { fetchById } from './fetch'
-
-/**
- * Update a gift card by ID
- *
- * @param id The ID of the gift card to update
- * @param data The updated gift card data
- * @returns The updated gift card record
- */
-export async function update(id: number, data: Omit<GiftCardUpdate, 'id'>): Promise<GiftCardJsonResponse | undefined> {
-  // Check if gift card exists
-  const existingGiftCard = await fetchById(id)
-  if (!existingGiftCard) {
-    throw new Error(`Gift card with ID ${id} not found`)
-  }
-
-  try {
-    // Update the gift card
-    await db
-      .updateTable('gift_cards')
-      .set({
-        ...data,
-        updated_at: formatDate(new Date()),
-      })
-      .where('id', '=', id)
-      .execute()
-
-    // Fetch and return the updated gift card
-    return await fetchById(id)
-  }
-  catch (error) {
-    if (error instanceof HttpError)
-      throw error
-    // Cross-dialect duplicate detection (#1957).
-    if (isUniqueViolation(error))
-      throw new HttpError(409, 'A gift card with this code already exists')
-    if (error instanceof Error)
-      throw new Error(`Failed to update gift card: ${error.message}`)
-    throw error
-  }
-}
-
-/**
- * Update a gift card's balance atomically (stacksjs/stacks#1879 Co-8).
- *
- * Pre-fix: read balance → compute new → write. Two parallel $50
- * redemptions of a $100 card both saw `current_balance = 100`,
- * both wrote `50`, leaving `50` instead of `0`. The post-read
- * negative-balance guard only caught single-threaded misuse.
- *
- * Post-fix: single conditional UPDATE that does the arithmetic and
- * enforces every precondition in the WHERE clause. The database
- * guarantees only one writer wins the race. Throws when the row
- * was found but the precondition failed (insufficient balance,
- * inactive, missing) so the caller can distinguish from a
- * not-found row.
- *
- * @param id The ID of the gift card
- * @param amount The amount to adjust (positive to add, negative to deduct)
- * @returns The updated gift card with new balance
- */
-export async function updateBalance(id: number, amount: number): Promise<GiftCardJsonResponse | undefined> {
-  const now = formatDate(new Date())
-
-  // Single atomic UPDATE — the arithmetic happens server-side via
-  // `current_balance + ?`, and the `>= 0` predicate stops over-spend.
-  // The new status flips to USED when the resulting balance is 0,
-  // computed inline via CASE so the status update is part of the
-  // same statement.
-  const result = await db
-    .updateTable('gift_cards')
-    .set({
-      current_balance: (db as any).raw(`current_balance + ${amount}`),
-      last_used_date: now,
-      status: (db as any).raw(`CASE WHEN current_balance + ${amount} = 0 THEN 'USED' ELSE 'ACTIVE' END`),
-      updated_at: now,
-    })
-    .where('id', '=', id)
-    .where('is_active', '=', 1)
-    .where('status', '=', 'ACTIVE')
-    .where((eb: StacksExpressionBuilder) => eb.cmpr(eb.raw(`current_balance + ${amount}`), '>=', 0))
-    .executeTakeFirst()
-
-  const affected = Number((result as any)?.numUpdatedRows ?? (result as any)?.affectedRows ?? 0)
-  if (affected > 0) {
-    return await fetchById(id)
-  }
-
-  // UPDATE matched zero rows — diagnose for a useful error.
-  const existing = await fetchById(id)
-  if (!existing) throw new Error(`Gift card with ID ${id} not found`)
-  if (!(existing as Record<string, unknown>).is_active || existing.status !== 'ACTIVE')
-    throw new Error(`Gift card is not active`)
-  // Fell through every other check — must be insufficient balance.
-  throw new Error(`Insufficient gift card balance`)
-}

package/src/index.ts

@@ -1,78 +0,0 @@
-// Main commerce module index file
-import * as coupons from './coupons'
-import * as customers from './customers'
-import * as devices from './devices'
-import * as errors from './errors'
-import * as giftCards from './gift-cards'
-import * as orders from './orders'
-import * as payments from './payments'
-import * as products from './products'
-import * as receipts from './receipts'
-import * as shippings from './shippings'
-import * as tax from './tax'
-import * as waitlists from './waitlists'
-import * as restaurant from './waitlists/restaurant'
-
-type CouponsModule = typeof coupons
-type CustomersModule = typeof customers
-type ErrorsModule = typeof errors
-type ShippingsModule = typeof shippings
-type GiftCardsModule = typeof giftCards
-type OrdersModule = typeof orders
-type PaymentsModule = typeof payments
-type ProductsModule = typeof products
-type RestaurantModule = typeof restaurant
-type TaxModule = typeof tax
-type WaitlistsModule = typeof waitlists
-type DevicesModule = typeof devices
-type ReceiptsModule = typeof receipts
-
-export interface CommerceNamespace {
-  coupons: CouponsModule
-  customers: CustomersModule
-  errors: ErrorsModule
-  giftCards: GiftCardsModule
-  orders: OrdersModule
-  payments: PaymentsModule
-  products: ProductsModule
-  restaurant: RestaurantModule
-  shippings: ShippingsModule
-  tax: TaxModule
-  waitlists: WaitlistsModule
-  devices: DevicesModule
-  receipts: ReceiptsModule
-}
-
-export const commerce: CommerceNamespace = {
-  coupons,
-  customers,
-  devices,
-  errors,
-  giftCards,
-  orders,
-  payments,
-  products,
-  receipts,
-  restaurant,
-  shippings,
-  tax,
-  waitlists,
-}
-
-export default commerce
-
-export {
-  coupons,
-  customers,
-  devices,
-  errors,
-  giftCards,
-  orders,
-  payments,
-  products,
-  receipts,
-  restaurant,
-  shippings,
-  tax,
-  waitlists,
-}