@highstate/library 0.7.2 → 0.7.3

package/dist/index.mjs

@@ -1,1725 +0,0 @@
-import { Type, defineEntity, defineUnit, text, defineComponent } from '@highstate/contract';
-import IPCIDR from 'ip-cidr';
-
-const keyTypeSchema = Type.Union([
-  //
-  Type.Literal("rsa"),
-  Type.Literal("ed25519")
-]);
-const keyPairEntity = defineEntity({
-  type: "ssh.key-pair",
-  schema: Type.Object({
-    type: keyTypeSchema,
-    privateKey: Type.String(),
-    publicKey: Type.String()
-  }),
-  meta: {
-    color: "#2b5797"
-  }
-});
-const credentialsSchema = Type.Object({
-  endpoint: Type.Optional(Type.String()),
-  user: Type.Optional(Type.String()),
-  port: Type.Optional(Type.Number()),
-  password: Type.Optional(Type.String()),
-  privateKey: Type.Optional(Type.String())
-});
-const keyPair = defineUnit({
-  type: "ssh.key-pair",
-  secrets: {
-    privateKey: Type.Optional(Type.String())
-  },
-  outputs: {
-    keyPair: keyPairEntity
-  },
-  meta: {
-    displayName: "SSH Key Pair",
-    description: "Holds the ED25519 SSH key pair and generates the private key if not provided.",
-    category: "ssh",
-    primaryIcon: "charm:key",
-    primaryIconColor: "#ffffff",
-    secondaryIcon: "mdi:lock",
-    secondaryIconColor: "#ffffff"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/common",
-    path: "ssh/key-pair"
-  }
-});
-
-var ssh = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  credentialsSchema: credentialsSchema,
-  keyPair: keyPair,
-  keyPairEntity: keyPairEntity,
-  keyTypeSchema: keyTypeSchema
-});
-
-const serverEntity = defineEntity({
-  type: "common.server",
-  schema: Type.Object({
-    endpoint: Type.String(),
-    hostname: Type.String(),
-    sshCredentials: Type.Optional(credentialsSchema)
-  }),
-  meta: {
-    color: "#009688"
-  }
-});
-const interfaceEntity = defineEntity({
-  type: "common.interface",
-  schema: Type.Object({
-    interface: Type.String()
-  }),
-  meta: {
-    color: "#2196F3",
-    description: "The interface in a network space of the kernel which can accept or transmit packets."
-  }
-});
-const endpointEntity = defineEntity({
-  type: "common.endpoint",
-  schema: Type.Object({
-    endpoint: Type.String()
-  }),
-  meta: {
-    color: "#FFC107",
-    description: "The L3-L4 endpoint for some network service."
-  }
-});
-const dnsProviderEntity = defineEntity({
-  type: "common.dns-provider",
-  schema: Type.Object({
-    name: Type.String(),
-    type: Type.String(),
-    data: Type.Record(Type.String(), Type.Unknown()),
-    domain: Type.String()
-  }),
-  meta: {
-    color: "#FF5722"
-  }
-});
-const existingServer = defineUnit({
-  type: "common.existing-server",
-  args: {
-    endpoint: Type.String(),
-    sshUser: Type.Optional(Type.String({ default: "root" })),
-    sshPort: Type.Optional(Type.Number({ default: 22 }))
-  },
-  secrets: {
-    sshPassword: Type.Optional(Type.String()),
-    sshPrivateKey: Type.Optional(Type.String())
-  },
-  inputs: {
-    sshKeyPair: {
-      entity: keyPairEntity,
-      required: false
-    }
-  },
-  outputs: {
-    server: serverEntity
-  },
-  meta: {
-    displayName: "Existing Server",
-    description: "An existing server that can be used in the configuration.",
-    primaryIcon: "mdi:server",
-    defaultNamePrefix: "server"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/common",
-    path: "existing-server"
-  }
-});
-
-var common = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  dnsProviderEntity: dnsProviderEntity,
-  endpointEntity: endpointEntity,
-  existingServer: existingServer,
-  interfaceEntity: interfaceEntity,
-  serverEntity: serverEntity
-});
-
-const clusterEntity$2 = defineEntity({
-  type: "proxmox.cluster",
-  schema: Type.Object({
-    endpoint: Type.String(),
-    insecure: Type.Optional(Type.Boolean()),
-    username: Type.Optional(Type.String()),
-    defaultNodeName: Type.String(),
-    defaultDatastoreId: Type.String(),
-    password: Type.Optional(Type.String()),
-    apiToken: Type.Optional(Type.String())
-  }),
-  meta: {
-    color: "#e56901"
-  }
-});
-const imageEntity = defineEntity({
-  type: "proxmox.image",
-  schema: Type.Object({
-    id: Type.String()
-  }),
-  meta: {
-    color: "#e56901"
-  }
-});
-const connection$1 = defineUnit({
-  type: "proxmox.connection",
-  args: {
-    endpoint: Type.String(),
-    insecure: Type.Optional(Type.Boolean()),
-    username: Type.Optional(Type.String()),
-    defaultNodeName: Type.Optional(Type.String()),
-    defaultDatastoreId: Type.Optional(Type.String())
-  },
-  secrets: {
-    password: Type.Optional(Type.String()),
-    apiToken: Type.Optional(Type.String())
-  },
-  outputs: {
-    proxmoxCluster: clusterEntity$2
-  },
-  meta: {
-    displayName: "Proxmox Connection",
-    description: "The connection to an existing Proxmox cluster.",
-    category: "Proxmox",
-    primaryIcon: "simple-icons:proxmox",
-    primaryIconColor: "#e56901",
-    secondaryIcon: "codicon:vm"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/proxmox",
-    path: "connection"
-  }
-});
-const image = defineUnit({
-  type: "proxmox.image",
-  args: {
-    url: Type.String(),
-    nodeName: Type.Optional(Type.String()),
-    sha256: Type.Optional(Type.String()),
-    datastoreId: Type.Optional(Type.String())
-  },
-  inputs: {
-    proxmoxCluster: clusterEntity$2
-  },
-  outputs: {
-    image: imageEntity
-  },
-  meta: {
-    displayName: "Proxmox Image",
-    description: "The image to upload to a Proxmox cluster.",
-    category: "Proxmox",
-    primaryIcon: "simple-icons:proxmox",
-    primaryIconColor: "#e56901",
-    secondaryIcon: "mage:compact-disk-fill"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/proxmox",
-    path: "image"
-  }
-});
-const existingImage = defineUnit({
-  type: "proxmox.existing-image",
-  args: {
-    id: Type.String()
-  },
-  outputs: {
-    image: imageEntity
-  },
-  meta: {
-    displayName: "Proxmox Existing Image",
-    description: "The existing image on a Proxmox cluster.",
-    category: "Proxmox",
-    primaryIcon: "simple-icons:proxmox",
-    primaryIconColor: "#e56901",
-    secondaryIcon: "mage:compact-disk-fill"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/proxmox",
-    path: "existing-image"
-  }
-});
-const virtualMachine = defineUnit({
-  type: "proxmox.virtual-machine",
-  args: {
-    nodeName: Type.Optional(Type.String()),
-    cpuType: Type.Optional(Type.String({ default: "host" })),
-    cores: Type.Optional(Type.Number({ default: 1 })),
-    sockets: Type.Optional(Type.Number({ default: 1 })),
-    memory: Type.Optional(Type.Number({ default: 512 })),
-    ipv4: Type.Optional(Type.String()),
-    ipv4Gateway: Type.Optional(Type.String()),
-    dns: Type.Optional(Type.Array(Type.String())),
-    datastoreId: Type.Optional(Type.String()),
-    diskSize: Type.Optional(Type.Number({ default: 8 })),
-    bridge: Type.Optional(Type.String({ default: "vmbr0" })),
-    sshPort: Type.Optional(Type.Number({ default: 22 })),
-    sshUser: Type.Optional(Type.String({ default: "root" })),
-    waitForAgent: Type.Optional(Type.Boolean({ default: true }))
-  },
-  inputs: {
-    proxmoxCluster: clusterEntity$2,
-    image: imageEntity,
-    sshKeyPair: {
-      entity: keyPairEntity,
-      required: false
-    }
-  },
-  secrets: {
-    sshPassword: Type.Optional(Type.String())
-  },
-  outputs: {
-    server: serverEntity
-  },
-  meta: {
-    displayName: "Proxmox Virtual Machine",
-    description: "The virtual machine on a Proxmox cluster.",
-    category: "Proxmox",
-    primaryIcon: "simple-icons:proxmox",
-    primaryIconColor: "#e56901",
-    secondaryIcon: "codicon:vm"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/proxmox",
-    path: "virtual-machine"
-  }
-});
-
-var proxmox = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  clusterEntity: clusterEntity$2,
-  connection: connection$1,
-  existingImage: existingImage,
-  image: image,
-  imageEntity: imageEntity,
-  virtualMachine: virtualMachine
-});
-
-const clusterInfoSchema = Type.Object({
-  id: Type.String(),
-  name: Type.String(),
-  cni: Type.Optional(Type.String())
-});
-const serviceTypeSchema = Type.Union([
-  Type.Literal("NodePort"),
-  Type.Literal("LoadBalancer"),
-  Type.Literal("ClusterIP")
-]);
-const metadataSchema = Type.Object({
-  namespace: Type.Optional(Type.String()),
-  name: Type.String(),
-  labels: Type.Optional(Type.Record(Type.String(), Type.String())),
-  annotations: Type.Optional(Type.Record(Type.String(), Type.String()))
-});
-const servicePortSchema = Type.Object({
-  name: Type.Optional(Type.String()),
-  port: Type.Optional(Type.Number()),
-  targetPort: Type.Optional(Type.Union([Type.Number(), Type.String()])),
-  protocol: Type.Optional(Type.String())
-});
-const serviceSpecSchema = Type.Object({
-  type: Type.Optional(Type.String()),
-  selector: Type.Record(Type.String(), Type.String()),
-  ports: Type.Array(servicePortSchema),
-  clusterIP: Type.Optional(Type.String()),
-  clusterIPs: Type.Optional(Type.Array(Type.String())),
-  externalIPs: Type.Optional(Type.Array(Type.String()))
-});
-const serviceEntity = defineEntity({
-  type: "k8s.service",
-  schema: Type.Object({
-    type: Type.Literal("k8s.service"),
-    clusterInfo: clusterInfoSchema,
-    metadata: metadataSchema,
-    spec: serviceSpecSchema
-  }),
-  meta: {
-    color: "#2196F3"
-  }
-});
-const clusterEntity$1 = defineEntity({
-  type: "k8s.cluster",
-  schema: Type.Object({
-    info: clusterInfoSchema,
-    kubeconfig: Type.String()
-  }),
-  meta: {
-    color: "#2196F3"
-  }
-});
-const existingCluster = defineUnit({
-  type: "k8s.existing-cluster",
-  secrets: {
-    kubeconfig: Type.Record(Type.String(), Type.Any())
-  },
-  outputs: {
-    cluster: clusterEntity$1
-  },
-  meta: {
-    displayName: "Existing Cluster",
-    description: "An existing Kubernetes cluster.",
-    primaryIcon: "mdi:kubernetes"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/k8s",
-    path: "existing-cluster"
-  }
-});
-const gatewayEntity = defineEntity({
-  type: "k8s.gateway",
-  schema: Type.Object({
-    clusterInfo: clusterInfoSchema,
-    gatewayClassName: Type.String(),
-    httpListenerPort: Type.Number(),
-    httpsListenerPort: Type.Number(),
-    ip: Type.String(),
-    service: Type.Optional(serviceEntity.schema)
-  }),
-  meta: {
-    color: "#4CAF50"
-  }
-});
-const tlsIssuerEntity = defineEntity({
-  type: "k8s.tls-issuer",
-  schema: Type.Object({
-    clusterInfo: clusterInfoSchema,
-    clusterIssuerName: Type.String()
-  }),
-  meta: {
-    color: "#f06292"
-  }
-});
-const accessPointEntity = defineEntity({
-  type: "common.access-point",
-  schema: Type.Object({
-    gateway: gatewayEntity.schema,
-    tlsIssuer: tlsIssuerEntity.schema,
-    dnsProvider: dnsProviderEntity.schema
-  }),
-  meta: {
-    color: "#FFC107"
-  }
-});
-const accessPoint = defineUnit({
-  type: "k8s.access-point",
-  inputs: {
-    gateway: gatewayEntity,
-    tlsIssuer: tlsIssuerEntity,
-    dnsProvider: dnsProviderEntity
-  },
-  outputs: {
-    accessPoint: accessPointEntity
-  },
-  meta: {
-    displayName: "Access Point",
-    description: "An access point which can be used to connect to services.",
-    primaryIcon: "mdi:access-point"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/k8s",
-    path: "access-point"
-  }
-});
-const certManager = defineUnit({
-  type: "k8s.cert-manager",
-  inputs: {
-    k8sCluster: clusterEntity$1
-  },
-  outputs: {
-    k8sCluster: clusterEntity$1
-  },
-  meta: {
-    displayName: "Cert Manager",
-    description: "A certificate manager for managing TLS certificates.",
-    primaryIcon: "simple-icons:letsencrypt"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/k8s",
-    path: "cert-manager"
-  }
-});
-const dns01TlsIssuer = defineUnit({
-  type: "k8s.dns01-issuer",
-  inputs: {
-    k8sCluster: clusterEntity$1,
-    dnsProvider: dnsProviderEntity
-  },
-  outputs: {
-    tlsIssuer: tlsIssuerEntity
-  },
-  meta: {
-    displayName: "DNS01 Issuer",
-    description: "A TLS issuer for issuing certificate using DNS01 challenge.",
-    primaryIcon: "mdi:certificate"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/k8s",
-    path: "dns01-issuer"
-  }
-});
-const containerSchema = Type.Object({
-  name: Type.String(),
-  image: Type.String()
-});
-const labelSelectorSchema = Type.Object({
-  matchLabels: Type.Record(Type.String(), Type.String())
-});
-const deploymentSpecSchema = Type.Object({
-  replicas: Type.Number(),
-  selector: labelSelectorSchema,
-  template: Type.Object({
-    metadata: metadataSchema,
-    spec: Type.Object({
-      containers: Type.Array(containerSchema)
-    })
-  })
-});
-const deploymentEntity = defineEntity({
-  type: "k8s.deployment",
-  schema: Type.Object({
-    type: Type.Literal("k8s.deployment"),
-    clusterInfo: clusterInfoSchema,
-    metadata: metadataSchema,
-    service: Type.Optional(serviceEntity.schema)
-  }),
-  meta: {
-    color: "#4CAF50"
-  }
-});
-const statefulSetEntity = defineEntity({
-  type: "k8s.stateful-set",
-  schema: Type.Object({
-    type: Type.Literal("k8s.stateful-set"),
-    clusterInfo: clusterInfoSchema,
-    metadata: metadataSchema,
-    service: Type.Optional(serviceEntity.schema)
-  }),
-  meta: {
-    color: "#FFC107"
-  }
-});
-const persistentVolumeClaimEntity = defineEntity({
-  type: "k8s.persistent-volume-claim",
-  schema: Type.Object({
-    type: Type.Literal("k8s.persistent-volume-claim"),
-    clusterInfo: clusterInfoSchema,
-    metadata: metadataSchema
-  }),
-  meta: {
-    color: "#FFC107"
-  }
-});
-
-var k8s = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  accessPoint: accessPoint,
-  accessPointEntity: accessPointEntity,
-  certManager: certManager,
-  clusterEntity: clusterEntity$1,
-  clusterInfoSchema: clusterInfoSchema,
-  containerSchema: containerSchema,
-  deploymentEntity: deploymentEntity,
-  deploymentSpecSchema: deploymentSpecSchema,
-  dns01TlsIssuer: dns01TlsIssuer,
-  existingCluster: existingCluster,
-  gatewayEntity: gatewayEntity,
-  labelSelectorSchema: labelSelectorSchema,
-  metadataSchema: metadataSchema,
-  persistentVolumeClaimEntity: persistentVolumeClaimEntity,
-  serviceEntity: serviceEntity,
-  servicePortSchema: servicePortSchema,
-  serviceSpecSchema: serviceSpecSchema,
-  serviceTypeSchema: serviceTypeSchema,
-  statefulSetEntity: statefulSetEntity,
-  tlsIssuerEntity: tlsIssuerEntity
-});
-
-const clusterEntity = defineEntity({
-  type: "talos.cluster",
-  schema: Type.Object({
-    clientConfiguration: Type.String(),
-    machineSecrets: Type.String()
-  }),
-  meta: {
-    color: "#2d2d2d"
-  }
-});
-const cniSchema = Type.Union([
-  Type.Literal("cilium"),
-  Type.Literal("flannel"),
-  Type.Literal("none")
-]);
-const csiSchema = Type.Union([Type.Literal("local-path-provisioner"), Type.Literal("none")]);
-const cluster$1 = defineUnit({
-  type: "talos.cluster",
-  args: {
-    scheduleOnMasters: {
-      schema: Type.Optional(Type.Boolean()),
-      description: text`
-        Allow scheduling workloads on the master nodes.
-        By default, "true" if no worker nodes are provided.
-      `
-    },
-    endpoint: {
-      schema: Type.Optional(Type.String()),
-      description: text`
-        The endpoint of the cluster.
-        By default, the first master node's endpoint is used.
-      `
-    },
-    clusterName: {
-      schema: Type.Optional(Type.String()),
-      description: text`
-        The name of the cluster.
-        By default, the name of the instance is used.
-      `
-    },
-    cni: {
-      schema: Type.Optional({ ...cniSchema, default: "cilium" }),
-      description: text`
-        The CNI plugin to use.
-
-        The following options are available:
-        - "cilium" (default)
-        - "flannel" (built-in in Talos)
-        - "none" (disable CNI, must be installed manually)
-
-        The "cilium" CNI plugin is recommended to cover advanced network policies like FQDNs.
-      `
-    },
-    csi: {
-      schema: Type.Optional({ ...csiSchema, default: "local-path-provisioner" }),
-      description: text`
-        The CSI plugin to use.
-
-        The following options are available:
-        - "local-path-provisioner" (default)
-        - "none" (disable CSI, must be installed manually if needed)
-      `
-    },
-    sharedConfigPatch: {
-      schema: Type.Optional(Type.Record(Type.String(), Type.Any())),
-      description: text`
-        The shared configuration patch.
-        It will be applied to all nodes.
-      `
-    },
-    masterConfigPatch: {
-      schema: Type.Optional(Type.Record(Type.String(), Type.Any())),
-      description: text`
-        The master configuration patch.
-        It will be applied to all master nodes.
-      `
-    },
-    workerConfigPatch: {
-      schema: Type.Optional(Type.Record(Type.String(), Type.Any())),
-      description: text`
-        The worker configuration patch.
-        It will be applied to all worker nodes.
-      `
-    }
-  },
-  inputs: {
-    masters: {
-      entity: serverEntity,
-      multiple: true
-    },
-    workers: {
-      entity: serverEntity,
-      multiple: true,
-      required: false
-    }
-  },
-  outputs: {
-    k8sCluster: clusterEntity$1,
-    talosCluster: clusterEntity
-  },
-  meta: {
-    displayName: "Talos Cluster",
-    description: "A Kubernetes cluster managed by Talos.",
-    category: "Talos",
-    color: "#2d2d2d",
-    primaryIcon: "simple-icons:talos",
-    secondaryIcon: "devicon:kubernetes"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/talos",
-    path: "cluster"
-  }
-});
-
-var talos = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  cluster: cluster$1,
-  clusterEntity: clusterEntity,
-  cniSchema: cniSchema,
-  csiSchema: csiSchema
-});
-
-const backendSchema = Type.Union([
-  //
-  Type.Literal("wireguard"),
-  Type.Literal("amneziawg")
-]);
-const presharedKeyModeSchema = Type.Union([
-  Type.Literal("none"),
-  Type.Literal("global"),
-  Type.Literal("secure")
-]);
-const networkEntity = defineEntity({
-  type: "wireguard.network",
-  schema: Type.Object({
-    backend: Type.Optional(backendSchema),
-    presharedKeyMode: presharedKeyModeSchema,
-    globalPresharedKey: Type.Optional(Type.String())
-  })
-});
-const identityEntity = defineEntity({
-  type: "wireguard.identity",
-  schema: Type.Object({
-    name: Type.String(),
-    network: Type.Optional(networkEntity.schema),
-    address: Type.Optional(Type.String()),
-    privateKey: Type.String(),
-    presharedKeyPart: Type.Optional(Type.String()),
-    k8sServices: Type.Array(serviceEntity.schema),
-    exitNode: Type.Boolean(),
-    listenPort: Type.Optional(Type.Number()),
-    externalIp: Type.Optional(Type.String()),
-    endpoint: Type.Optional(Type.String())
-  }),
-  meta: {
-    color: "#F44336"
-  }
-});
-const peerEntity = defineEntity({
-  type: "wireguard.peer",
-  schema: Type.Object({
-    name: Type.String(),
-    network: Type.Optional(networkEntity.schema),
-    publicKey: Type.String(),
-    address: Type.Optional(Type.String()),
-    allowedIps: Type.Array(Type.String()),
-    endpoint: Type.Optional(Type.String()),
-    presharedKeyPart: Type.Optional(Type.String())
-  }),
-  meta: {
-    color: "#673AB7"
-  }
-});
-const k8sNodeEntity = defineEntity({
-  type: "wireguard.node",
-  schema: Type.Object({
-    network: Type.String(),
-    address: Type.String(),
-    endpoint: Type.Optional(Type.String()),
-    peers: Type.Array(Type.String())
-  })
-});
-const network = defineUnit({
-  type: "wireguard.network",
-  args: {
-    /**
-     * The backend to use for the WireGuard network.
-     *
-     * Possible values are:
-     * 1. `wireguard` - The default backend.
-     * 2. `amneziawg` - The censorship-resistant fork of WireGuard.
-     *
-     * By default, the `wireguard` backend is used.
-     */
-    backend: backendSchema,
-    /**
-     * The option which defines how to handle pre-shared keys between peers.
-     *
-     * 1. `none` - No pre-shared keys will be used.
-     * 2. `global` - A single pre-shared key will be used for all peer pairs in the network.
-     * 3. `secure` - Each peer pair will have its own pre-shared key.
-     * In this case, each identity generates `presharedKeyPart` and the actual pre-shared key
-     * for each peer pair will be computed as `xor(peer1.presharedKeyPart, peer2.presharedKeyPart)`.
-     *
-     * If the whole network is managed by the HighState, the `secure` mode is recommended.
-     *
-     * By default, the `none` mode is used.
-     */
-    presharedKeyMode: Type.Optional(presharedKeyModeSchema)
-  },
-  secrets: {
-    /**
-     * The global pre-shared key to use for all peer pairs in the network.
-     *
-     * Will be used only if `presharedKeyMode` is set to `global`.
-     * Will be generated automatically if not provided.
-     */
-    globalPresharedKey: Type.Optional(Type.String())
-  },
-  outputs: {
-    network: networkEntity
-  },
-  meta: {
-    description: "The WireGuard network with some shared configuration.",
-    primaryIcon: "simple-icons:wireguard",
-    primaryIconColor: "#88171a",
-    secondaryIcon: "mdi:local-area-network-connect"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/wireguard",
-    path: "network"
-  }
-});
-const identity = defineUnit({
-  type: "wireguard.identity",
-  args: {
-    /**
-     * The name of the WireGuard identity.
-     *
-     * If not provided, the identity will be named after the unit.
-     */
-    peerName: Type.Optional(Type.String()),
-    /**
-     * The address of the WireGuard interface.
-     *
-     * The address may be any IPv4 or IPv6 address. CIDR notation is also supported.
-     */
-    address: Type.Optional(Type.String()),
-    /**
-     * The list of allowed IPs for the peer.
-     *
-     * Does not affect node which implements the identity, but is used in the peer configuration of other nodes.
-     *
-     * If not provided, the `address` will be used.
-     */
-    allowedIps: Type.Optional(Type.Array(Type.String())),
-    /**
-     * Whether the node should be used as an exit node.
-     *
-     * Just an alias for the `allowedIps` with the value of `0.0.0.0/0, ::/0`.
-     */
-    exitNode: Type.Optional(Type.Boolean()),
-    /**
-     * The port to listen on.
-     *
-     * Used by the implementation of the identity and to calculate the endpoint of the peer.
-     */
-    listenPort: Type.Optional(Type.Number()),
-    /**
-     * The external IP address of the WireGuard identity.
-     *
-     * Used by the implementation of the identity and to calculate the endpoint of the peer.
-     */
-    externalIp: Type.Optional(Type.String()),
-    /**
-     * The endpoint of the WireGuard peer.
-     *
-     * By default, the endpoint is calculated as `externalIp:listenPort`.
-     *
-     * If overridden, does not affect node which implements the identity, but is used in the peer configuration of other nodes.
-     */
-    endpoint: Type.Optional(Type.String())
-  },
-  secrets: {
-    /**
-     * The private key of the WireGuard identity.
-     *
-     * If not provided, the key will be generated automatically.
-     */
-    privateKey: Type.Optional(Type.String()),
-    /**
-     * The part of the pre-shared of the WireGuard identity.
-     *
-     * Will be generated automatically if not provided.
-     */
-    presharedKeyPart: Type.Optional(Type.String())
-  },
-  inputs: {
-    /**
-     * The network to use for the WireGuard identity.
-     *
-     * If not provided, the identity will use default network configuration.
-     */
-    network: {
-      entity: networkEntity,
-      required: false
-    },
-    /**
-     * The list of Kubernetes services to expose the WireGuard identity.
-     *
-     * Their IP addresses will be added to the `allowedIps` of the identity and passed to the node to set up network policies.
-     */
-    k8sServices: {
-      entity: serviceEntity,
-      multiple: true,
-      required: false
-    }
-  },
-  outputs: {
-    identity: identityEntity,
-    peer: peerEntity
-  },
-  meta: {
-    description: "The WireGuard identity with the public key.",
-    primaryIcon: "simple-icons:wireguard",
-    primaryIconColor: "#88171a",
-    secondaryIcon: "mdi:account"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/wireguard",
-    path: "identity"
-  }
-});
-const peer$1 = defineUnit({
-  type: "wireguard.peer",
-  args: {
-    /**
-     * The name of the WireGuard peer.
-     *
-     * If not provided, the peer will be named after the unit.
-     */
-    peerName: Type.Optional(Type.String()),
-    /**
-     * The address of the WireGuard interface.
-     *
-     * The address may be any IPv4 or IPv6 address. CIDR notation is also supported.
-     */
-    address: Type.Optional(Type.String()),
-    /**
-     * The list of allowed IPs for the peer.
-     *
-     * Does not affect node which implements the peer, but is used in the peer configuration of other nodes.
-     */
-    allowedIps: Type.Optional(Type.Array(Type.String())),
-    /**
-     * The endpoint of the WireGuard peer.
-     *
-     * By default, the endpoint is calculated as `externalIp:listenPort`.
-     *
-     * If overridden, does not affect node which implements the peer, but is used in the peer configuration of other nodes.
-     */
-    endpoint: Type.Optional(Type.String()),
-    /**
-     * The public key of the WireGuard peer.
-     */
-    publicKey: Type.String()
-  },
-  inputs: {
-    /**
-     * The network to use for the WireGuard peer.
-     *
-     * If not provided, the peer will use default network configuration.
-     */
-    network: {
-      entity: networkEntity,
-      required: false
-    }
-  },
-  outputs: {
-    peer: peerEntity
-  },
-  meta: {
-    description: "The WireGuard peer with the public key.",
-    primaryIcon: "simple-icons:wireguard",
-    primaryIconColor: "#88171a",
-    secondaryIcon: "mdi:badge-account-horizontal"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/wireguard",
-    path: "peer"
-  }
-});
-const node = defineUnit({
-  type: "wireguard.node",
-  args: {
-    appName: Type.Optional(Type.String()),
-    serviceType: Type.Optional(serviceTypeSchema),
-    prototype: Type.Optional(Type.Boolean()),
-    dns: Type.Optional(Type.Array(Type.String()))
-  },
-  inputs: {
-    identity: identityEntity,
-    k8sCluster: clusterEntity$1,
-    deployment: {
-      entity: deploymentEntity,
-      required: false
-    },
-    statefulSet: {
-      entity: statefulSetEntity,
-      required: false
-    },
-    peers: {
-      entity: peerEntity,
-      multiple: true,
-      required: false
-    }
-  },
-  outputs: {
-    deployment: {
-      entity: deploymentEntity,
-      required: false
-    },
-    service: {
-      entity: serviceEntity,
-      required: false
-    }
-  },
-  meta: {
-    description: "The WireGuard node running on the Kubernetes.",
-    primaryIcon: "simple-icons:wireguard",
-    primaryIconColor: "#88171a",
-    secondaryIcon: "mdi:server"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/wireguard",
-    path: "node"
-  }
-});
-const config = defineUnit({
-  type: "wireguard.config",
-  inputs: {
-    identity: identityEntity,
-    peers: {
-      entity: peerEntity,
-      multiple: true,
-      required: false
-    }
-  },
-  meta: {
-    description: "Just the WireGuard configuration for the identity and peers.",
-    primaryIcon: "simple-icons:wireguard",
-    primaryIconColor: "#88171a",
-    secondaryIcon: "mdi:settings"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/wireguard",
-    path: "config"
-  }
-});
-const generator = defineComponent({
-  type: "wireguard.generator",
-  args: {
-    clientNames: Type.Array(Type.String()),
-    cidr: Type.String()
-  },
-  inputs: {
-    network: networkEntity,
-    peer: peerEntity
-  },
-  outputs: {
-    peers: {
-      entity: peerEntity,
-      multiple: true
-    }
-  },
-  meta: {
-    description: "Bulk generate the WireGuard identities and peers.",
-    primaryIcon: "simple-icons:wireguard",
-    primaryIconColor: "#88171a",
-    secondaryIcon: "mdi:accounts"
-  },
-  create({ name, args, inputs }) {
-    const cidr = new IPCIDR(args.cidr);
-    const peers = [];
-    for (const [index, client] of args.clientNames.entries()) {
-      const fullName = `${name}.${client}`;
-      const { identity: wgIdentity, peer: wgPeer } = identity({
-        name: fullName,
-        args: {
-          address: cidr.start({ from: index, type: "addressObject" }).address
-        },
-        inputs: {
-          network: inputs.network,
-          k8sServices: []
-        }
-      });
-      peers.push(wgPeer);
-      config({
-        name: fullName,
-        inputs: {
-          identity: wgIdentity,
-          peers: [inputs.peer]
-        }
-      });
-    }
-    return { peers };
-  }
-});
-
-var wireguard = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  backendSchema: backendSchema,
-  config: config,
-  generator: generator,
-  identity: identity,
-  identityEntity: identityEntity,
-  k8sNodeEntity: k8sNodeEntity,
-  network: network,
-  networkEntity: networkEntity,
-  node: node,
-  peer: peer$1,
-  peerEntity: peerEntity,
-  presharedKeyModeSchema: presharedKeyModeSchema
-});
-
-const repoEntity = defineEntity({
-  type: "restic.repo",
-  schema: Type.Object({
-    password: Type.String(),
-    remoteDomains: Type.Array(Type.String()),
-    type: Type.Literal("rclone"),
-    rcloneConfig: Type.String(),
-    remoteName: Type.String(),
-    basePath: Type.String()
-  }),
-  meta: {
-    color: "#e56901"
-  }
-});
-const repo = defineUnit({
-  type: "restic.repo",
-  args: {
-    remoteDomains: Type.Optional(Type.Array(Type.String())),
-    basePath: Type.Optional(Type.String())
-  },
-  secrets: {
-    password: Type.Optional(Type.String()),
-    rcloneConfig: Type.String({ multiline: true })
-  },
-  outputs: {
-    repo: repoEntity
-  },
-  meta: {
-    displayName: "Restic Repo",
-    description: "Holds the configuration for a Restic repository and its remote storage.",
-    primaryIconColor: "#e56901",
-    primaryIcon: "material-symbols:backup"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/restic",
-    path: "repo"
-  }
-});
-
-var restic = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  repo: repo,
-  repoEntity: repoEntity
-});
-
-const mariadbEntity = defineEntity({
-  type: "apps.mariadb",
-  schema: Type.Object({
-    service: Type.Optional(serviceEntity.schema),
-    host: Type.String(),
-    port: Type.Number(),
-    rootPassword: Type.String()
-  }),
-  meta: {
-    color: "#f06292"
-  }
-});
-const mariadb = defineUnit({
-  type: "apps.mariadb",
-  args: {
-    fqdn: Type.Optional(Type.String()),
-    appName: Type.Optional(Type.String())
-  },
-  secrets: {
-    rootPassword: Type.Optional(Type.String())
-  },
-  inputs: {
-    k8sCluster: clusterEntity$1,
-    resticRepo: {
-      entity: repoEntity,
-      required: false
-    },
-    dnsProvider: {
-      entity: dnsProviderEntity,
-      required: false
-    }
-  },
-  outputs: {
-    mariadb: mariadbEntity,
-    service: serviceEntity
-  },
-  meta: {
-    displayName: "MariaDB",
-    description: "The MariaDB database deployed on Kubernetes.",
-    primaryIcon: "simple-icons:mariadb",
-    secondaryIcon: "mdi:database"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/apps",
-    path: "mariadb/app"
-  }
-});
-const mariadbDatabase = defineUnit({
-  type: "apps.mariadb.database",
-  args: {
-    database: Type.Optional(Type.String()),
-    username: Type.Optional(Type.String())
-  },
-  secrets: {
-    password: Type.Optional(Type.String())
-  },
-  inputs: {
-    k8sCluster: clusterEntity$1,
-    mariadb: mariadbEntity
-  },
-  meta: {
-    displayName: "MariaDB Database",
-    description: "The virtual MariaDB database created on the MariaDB instance. Works only for MariaDB instances deployed on Kubernetes.",
-    primaryIcon: "simple-icons:mariadb",
-    secondaryIcon: "mdi:database-plus"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/apps",
-    path: "mariadb/database"
-  }
-});
-
-const postgresqlEntity = defineEntity({
-  type: "apps.postgresql",
-  schema: Type.Object({
-    service: Type.Optional(serviceEntity.schema),
-    host: Type.String(),
-    port: Type.Number(),
-    rootPassword: Type.String()
-  }),
-  meta: {
-    color: "#336791"
-  }
-});
-const postgresql = defineUnit({
-  type: "apps.postgresql",
-  args: {
-    fqdn: Type.Optional(Type.String()),
-    appName: Type.Optional(Type.String())
-  },
-  secrets: {
-    rootPassword: Type.Optional(Type.String())
-  },
-  inputs: {
-    k8sCluster: clusterEntity$1,
-    resticRepo: {
-      entity: repoEntity,
-      required: false
-    },
-    dnsProvider: {
-      entity: dnsProviderEntity,
-      required: false
-    }
-  },
-  outputs: {
-    postgresql: postgresqlEntity,
-    service: serviceEntity
-  },
-  meta: {
-    displayName: "PostgreSQL",
-    description: "The PostgreSQL database deployed on Kubernetes.",
-    primaryIcon: "simple-icons:postgresql",
-    secondaryIcon: "mdi:database"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/apps",
-    path: "postgresql/app"
-  }
-});
-const postgresqlDatabase = defineUnit({
-  type: "apps.postgresql.database",
-  args: {
-    database: Type.Optional(Type.String()),
-    username: Type.Optional(Type.String())
-  },
-  secrets: {
-    password: Type.Optional(Type.String())
-  },
-  inputs: {
-    k8sCluster: clusterEntity$1,
-    postgresql: postgresqlEntity
-  },
-  meta: {
-    displayName: "PostgreSQL Database",
-    description: "The virtual PostgreSQL database created on the PostgreSQL instance. Works only for PostgreSQL instances deployed on Kubernetes.",
-    primaryIcon: "simple-icons:postgresql",
-    secondaryIcon: "mdi:database-plus"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/apps",
-    path: "postgresql/database"
-  }
-});
-
-const vaultwarden = defineUnit({
-  type: "apps.vaultwarden",
-  args: {
-    fqdn: Type.String(),
-    appName: Type.Optional(Type.String())
-  },
-  inputs: {
-    mariadb: mariadbEntity,
-    accessPoint: accessPointEntity,
-    k8sCluster: clusterEntity$1
-  },
-  secrets: {
-    mariadbPassword: Type.Optional(Type.String())
-  },
-  meta: {
-    displayName: "Vaultwarden",
-    description: "The Vaultwarden password manager deployed on Kubernetes.",
-    primaryIcon: "simple-icons:vaultwarden"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/apps",
-    path: "vaultwarden"
-  }
-});
-
-const traefikGateway = defineUnit({
-  type: "apps.traefik-gateway",
-  args: {
-    appName: Type.Optional(Type.String()),
-    className: Type.Optional(Type.String()),
-    serviceType: Type.Optional(serviceTypeSchema)
-  },
-  inputs: {
-    k8sCluster: clusterEntity$1
-  },
-  outputs: {
-    gateway: gatewayEntity,
-    service: serviceEntity
-  },
-  meta: {
-    displayName: "Traefik Gateway",
-    description: "A Traefik gateway for routing traffic to services.",
-    primaryIcon: "simple-icons:traefikproxy"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/apps",
-    path: "traefik"
-  }
-});
-
-const kubernetesDashboard = defineUnit({
-  type: "apps.kubernetes-dashboard",
-  args: {
-    fqdn: Type.String(),
-    appName: Type.Optional(Type.String())
-  },
-  inputs: {
-    k8sCluster: clusterEntity$1,
-    accessPoint: accessPointEntity
-  },
-  meta: {
-    displayName: "Kubernetes Dashboard",
-    description: "The Kubernetes Dashboard deployed on Kubernetes.",
-    primaryIcon: "simple-icons:kubernetes",
-    secondaryIcon: "mdi:dashboard"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/apps",
-    path: "kubernetes-dashboard"
-  }
-});
-
-const grocy = defineUnit({
-  type: "apps.grocy",
-  args: {
-    fqdn: Type.String(),
-    appName: Type.Optional(Type.String())
-  },
-  inputs: {
-    resticRepo: {
-      entity: repoEntity,
-      required: false
-    },
-    accessPoint: accessPointEntity,
-    k8sCluster: clusterEntity$1
-  },
-  meta: {
-    displayName: "Grocy",
-    description: "Grocy is a web-based self-hosted groceries & household management solution for your home.",
-    primaryIcon: "simple-icons:grocy"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/apps",
-    path: "grocy"
-  }
-});
-
-const maybe = defineUnit({
-  type: "apps.maybe",
-  args: {
-    fqdn: Type.String(),
-    appName: Type.Optional(Type.String())
-  },
-  inputs: {
-    postgresql: postgresqlEntity,
-    accessPoint: accessPointEntity,
-    k8sCluster: clusterEntity$1,
-    resticRepo: {
-      entity: repoEntity,
-      required: false
-    }
-  },
-  secrets: {
-    postgresqlPassword: Type.Optional(Type.String()),
-    secretKey: Type.Optional(Type.String())
-  },
-  meta: {
-    displayName: "Maybe",
-    description: "The OS for your personal finances.",
-    primaryIcon: "arcticons:finance-manager"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/apps",
-    path: "maybe"
-  }
-});
-
-const mongodbEntity = defineEntity({
-  type: "apps.mongodb",
-  schema: Type.Object({
-    service: Type.Optional(serviceEntity.schema),
-    host: Type.String(),
-    port: Type.Number(),
-    rootPassword: Type.String()
-  }),
-  meta: {
-    color: "#13aa52"
-  }
-});
-const mongodb = defineUnit({
-  type: "apps.mongodb",
-  args: {
-    fqdn: Type.Optional(Type.String()),
-    appName: Type.Optional(Type.String()),
-    serviceType: Type.Optional(serviceTypeSchema)
-  },
-  secrets: {
-    rootPassword: Type.Optional(Type.String())
-  },
-  inputs: {
-    k8sCluster: clusterEntity$1,
-    resticRepo: {
-      entity: repoEntity,
-      required: false
-    },
-    dnsProvider: {
-      entity: dnsProviderEntity,
-      required: false
-    }
-  },
-  outputs: {
-    mongodb: mongodbEntity,
-    service: serviceEntity
-  },
-  meta: {
-    displayName: "MongoDB",
-    description: "The MongoDB instance deployed on Kubernetes.",
-    primaryIcon: "simple-icons:mongodb",
-    secondaryIcon: "mdi:database"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/apps",
-    path: "mongodb/app"
-  }
-});
-const mongodbDatabase = defineUnit({
-  type: "apps.mongodb.database",
-  args: {
-    database: Type.Optional(Type.String()),
-    username: Type.Optional(Type.String())
-  },
-  secrets: {
-    password: Type.Optional(Type.String())
-  },
-  inputs: {
-    k8sCluster: clusterEntity$1,
-    mongodb: mongodbEntity
-  },
-  meta: {
-    displayName: "MongoDB Database",
-    description: "The virtual MongoDB database created on the MongoDB instance. Works only for MongoDB instances deployed on Kubernetes.",
-    primaryIcon: "simple-icons:mongodb",
-    secondaryIcon: "mdi:database-plus"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/apps",
-    path: "mongodb/database"
-  }
-});
-
-const deployment = defineUnit({
-  type: "apps.deployment",
-  args: {
-    appName: Type.Optional(Type.String()),
-    fqdn: Type.Optional(Type.String()),
-    serviceType: Type.Optional(serviceTypeSchema),
-    image: Type.Optional(Type.String()),
-    port: Type.Optional(Type.Number()),
-    replicas: Type.Optional(Type.Number()),
-    dataPath: Type.Optional(Type.String()),
-    env: Type.Optional(Type.Record(Type.String(), Type.Any())),
-    mariadbEnvMapping: Type.Optional(Type.Record(Type.String(), Type.Any())),
-    postgresqlEnvMapping: Type.Optional(Type.Record(Type.String(), Type.Any())),
-    mongodbEnvMapping: Type.Optional(Type.Record(Type.String(), Type.Any())),
-    manifest: Type.Optional(Type.Record(Type.String(), Type.Any())),
-    serviceManifest: Type.Optional(Type.Record(Type.String(), Type.Any())),
-    httpRouteManifest: Type.Optional(Type.Record(Type.String(), Type.Any()))
-  },
-  inputs: {
-    k8sCluster: clusterEntity$1,
-    mariadb: {
-      entity: mariadbEntity,
-      required: false
-    },
-    postgresql: {
-      entity: postgresqlEntity,
-      required: false
-    },
-    mongodb: {
-      entity: mongodbEntity,
-      required: false
-    },
-    resticRepo: {
-      entity: repoEntity,
-      required: false
-    },
-    dnsProvider: {
-      entity: dnsProviderEntity,
-      required: false
-    }
-  },
-  outputs: {
-    deployment: deploymentEntity,
-    service: serviceEntity
-  },
-  secrets: {
-    mariadbPassword: Type.Optional(Type.String()),
-    postgresqlPassword: Type.Optional(Type.String()),
-    mongodbPassword: Type.Optional(Type.String())
-  },
-  meta: {
-    displayName: "Kubernetes Deployment",
-    description: "A generic Kubernetes deployment with optional service and gateway routes.",
-    primaryIcon: "mdi:kubernetes",
-    secondaryIcon: "mdi:cube-outline"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/apps"
-  }
-});
-
-const backupModeSchema = Type.Union([Type.Literal("metadata"), Type.Literal("full")]);
-const syncthing = defineUnit({
-  type: "apps.syncthing",
-  args: {
-    fqdn: Type.String(),
-    deviceFqdn: Type.Optional(Type.String()),
-    appName: Type.Optional(Type.String()),
-    backupMode: Type.Optional({ ...backupModeSchema, default: "metadata" })
-  },
-  inputs: {
-    accessPoint: accessPointEntity,
-    k8sCluster: clusterEntity$1,
-    resticRepo: {
-      entity: repoEntity,
-      required: false
-    },
-    volume: {
-      entity: persistentVolumeClaimEntity,
-      required: false
-    }
-  },
-  outputs: {
-    service: serviceEntity,
-    volume: persistentVolumeClaimEntity
-  },
-  meta: {
-    displayName: "Syncthing",
-    description: "The Syncthing instance deployed on Kubernetes.",
-    primaryIcon: "simple-icons:syncthing"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/apps",
-    path: "syncthing"
-  }
-});
-
-const codeServer = defineUnit({
-  type: "apps.code-server",
-  args: {
-    fqdn: Type.String(),
-    appName: Type.Optional(Type.String())
-  },
-  secrets: {
-    password: Type.Optional(Type.String()),
-    sudoPassword: Type.Optional(Type.String())
-  },
-  inputs: {
-    accessPoint: accessPointEntity,
-    k8sCluster: clusterEntity$1,
-    resticRepo: {
-      entity: repoEntity,
-      required: false
-    },
-    volume: {
-      entity: persistentVolumeClaimEntity,
-      required: false
-    }
-  },
-  outputs: {
-    statefulSet: statefulSetEntity,
-    volume: persistentVolumeClaimEntity
-  },
-  meta: {
-    displayName: "Code Server",
-    description: "The Code Server instance deployed on Kubernetes.",
-    primaryIcon: "material-icon-theme:vscode"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/apps",
-    path: "code-server"
-  }
-});
-
-var index = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  backupModeSchema: backupModeSchema,
-  codeServer: codeServer,
-  deployment: deployment,
-  grocy: grocy,
-  kubernetesDashboard: kubernetesDashboard,
-  mariadb: mariadb,
-  mariadbDatabase: mariadbDatabase,
-  mariadbEntity: mariadbEntity,
-  maybe: maybe,
-  mongodb: mongodb,
-  mongodbDatabase: mongodbDatabase,
-  mongodbEntity: mongodbEntity,
-  postgresql: postgresql,
-  postgresqlDatabase: postgresqlDatabase,
-  postgresqlEntity: postgresqlEntity,
-  syncthing: syncthing,
-  traefikGateway: traefikGateway,
-  vaultwarden: vaultwarden
-});
-
-const connection = defineUnit({
-  type: "cloudflare.connection",
-  secrets: {
-    apiToken: Type.String()
-  },
-  outputs: {
-    dnsProvider: dnsProviderEntity
-  },
-  meta: {
-    displayName: "Cloudflare Connection",
-    description: "Creates a new Cloudflare connection for one zone.",
-    primaryIcon: "simple-icons:cloudflare"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/cloudflare",
-    path: "connection"
-  }
-});
-
-var cloudflare = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  connection: connection
-});
-
-const cluster = defineUnit({
-  type: "k3s.cluster",
-  inputs: {
-    server: serverEntity
-  },
-  outputs: {
-    k8sCluster: clusterEntity$1
-  },
-  meta: {
-    displayName: "K3s Cluster",
-    description: "The K3s cluster created on top of the server.",
-    category: "k3s",
-    primaryIcon: "devicon:k3s",
-    secondaryIcon: "devicon:kubernetes"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/k3s",
-    path: "cluster"
-  }
-});
-
-var k3s = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  cluster: cluster
-});
-
-const endpointType = Type.Union([
-  Type.Literal("fqdn"),
-  Type.Literal("ipv4"),
-  Type.Literal("ipv6")
-]);
-const peer = defineUnit({
-  type: "mullvad.peer",
-  args: {
-    hostname: Type.Optional(Type.String()),
-    endpointType: Type.Optional({ ...endpointType, default: "fqdn" })
-  },
-  outputs: {
-    peer: peerEntity
-  },
-  meta: {
-    displayName: "Mullvad Peer",
-    description: "The Mullvad WireGuard peer fetched from the Mullvad API.",
-    primaryIcon: "simple-icons:mullvad",
-    secondaryIcon: "cib:wireguard",
-    secondaryIconColor: "#88171a"
-  },
-  source: {
-    type: "npm",
-    package: "@highstate/mullvad",
-    path: "peer"
-  }
-});
-
-var mullvad = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  endpointType: endpointType,
-  peer: peer
-});
-
-export { index as apps, cloudflare, common, k3s, k8s, mullvad, proxmox, restic, ssh, talos, wireguard };