/**
 * Final component information on units for sale.
 *
 * `IShoppingSaleUnitStock` is a subsidiary entity of {@link IShoppingSaleUnit}
 * that represents a product catalog for sale, and is a kind of final stock that is
 * constructed by selecting all {@link IShoppingSaleUnitSelectableOption options}
 * (variable "select" type) and their
 * {@link IShoppingSaleUnitOptionCandidate candidate} values in the belonging unit.
 * It is the "good" itself that customers actually purchase.
 *
 * - Product Name) MacBook
 *   - Options
 *     - CPU: { i3, i5, i7, i9 }
 *     - RAM: { 8GB, 16GB, 32GB, 64GB, 96GB }
 *     - SSD: { 256GB, 512GB, 1TB }
 *   - Number of final stocks: 4 * 5 * 3 = 60
 *
 * For reference, the total number of `IShoppingSaleUnitStock` records in an
 * attribution unit can be obtained using Cartesian Product. In other words, the
 * value obtained by multiplying all the candidate values that each
 * (variable "select" type) option can have by the number of cases is the total
 * number of final stocks in the unit.
 *
 * Of course, without a single variable "select" type option, the final stocks
 * count in the unit is only 1.
 *
 * @author Samchon
 */
export interface IShoppingSaleUnitStock { ... }

/**
 * Product composition information handled in the sale.
 *
 * `IShoppingSaleUnit` is an entity that embodies the "individual product"
 * information handled in the {@link IShoppingSale sale}.
 *
 * For reference, the reason why `IShoppingSaleUnit` is separated from
 * {@link IShoppingSaleSnapshot} by an algebraic relationship of 1: N is because
 * there are some cases where multiple products are sold in one listing. This is
 * the case with so-called "bundled products".
 *
 * - Bundle from regular product (Mackbook Set)
 *   - Main Body
 *   - Keyboard
 *   - Mouse
 *   - Apple Care (Free A/S Voucher)
 *
 * And again, `IShoppingSaleUnit` does not in itself refer to the
 * {@link IShoppingSaleUnitStock final stock} that the
 * {@link IShoppingCustomer customer} will {@link IShoppingOrder purchase}.
 * The final stock can be found only after selecting all given
 * {@link IShoppingSaleUnitOption options} and their
 * {@link IShoppingSaleUnitOptionCandidate candidate values}.
 *
 * For example, even if you buy a Macbook, the final stocks are determined only
 * after selecting all the options (CPU / RAM / SSD), etc.
 *
 * @author Samchon
 */
export interface IShoppingSaleUnit { ... }

/**
 * Seller sales products.
 *
 * `IShoppingSale` is an entity that embodies "product sales" (sales)
 * information registered by the {@link ISoppingSeller seller}. And the main
 * information of the sale is recorded in the sub {@link IShoppingSaleSnapshot},
 * not in the main `IShoppingSale`. When a seller changes a previously registered
 * item, the existing `IShoppingSale` record is not changed, but a new
 * {@link IShoppingSaleSnapshot snapshot} record be created.
 *
 * This is to preserve the {@link IShoppingCustomer customer}'s
 * {@link IShoppingOrder purchase history} flawlessly after the customer
 * purchases a specific item, even if the seller changes the components or
 * price of the item. It is also intended to support sellers in so-called A/B
 * testing, which involves changing components or prices and measuring the
 * performance in each case.
 *
 * @author Samchon
 */
export interface IShoppingSale { ... }

import { tags } from "typia";
 
/**
 * Restriction information of the coupon.
 *
 * @author Samchon
 */
export interface IShoppingCouponRestriction {
  /**
   * Access level of coupon.
   *
   * - public: possible to find from public API
   * - private: unable to find from public API
   *   - arbitrarily assigned by the seller or administrator
   *   - issued from one-time link
   */
  access: "public" | "private";
 
