Presentamos VPasCode: La Plataforma Definitiva y Unificada de Texto a Diagrama

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

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

cliente --> UC_Cart
cliente --> 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
  - direccion: String
  - telefono: 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
  # titulo: String
  # editorial: String
  # anioPublicacion: int
  # disponible: boolean
  + obtenerDetalles(): String
  + establecerDisponibilidad(estado: boolean): void
}

abstract class Libro {
  - isbn: String
  - autor: String
  - numPaginas: int
  + obtenerAutor(): String
}

class EBook {
  - tamanoArchivoMB: double
  - formato: String
  - urlDescarga: String
  + descargar(): void
}

class LibroImpreso {
  - ubicacionEstante: String
  - condicion: String
  + obtenerUbicacionEstante(): String
}

class Revista {
  - numeroEdicion: int
  - numeroVolumen: int
  - fechaPortada: Date
}

class DVD {
  - duracionMinutos: int
  - director: String
  - idioma: String
  - subtítulosDisponibles: boolean
}

class Miembro {
  - idMiembro: String
  - nombre: String
  - email: String
  - telefono: String
  - fechaAfiliacion: Date
  + tomarItem(item: ItemBiblioteca): boolean
  + devolverItem(item: ItemBiblioteca): boolean
  + obtenerItemsPrestados(): List
}

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

class Multa {
  - idMulta: String
  - monto: double
  - fechaEmision: Date
  - pagada: boolean
  + pagarMulta(): void
}

class Bibliotecario {
  - idEmpleado: String
  - departamento: String
  + procesarPrestamo(miembro: Miembro, item: ItemBiblioteca): void
  + procesarDevolucion(item: ItemBiblioteca): void
  + generarInforme(): void
  + gestionarInventario(): void
}

' Relaciones de herencia
ItemBiblioteca <|-- Libro
ItemBiblioteca <|-- Revista
ItemBiblioteca <|-- DVD
Libro <|-- EBook
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 >

note top of Biblioteca : Sistema central que gestionanmiembros, items y préstamos
note right of ItemBiblioteca : Clase base abstractanpara todos los materiales bibliotecarios
@enduml

@startuml
' Título
title 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
database "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, intente de nuevo
    note right: 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 : Descontar 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 / Fin de la transacción

@enduml

@startuml InsuranceClaimSystem

inicio

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

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

:El ajustador revisa los documentos presentados;

if (¿Están presentes todos los documentos requeridos?) then (sí)
  :El ajustador inicia la validación de la reclamación;
else (no)
  :Solicitar documentos faltantes al asegurado;
  :Esperar documentos adicionales;
  :Revisar nuevamente los documentos;
  note right
    El sistema espera
    la respuesta del asegurado
  end note
  -> volver a "El ajustador revisa los documentos presentados";
endif

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

if (¿La reclamación es válida según los términos de la póliza?) then (sí)
  :Calcular monto aprobado;
  :Aplicar deducible si corresponde;
else (no)
  :Enviar notificación de rechazo con motivo;
  :Registrar decisión en el sistema;
  fin
endif

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

:El asegurado revisa la oferta;

if (¿El asegurado acepta la oferta?) then (sí)
  :Procesar el pago;
  :Actualizar estado de la reclamación a "Liquidado";
  :Enviar confirmación al asegurado;
  :Registrar detalles de cierre;
else (no)
  :Escalar a resolución de disputas;
  :Negociar liquidación;
  :Actualizar oferta;
  -> volver a "Enviar oferta de liquidación al asegurado";
endif

fin

@enduml

@startuml SmokeDetectionSystem

title Diagrama de estado - Sistema de detección de humo

[*] --> Apagado

state Apagado {
    [*] --> SinEnergia
    SinEnergia : El dispositivo está apagado
    SinEnergia --> Encendido : Botón de encendido presionado
}

