@highstate/library 0.1.2 → 0.2.1

package/dist/index.mjs

@@ -1,220 +1,849 @@
-import { z } from 'zod';
-import { defineComponent as defineComponent$1, defineUnit } from '@highstate/contract';
-import { defineComponent } from '@highstate/contract/component';
+import { defineEntity, defineUnit, text } from '@highstate/contract';
+import { Type } from '@sinclair/typebox';
 
-const serverSshCredentialsType = z.object({
-  type: z.literal("server.sshCredentials"),
-  endpoint: z.string().optional(),
-  port: z.number().optional(),
-  username: z.string().optional(),
-  password: z.string().optional(),
-  privateKey: z.string().optional()
-});
-const serverType = z.object({
-  type: z.literal("server"),
-  endpoint: z.string(),
-  sshCredentials: serverSshCredentialsType.optional()
+const keyTypeSchema = Type.Union([
+  //
+  Type.Literal("rsa"),
+  Type.Literal("ed25519")
+]);
+const keyPairEntity = defineEntity({
+  type: "ssh.key-pair",
+  sensitive: true,
+  schema: Type.Object({
+    type: keyTypeSchema,
+    privateKey: Type.String(),
+    publicKey: Type.String()
+  })
 });
-
-const sshKeyPairType = z.object({
-  type: z.literal("ssh.key"),
-  privateKey: z.string(),
-  publicKey: z.string()
+const publicKeyEntity = defineEntity({
+  type: "ssh.public-key",
+  schema: Type.Object({
+    publicKey: Type.String()
+  })
 });
-const sshPublicKeyType = z.object({
-  type: z.literal("ssh.key"),
-  publicKey: z.string()
+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: keyPairEntity.schema
 });
-defineComponent({
-  type: "ssh.key_pair",
+const keyPair = defineUnit({
+  type: "ssh.key-pair",
+  outputs: {
+    keyPair: keyPairEntity
+  },
   meta: {
     displayName: "SSH Key Pair",
-    description: "The private and public SSH key pair.",
-    category: "SSH",
+    description: "Generates a new ED25519 SSH key pair.",
+    category: "ssh",
     primaryIcon: "charm:key",
     primaryIconColor: "#ffffff",
     secondaryIcon: "mdi:lock",
     secondaryIconColor: "#ffffff"
   },
-  secrets: z.object({
-    privateKey: z.string()
-  }),
-  outputs: z.object({
-    sshKeyPair: sshKeyPairType,
-    sshPublicKey: sshPublicKeyType
-  }),
-  create({ secrets }) {
-    return {
-      sshKeyPair: {
-        type: "ssh.key"
-      }
-    };
+  source: {
+    type: "npm",
+    package: "@highstate/ssh"
+  }
+});
+const existingKeyPair = defineUnit({
+  type: "ssh.existing-key-pair",
+  args: {
+    type: {
+      schema: keyTypeSchema,
+      description: "The type of the key pair."
+    }
+  },
+  secrets: {
+    privateKey: Type.String()
+  },
+  outputs: {
+    keyPair: keyPairEntity
+  },
+  meta: {
+    displayName: "SSH Existing Key Pair",
+    description: "Uses an existing SSH key pair.",
+    category: "ssh",
+    primaryIcon: "charm:key",
+    primaryIconColor: "#ffffff",
+    secondaryIcon: "mdi:lock",
+    secondaryIconColor: "#ffffff"
+  },
+  source: {
+    type: "npm",
+    package: "@highstate/ssh"
   }
 });
-defineComponent({
-  type: "ssh.public_key",
+const existingPublicKey = defineUnit({
+  type: "ssh.existing-public-key",
+  args: {
+    type: {
+      schema: keyTypeSchema,
+      description: "The type of the key pair."
+    },
+    publicKey: {
+      schema: Type.String(),
+      description: "The public key in OpenSSH format."
+    }
+  },
+  outputs: {
+    publicKey: publicKeyEntity
+  },
   meta: {
-    displayName: "SSH Public Key",
-    description: "Only the public SSH key.",
-    category: "SSH",
+    displayName: "SSH Existing Public Key",
+    description: "Uses an existing SSH public key.",
+    category: "ssh",
     primaryIcon: "charm:key",
     primaryIconColor: "#ffffff",
     secondaryIcon: "mdi:public",
     secondaryIconColor: "#ffffff"
   },
-  args: z.object({
-    publicKey: z.string()
+  source: {
+    type: "npm",
+    package: "@highstate/ssh"
+  }
+});
+
+var ssh = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  credentialsSchema: credentialsSchema,
+  existingKeyPair: existingKeyPair,
+  existingPublicKey: existingPublicKey,
+  keyPair: keyPair,
+  keyPairEntity: keyPairEntity,
+  keyTypeSchema: keyTypeSchema,
+  publicKeyEntity: publicKeyEntity
+});
+
+const serverEntity = defineEntity({
+  type: "common.server",
+  schema: Type.Object({
+    endpoint: Type.String(),
+    sshCredentials: credentialsSchema
   }),
-  outputs: z.object({
-    sshPublicKey: sshPublicKeyType
+  meta: {
+    color: "#009688"
+  }
+});
+const gatewayEntity = defineEntity({
+  type: "common.gateway",
+  schema: Type.Object({
+    endpoint: Type.String()
   }),
-  create({ args }) {
-    return {
-      sshPublicKey: {
-        type: "ssh.key",
-        publicKey: args.publicKey
-      }
-    };
-  }
-});
-
-const clusterType = z.object({
-  type: z.literal("proxmox.cluster"),
-  endpoint: z.string(),
-  insecure: z.boolean().optional(),
-  nodeName: z.string(),
-  username: z.string().optional(),
-  password: z.string().optional(),
-  apiToken: z.string().optional()
-});
-const imageType = z.object({
-  type: z.literal("proxmox.image"),
-  id: z.string()
-});
-const connection = defineComponent$1({
+  meta: {
+    color: "#4CAF50"
+  }
+});
+const tlsIssuerEntity = defineEntity({
+  type: "common.tls-issuer",
+  schema: Type.Object({
+    endpoint: Type.String()
+  }),
+  meta: {
+    color: "#f06292"
+  }
+});
+const dnsProviderEntity = defineEntity({
+  type: "common.dns-provider",
+  schema: Type.Object({
+    endpoint: Type.String()
+  }),
+  meta: {
+    color: "#FF5722"
+  }
+});
+const accessPointEntity = defineEntity({
+  type: "common.access-point",
+  schema: Type.Object({
+    name: Type.String()
+  })
+});
+const accessPoint = defineUnit({
+  type: "common.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/common"
+  }
+});
+
+var common = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  accessPoint: accessPoint,
+  accessPointEntity: accessPointEntity,
+  dnsProviderEntity: dnsProviderEntity,
+  gatewayEntity: gatewayEntity,
+  serverEntity: serverEntity,
+  tlsIssuerEntity: tlsIssuerEntity
+});
+
+const clusterEntity$1 = 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.Optional(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.String(),
+    defaultDatastoreId: Type.Optional(Type.String())
+  },
+  secrets: {
+    password: Type.Optional(Type.String()),
+    apiToken: Type.Optional(Type.String())
+  },
+  outputs: {
+    proxmoxCluster: clusterEntity$1
+  },
   meta: {
     displayName: "Proxmox Connection",
     description: "The connection to an existing Proxmox cluster.",
     category: "Proxmox",
-    color: "#373b3e",
     primaryIcon: "simple-icons:proxmox",
     primaryIconColor: "#e56901",
     secondaryIcon: "codicon:vm"
   },
-  args: z.object({
-    endpoint: z.string(),
-    nodeName: z.string(),
-    username: z.string().optional()
-  }),
-  secrets: z.object({
-    password: z.string().optional(),
-    apiToken: z.string().optional()
-  }),
-  outputs: z.object({
-    proxmoxCluster: clusterType
-  }),
-  create({ args, secrets }) {
-    return {
-      proxmoxCluster: {
-        type: "proxmox.cluster",
-        nodeName: args.nodeName,
-        endpoint: args.endpoint,
-        username: args.username,
-        password: secrets.password,
-        apiToken: secrets.apiToken
-      }
-    };
+  source: {
+    type: "npm",
+    package: "@highstate/proxmox"
   }
 });
 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$1
+  },
+  outputs: {
+    image: imageEntity
+  },
   meta: {
     displayName: "Proxmox Image",
     description: "The image to upload to a Proxmox cluster.",
     category: "Proxmox",
-    color: "#373b3e",
     primaryIcon: "simple-icons:proxmox",
     primaryIconColor: "#e56901",
     secondaryIcon: "mage:compact-disk-fill"
   },
-  args: z.object({
-    url: z.string()
-  }),
-  inputs: z.object({
-    proxmoxCluster: clusterType
-  }),
-  outputs: z.object({
-    image: imageType
-  })
+  source: {
+    type: "npm",
+    package: "@highstate/proxmox"
+  }
 });
-const existingImage = defineComponent$1({
-  type: "proxmox.existing_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",
-    color: "#373b3e",
     primaryIcon: "simple-icons:proxmox",
     primaryIconColor: "#e56901",
     secondaryIcon: "mage:compact-disk-fill"
   },
-  args: z.object({
-    imageId: z.string()
-  }),
-  outputs: z.object({
-    image: imageType
-  }),
-  create({ args }) {
-    return {
-      image: {
-        type: "proxmox.image",
-        id: args.imageId
-      }
-    };
+  source: {
+    type: "npm",
+    package: "@highstate/proxmox"
   }
 });
 const virtualMachine = defineUnit({
-  type: "proxmox.virtual_machine",
+  type: "proxmox.virtual-machine",
+  args: {
+    nodeName: Type.Optional(Type.String()),
+    cores: Type.Optional(Type.Number()),
+    sockets: Type.Optional(Type.Number()),
+    memory: Type.Optional(Type.Number()),
+    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()),
+    bridge: Type.Optional(Type.String())
+  },
+  inputs: {
+    proxmoxCluster: clusterEntity$1,
+    image: imageEntity,
+    sshPublicKey: {
+      entity: publicKeyEntity,
+      required: false
+    },
+    sshKeyPair: {
+      entity: keyPairEntity,
+      required: false
+    }
+  },
+  outputs: {
+    server: serverEntity
+  },
   meta: {
     displayName: "Proxmox Virtual Machine",
     description: "The virtual machine on a Proxmox cluster.",
     category: "Proxmox",
-    color: "#373b3e",
     primaryIcon: "simple-icons:proxmox",
     primaryIconColor: "#e56901",
     secondaryIcon: "codicon:vm"
   },
-  args: z.object({
-    nodeName: z.string().optional(),
-    cores: z.number().optional(),
-    sockets: z.number().optional(),
-    memory: z.number().optional(),
-    ipv4: z.string().optional(),
-    ipv4Gateway: z.string().optional(),
-    dns: z.array(z.string()).optional(),
-    datastoreId: z.string().optional(),
-    diskSize: z.number().optional(),
-    bridge: z.string().optional()
-  }),
-  inputs: z.object({
-    proxmoxCluster: clusterType,
-    image: imageType,
-    sshPublicKey: sshPublicKeyType.optional()
-  }),
-  outputs: z.object({
-    server: serverType
-  })
+  source: {
+    type: "npm",
+    package: "@highstate/proxmox"
+  }
 });
 
 var proxmox = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  clusterType: clusterType,
-  connection: connection,
+  clusterEntity: clusterEntity$1,
+  connection: connection$1,
   existingImage: existingImage,
   image: image,
-  imageType: imageType,
+  imageEntity: imageEntity,
   virtualMachine: virtualMachine
 });
 
-export { proxmox };
+const clusterEntity = defineEntity({
+  type: "k8s.cluster",
+  schema: Type.Object({
+    kubeconfig: Type.String()
+  }),
+  meta: {
+    color: "#2196F3"
+  }
+});
+const routeEntity = defineEntity({
+  type: "k8s.route",
+  schema: Type.Object({
+    someField: Type.String()
+  }),
+  meta: {
+    color: "#F44336"
+  }
+});
+const traefikGateway = defineUnit({
+  type: "k8s.traefik-gateway",
+  inputs: {
+    k8sCluster: clusterEntity,
+    ingress: routeEntity
+  },
+  outputs: {
+    gateway: gatewayEntity
+  },
+  meta: {
+    displayName: "Traefik Gateway",
+    description: "A Traefik gateway for routing traffic to services.",
+    primaryIcon: "simple-icons:traefikproxy"
+  },
+  source: {
+    type: "npm",
+    package: "@highstate/k8s"
+  }
+});
+const certManager = defineUnit({
+  type: "k8s.cert-manager",
+  inputs: {
+    k8sCluster: clusterEntity,
+    dnsProvider: dnsProviderEntity
+  },
+  outputs: {
+    tlsIssuer: tlsIssuerEntity
+  },
+  meta: {
+    displayName: "Cert Manager",
+    description: "A certificate manager for managing TLS certificates.",
+    primaryIcon: "simple-icons:letsencrypt"
+  },
+  source: {
+    type: "npm",
+    package: "@highstate/k8s"
+  }
+});
+const coredns = defineUnit({
+  type: "k8s.coredns",
+  inputs: {
+    k8sCluster: clusterEntity
+  },
+  outputs: {
+    dnsProvider: dnsProviderEntity
+  },
+  meta: {
+    displayName: "CoreDNS",
+    description: "A separate CoreDNS instance for custom DNS records.",
+    primaryIcon: "mdi:dns"
+  },
+  source: {
+    type: "npm",
+    package: "@highstate/k8s"
+  }
+});
+
+var k8s = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  certManager: certManager,
+  clusterEntity: clusterEntity,
+  coredns: coredns,
+  routeEntity: routeEntity,
+  traefikGateway: traefikGateway
+});
+
+const cluster = 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.
+      `
+    }
+  },
+  inputs: {
+    masters: {
+      entity: serverEntity,
+      multiple: true
+    },
+    workers: {
+      entity: serverEntity,
+      multiple: true,
+      required: false
+    }
+  },
+  outputs: {
+    k8sCluster: clusterEntity,
+    egress: routeEntity
+  },
+  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"
+  }
+});
+
+var talos = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  cluster: cluster
+});
+
+const backendSchema = Type.Union([Type.Literal("wireguard"), Type.Literal("amneziawg")], {
+  default: "wireguard"
+});
+const networkEntity = defineEntity({
+  type: "wireguard.network",
+  schema: Type.Object({
+    backend: Type.Optional(backendSchema),
+    preSharedKey: Type.Optional(Type.String())
+  })
+});
+const identityEntity = defineEntity({
+  type: "wireguard.identity",
+  schema: Type.Object({
+    network: Type.String(),
+    address: Type.String(),
+    privateKey: Type.String()
+  }),
+  meta: {
+    color: "#F44336"
+  }
+});
+const peerEntity = defineEntity({
+  type: "wireguard.peer",
+  schema: Type.Object({
+    network: Type.String(),
+    address: Type.String(),
+    publicKey: Type.String(),
+    endpoint: Type.Optional(Type.String())
+  }),
+  meta: {
+    color: "#673AB7"
+  }
+});
+const k8sNodeEntity = defineEntity({
+  type: "wireguard.node",
+  schema: Type.Object({
+    network: Type.String(),
+    address: Type.String(),
+    allowedIps: Type.Array(Type.String()),
+    endpoint: Type.Optional(Type.String()),
+    peers: Type.Array(Type.String())
+  })
+});
+const network = defineUnit({
+  type: "wireguard.network",
+  args: {
+    backend: Type.Optional(backendSchema),
+    preSharedKey: 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"
+  }
+});
+const identity = defineUnit({
+  type: "wireguard.identity",
+  args: {
+    address: Type.String(),
+    endpoint: Type.Optional(Type.String())
+  },
+  inputs: {
+    network: networkEntity
+  },
+  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"
+  }
+});
+const node = defineUnit({
+  type: "wireguard.node-k8s",
+  args: {
+    allowedIps: Type.Optional(Type.Array(Type.String())),
+    listenPort: Type.Optional(Type.Number()),
+    externalIp: Type.Optional(Type.String()),
+    serviceType: Type.Optional(
+      Type.Union([
+        Type.Literal("NodePort"),
+        Type.Literal("LoadBalancer"),
+        Type.Literal("ClusterIP")
+      ])
+    )
+  },
+  inputs: {
+    identity: identityEntity,
+    k8sCluster: {
+      entity: clusterEntity,
+      required: false
+    },
+    peers: {
+      entity: peerEntity,
+      multiple: true,
+      required: false
+    }
+  },
+  outputs: {
+    egress: routeEntity
+  },
+  meta: {
+    description: "The WireGuard node running on the Kubernetes.",
+    primaryIcon: "simple-icons:wireguard",
+    primaryIconColor: "#88171a",
+    secondaryIcon: "mdi:server"
+  },
+  source: {
+    type: "npm",
+    package: "@highstate/wireguard"
+  }
+});
+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"
+  }
+});
+
+var wireguard = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  backendSchema: backendSchema,
+  config: config,
+  identity: identity,
+  identityEntity: identityEntity,
+  k8sNodeEntity: k8sNodeEntity,
+  network: network,
+  networkEntity: networkEntity,
+  node: node,
+  peerEntity: peerEntity
+});
+
+const mariadbEntity = defineEntity({
+  type: "mariadb",
+  schema: Type.Object({
+    rootPassword: Type.String(),
+    databases: Type.Array(Type.String())
+  }),
+  meta: {
+    color: "#f06292"
+  }
+});
+const postgresqlEntity = defineEntity({
+  type: "postgresql",
+  schema: Type.Object({
+    rootPassword: Type.String(),
+    databases: Type.Array(Type.String())
+  }),
+  meta: {
+    color: "#336791"
+  }
+});
+const mariadb = defineUnit({
+  type: "apps.mariadb",
+  args: {
+    rootPassword: Type.String(),
+    databases: Type.Array(Type.String())
+  },
+  inputs: {
+    k8sCluster: clusterEntity
+  },
+  outputs: {
+    mariadb: {
+      entity: mariadbEntity,
+      displayName: "MariaDB"
+    }
+  },
+  meta: {
+    displayName: "MariaDB",
+    description: "The MariaDB database deployed on Kubernetes.",
+    primaryIcon: "simple-icons:mariadb",
+    secondaryIcon: "mdi:database"
+  },
+  source: {
+    type: "npm",
+    package: "@highstate/apps"
+  }
+});
+const postgresql = defineUnit({
+  type: "apps.postgresql",
+  args: {
+    rootPassword: Type.String(),
+    databases: Type.Array(Type.String())
+  },
+  inputs: {
+    k8sCluster: clusterEntity
+  },
+  outputs: {
+    postgresql: {
+      entity: postgresqlEntity,
+      displayName: "PostgreSQL"
+    }
+  },
+  meta: {
+    displayName: "PostgreSQL",
+    description: "The PostgreSQL database deployed on Kubernetes.",
+    primaryIcon: "simple-icons:postgresql",
+    secondaryIcon: "mdi:database"
+  },
+  source: {
+    type: "npm",
+    package: "@highstate/apps"
+  }
+});
+const vaultwarden = defineUnit({
+  type: "apps.vaultwarden",
+  args: {
+    domain: Type.String()
+  },
+  inputs: {
+    mariadb: {
+      entity: mariadbEntity,
+      displayName: "MariaDB"
+    },
+    accessPoint: accessPointEntity
+  },
+  meta: {
+    displayName: "Vaultwarden",
+    description: "The Vaultwarden password manager deployed on Kubernetes.",
+    primaryIcon: "simple-icons:vaultwarden"
+  },
+  source: {
+    type: "npm",
+    package: "@highstate/apps"
+  }
+});
+const gitea = defineUnit({
+  type: "apps.gitea",
+  args: {
+    domain: Type.String()
+  },
+  inputs: {
+    mariadb: {
+      entity: mariadbEntity,
+      displayName: "MariaDB"
+    },
+    accessPoint: accessPointEntity
+  },
+  meta: {
+    displayName: "Gitea",
+    description: "The Gitea Git server deployed on Kubernetes.",
+    primaryIcon: "simple-icons:gitea"
+  },
+  source: {
+    type: "npm",
+    package: "@highstate/apps"
+  }
+});
+const zitadel = defineUnit({
+  type: "apps.zitadel",
+  args: {
+    domain: Type.String()
+  },
+  inputs: {
+    postgresql: {
+      entity: postgresqlEntity,
+      displayName: "PostgreSQL"
+    },
+    accessPoint: accessPointEntity
+  },
+  meta: {
+    displayName: "Zitadel",
+    description: "The Zitadel IAM deployed on Kubernetes.",
+    primaryIcon: "hugeicons:access"
+  },
+  source: {
+    type: "npm",
+    package: "@highstate/apps"
+  }
+});
+
+var apps = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  gitea: gitea,
+  mariadb: mariadb,
+  mariadbEntity: mariadbEntity,
+  postgresql: postgresql,
+  postgresqlEntity: postgresqlEntity,
+  vaultwarden: vaultwarden,
+  zitadel: zitadel
+});
+
+const connectionEntity = defineEntity({
+  type: "cloudflare.connection",
+  schema: Type.Object({
+    apiKey: Type.String()
+  }),
+  meta: {
+    color: "#f38020"
+  }
+});
+const connection = defineUnit({
+  type: "cloudflare.connection",
+  args: {
+    apiKey: {
+      schema: Type.String(),
+      secret: true
+    }
+  },
+  outputs: {
+    connection: connectionEntity
+  },
+  meta: {
+    displayName: "Cloudflare Connection",
+    description: "Creates a new Cloudflare connection.",
+    primaryIcon: "simple-icons:cloudflare"
+  },
+  source: {
+    type: "npm",
+    package: "@highstate/cloudflare"
+  }
+});
+const zone = defineUnit({
+  type: "cloudflare.zone",
+  args: {
+    zoneId: Type.String(),
+    domain: Type.String()
+  },
+  inputs: {
+    connection: connectionEntity
+  },
+  outputs: {
+    dnsProvider: dnsProviderEntity
+  },
+  meta: {
+    displayName: "Cloudflare Zone",
+    description: "Creates a new Cloudflare zone.",
+    primaryIcon: "simple-icons:cloudflare",
+    secondaryIcon: "material-symbols:domain"
+  },
+  source: {
+    type: "npm",
+    package: "@highstate/cloudflare"
+  }
+});
+
+var cloudflare = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  connection: connection,
+  connectionEntity: connectionEntity,
+  zone: zone
+});
+
+export { apps, cloudflare, common, k8s, proxmox, ssh, talos, wireguard };