  /**
   * Exclusivity or not.
   *
   * An exclusive discount coupon refers to a discount coupon that has an
   * exclusive relationship with other discount coupons and can only be
   * used alone. That is, when an exclusive discount coupon is used, no
   * other discount coupon can be used for the same
   * {@link IShoppingOrder order} or {@link IShoppingOrderGood good}.
   *
   * Please note that this exclusive attribute is a very different concept
   * from multiplicative, which means whether the same coupon can be
   * multiplied and applied to multiple coupons of the same order, so
   * please do not confuse them.
   */
  exclusive: boolean;
 
  /**
   * Limited quantity issued.
   *
   * If there is a limit to the quantity issued, it becomes impossible
   * to issue tickets exceeding this value.
   *
   * In other words, the concept of N coupons being issued on
   * a first-come, first-served basis is created.
   */
  volume: null | (number & tags.Type<"uint32">);
 
  /**
   * Limited quantity issued per person.
   *
   * As a limit to the total amount of issuance per person, it is
   * common to assign 1 to limit duplicate issuance to the same citizen,
   * or to use the NULL value to set no limit.
   *
   * Of course, by assigning a value of N, the total amount issued
   * to the same citizen can be limited.
   */
  volume_per_citizen: null | (number & tags.Type<"uint32">);
 
  /**
   * Expiration day(s) value.
   *
   * The concept of expiring N days after a discount coupon ticket is issued.
   *
   * Therefore, customers must use the ticket within N days, if possible,
   * from the time it is issued.
   */
  expired_in: null | (number & tags.Type<"uint32">);
 
  /**
   * Expiration date.
   *
   * A concept that expires after YYYY-MM-DD after a discount coupon ticket
   * is issued.
   *
   * Double restrictions are possible with expired_in, of which the one
   * with the shorter expiration date is used.
   */
  expired_at: null | (string & tags.Format<"date-time">);
}

import { tags } from "typia";
 
import { IShoppingCartCommodityStockChoice } from "./IShoppingCartCommodityStockChoice";
 
/**
 * Final stock information of commodity added to the shopping cart.
 *
 * `IShoppingCartCommodityStock` is a subsidiary entity of
 * {@link IShoppingCartCommodity} that embodies the information of the
 * {@link IShoppingSaleSnapshot snapshot} of the items in the shopping cart,
 * and is a concept that corresponds to the individual
 * {@link IShoppingSaleUnit units} in the target item snapshot and the
 * {@link IShoppingSaleUnitStock stock} finally selected among those units.
 *
 * Therefore, if the {@link IShoppingCustomer customer} selects multiple units
 * and stocks from the target sale snapshot, the attributed commodity record also
 * has multiple corresponding `IShoppingCartCommodityStock` records.
 *
 * And `IShoppingCartCommodityStock` has a {@link quantity} property that indicates
 * how many final stocks would be purchased in total. The final quantity actually
 * purchased can be multiplied by the {@link IShoppingCartCommodity.volume} value
 * of the parent entity.
 *
 * @author Samchon
 */
export namespace IShoppingCartCommodityStock {
  /**
   * Creation information of the commodity stock of shopping cart.
   *
   * When record being created, its corresponding structure would be
   * {@link IShoppingSaleSnapshotUnit.IInvert} and
   * {@link IShoppingSaleSnapshotUnitStock.IInvert}.
   */
  export interface ICreate {
    /**
     * Target unit's {@link IShoppingSaleUnit.id}.
     */
    unit_id: string & tags.Format<"uuid">;
 
    /**
     * Target stock's {@link IShoppingSaleUnitStock.id}.
     *
     * It must be matched with the {@link choices} property.
     */
    stock_id: string & tags.Format<"uuid">;
 
    /**
     * Creation information of the choices for each descriptive option.
     *
     * If target option is not of descriptive but of selective, then
     * this property must be an empty array.
     */
    choices: IShoppingCartCommodityStockChoice.ICreate[];
 
