Desde el texto hasta la intuición: dominando VPasCode de Visual Paradigm para el diagramado moderno

@startuml
dirección de izquierda a derecha
actor "Cliente de comercio electrónico" como customer
actor "Proveedor de identidad" como authPool
actor "Procesador de pagos" como stripe

rectángulo "Límite del sistema de pago" {
  usecase "Autenticar" como UC_Auth
  usecase "Ver carrito" como UC_Cart
  usecase "Pagar" como UC_Check
  usecase "Aplicar cupón" como UC_Promo
  usecase "Pagar con tarjeta de crédito" como UC_Pay
}

customer --> UC_Cart
customer --> UC_Check
UC_Check ..> UC_Auth : <>
UC_Check <.. UC_Promo : <>
UC_Check ..> UC_Pay : <>
UC_Auth --> authPool
UC_Pay --> stripe
@enduml

@startuml

class Biblioteca {
  - nombre: String
  - dirección: String
  - teléfono: String
  + agregarMiembro(miembro: Miembro): void
  + eliminarMiembro(idMiembro: String): void
  + agregarItem(item: ItemBiblioteca): void
  + eliminarItem(idItem: String): void
  + prestarItem(idMiembro: String, idItem: String): boolean
  + devolverItem(idItem: String): boolean
}

class ItemBiblioteca {
  # idItem: String
  # título: String
  # editorial: String
  # añoPublicación: int
  # disponible: boolean
  + obtenerDetalles(): String
  + establecerDisponibilidad(estado: boolean): void
}

clase abstracta Libro {
  - isbn: String
  - autor: String
  - númeroPáginas: int
  + obtenerAutor(): String
}

class LibroDigital {
  - tamañoMB: double
  - formato: String
  - urlDescarga: String
  + descargar(): void
}

class LibroImpreso {
  - ubicaciónEstante: String
  - estado: String
  + obtenerUbicaciónEstante(): String
}

class Revista {
  - númeroEdición: int
  - númeroVolumen: int
  - fechaPortada: Date
}

class DVD {
  - duraciónMinutos: int
  - director: String
  - idioma: String
  - subtítulosDisponibles: boolean
}

class Miembro {
  - idMiembro: String
  - nombre: String
  - correo: String
  - teléfono: String
  - fechaAfiliación: Date
  + prestarItem(item: ItemBiblioteca): boolean
  + devolverItem(item: ItemBiblioteca): boolean
  + obtenerItemsPrestados(): List
}

class RegistroPrestamo {
  - idRegistro: String
  - fechaPrestamo: Date
  - fechaVencimiento: Date
  - fechaDevolucion: Date
  - estáAtrasado(): boolean
  - calcularMulta(): double
}

class Multa {
  - idMulta: String
  - monto: double
  - fechaEmisión: Date
  - estáPagada: boolean
  + pagarMulta(): void
}

class Bibliotecario {
  - idPersonal: String
  - departamento: String
  + procesarPrestamo(miembro: Miembro, item: ItemBiblioteca): void
  + procesarDevolución(item: ItemBiblioteca): void
  + generarReporte(): void
  + gestionarInventario(): void
}

' Relaciones de herencia
ItemBiblioteca <|-- Libro
ItemBiblioteca <|-- Revista
ItemBiblioteca <|-- DVD
Libro <|-- LibroDigital
Libro <|-- LibroImpreso 

' Composición y agregación 

Biblioteca "1" -- "muchos" Miembro : tiene >
Biblioteca "1" -- "muchos" ItemBiblioteca : contiene >
Biblioteca "1" -- "muchos" Bibliotecario : emplea >

Miembro "1" -- "muchos" RegistroPrestamo : tiene >
RegistroPrestamo "1" -- "1..*" ItemBiblioteca : referencia >
RegistroPrestamo "1" -- "0..*" Multa : genera >

' Asociación
Bibliotecario --> RegistroPrestamo : gestiona >
Miembro --> RegistroPrestamo : crea >

nota arriba de Biblioteca : Sistema central que gestionanmiembros, artículos y préstamos
nota derecha de ItemBiblioteca : Clase base abstractanpara todos los materiales de biblioteca
@enduml

@startuml
' Título
título Retiro de efectivo en cajero automático - Diagrama de secuencia

' Actores y participantes
actor Cliente como C
participante "Cajero automático" como ATM
participante "Sistema bancario" como BS
base de datos "Cuenta del cliente" como DB

