@retaila/shared-types/dist/index.d.mts

Tipos compartidos para el proyecto Retail

interface BaseEntity {
    id: string;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date;
}
interface BaseEntityWithAccount extends BaseEntity {
    accountId: string;
}
interface BaseEntityWithUser extends BaseEntity {
    userId: string;
}
interface BaseEntityWithAccountAndUser extends BaseEntityWithAccount {
    userId: string;
}

interface Address {
    country: string;
    department: string;
    locality: string;
    street: string;
    number: string;
    mapPosition?: MapPosition;
}
interface MapPosition {
    lat: number;
    lng: number;
}

/**
 * Entidad Media
 * Se utiliza para almacenar y gestionar archivos y recursos multimedia.
 */
interface Media {
    id: string;
    accountId: string;
    filename: string;
    url: string;
    thumbnailUrl: string;
    mimeType: string;
    extension: string;
    size: number;
    type: MediaType;
    altText: string;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date | null;
}
declare enum MediaType {
    IMAGE = "IMAGE",
    VIDEO = "VIDEO",
    DOCUMENT = "DOCUMENT",
    AUDIO = "AUDIO",
    ARCHIVE = "ARCHIVE",
    OTHER = "OTHER"
}

interface Phone {
    countryCode: string;
    national: string;
    international: string;
    type: 'mobile' | 'landline';
    validated: boolean;
}

declare enum Currency {
    USD = "USD",
    EUR = "EUR",
    UYU = "UYU",
    ARS = "ARS",
    BRL = "BRL"
}
declare function getCurrencySymbol(currencyCode: Currency): string;

interface Account {
    id: string;
    name: string;
    address?: string;
    logoId?: string;
    currency: string;
    instagram?: string;
    facebook?: string;
    whatsapp?: string;
    phone?: string;
    email: string;
    timezone: string;
    hasDelivery: boolean;
    status: AccountStatus;
    themeConfig?: ThemeConfig;
    privateKey?: string;
    demo: boolean;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date;
}
declare enum AccountStatus {
    ACTIVE = "ACTIVE",
    INACTIVE = "INACTIVE",
    PENDING = "PENDING",
    SUSPENDED = "SUSPENDED"
}
interface ThemeConfig {
    backgroundColor: string;
    textColor: string;
    primaryColor: string;
    secondaryColor: string;
}

interface AccountIntegrationConfigDTO {
    accountId: string;
    integrationId: string;
    settingsProduction?: Record<string, any>;
    settingsDevelopment?: Record<string, any>;
    environment: AccountIntegrationEnvironment;
    status?: AccountIntegrationStatus;
}

/**
 * Entidad Integration
 * Define las integraciones de terceros disponibles en la plataforma (ej. pasarelas de pago, transportistas).
 * Almacena información sobre el proveedor, categoría y esquema de parámetros requeridos.
 */
declare enum IntegrationCategory {
    PAYMENT_GATEWAY = "PAYMENT_GATEWAY",
    SHIPPING_CARRIER = "SHIPPING_CARRIER",
    MARKETPLACE = "MARKETPLACE",
    EMAIL_MARKETING = "EMAIL_MARKETING",
    ANALYTICS = "ANALYTICS",
    ACCOUNTING = "ACCOUNTING",
    SOCIAL_MEDIA = "SOCIAL_MEDIA",
    OTHER = "OTHER"
}
declare enum IntegrationStatus {
    ACTIVE = "ACTIVE",
    INACTIVE = "INACTIVE",
    BETA = "BETA",
    DEPRECATED = "DEPRECATED"
}
interface Integration {
    id: string;
    category: IntegrationCategory;
    providerKey: string;
    name: string;
    description?: string;
    setupInstructions?: string;
    logoUrl?: string;
    requiredParamsSchema?: any;
    status: IntegrationStatus;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date | null;
    accountIntegration: AccountIntegration | null;
}