    /**
     * Quantity of the stock to purchase.
     *
     * This value is multiplied by the {@link IShoppingCartCommodity.volume}.
     */
    quantity: number & tags.Type<"uint32"> & tags.Minimum<1>;
  }
}

import { tags } from "typia";
 
import { IShoppingPrice } from "../base/IShoppingPrice";
import { IShoppingSaleUnitStockChoice } from "./IShoppingSaleUnitStockChoice";
import { IShoppingSaleUnitStockInventory } from "./IShoppingSaleUnitStockInventory";
 
/**
 * Final component information on units for sale.
 *
 * `IShoppingSaleUnitStock` is a subsidiary entity of {@link IShoppingSaleUnit}
 * that represents a product catalog for sale, and is a kind of final stock that is
 * constructed by selecting all {@link IShoppingSaleUnitSelectableOption options}
 * (variable "select" type) and their
 * {@link IShoppingSaleUnitOptionCandidate candidate} values in the belonging unit.
 * It is the "good" itself that customers actually purchase.
 *
 * - Product Name) MacBook
 *   - Options
 *     - CPU: { i3, i5, i7, i9 }
 *     - RAM: { 8GB, 16GB, 32GB, 64GB, 96GB }
 *     - SSD: { 256GB, 512GB, 1TB }
 *   - Number of final stocks: 4 * 5 * 3 = 60
 *
 * For reference, the total number of `IShoppingSaleUnitStock` records in an
 * attribution unit can be obtained using Cartesian Product. In other words, the
 * value obtained by multiplying all the candidate values that each
 * (variable "select" type) option can have by the number of cases is the total
 * number of final stocks in the unit.
 *
 * Of course, without a single variable "select" type option, the final stocks
 * count in the unit is only 1.
 *
 * @author Samchon
 */
export interface IShoppingSaleUnitStock {
  /**
   * Primary Key.
   */
  id: string & tags.Format<"uuid">;
 
  /**
   * Representative name of the stock.
   */
  name: string;
 
  /**
   * Price of the stock.
   */
  price: IShoppingPrice;
 
  /**
   * Current inventory status of the stock.
   */
  inventory: IShoppingSaleUnitStockInventory;
 
  /**
   * List of choices.
   *
   * Which candidate values being chosen for each option.
   */
  choices: IShoppingSaleUnitStockChoice[];
}
export namespace IShoppingSaleUnitStock {
  /**
   * Invert information from the cart.
   */
  export interface IInvert {
    /**
     * Primary Key.
     */
    id: string & tags.Format<"uuid">;
 
    /**
     * Representative name of the stock.
     */
    name: string;
 
    /**
     * Price of the stock.
     */
    price: IShoppingPrice;
 
    /**
     * Quantity of the stock in the cart.
     */
    quantity: number & tags.Type<"uint32"> & tags.Minimum<1>;
 
    /**
     * Current inventory status of the stock.
     */
    inventory: IShoppingSaleUnitStockInventory;
 
    /**
     * List of choices.
     *
     * Which values being written for each option.
     */
    choices: IShoppingSaleUnitStockChoice.IInvert[];
  }
 
  /**
   * Creation information of the stock.
   */
  export interface ICreate {
    /**
     * Representative name of the stock.
     */
    name: string;
 
    /**
     * Price of the stock.
     */
    price: IShoppingPrice;
 
    /**
     * Initial inventory quantity.
     */
    quantity: number & tags.Type<"uint32"> & tags.Minimum<1>;
 
    /**
     * List of choices.
     *
     * Which candidate values being chosen for each option.
     */
    choices: IShoppingSaleUnitStockChoice.ICreate[];
  }
}

import { tags } from "typia";
 
/**
 * Article entity.
 *
 * `IBbsArticle` is an entity representing an article in the BBS (Bulletin Board System).
 */
export interface IBbsArticle extends IBbsArticle.ICreate {
  /**
   * Primary Key.
   */
  id: string & tags.Format<"uuid">;
 
