import { Controller } from "@nestjs/common";
import { TypedRoute, TypedBody, TypedParam } from "@nestia/core";
import typia, { tags } from "typia";
 
import { ICart } from "../../api/structures/ICart";
import { IPageICart } from "../../api/structures/IPageICart";
 
@Controller("/carts")
export class CartsController {
  /**
   * Create a new shopping cart (member or guest) with optional initial
   * contents (CartOrder.carts).
   *
   * This operation creates a new shopping cart (possibly with initial
   * contents) for the authenticated user or guest (session_token provided).
   * The CartOrder.carts table supports multiple carts per user or session
   * (e.g., guest session and later migration to member).
   *
   * On creation, mandatory fields are: user_id (if authenticated, optional
   * for guest), and session_token (identifies guest cart until login).
   * Optionally, initial cart_items may be created.
   *
   * Business logic: Cart expiration is calculated on creation (configurable).
   * Duplicate cart creation with the same session_token/user is prevented
   * (enforced by DB unique constraints).
   *
   * Success returns full cart info (ID, status, items, expiry, etc.). Access
   * is restricted to the owner. Errors include violation of unique
   * constraints, invalid or expired session_token, and permission checks.
   * This endpoint complements cart listing, detail, and item-editing APIs.
   *
   * @param body Cart creation info (may include items, session_token,
   *   user_id).
   * @autobe Generated by AutoBE - https://github.com/wrtnlabs/autobe
   */
  @TypedRoute.Post()
  public async post(
    @TypedBody()
    body: ICart.ICreate,
  ): Promise<ICart> {
    body;
    return typia.random<ICart>();
  }
 
  /**
   * List/search the current user's shopping carts with pagination
   * (CartOrder.carts).
   *
   * Returns a paginated, filterable list of shopping carts owned by the
   * current user (including guest carts where session_token matches). The
   * CartOrder.carts table supports both user_id and session-based cart
   * tracking. Supports searching by cart status (active, expired), expiry
   * window, and optionally session_token (for guest/anonymous users).
   *
   * Results support pagination and sorting (e.g., by updated_at) to handle
   * users with multiple carts (frequent behavior with cart templates,
   * guest/member, and cross-device migration). RBAC ensures only the current
   * user's carts are returned.
   *
   * Business cases: resuming abandoned carts, cross-device shopping, cart
   * analytics, and migration on login. Errors include invalid search params
   * or permission denied for other users' carts.
   *
   * Relation to: cart detail (GET), create (POST), update (PUT), delete
   * (DELETE).
   *
   * @param body Filter/search/paging info for cart listing.
   * @autobe Generated by AutoBE - https://github.com/wrtnlabs/autobe
   */
  @TypedRoute.Patch()
  public async patch(
    @TypedBody()
    body: ICart.IRequest,
  ): Promise<IPageICart> {
    body;
    return typia.random<IPageICart>();
  }
 
  /**
   * Retrieve detail for a single cart owned by the user or guest
   * (CartOrder.carts).
   *
   * Returns all data and items for a specific shopping cart. The
   * CartOrder.carts table tracks authentic carts for users (member or guest).
   * The ID parameter identifies the cart; access is only granted for carts
   * that belong to the authenticated user or have a matching session_token
   * (for guest flows).
   *
   * Returned detail includes cart status, items, last updated, expiration,
   * and links to product variants for the contained items.
   *
   * Business logic: attempting to access someone else's cart returns 'not
   * found' or 'permission denied' for privacy/compliance. Edge cases:
   * expired/soft-deleted carts may require special handling (e.g., display as
   * 'abandoned').
   *
   * Paired with cart list/search (PATCH), item editing (PUT/POST), and
   * checkout order creation APIs.
   *
   * @param id Cart unique ID for lookup.
   * @autobe Generated by AutoBE - https://github.com/wrtnlabs/autobe
   */
  @TypedRoute.Get(":id")
  public async getById(
    @TypedParam("id")
    id: string,
  ): Promise<ICart> {
    id;
    return typia.random<ICart>();
  }
 