/**
 * Entidad AccountIntegration
 * Contiene información de la integración y sus credenciales.
 */
declare enum AccountIntegrationStatus {
    ACTIVE = "ACTIVE",
    INACTIVE = "INACTIVE",
    BETA = "BETA",
    DEPRECATED = "DEPRECATED"
}
declare enum AccountIntegrationConnectionStatus {
    CONNECTED = "CONNECTED",
    DISCONNECTED = "DISCONNECTED",
    ERROR = "ERROR",
    WARNING = "WARNING"
}
declare enum AccountIntegrationEnvironment {
    PRODUCTION = "PRODUCTION",
    DEVELOPMENT = "DEVELOPMENT"
}
interface AccountIntegration {
    id: string;
    accountId: string;
    integrationId: string;
    settingsProduction: Object | null;
    settingsDevelopment: Object | null;
    environment: AccountIntegrationEnvironment;
    productionStatus: AccountIntegrationConnectionStatus;
    developmentStatus: AccountIntegrationConnectionStatus;
    status: AccountIntegrationStatus;
    demo: boolean;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date | null;
    integration: Integration;
    settings: Record<string, any>;
}

/**
 * Entidad AccountDeliveryOption
 * Representa una opción de envío de una cuenta.
 */
interface AccountDeliveryOption {
    id: string;
    accountId: string;
    accountBranchId: string;
    name: string;
    integrationId?: string;
    isScheduled: boolean;
    priceLogic: AccountDeliveryOptionPriceLogic;
    status: AccountDeliveryOptionStatus;
    demo: boolean;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date | null;
    zones: AccountDeliveryOptionZone[];
    integration?: AccountIntegration | null;
    calculatedCost?: AccountDeliveryOptionCalculatedCost | null;
    accountBranch?: AccountBranch | null;
}
declare enum AccountDeliveryOptionPriceLogic {
    FIXED = "FIXED",
    PER_KM = "PER_KM"
}
declare enum AccountDeliveryOptionStatus {
    ACTIVE = "ACTIVE",
    INACTIVE = "INACTIVE"
}
interface AccountDeliveryOptionCalculatedCost {
    basePrice: number;
    distanceKm: number;
    finalPrice: number;
    priceLogic: AccountDeliveryOptionPriceLogic;
    currency: string;
}
interface AccountDeliveryOptionZone {
    id: string;
    accountId: string;
    accountDeliveryOptionId: string;
    name: string;
    price: number;
    priceMin: number;
    area: string;
    status: AccountDeliveryOptionZoneStatus;
    demo: boolean;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date | null;
}
declare enum AccountDeliveryOptionZoneStatus {
    ACTIVE = "ACTIVE",
    INACTIVE = "INACTIVE"
}

/**
 * Entidad AccountBranch
 * Representa una sucursal de una cuenta.
 */
interface AccountBranch {
    id: string;
    accountId: string;
    name: string;
    address?: Address;
    addressInstructions?: string;
    addressCoordinates?: MapPosition | null;
    phone?: Phone | null;
    email?: string | null;
    demo: boolean;
    status: AccountBranchStatus;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date | null;
    schedule: AccountBranchSchedule[];
    deliveryOptions: AccountDeliveryOption[];
}
declare enum AccountBranchStatus {
    ACTIVE = "ACTIVE",
    INACTIVE = "INACTIVE"
}
interface AccountBranchSchedule {
    id: string;
    accountBranchId: string;
    day: AccountBranchScheduleDay;
    start: number;
    end: number;
    status: AccountBranchScheduleStatus;
    demo: boolean;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date | null;
}
declare enum AccountBranchScheduleStatus {
    ACTIVE = "ACTIVE",
    INACTIVE = "INACTIVE"
}
declare enum AccountBranchScheduleDay {
    MONDAY = "MONDAY",
    TUESDAY = "TUESDAY",
    WEDNESDAY = "WEDNESDAY",
    THURSDAY = "THURSDAY",
    FRIDAY = "FRIDAY",
    SATURDAY = "SATURDAY",
    SUNDAY = "SUNDAY"
}