' Secuencia
C -> ATM : Insertar tarjeta
ATM -> ATM : Leer detalles de la tarjeta
ATM -> C : Solicitar PIN
C -> ATM : Ingresar PIN
ATM -> BS : Validar tarjeta y PIN
BS -> DB : Verificar credenciales
DB --> BS : Resultado de validación

alt PIN inválido
    BS --> ATM : PIN inválido
    ATM -> C : PIN inválido, inténtelo de nuevo
    nota derecha: Después de 3 intentos fallidos,nla tarjeta se retiene
else PIN válido
    BS --> ATM : PIN válido
    ATM -> C : Mostrar menú principal
    C -> ATM : Seleccionar retiro
    ATM -> C : Solicitar monto
    C -> ATM : Ingresar monto
    ATM -> BS : Verificar saldo y límite
    BS -> DB : Consultar saldo
    DB --> BS : Saldo actual
    
    alt Fondos insuficientes
        BS --> ATM : Saldo insuficiente
        ATM -> C : Transacción rechazadan(Mostrar saldo)
        C -> ATM : Cancelar transacción
        ATM -> C : Devolver tarjeta
    else Fondos suficientes
        BS --> ATM : Aprobado
        ATM -> ATM : Dispensar efectivo
        ATM -> C : Dispensar efectivo
        C -> ATM : Recoger efectivo
        ATM -> BS : Confirmar dispensación de efectivo
        BS -> DB : Debitar cuenta y registrar transacción
        DB --> BS : Actualización completa
        BS --> ATM : Transacción completada
        ATM -> C : Imprimir recibo
        alt Recibo solicitado
            C -> ATM : Recoger recibo
        else Sin recibo
            C -> ATM : Rechazar recibo
        end
        ATM -> C : Devolver tarjeta
        C -> ATM : Recoger tarjeta
    end
end

ATM -> C : Gracias / Finalizar transacción

@enduml

@startuml SistemaReclamacionesSeguros

start

:El asegurado presenta la reclamación;
:La reclamación se registra en el sistema;

si (¿La póliza está activa y es válida?) entonces (sí)
  :Asignar la reclamación al ajustador;
  :Notificar al ajustador sobre la nueva reclamación;
sino (no)
  :Enviar notificación de rechazo al asegurado;
  :Registrar motivo: Póliza inactiva/inválida;
  stop
fin si

:El ajustador revisa los documentos presentados;

si (¿Están todos los documentos requeridos presentes?) entonces (sí)
  :El ajustador inicia la validación de la reclamación;
sino (no)
  :Solicitar documentos faltantes al asegurado;
  :Esperar documentos adicionales;
  :Volver a revisar los documentos;
  nota derecha
    El sistema espera la
    respuesta del asegurado
  fin nota
  -> volver a "El ajustador revisa los documentos presentados";
fin si

:El ajustador investiga la reclamación;
:Contactar testigos/expertos si es necesario;
:Estimar el monto de daños/pérdidas;

si (¿La reclamación es válida según los términos de la póliza?) entonces (sí)
  :Calcular el monto aprobado;
  :Aplicar la franquicia si es aplicable;
sino (no)
  :Enviar notificación de rechazo con motivo;
  :Registrar decisión en el sistema;
  stop
fin si

:Generar oferta de resolución;
:Enviar oferta de resolución al asegurado;

:El asegurado revisa la oferta;

si (¿El asegurado acepta la oferta?) entonces (sí)
  :Procesar el pago;
  :Actualizar el estado de la reclamación a "Resuelta";
  :Enviar confirmación al asegurado;
  :Registrar detalles de cierre;
sino (no)
  :Escalar a resolución de disputas;
  :Negociar la resolución;
  :Actualizar la oferta;
  -> volver a "Enviar oferta de resolución al asegurado";
fin si

stop

@enduml

@startuml SistemaDeteccionHumo

titulo Diagrama de estados - Sistema de detección de humo

[*] --> Apagado

estado Apagado {
    [*] --> SinAlimentacion
    SinAlimentacion : Dispositivo apagado
    SinAlimentacion --> Encendido : Botón de encendido pulsado
}