  /**
   * Creation time of the article.
   */
  created_at: string & tags.Format<"date-time">;
 
  /**
   * Last updated time of the article.
   */
  updated_at: string & tags.Format<"date-time">;
}
export namespace IBbsArticle {
  /**
   * Information of the article to create.
   */
  export interface ICreate {
    /**
     * Title of the article.
     *
     * Representative title of the article.
     */
    title: string;
 
    /**
     * Content body.
     *
     * Content body of the article writtn in the markdown format.
     */
    body: string;
 
    /**
     * Thumbnail image URI.
     *
     * Thumbnail image URI which can represent the article.
     *
     * If configured as `null`, it means that no thumbnail image in the article.
     */
    thumbnail:
      | null
      | (string & tags.Format<"uri"> & tags.ContentMediaType<"image/*">);
  }
 
  /**
   * Information of the article to update.
   *
   * Only the filled properties will be updated.
   */
  export type IUpdate = Partial<ICreate>;
}

import { tags } from "typia";
import { v4 } from "uuid";
 
import { IBbsArticle } from "./IBbsArticle";
 
export class BbsArticleService {
  private readonly articles: IBbsArticle[] = [];
 
  /**
   * Get all articles.
   *
   * List up every articles archived in the BBS DB.
   *
   * @returns List of every articles
   */
  public index(): IBbsArticle[] {
    return this.articles;
  }
 
  /**
   * Create a new article.
   *
   * Writes a new article and archives it into the DB.
   *
   * @param props Properties of create function
   * @returns Newly created article
   */
  public create(props: {
    /**
     * Information of the article to create
     */
    input: IBbsArticle.ICreate;
  }): IBbsArticle {
    const article: IBbsArticle = {
      id: v4(),
      title: props.input.title,
      body: props.input.body,
      thumbnail: props.input.thumbnail,
      created_at: new Date().toISOString(),
      updated_at: new Date().toISOString(),
    };
    this.articles.push(article);
    return article;
  }
 
  /**
   * Update an article.
   *
   * Updates an article with new content.
   *
   * @param props Properties of update function
   * @param input New content to update
   */
  public update(props: {
    /**
     * Target article's {@link IBbsArticle.id}.
     */
    id: string & tags.Format<"uuid">;
 
    /**
     * New content to update.
     */
    input: IBbsArticle.IUpdate;
  }): void {
    const article: IBbsArticle | undefined = this.articles.find(
      (a) => a.id === props.id,
    );
    if (article === undefined)
      throw new Error("Unable to find the matched article.");
    if (props.input.title !== undefined) article.title = props.input.title;
    if (props.input.body !== undefined) article.body = props.input.body;
    if (props.input.thumbnail !== undefined)
      article.thumbnail = props.input.thumbnail;
    article.updated_at = new Date().toISOString();
  }
 
  /**
   * Erase an article.
   *
   * Erases an article from the DB.
   *
   * @param props Properties of erase function
   */
  public erase(props: {
    /**
     * Target article's {@link IBbsArticle.id}.
     */
    id: string & tags.Format<"uuid">;
  }): void {
    const index: number = this.articles.findIndex((a) => a.id === props.id);
    if (index === -1) throw new Error("Unable to find the matched article.");
    this.articles.splice(index, 1);
  }
}

import { ILlmApplication } from "@samchon/openapi";
import typia from "typia";
 
import { BbsArticleService } from "./BbsArticleService";
 
const app: ILlmApplication<"chatgpt"> = typia.llm.application<
  BbsArticleService,
  "chatgpt"
>();
console.log(app);

Information of the article to create.
 
------------------------------
 
Description of the current {@link IBbsArticle.ICreate} type:
 
Information of the article to create.
 
> Description of the parent {@link IBbsArticle} type: Article entity.
> 
> `IBbsArticle` is an entity representing an article in the BBS (Bulletin Board System).