state Encendido {
    [*] --> Espera
    Espera : Sistema listo
    Espera --> Autocomprobacion : Autocomprobación periódica (cada 24h)
    Espera --> Monitoreo : Iniciar monitoreo (sensor activo)
    
    state Autocomprobacion {
        [*] --> ProbandoSensores
        ProbandoSensores --> PruebaAprobada : Todos los sensores OK
        ProbandoSensores --> PruebaFallida : Error de sensor detectado
        PruebaAprobada --> Espera : Volver a espera
        PruebaFallida --> EstadoError : Reportar error
    }
    
    state Monitoreo {
        [*] --> SinHumo
        SinHumo : Operación normal
        SinHumo --> HumoDetectado : Nivel de humo > umbral
        SinHumo --> BajaBateria : Batería baja (inalámbrico)
        BajaBateria --> SinHumo : Batería reemplazada
        
        state HumoDetectado {
            [*] --> AlertaInicial
            AlertaInicial --> HumoConfirmado : Humo persiste > 5 seg
            AlertaInicial --> FalsaAlarma : Humo se disipa < 5 seg FalsaAlarma --> SinHumo : Reiniciar
            HumoConfirmado --> AlarmaActiva
        }
        
        state AlarmaActiva {
            [*] --> SonarAlarma : Activar sirena y luces
            SonarAlarma --> EnviarNotificacion : Notificar panel de control / app
            EnviarNotificacion --> EsperarReinicio
            EsperarReinicio --> AlarmaActiva : Humo aún presente
            EsperarReinicio --> ReiniciarSistema : Botón de reinicio presionado
            ReiniciarSistema --> SinHumo : Sistema reiniciado
        }
    }
}

state EstadoError {
    [*] --> IndicadorFalla : Parpadeo LED de error
    IndicadorFalla --> Apagado : Ciclo de energía manual requerido
}

Encendido --> EstadoError : Fallo de autocomprobación
EstadoError --> Apagado : Ciclo de energía

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

@enduml

@startuml CourierSystem

title Sistema de mensajería - Diagrama de componentes

' === Componentes ===
component "Aplicación del cliente" as CustomerApp
component "Aplicación móvil del mensajero" as CourierApp
component "Panel web de administración" as AdminWeb

component "Puerta de enlace API" as ApiGateway

component "Servicio de pedidos" as OrderService
component "Servicio de distribución" as DispatchService
component "Servicio de seguimiento" as TrackingService
component "Servicio de pagos" as PaymentService
component "Servicio de notificaciones" as NotificationService
component "Servicio de usuarios" as UserService

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

database "Base de datos PostgreSQL" as SQLDB
database "MongoDBn(Logs/Historial de seguimiento)" as MongoLogs

' === Interfaces / Puertos ===
CustomerApp --> ApiGateway : "REST / WebSocket"
CourierApp --> ApiGateway : "REST / WebSocket"
AdminWeb --> ApiGateway : "REST"

ApiGateway --> OrderService
ApiGateway --> TrackingService
ApiGateway --> PaymentService
ApiGateway --> UserService

' === Dependencias de servicios ===
OrderService --> DispatchService : "gRPC / REST"
OrderService --> PaymentService
OrderService --> NotificationService
OrderService --> SQLDB : "JDBC"
OrderService --> RedisCache : "Caché"

DispatchService --> MessageQueue : "Publicar eventos"
DispatchService --> CourierApp : "Empujar a través de la puerta de enlace API"
DispatchService --> SQLDB

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

PaymentService --> SQLDB
PaymentService --> NotificationService

NotificationService --> MessageQueue : "Consumir notificaciones"
NotificationService --> CustomerApp : "Empujar a través de la puerta de enlace API"

UserService --> SQLDB
UserService --> RedisCache

' === Notas ===
note right of OrderService
  Maneja la creación de paquetes,
  precios y estado del pedido
end note

note right of DispatchService
  Empareja pedidos con mensajeros,
  optimiza rutas
end note