estado Encendido {
    [*] --> Espera
    Espera : Sistema listo
    Espera --> Autoprueba : Autoprueba periódica (cada 24h)
    Espera --> Monitoreo : Iniciar monitoreo (sensor activo)
    
    estado Autoprueba {
        [*] --> PruebaSensores
        PruebaSensores --> PruebaExitosa : Todos los sensores OK
        PruebaSensores --> PruebaFallida : Error detectado en sensor
        PruebaExitosa --> Espera : Volver a espera
        PruebaFallida --> EstadoError : Reportar error
    }
    
    estado Monitoreo {
        [*] --> SinHumo
        SinHumo : Operación normal
        SinHumo --> DeteccionHumo : Nivel de humo > umbral
        SinHumo --> BateriaBaja : Batería baja (inalámbrico)
        BateriaBaja --> SinHumo : Batería reemplazada
        
        estado DeteccionHumo {
            [*] --> AlertaInicial
            AlertaInicial --> ConfirmacionHumo : El humo persiste > 5 segundos
            AlertaInicial --> FalsaAlarma : El humo desaparece < 5 segundos FalsaAlarma --> SinHumo : Reinicio
            ConfirmacionHumo --> AlarmaActivada
        }
        
        estado AlarmaActivada {
            [*] --> ActivarAlarma : Activar sirena y luces
            ActivarAlarma --> EnviarNotificacion : Notificar panel de control / app
            EnviarNotificacion --> EsperarReinicio
            EsperarReinicio --> AlarmaActivada : El humo aún está presente
            EsperarReinicio --> ReiniciarSistema : Botón de reinicio pulsado
            ReiniciarSistema --> SinHumo : El sistema se reinicia
        }
    }
}

estado EstadoError {
    [*] --> IndicadorFallo : Parpadeo del LED de error
    IndicadorFallo --> Apagado : Se requiere reinicio manual de alimentación
}

Encendido --> EstadoError : Falla en autoprueba
EstadoError --> Apagado : Reinicio de alimentación

Apagado --> [*] : Sistema desenchufado / batería retirada

@enduml

@startuml SistemaMensajeria

titulo Sistema de mensajería - Diagrama de componentes

' === Componentes ===
component "Aplicación del cliente" as ClienteApp
component "Aplicación móvil del mensajero" as MensajeroApp
component "Panel web de administración" as PanelAdmin

component "Pasarela de API" as PasarelaAPI

component "Servicio de pedidos" as ServicioPedidos
component "Servicio de despacho" as ServicioDespacho
component "Servicio de seguimiento" as ServicioSeguimiento
component "Servicio de pagos" as ServicioPagos
component "Servicio de notificaciones" as ServicioNotificaciones
component "Servicio de usuarios" as ServicioUsuarios

component "Cola de mensajesn(RabbitMQ/Kafka)" as ColaMensajes
component "Caché Redis" as RedisCache

database "Base de datos PostgreSQL" as SQLDB
database "MongoDBn(Los registros/historial de seguimiento)" as MongoLogs

' === Interfaces / Puertos ===
ClienteApp --> PasarelaAPI : "REST / WebSocket"
MensajeroApp --> PasarelaAPI : "REST / WebSocket"
PanelAdmin --> PasarelaAPI : "REST"

PasarelaAPI --> ServicioPedidos
PasarelaAPI --> ServicioSeguimiento
PasarelaAPI --> ServicioPagos
PasarelaAPI --> ServicioUsuarios

' === Dependencias de servicios ===
ServicioPedidos --> ServicioDespacho : "gRPC / REST"
ServicioPedidos --> ServicioPagos
ServicioPedidos --> ServicioNotificaciones
ServicioPedidos --> SQLDB : "JDBC"
ServicioPedidos --> RedisCache : "Caché"

ServicioDespacho --> ColaMensajes : "Publicar eventos"
ServicioDespacho --> MensajeroApp : "Enviar por pasarela de API"
ServicioDespacho --> SQLDB

ServicioSeguimiento --> ColaMensajes : "Suscribirse a actualizaciones de ubicación"
ServicioSeguimiento --> MongoLogs : "Escribir historial de seguimiento"
ServicioSeguimiento --> RedisCache : "Caché de ubicación actual"

ServicioPagos --> SQLDB
ServicioPagos --> ServicioNotificaciones

ServicioNotificaciones --> ColaMensajes : "Consumir notificaciones"
ServicioNotificaciones --> ClienteApp : "Enviar por pasarela de API"

ServicioUsuarios --> SQLDB
ServicioUsuarios --> RedisCache