/**
 * Entidad AccountDomain
 * Representa un dominio personalizado asociado a una cuenta.
 * Permite dominios completos y subdominios, con control de estado y verificación.
 */
interface AccountDomain {
    id: string;
    accountId: string;
    domain: string; /** Dominio completo (ej: example.com) */
    subdomain?: string; /** Subdominio opcional (ej: shop, blog) */
    isPrimary: boolean; /** Indica si este es el dominio principal de la cuenta */
    status: AccountDomainStatus; /** Estado del dominio: PENDING, ACTIVE, INACTIVE */
    verifiedAt?: Date; /** Fecha de verificación del dominio */
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date | null;
}
declare enum AccountDomainStatus {
    PENDING = "PENDING",
    ACTIVE = "ACTIVE",
    INACTIVE = "INACTIVE"
}

/**
 * Entidad Customer
 * Cliente de la tienda
*/

interface Customer {
    id: string;
    accountId: string;
    firstName?: string;
    lastName?: string;
    email: string;
    phone?: Phone;
    status: CustomerStatus;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date | null;
}
declare enum CustomerStatus {
    ACTIVE = "ACTIVE",
    INACTIVE = "INACTIVE",
    BLACKLISTED = "BLACKLISTED",// e.g., for fraudulent activity
    PENDING = "PENDING"
}

/**
 * Register or update a customer
 */
interface CustomerUpsertDto {
    id?: string;
    accountId: string;
    firstName?: string;
    lastName?: string;
    email: string;
    phone?: Phone;
}

/**
 * Entidad Order
 * Define la orden de compra de un cliente en el sitio web.
 */
interface Order {
    id: string;
    accountId: string;
    customerId: string;
    cartId?: string;
    code: string;
    deliveryType?: OrderDeliveryType;
    deliveryFirstName?: string;
    deliveryLastName?: string;
    deliveryAddress?: any;
    deliveryPhone?: any;
    deliveryOptionId?: string;
    pickupBranchId?: string;
    paymentMethodIntegrationId?: string;
    billingInformation?: any;
    currency: Currency;
    subtotalPrice: number;
    totalDiscounts: number;
    totalShippingPrice: number;
    totalTax: number;
    taxDetails?: any;
    totalPrice: number;
    totalRefunded: number;
    status: OrderStatus;
    paymentStatus: OrderPaymentStatus;
    fulfillmentStatus: OrderFulfillmentStatus;
    statusHistory?: StatusChangeHistory[];
    customerNote?: string;
    internalNote?: string;
    source: OrderSource;
    sourceAccountDomainId?: string;
    demo: boolean;
    createdAt: Date;
    updatedAt: Date;
    cancelledAt?: Date;
    cancelReason?: string;
    deletedAt?: Date;
    items?: OrderItem[];
    customer?: Customer | null;
    paymentMethodIntegration?: AccountIntegration | null;
    accountDomain?: AccountDomain;
}
interface OrderItem {
    id: string;
    accountId: string;
    orderId: string;
    productId: string;
    productVariantId: string;
    sku?: string;
    productName: string;
    variantName?: string;
    currency: Currency;
    unitPrice: number;
    totalDiscount: number;
    totalPrice: number;
    quantity: number;
    quantityFulfilled: number;
    quantityRefunded: number;
    quantityReturned: number;
    totalTax: number;
    taxName?: string;
    createdAt: Date;
    updatedAt: Date;
}
declare enum OrderStatus {
    PENDING = "PENDING",// Order placed, awaiting payment confirmation
    CONFIRMED = "CONFIRMED",// Payment received, order confirmed
    PROCESSING = "PROCESSING",// Order being prepared
    PROCESSED = "PROCESSED",// Order ready to be shipped
    ON_HOLD = "ON_HOLD",// Order temporarily paused
    COMPLETED = "COMPLETED",// Order finished (e.g., after return period)
    CANCELLED = "CANCELLED",// Order cancelled before fulfillment
    FAILED = "FAILED"
}
declare enum OrderPaymentStatus {
    PENDING = "PENDING",
    PARTIAL = "PARTIAL",
    PAID = "PAID",
    OVERPAID = "OVERPAID",
    REFUNDED = "REFUNDED",
    PARTIALLY_REFUNDED = "PARTIALLY_REFUNDED"
}
declare enum OrderFulfillmentStatus {
    PENDING = "PENDING",
    PARTIAL = "PARTIAL",
    FULFILLED = "FULFILLED"
}
declare enum OrderSource {
    WEB = "WEB",
    POS = "POS",
    API = "API"
}
declare enum OrderDeliveryType {
    SHIPPING = "shipping",
    PICKUP = "pickup"
}
interface StatusChangeHistory {
    status: OrderStatus;
    timestamp: Date;
    reason?: string;
    userId?: string;
    metadata?: Record<string, any>;
}