  /**
   * Replace or update an existing cart by its ID in the carts table.
   *
   * This API operation allows updating or replacing the persistent shopping
   * cart identified by the provided cart ID. The carts table represents user
   * or session scoped shopping carts, supporting both guest and member flows
   * as outlined in Cart & Order requirements. The operation requires a full
   * update of the atomic cart state, such as user assignment (migrating guest
   * to member), session token changes (e.g., after login), or updating
   * expiration logic.
   *
   * When a cart is updated, new metadata (like extension of expiry or session
   * handoff) triggers compliance tracking via audit fields (e.g.,
   * updated_at). User and session linkage are validated; associated cart
   * items are NOT affected and remain intact unless separately updated
   * through cart item endpoints. All changes are strictly audit-logged to
   * meet regulatory traceability.
   *
   * This operation enforces full replacement of the specified cart resource,
   * not partial patching. In accordance with soft delete policy, 'deleted_at'
   * may be set to force logical deletion.
   *
   * Related operations include creating a new cart (POST /carts) or deleting
   * a cart (DELETE /carts/{id}). For managing cart items, dedicated endpoints
   * (e.g., /cartItems) are used.
   *
   * On error, validation failures (invalid user/session or expired cart)
   * return explicit error codes. Soft delete compliance is enforced in all
   * flows by marking 'deleted_at', not physical deletion.
   *
   * @param id Unique identifier for the target cart.
   * @param body Updated cart entity data.
   * @autobe Generated by AutoBE - https://github.com/wrtnlabs/autobe
   */
  @TypedRoute.Put(":id")
  public async putById(
    @TypedParam("id")
    id: string & tags.Format<"uuid">,
    @TypedBody()
    body: ICart.IUpdate,
  ): Promise<ICart> {
    id;
    body;
    return typia.random<ICart>();
  }
 
  /**
   * Soft delete a cart by its ID in the carts table.
   *
   * This API operation performs a logical (soft) deletion of the persistent
   * shopping cart referenced by the provided cart ID. The carts table
   * enforces soft delete across all shopping carts in the system to meet
   * compliance, full audit, and reversibility requirements specified in Cart
   * & Order.
   *
   * When invoked, this endpoint updates the 'deleted_at' column for the
   * specified cart record, marking it as deleted but retaining the record for
   * later audit analysis or undelete flows if necessary. Attempting to delete
   * a non-existent or already deleted cart returns an error with reason.
   *
   * Related endpoints include creating a cart (POST /carts), updating a cart
   * (PUT /carts/{id}), and managing cart items separately. Carts must be
   * referenced using their unique identifier and must match RBAC and session
   * ownership rules to protect user/session scoping integrity.
   *
   * No physical deletion occurs; full compliance with GDPR, CCPA, and
   * regional audit laws is enforced. This endpoint does not affect related
   * cart items, which must be deleted via dedicated cartItem endpoints if
   * needed.
   *
   * @param id Unique identifier of the cart to delete.
   * @autobe Generated by AutoBE - https://github.com/wrtnlabs/autobe
   */
  @TypedRoute.Delete(":id")
  public async eraseById(
    @TypedParam("id")
    id: string & tags.Format<"uuid">,
  ): Promise<ICart> {
    id;
    return typia.random<ICart>();
  }
}

import { tags } from "typia";
 
/**
 * Normalized record of a line item in an order (individual SKUs/variants,
 * quantity, reference to order and variant). Matches the atomic database row.
 * All order items are immutable audit records after order is completed, not
 * destroyed but soft-deleted if removed.
 *
 * @autobe Generated by AutoBE - https://github.com/wrtnlabs/autobe
 */