' === Notas ===
nota derecha de ServicioPedidos
  Maneja la creación de paquetes,
  precios y estado de pedidos
fin nota

nota derecha de ServicioDespacho
  Asigna pedidos a mensajeros,
  optimiza rutas
fin nota

nota abajo de ColaMensajes
  Eventos asíncronos: pedido_creado,
  ubicacion_actualizada,
  estado_entrega_cambiado
fin nota

@enduml

@startuml
nodo "AWS Cloud Route53" como DNS

nodo "VPC (10.0.0.0/16)" {
  nodo "Subred pública" {
    artefacto "Balanceador de carga NGINX" como ALB
  }
  
  nodo "Cluster de subred privada" {
    nodo "Instancia EC2 1" {
      componente "API de Node.js [Pod 1]" como Pod1
    }
    nodo "Instancia EC2 2" {
      componente "API de Node.js [Pod 2]" como Pod2
    }
  }
  
  nodo "Subred de base de datos" {
    base de datos "Amazon RDS (Aurora Multi-AZ)" como Aurora
  }
}

DNS --> ALB : Resuelve el tráfico
ALB --> Pod1 : Balanceo round-robin
ALB --> Pod2
Pod1 --> Aurora : Grupo de conexiones
Pod2 --> Aurora
@enduml

@startuml Internet Browser Sample
!include <archimate/Archimate>

title Muestra ArchiMate - Navegador de Internet

'LAYOUT_AS_SKETCH()
'LAYOUT_LEFT_RIGHT()
'LAYOUT_TOP_DOWN()

Grouping(business, "Negocio"){
  Business_Object(businessObject, "Un objeto de negocio")
  Business_Process(someBusinessProcess,"Algún proceso de negocio")
  Business_Service(itSupportService, "Soporte de TI para el negocio (servicio de aplicación)")
}

Grouping(application, "Aplicación"){
  Application_DataObject(dataObject, "Datos de página web n 'en tiempo real'")
  Application_Function(webpageBehaviour, "Comportamiento de página web")
  Application_Component(ActivePartWebPage, "Parte activa de la página web n 'en tiempo real'")
}

Grouping(technology, "Tecnología"){
  Technology_Artifact(inMemoryItem,"en memoria / 'en tiempo real' html/javascript")
  Technology_Service(internetBrowser, "Navegador de internet genérico y complemento")
  Technology_Service(internetBrowserPlugin, "Algún complemento de navegador de internet")
  Technology_Service(webServer, "Algún servidor web")
}


Rel_Flow_Left(someBusinessProcess, businessObject, "")
Rel_Serving_Up(itSupportService, someBusinessProcess, "")
Rel_Specialization_Up(webpageBehaviour, itSupportService, "")
Rel_Flow_Right(dataObject, webpageBehaviour, "")
Rel_Specialization_Up(dataObject, businessObject, "")
Rel_Assignment_Left(ActivePartWebPage, webpageBehaviour, "")
Rel_Specialization_Up(inMemoryItem, dataObject, "")
Rel_Realization_Up(inMemoryItem, ActivePartWebPage, "")
Rel_Specialization_Right(inMemoryItem,internetBrowser, "")
Rel_Serving_Up(internetBrowser, webpageBehaviour, "")
Rel_Serving_Up(internetBrowserPlugin, webpageBehaviour, "")
Rel_Aggregation_Right(internetBrowser, internetBrowserPlugin, "")
Rel_Access_Up(webServer, inMemoryItem, "")
Rel_Serving_Up(webServer, internetBrowser, "")

@enduml

@startuml

entity "Cliente" as customer {
  * customer_id : UUID <>
  --
  * first_name : VARCHAR(50)
  * last_name : VARCHAR(50)
  * email : VARCHAR(100) <>
  * phone : VARCHAR(20)
  * loyalty_points : INT
  * registration_date : TIMESTAMP
}

entity "Película" as movie {
  * movie_id : UUID <>
  --
  * title : VARCHAR(200)
  * description : TEXT
  * duration_minutes : INT
  * genre : VARCHAR(50)
  * release_date : DATE
  * rating : VARCHAR(10)
}

entity "Teatro" as theater {
  * theater_id : UUID <>
  --
  * theater_name : VARCHAR(100)
  * total_seats : INT
  * seat_layout : JSON
}