interface OrderCreateFromCartDto {
    cartId: string;
    paymentMethodIntegrationId?: string;
    customerNote?: string;
}
interface AdminOrderStatusChangeDto {
    status: OrderStatus;
}

/**
 * Add an item to the cart
*/
interface CartItemAddDto {
    cartId: string;
    productId: string;
    variantId?: string;
    quantity: number;
    attributes?: {
        [key: string]: string | number;
    };
    userEmail?: string;
    userId?: string;
}
/**
 * Update an item in the cart
 */
interface CartItemUpdateDto {
    cartId: string;
    itemId: string;
    quantity: number;
}
/**
 * Remove an item from the cart
 */
interface CartItemRemoveDto {
    cartId: string;
    itemId: string;
}
interface CartUpdateDto {
    cartId: string;
    source: OrderSource;
    accountDomainId?: string;
    customer: {
        email: string;
    };
    delivery: {
        type: 'shipping' | 'pickup';
        deliveryOptionId?: string;
        pickupBranchId?: string;
        firstname: string;
        lastname: string;
        phone: {
            countryCode: string;
            national: string;
            international: string;
            type: string;
            validated: boolean;
        };
        address: {
            country: string;
            department: string;
            locality: string;
            street: string;
            complement?: string;
            notes?: string;
            postalCode: string;
            mapPosition: {
                lat: number;
                lng: number;
            };
        };
    };
    billing: {
        name: string;
        address: string;
        city: string;
        department: string;
    };
}
/**
 * Confirm a cart
 */
interface CartConfirmDto {
    cartId: string;
}
/**
 * Validation information for a cart item
 */
interface CartItemValidation {
    hasIssues: boolean;
    issues: string[];
    errorCode?: CartItemErrorCode;
    currentPrice?: number;
    availableStock?: number;
    isProductActive?: boolean;
}
/**
 * Error codes for cart items
 */
declare enum CartItemErrorCode {
    PRICE_INCREASED = "PRICE_INCREASED",// Precio aumentó
    PRICE_DECREASED = "PRICE_DECREASED",// Precio disminuyó  
    PRODUCT_INACTIVE = "PRODUCT_INACTIVE",// Producto ya no está disponible
    STOCK_INSUFFICIENT = "STOCK_INSUFFICIENT",// Stock insuficiente (hay algo disponible)
    STOCK_UNAVAILABLE = "STOCK_UNAVAILABLE",// Sin stock (0 disponible)
    VALIDATION_ERROR = "VALIDATION_ERROR"
}

/**
 * Entidad Cart
 * Define el carrito de compras de un cliente en el sitio web.
 */