note bottom of MessageQueue
  Eventos asíncronos: pedido_creado,
  ubicación_actualizada,
  estado_de_entrega_cambiado
end note

@enduml

@startuml
node "AWS Cloud Route53" as DNS

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

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

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

title Muestra de 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,"Alguno 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, "Alguno complemento de navegador de Internet")
  Technology_Service(webServer, "Alguno 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 cliente {
  * cliente_id : UUID <>
  --
  * nombre : VARCHAR(50)
  * apellido : VARCHAR(50)
  * email : VARCHAR(100) <>
  * telefono : VARCHAR(20)
  * puntos_fidelidad : INT
  * fecha_registro : TIMESTAMP
}

entity "Película" as pelicula {
  * pelicula_id : UUID <>
  --
  * titulo : VARCHAR(200)
  * descripcion : TEXT
  * duracion_minutos : INT
  * genero : VARCHAR(50)
  * fecha_lanzamiento : DATE
  * calificacion : VARCHAR(10)
}

entity "Cine" as cine {
  * cine_id : UUID <>
  --
  * nombre_cine : VARCHAR(100)
  * asientos_totales : INT
  * disposicion_asientos : JSON
}

entity "Función" as funcion {
  * funcion_id : UUID <>
  --
  * pelicula_id : UUID <>
  * cine_id : UUID <>
  * hora_funcion : TIMESTAMP
  * hora_fin : TIMESTAMP
  * idioma : VARCHAR(50)
  * subtitulos : BOOLEAN
  * precio_regular : DECIMAL(10,2)
  * precio_vip : DECIMAL(10,2)
}

entity "Asiento" as asiento {
  * asiento_id : UUID <>
  --
  * cine_id : UUID <>
  * etiqueta_fila : CHAR(2)
  * numero_asiento : INT
  * tipo_asiento : VARCHAR(20)
  * es_accesible : BOOLEAN
}

entity "Reserva" as reserva {
  * reserva_id : UUID <>
  --
  * cliente_id : UUID <>
  * funcion_id : UUID <>
  * hora_reserva : TIMESTAMP
  * monto_total : DECIMAL(10,2)
  * estado : VARCHAR(20)
  * metodo_pago : VARCHAR(30)
  * id_transaccion : VARCHAR(100)
}

entity "ReservaAsiento" as reserva_asiento {
  * reserva_id : UUID <<FK,PK>>
  * asiento_id : UUID <<FK,PK>>
  --
  * precio_boleto : DECIMAL(10,2)
  * descuento_aplicado : DECIMAL(10,2)
}

entity "Pago" as pago {
  * pago_id : UUID <>
  --
  * reserva_id : UUID <>
  * monto : DECIMAL(10,2)
  * fecha_pago : TIMESTAMP
  * estado_pago : VARCHAR(20)
  * pasarela_pago : VARCHAR(30)
  * referencia_pasarela : VARCHAR(200)
}

entity "Reseña" as resena {
  * resena_id : UUID <>
  --
  * cliente_id : UUID <>
  * pelicula_id : UUID <>
  * calificacion : INT
  * comentario : TEXT
  * fecha_resena : TIMESTAMP
}

' Relaciones
cliente ||--o{ reserva : "realiza"
pelicula ||--o{ funcion : "programada como"
cine ||--o{ funcion : "aloja"
funcion ||--o{ reserva : "tiene"
reserva ||--|{ reserva_asiento : "contiene"
asiento ||--o{ reserva_asiento : "asignado a"
reserva ||--|| pago : "tiene"
cliente ||--o{ resena : "escribe"
pelicula ||--o{ resena : "recibe"

nota derecha de reserva : Estado: PENDIENTE, CONFIRMADO, CANCELADO, EXPIRADO
nota izquierda de asiento : tipo_asiento: REGULAR, VIP, PAREJA
nota derecha de pago : 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 a urgencias]
    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 hecho 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 de columna vertebral de topología de red de malla de 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 conmutación por error"]
}