entity "Función" as show {
  * show_id : UUID <>
  --
  * movie_id : UUID <>
  * theater_id : UUID <>
  * show_time : TIMESTAMP
  * end_time : TIMESTAMP
  * language : VARCHAR(50)
  * subtitle : BOOLEAN
  * price_regular : DECIMAL(10,2)
  * price_vip : DECIMAL(10,2)
}

entity "Asiento" as seat {
  * seat_id : UUID <>
  --
  * theater_id : UUID <>
  * row_label : CHAR(2)
  * seat_number : INT
  * seat_type : VARCHAR(20)
  * is_accessible : BOOLEAN
}

entity "Reserva" as booking {
  * booking_id : UUID <>
  --
  * customer_id : UUID <>
  * show_id : UUID <>
  * booking_time : TIMESTAMP
  * total_amount : DECIMAL(10,2)
  * status : VARCHAR(20)
  * payment_method : VARCHAR(30)
  * transaction_id : VARCHAR(100)
}

entity "BookingSeat" as booking_seat {
  * booking_id : UUID <<FK,PK>>
  * seat_id : UUID <<FK,PK>>
  --
  * ticket_price : DECIMAL(10,2)
  * discount_applied : DECIMAL(10,2)
}

entity "Pago" as payment {
  * payment_id : UUID <>
  --
  * booking_id : UUID <>
  * amount : DECIMAL(10,2)
  * payment_date : TIMESTAMP
  * payment_status : VARCHAR(20)
  * payment_gateway : VARCHAR(30)
  * gateway_reference : VARCHAR(200)
}

entity "Reseña" as review {
  * review_id : UUID <>
  --
  * customer_id : UUID <>
  * movie_id : UUID <>
  * rating : INT
  * comment : TEXT
  * review_date : TIMESTAMP
}

' Relaciones
customer ||--o{ booking : "realiza"
movie ||--o{ show : "programada como"
theater ||--o{ show : "aloja"
show ||--o{ booking : "tiene"
booking ||--|{ booking_seat : "contiene"
seat ||--o{ booking_seat : "asignado a"
booking ||--|| payment : "tiene"
customer ||--o{ review : "escribe"
movie ||--o{ review : "recibe"

note right of booking : Estado: PENDIENTE, CONFIRMADO, CANCELADO, EXPIRADO
note left of seat : tipo_asiento: NORMAL, VIP, PAREJAS
note right of payment : estado_pago: PENDIENTE, EXITOSO, FALLIDO, REEMBOLSADO

@enduml

flowchart TD
    A[Sentirse mal o necesitar consejo médico] --> B{¿Es una emergencia?}

    B -->|Sí| C[Llamar a servicios de emergencia o ir al hospital]
    B -->|No| D[Programar cita con el médico]

    D --> E[Asistir a la cita]
    E --> F[Evaluación del médico]

    F --> G{¿Se ha realizado el diagnóstico?}

    G -->|Sí| H[Plan de tratamiento]
    G -->|No| I[Ordenar pruebas]

    I --> J[Recibir resultados de las pruebas]
    J --> F

    H --> K[Seguir el tratamiento]
    K --> L{¿Mejoraron los síntomas?}

    L -->|Sí| M[Recuperación / seguimiento rutinario]
    L -->|No| N[Volver al médico]
    N --> F

graph UndirectedSpanningTree {
    fontname="Helvetica,Arial,sans-serif"
    label="Infraestructura principal de topología de red en malla para centro de datos"
    labelloc="b"
    fontsize=14
    
    node [fontname="Helvetica,Arial,sans-serif", shape=circle, style=filled, color="#475569", fillcolor="#f1f5f9", width=0.8, fixedsize=true]
    edge [color="#94a3b8", penwidth=2.5]
    
    SwitchAlpha  [label="SW_A", fillcolor="#cbd5e1"]
    SwitchBeta   [label="SW_B", fillcolor="#cbd5e1"]
    Node1        [label="Host_01"]
    Node2        [label="Host_02"]
    Node3        [label="Host_03"]
    Node4        [label="Host_04"]
    
    SwitchAlpha -- SwitchBeta [label=" Enlace troncal", weight=5]
    SwitchAlpha -- Node1
    SwitchAlpha -- Node2
    SwitchBeta -- Node3
    SwitchBeta -- Node4
    Node1 -- Node2 [style=dashed, color="#cbd5e1", label=" Interconexión de respaldo"]
}