interface Cart {
    id: string;
    code: string;
    customerId?: string;
    sessionId?: string;
    items: CartItem[];
    currency: string;
    subtotal: number;
    total: number;
    deliveryType: CartDeliveryType;
    itemCount: number;
    createdAt: Date;
    updatedAt: Date;
    status: CartStatus;
    source: CartSource;
    sourceAccountDomainId?: string;
    recoveryToken?: string;
    customerNote?: string;
    hasIssues: boolean;
    issuesCount: number;
    subtotalPrice?: number;
    totalDiscounts?: number;
    totalShippingPrice?: number;
    totalTax?: number;
    totalPrice?: number;
    taxDetails?: any;
    customer?: Customer | null;
    accountDomain?: AccountDomain;
}
interface CartItem {
    id: string;
    productId: string;
    productVariantId: string;
    name: string;
    unitPrice: number;
    quantity: number;
    image?: string;
    thumbnailUrl?: string;
    sku?: string;
    attributeDetails: CartItemAttributeDetail[];
    validation?: CartItemValidation;
}
interface CartItemAttributeDetail {
    name: string;
    value: string;
    type?: string;
}
declare enum CartStatus {
    ACTIVE = "ACTIVE",
    LOCKED = "LOCKED",
    EXPIRED = "EXPIRED",
    CONVERTED = "CONVERTED",
    ABANDONED = "ABANDONED",
    MERGED = "MERGED"
}
declare enum CartSource {
    WEB = "WEB",
    POS = "POS",
    API = "API"
}
declare enum CartDeliveryType {
    DELIVERY = "delivery",
    PICKUP = "pickup"
}

declare enum PaymentStatus {
    PENDING = "PENDING",// Pendiente
    PREAUTHORIZED = "PREAUTHORIZED",
    APPROVED = "APPROVED",// Pago aprobado online
    PAID = "PAID",// Pago realizado por redes fisicas
    REJECTED = "REJECTED",// Pago rechazado
    REFUND_IN_PROCESS = "REFUND_IN_PROCESS",// En proceso de reembolso con la plataforma de pagos
    PARTIAL_REFUND = "PARTIAL_REFUND",// Pago parcialmente reembolsado
    REFUNDED = "REFUNDED"
}
declare enum PaymentMethodType {
    BANK_TRANSFER = "BANK_TRANSFER",
    CREDIT_CARD = "CREDIT_CARD",
    DEBIT_CARD = "DEBIT_CARD",
    MERCADOPAGO = "MERCADOPAGO",
    PHYSICAL = "PHYSICAL",
    INTERNATIONAL = "INTERNATIONAL",
    PAYPAL = "PAYPAL",
    CASH = "CASH",
    OTHER = "OTHER"
}
interface Payment {
    id: string;
    accountId: string;
    orderId: string;
    invoiceId?: string;
    gatewayPaymentId?: string;
    referenceCode?: string;
    paymentMethodType?: PaymentMethodType;
    currency: Currency;
    amount: number;
    amountReceived: number;
    amountRefunded: number;
    paidAt?: string | Date;
    refundedAt?: string | Date;
    status: PaymentStatus;
    cardBrand?: string;
    cardLast4?: string;
    metadata?: Record<string, any>;
    demo: boolean;
    createdAt: string | Date;
    updatedAt: string | Date;
    deletedAt?: string | Date;
}

/**
 * Entidad Product
 * Representa un producto vendible en la tienda. Es la entidad base que puede tener múltiples variantes.
 */