export type IOrderItem = {
  /**
   * Primary key: unique identifier of the order item, from the order_items.id
   * column.
   */
  id: string & tags.Format<"uuid">;
 
  /** Foreign key referencing the parent order (order_items.order_id). */
  order_id: string & tags.Format<"uuid">;
 
  /**
   * Foreign key referencing the product variant purchased
   * (order_items.product_variant_id).
   */
  product_variant_id: string & tags.Format<"uuid">;
 
  /** Number of units purchased for this variant in the order. */
  quantity: number &
    tags.Type<"int32"> &
    tags.JsonSchemaPlugin<{
      format: "int32";
    }>;
 
  /** Optional memo per item – e.g. gift message or special handling. */
  note?: string | null;
 
  /** Timestamp of item creation. */
  created_at: string & tags.Format<"date-time">;
 
  /** Timestamp of last modification. */
  updated_at: string & tags.Format<"date-time">;
 
  /** Timestamp for soft deletion (data not removed for compliance purposes). */
  deleted_at?: (string & tags.Format<"date-time">) | null;
};
export namespace IOrderItem {
  /**
   * Filter/search/pagination structure for listing order items. Fields
   * represent all typical search or filter requirements according to the
   * order_items schema and analytics/business needs.
   */
  export type IRequest = {
    /**
     * Filter item listing by associated order. Implements the need to fetch
     * items by order context according to the normalized order_items
     * schema.
     */
    order_id?: (string & tags.Format<"uuid">) | null;
 
    /**
     * Filter for cart/order items by specific product_variant. Enables
     * lookup of all orders containing a particular SKU variant.
     */
    product_variant_id?: (string & tags.Format<"uuid">) | null;
 
    /** Filter: Return items with creation datetime at or after this value. */
    created_at_from?: (string & tags.Format<"date-time">) | null;
 
    /** Filter: Return items with creation datetime at or before this value. */
    created_at_to?: (string & tags.Format<"date-time">) | null;
 
    /** Page number for pagination; starts from 1. */
    page?:
      | (number &
          tags.Type<"int32"> &
          tags.JsonSchemaPlugin<{
            format: "int32";
          }>)
      | null;
 
    /**
     * Number of items to return per page. Used in scalable APIs for UI
     * display or analytics.
     */
    limit?:
      | (number &
          tags.Type<"int32"> &
          tags.JsonSchemaPlugin<{
            format: "int32";
          }>)
      | null;
  };
 
  /**
   * Payload to add a single item to an order in the creation step. Restricts
   * to product variant, quantity, and memo/notes. Follows normalized data
   * principles, with all relation handled at the top level (orders -> items
   * array).
   */
  export type ICreate = {
    /**
     * ID of the product variant this item is for. Fulfills the need for
     * SKU-level detail control as described in
     * order_items.product_variant_id.
     */
    product_variant_id: string & tags.Format<"uuid">;
 
    /** The ordered quantity for this variant. */
    quantity: number &
      tags.Type<"int32"> &
      tags.JsonSchemaPlugin<{
        format: "int32";
      }>;
 
    /**
     * Optional memo on this item (special instructions, e.g., gift
     * message).
     */
    note?: string | null;
  };
 
  /**
   * Payload type for mutation/update of an order item during order update
   * flows. Only quantity and note are mutable; references remain the same for
   * auditability.
   */
  export type IUpdate = {
    /**
     * ID of the order item to update. Used for replacement or update
     * semantics on an existing order item during order update workflows.
     */
    id: string & tags.Format<"uuid">;
 
    /**
     * New quantity for this order item. If omitted, quantity is not
     * changed. SET nullable for partial update scenarios.
     */
    quantity?:
      | (number &
          tags.Type<"int32"> &
          tags.JsonSchemaPlugin<{
            format: "int32";
          }>)
      | null;
 
    /** Update for item-level memo/instructions. */
    note?: string | null;
  };
}

import api from "@ORGANIZATION/PROJECT-api";
import typia, { tags } from "typia";
 
import { ICoupon } from "@ORGANIZATION/PROJECT-api/lib/structures/ICoupon";
 
export async function test_api_coupons_putById(connection: api.IConnection) {
  const output: ICoupon = await api.functional.coupons.putById(connection, {
    id: typia.random<string & tags.Format<"uuid">>(),
    body: typia.random<ICoupon.IUpdate>(),
  });
  typia.assert(output);
}