interface Product {
    id: string;
    accountId: string;
    code: string;
    brandId?: string | null;
    supplierId?: string | null;
    productType: ProductType;
    sku?: string | null;
    barcode?: string | null;
    name: string;
    slug: string;
    description?: string | null;
    isFeatured: boolean;
    allowBackorder: boolean;
    weight?: number | null;
    weightUnit?: string | null;
    height?: number | null;
    width?: number | null;
    depth?: number | null;
    dimensionUnit?: string | null;
    shippingLeadTime?: string | null;
    status: ProductStatus;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date | null;
}
declare enum ProductStatus {
    ACTIVE = "ACTIVE",// Available for sale
    INACTIVE = "INACTIVE",// Not visible/purchasable
    ARCHIVED = "ARCHIVED",// Not visible, kept for records
    DRAFT = "DRAFT"
}
declare enum ProductType {
    SIMPLE = "SIMPLE",// Product without variants (may have a default hidden variant)
    VARIABLE = "VARIABLE",// Product with distinct variants (color, size, etc.)
    BUNDLE = "BUNDLE",// A package of other products/variants
    GIFT_CARD = "GIFT_CARD"
}
interface ProductVariant {
    id: string;
    accountId: string;
    productId: string;
    sku?: string | null;
    barcode?: string | null;
    currency: string;
    price: number;
    compareAtPrice?: number;
    allowBackorder?: boolean;
    stock: number;
    weight?: number | null;
    weightUnit?: string | null;
    height?: number | null;
    width?: number | null;
    depth?: number | null;
    dimensionUnit?: string | null;
    shippingLeadTime?: string | null;
    order: number;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date;
}

/**
 * Entidad ProductAttribute
 * Define los atributos disponibles que se pueden asignar a las variantes de producto (ej. Color, Talla).
 * Especifica el nombre y tipo del atributo para ayudar en la representación y filtrado.
 */
interface ProductAttribute {
    id: string;
    accountId: string;
    name: string;
    alias: string;
    slug: string;
    type: ProductAttributeType;
    isRequired: boolean;
    suffix: string;
    status: ProductAttributeStatus;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date | null;
    options: ProductAttributeOption[];
    displayOrder: number;
}
declare enum ProductAttributeStatus {
    ACTIVE = "ACTIVE",
    INACTIVE = "INACTIVE"
}
declare enum ProductAttributeType {
    TEXT = "TEXT",// text input
    NUMBER = "NUMBER",// number input
    COLOR = "COLOR",// Special type for color swatches
    SELECT = "SELECT",// Dropdown list
    BOOLEAN = "BOOLEAN"
}
/**
 * Una opción específica para un atributo (ej. "Talle 42" para el atributo "Talle").
 */
interface ProductAttributeOption {
    id: string;
    accountId: string;
    productAttributeId: string;
    value: string;
    imageId?: string | null;
    order: number;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date | null;
    count: number;
}

/**
 * Entidad StandardCategory
 * Define las categorías estándar de productos.
 * Estas categorías estan pensadas para unificar o agrupar productos de diferentes cuentas.
 */
interface StandardCategory {
    id: string;
    parentId?: string;
    name: string;
    slug: string;
    description?: string;
    imageId?: string | null;
    order: number;
    status: StandardCategoryStatus;
    metadata?: {
        icon?: string;
        displayInMenu?: boolean;
        seoTitle?: string;
        seoDescription?: string;
        attributes?: string[];
    };
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date | null;
    children: StandardCategory[];
    parent: StandardCategory | null;
}
declare enum StandardCategoryStatus {
    ACTIVE = "ACTIVE",
    INACTIVE = "INACTIVE"
}

/**
 * Entidad ProductCategory
 * Define las categorías de productos.
 * Soporta una estructura jerárquica (categorías y subcategorías) mediante el campo parentId.
 * Cada categoría debe estar asociada a una categoría estándar del sistema.
 */
interface ProductCategory {
    id: string;
    accountId: string;
    parentId?: string;
    standardCategoryId: string;
    name: string;
    slug: string;
    description?: string;
    imageId?: string | null;
    order: number;
    isFeatured: boolean;
    status: ProductCategoryStatus;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date | null;
    children: ProductCategory[];
    parent: ProductCategory | null;
    standardCategory: StandardCategory;
}
declare enum ProductCategoryStatus {
    ACTIVE = "ACTIVE",
    INACTIVE = "INACTIVE"
}

/**
 * Entidad StoreBanner
 * Banners para la portada de la web de la tienda
 */

interface StoreBanner {
    id: string;
    accountId: string;
    title: string;
    desktopMediaId: string;
    mobileMediaId?: string | null;
    linkUrl?: string | null;
    altText?: string | null;
    displayOrder: number;
    startDate?: Date | null;
    endDate?: Date | null;
    status: StoreBannerStatus;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date | null;
    desktopMedia?: Partial<Media> | null;
    mobileMedia?: Partial<Media> | null;
}
declare enum StoreBannerStatus {
    ACTIVE = "ACTIVE",
    INACTIVE = "INACTIVE"
}

/**
 * Entidad StorePage
 * Páginas de la web de la tienda
 */
interface StorePage {
    id: string;
    accountId: string;
    type: StorePageType;
    title: string;
    slug: string;
    content?: string | null;
    seoTitle?: string | null;
    seoDescription?: string | null;
    status: StorePageStatus;
    canDelete: boolean;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date | null;
}
declare enum StorePageStatus {
    PUBLISHED = "PUBLISHED",
    DRAFT = "DRAFT",
    ARCHIVED = "ARCHIVED"
}
declare enum StorePageType {
    ABOUT_US = "ABOUT_US",
    CONTACT = "CONTACT",
    FAQ = "FAQ",
    TERMS_AND_CONDITIONS = "TERMS_AND_CONDITIONS",
    PRIVACY_POLICY = "PRIVACY_POLICY",
    RETURN_POLICY = "RETURN_POLICY",
    SHIPPING_POLICY = "SHIPPING_POLICY",
    BRANCHES = "BRANCHES",
    JOBS = "JOBS",
    OTHER = "OTHER"
}

declare enum PubSubTopics {
    ORDER_PLACED = "order-placed",
    NOTIFICATION_CREATED = "notification-created"
}

export { type Account, type AccountBranch, type AccountBranchSchedule, AccountBranchScheduleDay, AccountBranchScheduleStatus, AccountBranchStatus, type AccountDeliveryOption, type AccountDeliveryOptionCalculatedCost, AccountDeliveryOptionPriceLogic, AccountDeliveryOptionStatus, type AccountDeliveryOptionZone, AccountDeliveryOptionZoneStatus, type AccountDomain, AccountDomainStatus, type AccountIntegration, type AccountIntegrationConfigDTO, AccountIntegrationConnectionStatus, AccountIntegrationEnvironment, AccountIntegrationStatus, AccountStatus, type Address, type AdminOrderStatusChangeDto, type BaseEntity, type BaseEntityWithAccount, type BaseEntityWithAccountAndUser, type BaseEntityWithUser, type Cart, type CartConfirmDto, CartDeliveryType, type CartItem, type CartItemAddDto, type CartItemAttributeDetail, CartItemErrorCode, type CartItemRemoveDto, type CartItemUpdateDto, type CartItemValidation, CartSource, CartStatus, type CartUpdateDto, Currency, type Customer, CustomerStatus, type CustomerUpsertDto, type Integration, IntegrationCategory, IntegrationStatus, type MapPosition, type Media, MediaType, type Order, type OrderCreateFromCartDto, OrderDeliveryType, OrderFulfillmentStatus, type OrderItem, OrderPaymentStatus, OrderSource, OrderStatus, type Payment, PaymentMethodType, PaymentStatus, type Phone, type Product, type ProductAttribute, type ProductAttributeOption, ProductAttributeStatus, ProductAttributeType, type ProductCategory, ProductCategoryStatus, ProductStatus, ProductType, type ProductVariant, PubSubTopics, type StandardCategory, StandardCategoryStatus, type StatusChangeHistory, type StoreBanner, StoreBannerStatus, type StorePage, StorePageStatus, StorePageType, type ThemeConfig, getCurrencySymbol };