@highstate/library 0.19.1 → 0.20.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { registerKnownAbbreviations, z, defineEntity, camelCaseToHumanReadable, genericNameSchema, $args, $addArgumentDescription, defineUnit, $addInputDescription, fileContentSchema as fileContentSchema$1, fileMetaSchema, unitArtifactSchema, $secrets, $inputs, $outputs, text } from '@highstate/contract';
+import { registerKnownAbbreviations, z, defineEntity, camelCaseToHumanReadable, defineUnit, $addInputDescription, $addArgumentDescription, genericNameSchema, $args, secretSchema, $secrets, $inputs, $outputs, fileContentSchema as fileContentSchema$1, fileMetaSchema, unitArtifactSchema, text } from '@highstate/contract';
 import { mapValues, pick } from 'remeda';
 
 var __defProp = Object.defineProperty;
@@ -34,9 +34,14 @@ registerKnownAbbreviations([
   "CNI",
   "CSI",
   "MariaDB",
+  "MySQL",
   "PostgreSQL",
   "MongoDB",
-  "etcd"
+  "etcd",
+  "MAS",
+  // Matrix Authentication Service
+  "LC"
+  // Locale
 ]);
 
 // src/common/index.ts
@@ -78,24 +83,27 @@ __export(network_exports, {
   addressSpace: () => addressSpace,
   addressSpaceEntity: () => addressSpaceEntity,
   addressTypeSchema: () => addressTypeSchema,
-  dynamicL3EndpointEntity: () => dynamicL3EndpointEntity,
-  dynamicL4EndpointEntity: () => dynamicL4EndpointEntity,
-  dynamicL7EndpointEntity: () => dynamicL7EndpointEntity,
   endpointArgs: () => endpointArgs,
   endpointFilter: () => endpointFilter,
   ipv46Schema: () => ipv46Schema,
   ipv4PrefixSchema: () => ipv4PrefixSchema,
   l3Endpoint: () => l3Endpoint,
+  l3EndpointContainer: () => l3EndpointContainer,
   l3EndpointEntity: () => l3EndpointEntity,
+  l3EndpointReplacer: () => l3EndpointReplacer,
   l3EndpointSchema: () => l3EndpointSchema,
   l4Endpoint: () => l4Endpoint,
+  l4EndpointContainer: () => l4EndpointContainer,
   l4EndpointEntity: () => l4EndpointEntity,
+  l4EndpointReplacer: () => l4EndpointReplacer,
   l4EndpointSchema: () => l4EndpointSchema,
   l4PortInfoSchema: () => l4PortInfoSchema,
   l4ProtocolSchema: () => l4ProtocolSchema,
   l7AppInfoSchema: () => l7AppInfoSchema,
   l7Endpoint: () => l7Endpoint,
+  l7EndpointContainer: () => l7EndpointContainer,
   l7EndpointEntity: () => l7EndpointEntity,
+  l7EndpointReplacer: () => l7EndpointReplacer,
   l7EndpointSchema: () => l7EndpointSchema,
   networkArgs: () => networkArgs,
   optionalNetworkArgs: () => optionalNetworkArgs,
@@ -120,6 +128,8 @@ var subnetEntity = defineEntity({
     prefixLength: z.number().int().nonnegative().meta({ title: camelCaseToHumanReadable("prefixLength"), description: `The prefix length of the subnet.` })
   }),
   meta: {
+    title: "Subnet",
+    icon: "ri:network-line",
     color: "#3F51B5"
   }
 });
@@ -131,7 +141,12 @@ var addressEntity = defineEntity({
     /**
      * The subnet to which the address belongs.
      */
-    subnet: subnetEntity
+    subnet: subnetEntity,
+    /**
+     * The subnet containing the single address.
+     * Can be used to provide address entity where subnet entity is expected.
+     */
+    asSubnet: subnetEntity
   },
   schema: z.object({
     /**
@@ -154,7 +169,97 @@ var addressEntity = defineEntity({
  For example:
  - IPv4: \`192.168.1.1\`
  - IPv6: \`2001:db8:85a3::8a2e:370:7334\`` })
-  })
+  }),
+  meta: {
+    title: "Address",
+    icon: "mdi:ip"
+  }
+});
+var addressSpaceEntity = defineEntity({
+  type: "network.address-space.v1",
+  includes: {
+    /**
+     * The minimal set of subnets that fully cover the address space.
+     */
+    subnets: {
+      entity: subnetEntity,
+      multiple: true,
+      required: false
+    }
+  },
+  schema: z.unknown(),
+  meta: {
+    description: `The entity representing a network address space.`,
+    color: "#3F51B5",
+    title: "Address Space",
+    icon: "mdi:network",
+    iconColor: "#3F51B5"
+  }
+});
+var addressSpace = defineUnit({
+  type: "network.address-space.v1",
+  args: {
+    /**
+     * The list of addresses to include in the address space.
+     *
+     * The supported formats are:
+     * - Single IP address (e.g., `192.168.1.1`);
+     * - CIDR notation (e.g., `192.168.1.1/24`);
+     * - Dash notation (e.g., `192.168.1.1-192.168.1.254`).
+     *
+     * The addresses can be a mix of IPv4 and IPv6.
+     */
+    included: $addArgumentDescription(z.string().array().default([]), `The list of addresses to include in the address space.
+
+ The supported formats are:
+ - Single IP address (e.g., \`192.168.1.1\`);
+ - CIDR notation (e.g., \`192.168.1.1/24\`);
+ - Dash notation (e.g., \`192.168.1.1-192.168.1.254\`).
+
+ The addresses can be a mix of IPv4 and IPv6.`),
+    /**
+     * The list of addresses to exclude from the `addresses` list.
+     *
+     * The supported formats are the same as in `addresses`.
+     */
+    excluded: $addArgumentDescription(z.string().array().default([]), `The list of addresses to exclude from the \`addresses\` list.
+
+ The supported formats are the same as in \`addresses\`.`)
+  },
+  inputs: {
+    /**
+     * The subnets to include in the address space.
+     */
+    included: $addInputDescription({
+      entity: subnetEntity,
+      multiple: true,
+      required: false
+    }, `The subnets to include in the address space.`),
+    /**
+     * The subnets to exclude from the `included` list.
+     */
+    excluded: $addInputDescription({
+      entity: subnetEntity,
+      multiple: true,
+      required: false
+    }, `The subnets to exclude from the \`included\` list.`)
+  },
+  outputs: {
+    /**
+     * The address space entity representing the created address space.
+     */
+    addressSpace: $addInputDescription(addressSpaceEntity, `The address space entity representing the created address space.`)
+  },
+  meta: {
+    description: `Defines an address space from a list of addresses/subnets/ranges.`,
+    title: "Address Space",
+    icon: "mdi:network",
+    category: "Network"
+  },
+  source: {
+    package: "@highstate/common",
+    path: "units/network/address-space"
+  }
 });
 function prefixWith(string, prefix) {
   return prefix ? `${prefix}${string.charAt(0).toUpperCase()}${string.slice(1)}` : string;
@@ -189,6 +294,8 @@ var implementationReferenceSchema = z.object({
    */
   data: z.record(z.string(), z.unknown()).meta({ title: camelCaseToHumanReadable("data"), description: `The implementation specific data.` })
 });
+
+// src/network/endpoint-schema.ts
 function createEndpointSchema(level, shape) {
   return z.intersection(
     z.object({
@@ -217,6 +324,14 @@ function createEndpointSchema(level, shape) {
       ).meta({ title: camelCaseToHumanReadable("metadata"), description: `The extra metadata for the endpoint.
 
  In most cases, this is provided by the endpoint origin (e.g., a Kubernetes service).` }),
+      /**
+       * The implementation reference that will be used to resolve the endpoint at runtime.
+       *
+       * Used primarily to expose endpoints from private networks to the Pulumi program.
+       */
+      implRef: implementationReferenceSchema.optional().meta({ title: camelCaseToHumanReadable("implRef"), description: `The implementation reference that will be used to resolve the endpoint at runtime.
+
+ Used primarily to expose endpoints from private networks to the Pulumi program.` }),
       ...shape
     }),
     z.union([
@@ -284,32 +399,6 @@ var l3EndpointSchema = z.union([
 var l4EndpointSchema = z.union([onlyl4EndpointSchema, onlyl7EndpointSchema]);
 var l7EndpointSchema = onlyl7EndpointSchema;
 
-// src/network/dynamic-endpoint.ts
-function defineDynamicEndpointEntity(level, endpointSchema) {
-  return defineEntity({
-    type: `network.dynamic-l${level}-endpoint.v1`,
-    schema: z.union([
-      z.object({
-        type: z.literal("static"),
-        /**
-         * The static endpoint.
-         */
-        endpoint: endpointSchema.meta({ title: camelCaseToHumanReadable("endpoint"), description: `The static endpoint.` })
-      }),
-      z.object({
-        type: z.literal("dynamic"),
-        /**
-         * The implementation reference to resolve the dynamic endpoint.
-         */
-        implRef: implementationReferenceSchema.meta({ title: camelCaseToHumanReadable("implRef"), description: `The implementation reference to resolve the dynamic endpoint.` })
-      })
-    ])
-  });
-}
-var dynamicL3EndpointEntity = defineDynamicEndpointEntity(3, l3EndpointSchema);
-var dynamicL4EndpointEntity = defineDynamicEndpointEntity(4, l3EndpointSchema);
-var dynamicL7EndpointEntity = defineDynamicEndpointEntity(7, l3EndpointSchema);
-
 // src/network/endpoint.ts
 var l3EndpointEntity = defineEntity({
   type: "network.l3-endpoint.v1",
@@ -331,15 +420,6 @@ var l3EndpointEntity = defineEntity({
     address: {
       entity: addressEntity,
       required: false
-    },
-    /**
-     * The dynamic endpoint which statically resolves to this endpoint.
-     *
-     * Allows to use any static endpoint as a dynamic without extra units.
-     */
-    dynamic: {
-      entity: dynamicL3EndpointEntity,
-      required: false
     }
   },
   schema: l3EndpointSchema,
@@ -347,7 +427,10 @@ var l3EndpointEntity = defineEntity({
     description: `The L3 endpoint for some service.
 
  May be a domain name or an IP address.`,
-    color: "#4CAF50"
+    color: "#4CAF50",
+    title: "L3 Endpoint",
+    icon: "mdi:network-outline",
+    iconColor: "#4CAF50"
   }
 });
 var ipv4PrefixSchema = z.number().int().min(0).max(32);
@@ -355,39 +438,29 @@ var ipv46Schema = z.union([z.ipv4(), z.ipv6()]);
 var l4EndpointEntity = defineEntity({
   type: "network.l4-endpoint.v1",
   extends: { l3EndpointEntity },
-  includes: {
-    /**
-     * The dynamic endpoint which statically resolves to this endpoint.
-     *
-     * Allows to use any static endpoint as a dynamic without extra units.
-     */
-    dynamic: dynamicL4EndpointEntity
-  },
   schema: l4EndpointSchema,
   meta: {
     description: `The L4 endpoint for some service.
 
  Extends an L3 endpoint with a port and protocol.`,
-    color: "#2196F3"
+    color: "#2196F3",
+    title: "L4 Endpoint",
+    icon: "mdi:network-outline",
+    iconColor: "#2196F3"
   }
 });
 var l7EndpointEntity = defineEntity({
   type: "network.l7-endpoint.v1",
   extends: { l4EndpointEntity },
-  includes: {
-    /**
-     * The dynamic endpoint which statically resolves to this endpoint.
-     *
-     * Allows to use any static endpoint as a dynamic without extra units.
-     */
-    dynamic: dynamicL7EndpointEntity
-  },
   schema: l7EndpointSchema,
   meta: {
     description: `The L7 endpoint for some service.
 
  Extends an L4 endpoint with application protocol information.`,
-    color: "#FF9800"
+    color: "#FF9800",
+    title: "L7 Endpoint",
+    icon: "mdi:network-outline",
+    iconColor: "#FF9800"
   }
 });
 var endpointArgs = $args({
@@ -585,88 +658,174 @@ var endpointFilter = defineUnit({
     path: "units/network/endpoint-filter"
   }
 });
-
-// src/network/address-space.ts
-var addressSpaceEntity = defineEntity({
-  type: "network.address-space.v1",
+var l3EndpointContainer = defineEntity({
+  type: "network.l3-endpoint-container.v1",
   includes: {
-    /**
-     * The minimal set of subnets that fully cover the address space.
-     */
-    subnets: {
-      entity: subnetEntity,
+    endpoints: {
+      entity: l3EndpointEntity,
       multiple: true
     }
   },
   schema: z.unknown(),
   meta: {
-    description: `The entity representing a network address space.`,
-    color: "#3F51B5"
+    color: "#4CAF50",
+    title: "L3 Endpoint Container",
+    icon: "mdi:network-outline",
+    iconColor: "#4CAF50"
   }
 });
-var addressSpace = defineUnit({
-  type: "network.address-space.v1",
-  args: {
-    /**
-     * The list of addresses to include in the address space.
-     *
-     * The supported formats are:
-     * - Single IP address (e.g., `192.168.1.1`);
-     * - CIDR notation (e.g., `192.168.1.1/24`);
-     * - Dash notation (e.g., `192.168.1.1-192.168.1.254`).
-     *
-     * The addresses can be a mix of IPv4 and IPv6.
-     */
-    included: $addArgumentDescription(z.string().array().default([]), `The list of addresses to include in the address space.
-
- The supported formats are:
- - Single IP address (e.g., \`192.168.1.1\`);
- - CIDR notation (e.g., \`192.168.1.1/24\`);
- - Dash notation (e.g., \`192.168.1.1-192.168.1.254\`).
+var l4EndpointContainer = defineEntity({
+  type: "network.l4-endpoint-container.v1",
+  includes: {
+    endpoints: {
+      entity: l4EndpointEntity,
+      multiple: true
+    }
+  },
+  schema: z.unknown(),
+  meta: {
+    color: "#2196F3",
+    title: "L4 Endpoint Container",
+    icon: "mdi:network-outline",
+    iconColor: "#2196F3"
+  }
+});
+var l7EndpointContainer = defineEntity({
+  type: "network.l7-endpoint-container.v1",
+  includes: {
+    endpoints: {
+      entity: l7EndpointEntity,
+      multiple: true
+    }
+  },
+  schema: z.unknown(),
+  meta: {
+    color: "#FF9800",
+    title: "L7 Endpoint Container",
+    icon: "mdi:network-outline",
+    iconColor: "#FF9800"
+  }
+});
+var endpointReplacerArgs = $args({
+  /**
+   * The strings to parse as endpoints and add to the replacement list.
+   */
+  endpoints: $addArgumentDescription(z.string().array().default([]), `The strings to parse as endpoints and add to the replacement list.`),
+  /**
+   * Whether to add current endpoints of the entity to the replacement list.
+   *
+   * Defaults to `true`.
+   */
+  includeCurrent: $addArgumentDescription(z.boolean().default(true), `Whether to add current endpoints of the entity to the replacement list.
 
- The addresses can be a mix of IPv4 and IPv6.`),
+ Defaults to \`true\`.`),
+  ...pick(optionalNetworkArgs, ["endpointFilter"])
+});
+var l3EndpointReplacer = defineUnit({
+  type: "network.l3-endpoint-replacer.v1",
+  args: endpointReplacerArgs,
+  inputs: {
     /**
-     * The list of addresses to exclude from the `addresses` list.
-     *
-     * The supported formats are the same as in `addresses`.
+     * The entity containing the "endpoints" inclusion to replace.
      */
-    excluded: $addArgumentDescription(z.string().array().default([]), `The list of addresses to exclude from the \`addresses\` list.
-
- The supported formats are the same as in \`addresses\`.`)
-  },
-  inputs: {
+    entity: $addInputDescription(l3EndpointContainer, `The entity containing the "endpoints" inclusion to replace.`),
     /**
-     * The endpoints to include in the address space.
+     * The endpoints to add to the replacement list.
      */
-    included: $addInputDescription({
+    endpoints: $addInputDescription({
       entity: l3EndpointEntity,
       multiple: true,
       required: false
-    }, `The endpoints to include in the address space.`),
+    }, `The endpoints to add to the replacement list.`),
     /**
-     * The endpoints to exclude from the `included` list.
+     * The IP addresses to parse as endpoints and add to the replacement list.
      */
-    excluded: $addInputDescription({
-      entity: l3EndpointEntity,
+    addresses: $addInputDescription({
+      entity: addressEntity,
       multiple: true,
       required: false
-    }, `The endpoints to exclude from the \`included\` list.`)
+    }, `The IP addresses to parse as endpoints and add to the replacement list.`)
   },
   outputs: {
+    entity: { fromInput: "entity" }
+  },
+  meta: {
+    description: `Replaces the L3 endpoints in the entity.`,
+    title: "L3 Endpoint Replacer",
+    icon: "mdi:network-outline",
+    iconColor: "#FF9800",
+    secondaryIcon: "mdi:swap-horizontal-bold",
+    category: "Network"
+  },
+  source: {
+    package: "@highstate/common",
+    path: "units/network/l3-endpoint-replacer"
+  }
+});
+var l4EndpointReplacer = defineUnit({
+  type: "network.l4-endpoint-replacer.v1",
+  args: endpointReplacerArgs,
+  inputs: {
     /**
-     * The address space entity representing the created address space.
+     * The entity containing the "endpoints" inclusion to replace.
      */
-    addressSpace: $addInputDescription(addressSpaceEntity, `The address space entity representing the created address space.`)
+    entity: $addInputDescription(l4EndpointContainer, `The entity containing the "endpoints" inclusion to replace.`),
+    /**
+     * The endpoints to add to the replacement list.
+     */
+    endpoints: $addInputDescription({
+      entity: l4EndpointEntity,
+      multiple: true,
+      required: false
+    }, `The endpoints to add to the replacement list.`)
+  },
+  outputs: {
+    entity: { fromInput: "entity" }
   },
   meta: {
-    description: `Defines an address space from a list of addresses/subnets/ranges.`,
-    title: "Address Space",
-    icon: "mdi:network",
+    description: `Replaces the L4 endpoints in the entity.`,
+    title: "L4 Endpoint Replacer",
+    icon: "mdi:network-outline",
+    iconColor: "#FF9800",
+    secondaryIcon: "mdi:swap-horizontal-bold",
     category: "Network"
   },
   source: {
     package: "@highstate/common",
-    path: "units/network/address-space"
+    path: "units/network/l4-endpoint-replacer"
+  }
+});
+var l7EndpointReplacer = defineUnit({
+  type: "network.l7-endpoint-replacer.v1",
+  args: endpointReplacerArgs,
+  inputs: {
+    /**
+     * The entity containing the "endpoints" inclusion to replace.
+     */
+    entity: $addInputDescription(l7EndpointContainer, `The entity containing the "endpoints" inclusion to replace.`),
+    /**
+     * The endpoints to add to the replacement list.
+     */
+    endpoints: $addInputDescription({
+      entity: l7EndpointEntity,
+      multiple: true,
+      required: false
+    }, `The endpoints to add to the replacement list.`)
+  },
+  outputs: {
+    entity: { fromInput: "entity" }
+  },
+  meta: {
+    description: `Replaces the L7 endpoints in the entity.`,
+    title: "L7 Endpoint Replacer",
+    icon: "mdi:network-outline",
+    iconColor: "#FF9800",
+    secondaryIcon: "mdi:swap-horizontal-bold",
+    category: "Network"
+  },
+  source: {
+    package: "@highstate/common",
+    path: "units/network/l7-endpoint-replacer"
   }
 });
 
@@ -674,7 +833,7 @@ var addressSpace = defineUnit({
 var ssh_exports = {};
 __export(ssh_exports, {
   argsSchema: () => argsSchema,
-  connectionSchema: () => connectionSchema,
+  connectionEntity: () => connectionEntity,
   inputs: () => inputs,
   keyPair: () => keyPair,
   keyPairEntity: () => keyPairEntity,
@@ -683,118 +842,6 @@ __export(ssh_exports, {
   publicKeyEntity: () => publicKeyEntity,
   secrets: () => secrets
 });
-var checksumAlgorithmSchema = z.enum(["md5", "sha1", "sha256", "sha384", "sha512"]);
-var checksumSchema = z.object({
-  algorithm: checksumAlgorithmSchema,
-  value: z.string()
-});
-var fileContentSchema = z.union([
-  fileContentSchema$1,
-  z.object({
-    type: z.literal("local"),
-    path: z.string()
-  }),
-  z.object({
-    type: z.literal("remote"),
-    endpoint: l7EndpointEntity.schema,
-    checksum: checksumSchema.optional()
-  })
-]);
-var fileEntity = defineEntity({
-  type: "common.file.v1",
-  schema: z.object({
-    meta: fileMetaSchema,
-    content: fileContentSchema
-  }),
-  meta: {
-    color: "#FF5722"
-  }
-});
-var folderMetaSchema = z.object({
-  name: z.string(),
-  mode: z.number().optional()
-});
-var folderContentSchema = z.union([
-  z.object({
-    type: z.literal("embedded"),
-    files: fileEntity.schema.array(),
-    folders: z.object({
-      meta: folderMetaSchema,
-      get content() {
-        return folderContentSchema;
-      }
-    }).array()
-  }),
-  z.object({
-    type: z.literal("artifact"),
-    ...unitArtifactSchema.shape
-  }),
-  z.object({
-    type: z.literal("local"),
-    path: z.string()
-  }),
-  z.object({
-    type: z.literal("remote"),
-    endpoint: l7EndpointEntity.schema
-  })
-]);
-var folderEntity = defineEntity({
-  type: "common.folder.v1",
-  schema: z.object({
-    meta: folderMetaSchema,
-    content: folderContentSchema
-  }),
-  meta: {
-    color: "#FF9800"
-  }
-});
-var remoteFile = defineUnit({
-  type: "common.remote-file.v1",
-  args: {
-    /**
-     * The URL of the remote file.
-     *
-     * Either this or the 'endpoint' input must be provided.
-     */
-    url: $addArgumentDescription(z.string().optional(), `The URL of the remote file.
-
- Either this or the 'endpoint' input must be provided.`),
-    /**
-     * The name of the file.
-     *
-     * If not provided, the name will be derived from the URL or endpoint path.
-     * If not possible, the name of the unit will be used.
-     */
-    fileName: $addArgumentDescription(z.string().optional(), `The name of the file.
-
- If not provided, the name will be derived from the URL or endpoint path.
- If not possible, the name of the unit will be used.`)
-  },
-  inputs: {
-    /**
-     * The L7 endpoint of the remote file.
-     */
-    endpoint: $addInputDescription({
-      entity: l7EndpointEntity,
-      required: false
-    }, `The L7 endpoint of the remote file.`)
-  },
-  outputs: {
-    file: fileEntity
-  },
-  meta: {
-    description: `References a file from a remote URL.`,
-    title: "Remote File",
-    icon: "mdi:file-download",
-    category: "Files"
-  },
-  source: {
-    package: "@highstate/common",
-    path: "units/remote-file"
-  }
-});
-
-// src/ssh.ts
 var keyTypeSchema = z.enum(["ed25519"]);
 var publicKeyEntity = defineEntity({
   type: "ssh.public-key.v1",
@@ -827,34 +874,57 @@ var keyPairEntity = defineEntity({
     /**
      * The private key in PEM format.
      */
-    privateKey: z.string().meta({ title: camelCaseToHumanReadable("privateKey"), description: `The private key in PEM format.` })
+    privateKey: secretSchema(z.string()).meta({ title: camelCaseToHumanReadable("privateKey"), description: `The private key in PEM format.` })
   }),
   meta: {
     description: `The entity representing an SSH key pair.`,
-    color: "#2b5797"
+    color: "#2b5797",
+    title: "SSH Key Pair",
+    icon: "charm:key",
+    iconColor: "#ffffff",
+    secondaryIcon: "mdi:lock",
+    secondaryIconColor: "#ffffff"
   }
 });
-var connectionSchema = z.object({
-  /**
-   * The list of L4 endpoints which can be used to connect to the SSH server.
-   */
-  endpoints: l4EndpointEntity.schema.array().meta({ title: camelCaseToHumanReadable("endpoints"), description: `The list of L4 endpoints which can be used to connect to the SSH server.` }),
-  /**
-   * The host key of the SSH server which will be used to verify the server's identity.
-   */
-  hostKey: z.string().meta({ title: camelCaseToHumanReadable("hostKey"), description: `The host key of the SSH server which will be used to verify the server's identity.` }),
-  /**
-   * The user to connect as.
-   */
-  user: z.string().meta({ title: camelCaseToHumanReadable("user"), description: `The user to connect as.` }),
-  /**
-   * The password to use for authentication.
-   */
-  password: z.string().optional().meta({ title: camelCaseToHumanReadable("password"), description: `The password to use for authentication.` }),
-  /**
-   * The SSH key pair to use for authentication.
-   */
-  keyPair: keyPairEntity.schema.optional().meta({ title: camelCaseToHumanReadable("keyPair"), description: `The SSH key pair to use for authentication.` })
+var connectionEntity = defineEntity({
+  type: "ssh.connection.v1",
+  includes: {
+    /**
+     * The endpoints to connect to.
+     */
+    endpoints: {
+      entity: l4EndpointEntity,
+      multiple: true
+    },
+    /**
+     * The SSH key pair to use for authentication.
+     */
+    keyPair: {
+      entity: keyPairEntity,
+      required: false
+    }
+  },
+  schema: z.object({
+    /**
+     * The host key of the SSH server which will be used to verify the server's identity.
+     */
+    hostKey: z.string().meta({ title: camelCaseToHumanReadable("hostKey"), description: `The host key of the SSH server which will be used to verify the server's identity.` }),
+    /**
+     * The user to connect as.
+     */
+    user: z.string().meta({ title: camelCaseToHumanReadable("user"), description: `The user to connect as.` }),
+    /**
+     * The password to use for authentication.
+     */
+    password: secretSchema(z.string()).optional().meta({ title: camelCaseToHumanReadable("password"), description: `The password to use for authentication.` })
+  }),
+  meta: {
+    description: `The schema for the SSH connection credentials.`,
+    color: "#2b5797",
+    title: "SSH Connection",
+    icon: "mdi:terminal",
+    iconColor: "#2b5797"
+  }
 });
 var argsSchema = z.object({
   /**
@@ -947,8 +1017,7 @@ var keyPair = defineUnit({
  If not provided, a new key pair will be generated and stored.`)
   },
   outputs: {
-    keyPair: keyPairEntity,
-    publicKeyFile: fileEntity
+    keyPair: keyPairEntity
   },
   meta: {
     description: `Holds the ED25519 SSH key pair and generates the private key if not provided.`,
@@ -968,15 +1037,23 @@ var keyPair = defineUnit({
 // src/common/server.ts
 var serverEntity = defineEntity({
   type: "common.server.v1",
+  extends: { l3EndpointContainer },
   includes: {
-    endpoints: {
-      entity: l3EndpointEntity,
-      multiple: true
+    /**
+     * The SSH configuration for the server.
+     *
+     * If not specified, it will be assumed that the server is not accessible via SSH.
+     */
+    ssh: {
+      entity: connectionEntity,
+      required: false
     }
   },
   schema: z.object({
-    hostname: z.string(),
-    ssh: connectionSchema.optional()
+    /**
+     * The hostname of the server.
+     */
+    hostname: z.string().meta({ title: camelCaseToHumanReadable("hostname"), description: `The hostname of the server.` })
   }),
   meta: {
     description: `The server entity represents a server with its hostname, endpoints, and optional SSH configuration.
@@ -984,7 +1061,10 @@ var serverEntity = defineEntity({
  The OS of the server is not specified (but in most cases it will one of the Linux distributions).
 
  In fact, anything that have hostname (which can be any string) and L3 endpoints can be represented by this entity.`,
-    color: "#009688"
+    color: "#009688",
+    title: "Server",
+    icon: "mdi:server",
+    iconColor: "#009688"
   }
 });
 var serverOutputs = $outputs({
@@ -1124,10 +1204,6 @@ var script = defineUnit({
 var providerEntity = defineEntity({
   type: "dns.provider.v1",
   schema: z.object({
-    /**
-     * The ID of the DNS provider unique within the system.
-     */
-    id: z.string().meta({ title: camelCaseToHumanReadable("id"), description: `The ID of the DNS provider unique within the system.` }),
     /**
      * The zones managed by the DNS provider.
      */
@@ -1138,7 +1214,10 @@ var providerEntity = defineEntity({
     implRef: implementationReferenceSchema.meta({ title: camelCaseToHumanReadable("implRef"), description: `The reference to the implementation of the DNS provider.` })
   }),
   meta: {
-    color: "#FF5722"
+    color: "#FF5722",
+    title: "DNS Provider",
+    icon: "mdi:dns",
+    iconColor: "#FF5722"
   }
 });
 var recordSet = defineUnit({
@@ -1302,6 +1381,9 @@ var gatewayEntity = defineEntity({
  If not provided, should be automatically detected by the implementation.` })
   }),
   meta: {
+    title: "Gateway",
+    icon: "mdi:router-network",
+    iconColor: "#F57F17",
     color: "#F57F17"
   }
 });
@@ -1318,6 +1400,9 @@ var tlsIssuerEntity = defineEntity({
     implRef: implementationReferenceSchema.meta({ title: camelCaseToHumanReadable("implRef"), description: `The reference to the implementation of the TLS issuer.` })
   }),
   meta: {
+    title: "TLS Issuer",
+    icon: "mdi:certificate-outline",
+    iconColor: "#F57F17",
     color: "#F57F17"
   }
 });
@@ -1342,6 +1427,9 @@ var accessPointEntity = defineEntity({
     proxied: z.boolean().default(false).meta({ title: camelCaseToHumanReadable("proxied"), description: `Whether the DNS records created for the access point should be proxied.` })
   }),
   meta: {
+    title: "Access Point",
+    icon: "mdi:access-point",
+    iconColor: "#F57F17",
     color: "#F57F17"
   }
 });
@@ -1392,544 +1480,1171 @@ var accessPoint = defineUnit({
     path: "units/access-point"
   }
 });
-
-// src/databases/index.ts
-var databases_exports = {};
-__export(databases_exports, {
-  etcdEntity: () => etcdEntity,
-  etcdPatch: () => etcdPatch,
-  existingEtcd: () => existingEtcd,
-  existingMariadb: () => existingMariadb,
-  existingMongodb: () => existingMongodb,
-  existingPostgresql: () => existingPostgresql,
-  existingRedis: () => existingRedis,
-  existingS3: () => existingS3,
-  mariadbEntity: () => mariadbEntity,
-  mariadbPatch: () => mariadbPatch,
-  mongodbEntity: () => mongodbEntity,
-  mongodbPatch: () => mongodbPatch,
-  optionalSharedArgs: () => optionalSharedArgs,
-  postgresqlEntity: () => postgresqlEntity,
-  postgresqlPatch: () => postgresqlPatch,
-  redisEntity: () => redisEntity,
-  redisPatch: () => redisPatch,
-  s3BucketPolicySchema: () => s3BucketPolicySchema,
-  s3BucketSchema: () => s3BucketSchema,
-  s3Entity: () => s3Entity,
-  s3Patch: () => s3Patch,
-  sharedArgs: () => sharedArgs,
-  sharedInputs: () => sharedInputs,
-  sharedSchema: () => sharedSchema,
-  sharedSecrets: () => sharedSecrets
+var checksumAlgorithmSchema = z.enum(["md5", "sha1", "sha256", "sha384", "sha512"]);
+var checksumSchema = z.object({
+  algorithm: checksumAlgorithmSchema,
+  value: z.string()
 });
-var etcdArgs = {
-  endpoints: {
-    schema: z.string().array().default([])
+var fileContentSchema = z.union([
+  fileContentSchema$1,
+  z.object({
+    type: z.literal("remote"),
+    endpoint: l7EndpointEntity.schema,
+    checksum: checksumSchema.optional()
+  })
+]);
+var fileEntity = defineEntity({
+  type: "common.file.v1",
+  schema: z.object({
+    meta: fileMetaSchema,
+    content: fileContentSchema
+  }),
+  meta: {
+    title: "File",
+    icon: "mdi:file",
+    iconColor: "#2196F3",
+    color: "#2196F3"
   }
-};
-var etcdEntity = defineEntity({
-  type: "databases.etcd.v1",
+});
+var folderMetaSchema = z.object({
+  name: z.string(),
+  mode: z.number().optional()
+});
+var folderContentSchema = z.union([
+  z.object({
+    type: z.literal("embedded")
+  }),
+  z.object({
+    type: z.literal("artifact"),
+    ...unitArtifactSchema.shape
+  }),
+  z.object({
+    type: z.literal("local"),
+    path: z.string()
+  }),
+  z.object({
+    type: z.literal("remote"),
+    endpoint: l7EndpointEntity.schema
+  })
+]);
+var folderEntity = defineEntity({
+  type: "common.folder.v1",
   includes: {
-    endpoints: {
-      entity: l4EndpointEntity,
-      multiple: true
+    files: {
+      entity: fileEntity,
+      multiple: true,
+      required: false
+    },
+    folders: {
+      entity: () => folderEntity,
+      multiple: true,
+      required: false
     }
   },
-  schema: z.unknown(),
+  schema: z.object({
+    meta: folderMetaSchema,
+    content: folderContentSchema
+  }),
   meta: {
-    description: `Represents the etcd database instance.`,
-    color: "#0064bf"
+    title: "Folder",
+    icon: "mdi:folder",
+    iconColor: "#4CAF50",
+    color: "#4CAF50"
   }
 });
-var existingEtcd = defineUnit({
-  type: "databases.etcd.existing.v1",
-  args: etcdArgs,
+var remoteFile = defineUnit({
+  type: "common.remote-file.v1",
+  args: {
+    /**
+     * The URL of the remote file.
+     *
+     * Either this or the 'endpoint' input must be provided.
+     */
+    url: $addArgumentDescription(z.string().optional(), `The URL of the remote file.
+
+ Either this or the 'endpoint' input must be provided.`),
+    /**
+     * The name of the file.
+     *
+     * If not provided, the name will be derived from the URL or endpoint path.
+     * If not possible, the name of the unit will be used.
+     */
+    fileName: $addArgumentDescription(z.string().optional(), `The name of the file.
+
+ If not provided, the name will be derived from the URL or endpoint path.
+ If not possible, the name of the unit will be used.`)
+  },
   inputs: {
-    endpoints: {
-      entity: l4EndpointEntity,
-      multiple: true,
+    /**
+     * The L7 endpoint of the remote file.
+     */
+    endpoint: $addInputDescription({
+      entity: l7EndpointEntity,
       required: false
-    }
+    }, `The L7 endpoint of the remote file.`)
   },
   outputs: {
-    etcd: etcdEntity
-  },
-  source: {
-    package: "@highstate/common",
-    path: "units/databases/existing-etcd"
+    file: fileEntity
   },
   meta: {
-    description: `The existing etcd database instance.`,
-    title: "Existing etcd Database",
-    icon: "simple-icons:etcd",
-    secondaryIcon: "mdi:database",
-    category: "Databases"
+    description: `References a file from a remote URL.`,
+    title: "Remote File",
+    icon: "mdi:file-download",
+    category: "Files"
+  },
+  source: {
+    package: "@highstate/common",
+    path: "units/remote-file"
+  }
+});
+
+// src/databases/etcd.ts
+var etcd_exports = {};
+__export(etcd_exports, {
+  connection: () => connection,
+  connectionEntity: () => connectionEntity2,
+  credentialsSchema: () => credentialsSchema,
+  namespace: () => namespace,
+  namespacePermissionSchema: () => namespacePermissionSchema
+});
+var certificateEntity = defineEntity({
+  type: "tls.certificate.v1",
+  includes: {
+    /**
+     * The file containing the certificate in PEM format.
+     */
+    file: fileEntity
+  },
+  schema: z.unknown(),
+  meta: {
+    title: "TLS Certificate",
+    color: "#4caf50",
+    icon: "mdi:certificate",
+    iconColor: "#4caf50"
   }
 });
-var etcdPatch = defineUnit({
-  type: "databases.etcd-patch.v1",
-  args: toPatchArgs(etcdArgs),
+
+// src/databases/etcd.ts
+var credentialsSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("password"),
+    /**
+     * The username used to authenticate against the database.
+     */
+    username: z.string().meta({ title: camelCaseToHumanReadable("username"), description: `The username used to authenticate against the database.` }),
+    /**
+     * The password used to authenticate against the database.
+     */
+    password: secretSchema(z.string()).meta({ title: camelCaseToHumanReadable("password"), description: `The password used to authenticate against the database.` })
+  })
+]);
+var connectionEntity2 = defineEntity({
+  type: "etcd.connection.v1",
+  extends: { l4EndpointContainer },
+  includes: {
+    /**
+     * The TLS certificate of the server if any.
+     */
+    certificate: {
+      entity: certificateEntity,
+      required: false
+    }
+  },
+  schema: z.object({
+    /**
+     * The credentials for authenticating to the etcd cluster.
+     */
+    credentials: credentialsSchema.optional().meta({ title: camelCaseToHumanReadable("credentials"), description: `The credentials for authenticating to the etcd cluster.` })
+  }),
+  meta: {
+    description: `Represents a connection to the etcd cluster.`,
+    color: "#0064bf"
+  }
+});
+var connection = defineUnit({
+  type: "etcd.connection.v1",
+  args: {
+    /**
+     * The endpoints to connect to the etcd cluster.
+     */
+    endpoints: $addArgumentDescription(z.string().array().default([]), `The endpoints to connect to the etcd cluster.`),
+    /**
+     * The username to authenticate with.
+     */
+    username: $addArgumentDescription(z.string().optional(), `The username to authenticate with.`)
+  },
+  secrets: {
+    /**
+     * The password to authenticate with.
+     */
+    password: $addArgumentDescription(z.string().optional(), `The password to authenticate with.`)
+  },
   inputs: {
-    etcd: etcdEntity,
-    endpoints: {
+    /**
+     * The endpoints to connect to the etcd cluster.
+     */
+    endpoints: $addInputDescription({
       entity: l4EndpointEntity,
       multiple: true,
       required: false
-    }
+    }, `The endpoints to connect to the etcd cluster.`)
   },
   outputs: {
-    etcd: etcdEntity
+    connection: connectionEntity2
   },
   source: {
-    package: "@highstate/common",
-    path: "units/databases/etcd-patch"
+    package: "@highstate/etcd",
+    path: "units/connection"
   },
   meta: {
-    description: `Patches some properties of the etcd database and outputs the updated database.`,
-    title: "etcd Patch",
+    description: `The connection to an existing etcd cluster hosted on a server or a managed service.`,
+    title: "Existing etcd Database",
     icon: "simple-icons:etcd",
-    secondaryIcon: "fluent:patch-20-filled",
+    secondaryIcon: "mdi:database",
     category: "Databases"
   }
 });
-var sharedSchema = z.object({
+var namespacePermissionSchema = z.object({
   /**
-   * The username to connect to the database with.
+   * The prefix of the namespace to grant access to.
    */
-  username: z.string().meta({ title: camelCaseToHumanReadable("username"), description: `The username to connect to the database with.` }),
+  prefix: z.string().meta({ title: camelCaseToHumanReadable("prefix"), description: `The prefix of the namespace to grant access to.` }),
   /**
-   * The password to connect to the database with.
+   * The range end of the namespace to grant access to.
+   *
+   * If not specified, all keys with the given prefix will be included in the namespace.
    */
-  password: z.string().optional().meta({ title: camelCaseToHumanReadable("password"), description: `The password to connect to the database with.` }),
+  rangeEnd: z.string().optional().meta({ title: camelCaseToHumanReadable("rangeEnd"), description: `The range end of the namespace to grant access to.
+
+ If not specified, all keys with the given prefix will be included in the namespace.` }),
   /**
-   * The name of the database to connect to.
+   * The access level to grant to the namespace.
+   *
+   * If not specified, defaults to `readwrite`.
    */
-  database: z.string().optional().meta({ title: camelCaseToHumanReadable("database"), description: `The name of the database to connect to.` })
+  permission: z.enum(["read", "write", "readwrite"]).default("readwrite").meta({ title: camelCaseToHumanReadable("permission"), description: `The access level to grant to the namespace.
+
+ If not specified, defaults to \`readwrite\`.` })
 });
-var sharedArgs = $args({
+var namespace = defineUnit({
+  type: "etcd.namespace.v1",
+  args: {
+    /**
+     * The name of the role to define for the namespace.
+     *
+     * If not provided, the name of the unit will be used.
+     */
+    roleName: $addArgumentDescription(z.string().optional(), `The name of the role to define for the namespace.
+
+ If not provided, the name of the unit will be used.`),
+    /**
+     * The username of the user to create for the namespace.
+     *
+     * If not provided, the name of the role will be used.
+     */
+    username: $addArgumentDescription(z.string().optional(), `The username of the user to create for the namespace.
+
+ If not provided, the name of the role will be used.`),
+    /**
+     * The permissions to grant to the namespace.
+     */
+    permissions: $addArgumentDescription(namespacePermissionSchema.array(), `The permissions to grant to the namespace.`)
+  },
+  secrets: {
+    /**
+     * The password of the user to create for the namespace.
+     *
+     * If not provided, a random password will be generated.
+     */
+    password: $addArgumentDescription(z.string().optional(), `The password of the user to create for the namespace.
+
+ If not provided, a random password will be generated.`)
+  },
+  inputs: {
+    /**
+     * The connection to the etcd cluster.
+     */
+    connection: $addInputDescription({
+      entity: connectionEntity2,
+      required: true
+    }, `The connection to the etcd cluster.`)
+  },
+  outputs: {
+    connection: connectionEntity2
+  },
+  source: {
+    package: "@highstate/etcd",
+    path: "units/namespace"
+  },
+  meta: {
+    description: `The namespace within an existing etcd cluster.`,
+    title: "etcd Namespace",
+    icon: "simple-icons:etcd",
+    iconColor: "#0069ab",
+    secondaryIcon: "mdi:database",
+    category: "Databases"
+  }
+});
+
+// src/databases/influxdb3.ts
+var influxdb3_exports = {};
+__export(influxdb3_exports, {
+  connectionEntity: () => connectionEntity3,
+  credentialsSchema: () => credentialsSchema2,
+  database: () => database,
+  databaseEntity: () => databaseEntity
+});
+var credentialsSchema2 = z.object({
   /**
-   * The endpoints to connect to the database in form of `host:port`.
+   * The token for authenticating to the InfluxDB 3 instance.
    */
-  endpoints: $addArgumentDescription(z.string().array().min(1), `The endpoints to connect to the database in form of \`host:port\`.`),
+  token: secretSchema(z.string()).meta({ title: camelCaseToHumanReadable("token"), description: `The token for authenticating to the InfluxDB 3 instance.` })
+});
+var connectionEntity3 = defineEntity({
+  type: "influxdb3.connection.v1",
+  extends: { l7EndpointContainer },
+  schema: z.object({
+    /**
+     * The credentials for authenticating to the InfluxDB 3 instance.
+     */
+    credentials: credentialsSchema2.meta({ title: camelCaseToHumanReadable("credentials"), description: `The credentials for authenticating to the InfluxDB 3 instance.` })
+  }),
+  meta: {
+    description: `Represents a connection to a InfluxDB 3 instance, including the endpoints and credentials.`,
+    color: "#22adf6"
+  }
+});
+var databaseEntity = defineEntity({
+  type: "influxdb3.database.v1",
+  extends: { connectionEntity: connectionEntity3 },
+  schema: z.object({
+    /**
+     * The name of the database.
+     */
+    name: z.string().meta({ title: camelCaseToHumanReadable("name"), description: `The name of the database.` })
+  }),
+  meta: {
+    description: `Represents an InfluxDB 3 database with credentials and endpoints to access it.`,
+    color: "#22adf6"
+  }
+});
+var database = defineUnit({
+  type: "influxdb3.database.v1",
+  args: {
+    /**
+     * The name of the database.
+     *
+     * If not provided, it will be set to the unit name.
+     */
+    databaseName: $addArgumentDescription(z.string().optional(), `The name of the database.
+
+ If not provided, it will be set to the unit name.`),
+    /**
+     * The retention period for the database.
+     *
+     * The value is passed through to InfluxDB 3 as-is.
+     */
+    retention_period: $addArgumentDescription(z.string().optional(), `The retention period for the database.
+
+ The value is passed through to InfluxDB 3 as-is.`)
+  },
+  inputs: {
+    connection: connectionEntity3
+  },
+  outputs: {
+    database: databaseEntity
+  },
+  meta: {
+    description: `Creates a database in an InfluxDB 3 instance.`,
+    title: "InfluxDB 3 Database",
+    icon: "simple-icons:influxdb",
+    category: "Databases"
+  },
+  source: {
+    package: "@highstate/influxdb3",
+    path: "units/database"
+  }
+});
+
+// src/databases/minio.ts
+var minio_exports = {};
+__export(minio_exports, {
+  bucket: () => bucket,
+  connection: () => connection2,
+  connectionEntity: () => connectionEntity4,
+  credentialsSchema: () => credentialsSchema4
+});
+
+// src/databases/s3.ts
+var s3_exports = {};
+__export(s3_exports, {
+  bucketEntity: () => bucketEntity,
+  credentialsSchema: () => credentialsSchema3,
+  existingBucket: () => existingBucket
+});
+var credentialsSchema3 = z.object({
   /**
-   * The username to connect to the database with.
-   *
-   * If not provided, defaults to `root`.
+   * The access key used to authenticate against the API.
    */
-  username: $addArgumentDescription(z.string().default("root"), `The username to connect to the database with.
-
- If not provided, defaults to \`root\`.`),
+  accessKey: secretSchema(z.string()).meta({ title: camelCaseToHumanReadable("accessKey"), description: `The access key used to authenticate against the API.` }),
   /**
-   * The name of the database to connect to.
+   * The secret key used to authenticate against the API.
    */
-  database: $addArgumentDescription(z.string().optional(), `The name of the database to connect to.`)
+  secretKey: secretSchema(z.string()).meta({ title: camelCaseToHumanReadable("secretKey"), description: `The secret key used to authenticate against the API.` })
 });
-var optionalSharedArgs = mapValues(sharedArgs, (arg) => ({
-  ...arg,
-  schema: arg.schema.optional()
-}));
-var sharedSecrets = $secrets({
+var bucketEntity = defineEntity({
+  type: "s3.bucket.v1",
+  extends: { l7EndpointContainer },
+  schema: z.object({
+    /**
+     * The name of the S3 bucket.
+     */
+    name: z.string().meta({ title: camelCaseToHumanReadable("name"), description: `The name of the S3 bucket.` }),
+    /**
+     * The region where the S3 bucket is located.
+     */
+    region: z.string().meta({ title: camelCaseToHumanReadable("region"), description: `The region where the S3 bucket is located.` }),
+    /**
+     * The credentials that can be used to access the S3 bucket.
+     */
+    credentials: credentialsSchema3.meta({ title: camelCaseToHumanReadable("credentials"), description: `The credentials that can be used to access the S3 bucket.` })
+  }),
+  meta: {
+    description: `Represents an S3 bucket with credentials and endpoints to access it.`,
+    color: "#ff9900"
+  }
+});
+var existingBucket = defineUnit({
+  type: "s3.existing-bucket.v1",
+  args: {
+    /**
+     * The name of the existing S3 bucket.
+     */
+    bucketName: $addArgumentDescription(z.string(), `The name of the existing S3 bucket.`),
+    /**
+     * The region where the existing S3 bucket is located.
+     */
+    region: $addArgumentDescription(z.string(), `The region where the existing S3 bucket is located.`),
+    /**
+     * The endpoints to connect to the S3 bucket.
+     */
+    endpoints: $addArgumentDescription(z.string().array().default([]), `The endpoints to connect to the S3 bucket.`)
+  },
+  inputs: {
+    /**
+     * The endpoints to connect to the S3 bucket.
+     */
+    endpoints: $addInputDescription({
+      entity: l4EndpointEntity,
+      multiple: true,
+      required: false
+    }, `The endpoints to connect to the S3 bucket.`)
+  },
+  outputs: {
+    bucket: bucketEntity
+  },
+  source: {
+    package: "@highstate/common",
+    path: "units/databases/existing-s3-bucket"
+  },
+  meta: {
+    description: `The existing S3 bucket hosted on AWS or another S3-compatible service.`,
+    title: "Existing S3 Bucket",
+    icon: "simple-icons:amazonaws",
+    secondaryIcon: "mdi:database",
+    category: "Databases"
+  }
+});
+
+// src/databases/minio.ts
+var credentialsSchema4 = z.object({
   /**
-   * The password to connect to the database with.
+   * The username used to authenticate against the API.
    */
-  password: $addArgumentDescription(z.string().optional(), `The password to connect to the database with.`)
-});
-var sharedInputs = $inputs({
+  username: z.string().meta({ title: camelCaseToHumanReadable("username"), description: `The username used to authenticate against the API.` }),
   /**
-   * The endpoints to connect to the database.
+   * The password used to authenticate against the API.
    */
-  endpoints: $addInputDescription({
-    entity: l4EndpointEntity,
-    multiple: true,
-    required: false
-  }, `The endpoints to connect to the database.`)
+  password: secretSchema(z.string()).meta({ title: camelCaseToHumanReadable("password"), description: `The password used to authenticate against the API.` })
 });
-
-// src/databases/mariadb.ts
-var mariadbEntity = defineEntity({
-  type: "databases.mariadb.v1",
-  includes: {
-    endpoints: {
-      entity: l4EndpointEntity,
-      multiple: true
-    }
-  },
-  schema: sharedSchema,
+var connectionEntity4 = defineEntity({
+  type: "minio.connection.v1",
+  extends: { l7EndpointContainer },
+  schema: z.object({
+    /**
+     * The region of the MinIO instance.
+     */
+    region: z.string().meta({ title: camelCaseToHumanReadable("region"), description: `The region of the MinIO instance.` }),
+    /**
+     * The credentials for authenticating to the MinIO instance.
+     */
+    credentials: credentialsSchema4.meta({ title: camelCaseToHumanReadable("credentials"), description: `The credentials for authenticating to the MinIO instance.` })
+  }),
   meta: {
-    description: `Represents the MariaDB database or virtual database behind it.`,
-    color: "#f06292"
+    description: `Represents a connection to a MinIO instance, including the endpoints and credentials.`,
+    color: "#C72E49"
   }
 });
-var existingMariadb = defineUnit({
-  type: "databases.mariadb.existing.v1",
-  args: sharedArgs,
-  secrets: sharedSecrets,
-  inputs: sharedInputs,
+var connection2 = defineUnit({
+  type: "minio.connection.v1",
+  args: {
+    /**
+     * The username to authenticate with.
+     */
+    username: $addArgumentDescription(z.string(), `The username to authenticate with.`),
+    /**
+     * The region of the MinIO instance.
+     *
+     * If not provided, it will default to "us-east-1".
+     */
+    region: $addArgumentDescription(z.string().default("us-east-1"), `The region of the MinIO instance.
+
+ If not provided, it will default to "us-east-1".`),
+    /**
+     * The endpoints to connect to the MinIO instance.
+     */
+    endpoints: $addArgumentDescription(z.string().array().default([]), `The endpoints to connect to the MinIO instance.`)
+  },
+  inputs: {
+    /**
+     * The endpoints to connect to the MinIO instance.
+     */
+    endpoints: $addInputDescription({
+      entity: l7EndpointEntity,
+      multiple: true,
+      required: false
+    }, `The endpoints to connect to the MinIO instance.`)
+  },
+  secrets: {
+    /**
+     * The password to authenticate with.
+     */
+    password: $addArgumentDescription(z.string(), `The password to authenticate with.`)
+  },
   outputs: {
-    mariadb: mariadbEntity
+    connection: connectionEntity4
   },
   source: {
-    package: "@highstate/common",
-    path: "units/databases/existing-mariadb"
+    package: "@highstate/minio",
+    path: "connection"
   },
   meta: {
-    description: `The existing MariaDB database or virtual database behind it.`,
-    title: "Existing MariaDB Database",
-    icon: "simple-icons:mariadb",
+    description: `The existing MinIO connection hosted on a server or a managed service.`,
+    title: "MinIO Connection",
+    icon: "simple-icons:minio",
     secondaryIcon: "mdi:database",
     category: "Databases"
   }
 });
-var mariadbPatch = defineUnit({
-  type: "databases.mariadb-patch.v1",
+var bucket = defineUnit({
+  type: "minio.bucket.v1",
   args: {
-    ...toPatchArgs(optionalSharedArgs),
-    endpoints: {
-      ...sharedArgs.endpoints,
-      schema: z.string().array().default([])
-    }
+    /**
+     * The name of the bucket to create.
+     *
+     * Defaults to the name of the unit if not provided.
+     */
+    bucketName: $addArgumentDescription(z.string().optional(), `The name of the bucket to create.
+
+ Defaults to the name of the unit if not provided.`),
+    /**
+     * The quota for the bucket as string with size suffix, e.g. "10GB". If not provided, the bucket will have no quota.
+     */
+    quota: $addArgumentDescription(z.string().optional(), `The quota for the bucket as string with size suffix, e.g. "10GB". If not provided, the bucket will have no quota.`)
   },
   inputs: {
-    mariadb: mariadbEntity,
-    ...sharedInputs
+    /**
+     * The connection to the MinIO instance where the bucket should be created.
+     */
+    connection: $addInputDescription(connectionEntity4, `The connection to the MinIO instance where the bucket should be created.`)
   },
   outputs: {
-    mariadb: mariadbEntity
+    /**
+     * The created bucket.
+     */
+    bucket: $addInputDescription(bucketEntity, `The created bucket.`)
   },
   source: {
-    package: "@highstate/common",
-    path: "units/databases/mariadb-patch"
+    package: "@highstate/minio",
+    path: "bucket"
   },
   meta: {
-    description: `Patches some properties of the MariaDB database and outputs the updated database.`,
-    title: "MariaDB Patch",
-    icon: "simple-icons:mariadb",
-    secondaryIcon: "fluent:patch-20-filled",
+    description: `Creates a bucket on a MinIO instance.`,
+    title: "MinIO Bucket",
+    icon: "simple-icons:minio",
+    secondaryIcon: "mdi:database",
     category: "Databases"
   }
 });
-var mongodbEntity = defineEntity({
-  type: "databases.mongodb.v1",
+
+// src/databases/mongodb.ts
+var mongodb_exports = {};
+__export(mongodb_exports, {
+  connection: () => connection3,
+  connectionEntity: () => connectionEntity5,
+  credentialsSchema: () => credentialsSchema5,
+  database: () => database2
+});
+var credentialsSchema5 = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("password"),
+    /**
+     * The username used to authenticate against the database.
+     */
+    username: z.string().meta({ title: camelCaseToHumanReadable("username"), description: `The username used to authenticate against the database.` }),
+    /**
+     * The password used to authenticate against the database.
+     */
+    password: secretSchema(z.string()).meta({ title: camelCaseToHumanReadable("password"), description: `The password used to authenticate against the database.` })
+  })
+]);
+var connectionEntity5 = defineEntity({
+  type: "mongodb.connection.v1",
+  extends: { l4EndpointContainer },
   includes: {
-    endpoints: {
-      entity: l4EndpointEntity,
-      multiple: true
+    /**
+     * The TLS certificate of the server if any.
+     */
+    certificate: {
+      entity: certificateEntity,
+      required: false
     }
   },
-  schema: sharedSchema,
+  schema: z.object({
+    /**
+     * The credentials for authenticating to the MongoDB instance.
+     */
+    credentials: credentialsSchema5.meta({ title: camelCaseToHumanReadable("credentials"), description: `The credentials for authenticating to the MongoDB instance.` }),
+    /**
+     * The name of the database to operate on.
+     */
+    database: z.string().optional().meta({ title: camelCaseToHumanReadable("database"), description: `The name of the database to operate on.` })
+  }),
   meta: {
-    description: `Represents the MongoDB database or virtual database behind it.`,
+    description: `Represents a connection to a MongoDB instance, including the endpoints and credentials.`,
     color: "#13aa52"
   }
 });
-var existingMongodb = defineUnit({
-  type: "databases.mongodb.existing.v1",
-  args: sharedArgs,
-  secrets: sharedSecrets,
-  inputs: sharedInputs,
+var connection3 = defineUnit({
+  type: "mongodb.connection.v1",
+  args: {
+    /**
+     * The username to authenticate with.
+     */
+    username: $addArgumentDescription(z.string(), `The username to authenticate with.`),
+    /**
+     * The endpoints to connect to the MongoDB instance in form of `host:port`.
+     */
+    endpoints: $addArgumentDescription(z.string().array().default([]), `The endpoints to connect to the MongoDB instance in form of \`host:port\`.`)
+  },
+  inputs: {
+    /**
+     * The endpoints to connect to the MongoDB instance.
+     */
+    endpoints: $addInputDescription({
+      entity: l4EndpointEntity,
+      multiple: true,
+      required: false
+    }, `The endpoints to connect to the MongoDB instance.`)
+  },
+  secrets: {
+    /**
+     * The password to authenticate with.
+     */
+    password: $addArgumentDescription(z.string(), `The password to authenticate with.`)
+  },
   outputs: {
-    mongodb: mongodbEntity
+    connection: connectionEntity5
   },
   source: {
-    package: "@highstate/common",
-    path: "units/databases/existing-mongodb"
+    package: "@highstate/mongodb",
+    path: "units/connection"
   },
   meta: {
-    description: `The existing MongoDB database or virtual database behind it.`,
-    title: "Existing MongoDB Database",
+    description: `The existing MongoDB connection hosted on a server or a managed service.`,
+    title: "MongoDB Connection",
     icon: "simple-icons:mongodb",
     secondaryIcon: "mdi:database",
     category: "Databases"
   }
 });
-var mongodbPatch = defineUnit({
-  type: "databases.mongodb-patch.v1",
+var database2 = defineUnit({
+  type: "mongodb.database.v1",
   args: {
-    ...toPatchArgs(optionalSharedArgs),
-    endpoints: {
-      ...sharedArgs.endpoints,
-      schema: z.string().array().default([])
-    }
+    /**
+     * The name of the database.
+     *
+     * If not provided, it will be set to the unit name.
+     */
+    databaseName: $addArgumentDescription(z.string().optional(), `The name of the database.
+
+ If not provided, it will be set to the unit name.`),
+    /**
+     * The username to create.
+     *
+     * If not provided, it will be set to the database name.
+     */
+    username: $addArgumentDescription(z.string().optional(), `The username to create.
+
+ If not provided, it will be set to the database name.`)
   },
   inputs: {
-    mongodb: mongodbEntity,
-    ...sharedInputs
+    /**
+     * The connection to the MongoDB instance where the database should be created.
+     */
+    connection: $addInputDescription(connectionEntity5, `The connection to the MongoDB instance where the database should be created.`)
   },
-  outputs: {
-    mongodb: mongodbEntity
+  secrets: {
+    /**
+     * The password of the created user.
+     *
+     * If not provided, a random password will be generated.
+     */
+    password: $addArgumentDescription(z.string().optional(), `The password of the created user.
+
+ If not provided, a random password will be generated.`)
   },
-  source: {
-    package: "@highstate/common",
-    path: "units/databases/mongodb-patch"
+  outputs: {
+    connection: connectionEntity5
   },
   meta: {
-    description: `Patches some properties of the MongoDB database and outputs the updated database.`,
-    title: "MongoDB Patch",
+    description: `Creates a database in a MongoDB instance.`,
+    title: "MongoDB Database",
     icon: "simple-icons:mongodb",
-    secondaryIcon: "fluent:patch-20-filled",
+    secondaryIcon: "mdi:database-plus",
     category: "Databases"
+  },
+  source: {
+    package: "@highstate/mongodb",
+    path: "units/database"
   }
 });
-var postgresqlEntity = defineEntity({
-  type: "databases.postgresql.v1",
+
+// src/databases/mysql.ts
+var mysql_exports = {};
+__export(mysql_exports, {
+  connection: () => connection4,
+  connectionEntity: () => connectionEntity6,
+  credentialsSchema: () => credentialsSchema6,
+  database: () => database3
+});
+var credentialsSchema6 = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("password"),
+    /**
+     * The username used to authenticate against the database.
+     */
+    username: z.string().meta({ title: camelCaseToHumanReadable("username"), description: `The username used to authenticate against the database.` }),
+    /**
+     * The password used to authenticate against the database.
+     */
+    password: secretSchema(z.string()).meta({ title: camelCaseToHumanReadable("password"), description: `The password used to authenticate against the database.` })
+  })
+]);
+var connectionEntity6 = defineEntity({
+  type: "mysql.connection.v1",
+  extends: { l4EndpointContainer },
   includes: {
-    endpoints: {
-      entity: l4EndpointEntity,
-      multiple: true
+    /**
+     * The TLS certificate of the server if any.
+     */
+    certificate: {
+      entity: certificateEntity,
+      required: false
     }
   },
-  schema: sharedSchema,
+  schema: z.object({
+    /**
+     * The credentials for authenticating to the MySQL instance.
+     */
+    credentials: credentialsSchema6.meta({ title: camelCaseToHumanReadable("credentials"), description: `The credentials for authenticating to the MySQL instance.` }),
+    /**
+     * The optional name of the database to operate on.
+     */
+    database: z.string().optional().meta({ title: camelCaseToHumanReadable("database"), description: `The optional name of the database to operate on.` })
+  }),
   meta: {
-    description: `Represents the PostgreSQL database or virtual database behind it.`,
-    color: "#336791"
+    description: `Represents a connection to a MySQL instance, including the endpoints and credentials.`,
+    color: "#f06292"
   }
 });
-var existingPostgresql = defineUnit({
-  type: "databases.postgresql.existing.v1",
-  args: sharedArgs,
-  secrets: sharedSecrets,
-  inputs: sharedInputs,
+var connection4 = defineUnit({
+  type: "mysql.connection.v1",
+  args: {
+    /**
+     * The username to authenticate with.
+     */
+    username: $addArgumentDescription(z.string(), `The username to authenticate with.`),
+    /**
+     * The endpoints to connect to the MySQL instance in form of `host:port`.
+     */
+    endpoints: $addArgumentDescription(z.string().array().default([]), `The endpoints to connect to the MySQL instance in form of \`host:port\`.`)
+  },
+  inputs: {
+    /**
+     * The endpoints to connect to the MySQL instance.
+     */
+    endpoints: $addInputDescription({
+      entity: l4EndpointEntity,
+      multiple: true,
+      required: false
+    }, `The endpoints to connect to the MySQL instance.`)
+  },
+  secrets: {
+    /**
+     * The password to authenticate with.
+     */
+    password: $addArgumentDescription(z.string(), `The password to authenticate with.`)
+  },
   outputs: {
-    postgresql: postgresqlEntity
+    connection: connectionEntity6
   },
   source: {
-    package: "@highstate/common",
-    path: "units/databases/existing-postgresql"
+    package: "@highstate/mysql",
+    path: "units/connection"
   },
   meta: {
-    description: `The existing PostgreSQL database or virtual database behind it.`,
-    title: "Existing PostgreSQL Database",
-    icon: "simple-icons:postgresql",
+    description: `The existing MySQL connection hosted on a server or a managed service.`,
+    title: "MySQL Connection",
+    icon: "simple-icons:mysql",
     secondaryIcon: "mdi:database",
     category: "Databases"
   }
 });
-var postgresqlPatch = defineUnit({
-  type: "databases.postgresql-patch.v1",
+var database3 = defineUnit({
+  type: "mysql.database.v1",
   args: {
-    ...toPatchArgs(optionalSharedArgs),
     /**
-     * The endpoints to connect to the database in form of `host:port`.
+     * The name of the database.
+     *
+     * If not provided, it will be set to the unit name.
+     */
+    databaseName: $addArgumentDescription(z.string().optional(), `The name of the database.
+
+ If not provided, it will be set to the unit name.`),
+    /**
+     * The username of the database admin user to create.
      *
-     * If at least one endpoint is provided (either via args or inputs), the existing endpoints
-     * will be replaced completely.
+     * If not provided, it will be set to the database name.
      */
-    endpoints: $addArgumentDescription(z.string().array().default([]), `The endpoints to connect to the database in form of \`host:port\`.
+    username: $addArgumentDescription(z.string().optional(), `The username of the database admin user to create.
 
- If at least one endpoint is provided (either via args or inputs), the existing endpoints
- will be replaced completely.`)
+ If not provided, it will be set to the database name.`)
   },
   inputs: {
-    postgresql: postgresqlEntity,
-    ...sharedInputs
+    /**
+     * The connection to the MySQL instance where the database should be created.
+     */
+    connection: $addInputDescription(connectionEntity6, `The connection to the MySQL instance where the database should be created.`)
   },
-  outputs: {
-    postgresql: postgresqlEntity
+  secrets: {
+    /**
+     * The password of the created user.
+     *
+     * If not provided, a random password will be generated.
+     */
+    password: $addArgumentDescription(z.string().optional(), `The password of the created user.
+
+ If not provided, a random password will be generated.`)
   },
-  source: {
-    package: "@highstate/common",
-    path: "units/databases/postgresql-patch"
+  outputs: {
+    connection: connectionEntity6
   },
   meta: {
-    description: `Patches some properties of the PostgreSQL database and outputs the updated database.`,
-    title: "PostgreSQL Patch",
-    icon: "simple-icons:postgresql",
-    secondaryIcon: "fluent:patch-20-filled",
+    description: `Creates a database in a MySQL instance.`,
+    title: "MySQL Database",
+    icon: "simple-icons:mysql",
+    secondaryIcon: "mdi:database-plus",
     category: "Databases"
+  },
+  source: {
+    package: "@highstate/mysql",
+    path: "units/database"
   }
 });
-var redisEntity = defineEntity({
-  type: "databases.redis.v1",
+
+// src/databases/postgresql.ts
+var postgresql_exports = {};
+__export(postgresql_exports, {
+  connection: () => connection5,
+  connectionEntity: () => connectionEntity7,
+  credentialsSchema: () => credentialsSchema7,
+  database: () => database4
+});
+var credentialsSchema7 = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("password"),
+    /**
+     * The username used to authenticate against the database.
+     */
+    username: z.string().meta({ title: camelCaseToHumanReadable("username"), description: `The username used to authenticate against the database.` }),
+    /**
+     * The password used to authenticate against the database.
+     */
+    password: secretSchema(z.string()).meta({ title: camelCaseToHumanReadable("password"), description: `The password used to authenticate against the database.` })
+  })
+]);
+var connectionEntity7 = defineEntity({
+  type: "postgresql.connection.v1",
+  extends: { l4EndpointContainer },
   includes: {
-    endpoints: {
-      entity: l4EndpointEntity,
-      multiple: true
+    /**
+     * The TLS certificate of the server if any.
+     */
+    certificate: {
+      entity: certificateEntity,
+      required: false
     }
   },
   schema: z.object({
     /**
-     * The number of the database to use.
+     * Whether SSL is not required to connect to the database.
+     */
+    insecure: z.boolean().default(false).meta({ title: camelCaseToHumanReadable("insecure"), description: `Whether SSL is not required to connect to the database.` }),
+    /**
+     * The credentials for authenticating to the PostgreSQL instance.
      */
-    database: z.number().default(0).meta({ title: camelCaseToHumanReadable("database"), description: `The number of the database to use.` })
+    credentials: credentialsSchema7.meta({ title: camelCaseToHumanReadable("credentials"), description: `The credentials for authenticating to the PostgreSQL instance.` }),
+    /**
+     * The name of the database to operate on.
+     */
+    database: z.string().optional().meta({ title: camelCaseToHumanReadable("database"), description: `The name of the database to operate on.` })
   }),
   meta: {
-    description: `Represents the Redis database or virtual database behind it.`,
-    color: "#dc382d"
+    description: `Represents a connection to a PostgreSQL instance, including the endpoints and credentials.`,
+    color: "#336791"
   }
 });
-var existingRedis = defineUnit({
-  type: "databases.redis.existing.v1",
-  args: sharedArgs,
-  inputs: sharedInputs,
+var connection5 = defineUnit({
+  type: "postgresql.connection.v1",
+  args: {
+    /**
+     * The username to authenticate with.
+     */
+    username: $addArgumentDescription(z.string(), `The username to authenticate with.`),
+    /**
+     * The endpoints to connect to the PostgreSQL instance in form of `host:port`.
+     */
+    endpoints: $addArgumentDescription(z.string().array().default([]), `The endpoints to connect to the PostgreSQL instance in form of \`host:port\`.`)
+  },
+  inputs: {
+    /**
+     * The endpoints to connect to the PostgreSQL instance.
+     */
+    endpoints: $addInputDescription({
+      entity: l4EndpointEntity,
+      multiple: true,
+      required: false
+    }, `The endpoints to connect to the PostgreSQL instance.`)
+  },
+  secrets: {
+    /**
+     * The password to authenticate with.
+     */
+    password: $addArgumentDescription(z.string(), `The password to authenticate with.`)
+  },
   outputs: {
-    redis: redisEntity
+    connection: connectionEntity7
   },
   source: {
-    package: "@highstate/common",
-    path: "units/databases/existing-redis"
+    package: "@highstate/postgresql",
+    path: "units/connection"
   },
   meta: {
-    description: `The existing Redis database or virtual database behind it.`,
-    title: "Existing Redis Database",
-    icon: "simple-icons:redis",
+    description: `The existing PostgreSQL connection hosted on a server or a managed service.`,
+    title: "PostgreSQL Connection",
+    icon: "simple-icons:postgresql",
     secondaryIcon: "mdi:database",
     category: "Databases"
   }
 });
-var redisPatch = defineUnit({
-  type: "databases.redis-patch.v1",
+var database4 = defineUnit({
+  type: "postgresql.database.v1",
   args: {
-    ...toPatchArgs(optionalSharedArgs),
-    endpoints: {
-      ...sharedArgs.endpoints,
-      schema: z.string().array().default([])
-    }
+    /**
+     * The name of the database.
+     *
+     * If not provided, it will be set to the unit name.
+     */
+    databaseName: $addArgumentDescription(z.string().optional(), `The name of the database.
+
+ If not provided, it will be set to the unit name.`),
+    /**
+     * The username to create.
+     *
+     * If not provided, it will be set to the database name.
+     */
+    username: $addArgumentDescription(z.string().optional(), `The username to create.
+
+ If not provided, it will be set to the database name.`),
+    /**
+     * The LC_COLLATE setting for the database, which determines the collation order (i.e., how string comparison is performed).
+     */
+    lcCollate: $addArgumentDescription(z.string().optional(), `The LC_COLLATE setting for the database, which determines the collation order (i.e., how string comparison is performed).`),
+    /**
+     * The LC_CTYPE setting for the database, which determines the character classification (i.e., how characters are categorized and compared).
+     */
+    lcCtype: $addArgumentDescription(z.string().optional(), `The LC_CTYPE setting for the database, which determines the character classification (i.e., how characters are categorized and compared).`)
   },
   inputs: {
-    redis: redisEntity,
-    ...sharedInputs
+    /**
+     * The connection to the PostgreSQL instance where the database should be created.
+     */
+    connection: $addInputDescription(connectionEntity7, `The connection to the PostgreSQL instance where the database should be created.`)
   },
-  outputs: {
-    redis: redisEntity
+  secrets: {
+    /**
+     * The password of the created user.
+     *
+     * If not provided, a random password will be generated.
+     */
+    password: $addArgumentDescription(z.string().optional(), `The password of the created user.
+
+ If not provided, a random password will be generated.`)
   },
-  source: {
-    package: "@highstate/common",
-    path: "units/databases/redis-patch"
+  outputs: {
+    connection: connectionEntity7
   },
   meta: {
-    description: `Patches some properties of the Redis database and outputs the updated database.`,
-    title: "Redis Patch",
-    icon: "simple-icons:redis",
-    secondaryIcon: "fluent:patch-20-filled",
+    description: `Creates a database in a PostgreSQL instance.`,
+    title: "PostgreSQL Database",
+    icon: "simple-icons:postgresql",
+    secondaryIcon: "mdi:database-plus",
     category: "Databases"
+  },
+  source: {
+    package: "@highstate/postgresql",
+    path: "units/database"
   }
 });
-var s3BucketPolicySchema = z.enum(["none", "download", "upload", "public"]);
-var s3BucketSchema = z.object({
-  /**
-   * The name of the bucket.
-   */
-  name: z.string().meta({ title: camelCaseToHumanReadable("name"), description: `The name of the bucket.` }),
-  /**
-   * The optional policy applied to the bucket.
-   */
-  policy: s3BucketPolicySchema.optional().meta({ title: camelCaseToHumanReadable("policy"), description: `The optional policy applied to the bucket.` })
-});
-var s3Args = $args({
-  /**
-   * The endpoints to connect to the S3-compatible API in form of `host:port`.
-   */
-  endpoints: $addArgumentDescription(z.string().array().min(1), `The endpoints to connect to the S3-compatible API in form of \`host:port\`.`),
-  /**
-   * The access key used to authenticate against the S3-compatible API.
-   */
-  accessKey: $addArgumentDescription(z.string(), `The access key used to authenticate against the S3-compatible API.`),
-  /**
-   * The region associated with the S3-compatible deployment.
-   */
-  region: $addArgumentDescription(z.string().optional(), `The region associated with the S3-compatible deployment.`),
-  /**
-   * The buckets that must exist on the instance.
-   */
-  buckets: $addArgumentDescription(s3BucketSchema.array().default([]), `The buckets that must exist on the instance.`)
-});
-var optionalS3Args = mapValues(s3Args, (arg) => ({
-  ...arg,
-  schema: arg.schema.optional()
-}));
-var s3Secrets = $secrets({
-  /**
-   * The secret key used to authenticate against the S3-compatible API.
-   */
-  secretKey: $addArgumentDescription(z.string(), `The secret key used to authenticate against the S3-compatible API.`)
+
+// src/databases/redis.ts
+var redis_exports = {};
+__export(redis_exports, {
+  connection: () => connection6,
+  connectionEntity: () => connectionEntity8,
+  credentialsSchema: () => credentialsSchema8,
+  databaseNumberSchema: () => databaseNumberSchema,
+  namespace: () => namespace2,
+  namespaceEntity: () => namespaceEntity
 });
-var s3Inputs = $inputs({
+var credentialsSchema8 = z.object({
   /**
-   * The endpoints to connect to the S3-compatible API.
+   * The username used to authenticate against the database.
    */
-  endpoints: $addInputDescription({
-    entity: l4EndpointEntity,
-    multiple: true,
-    required: false
-  }, `The endpoints to connect to the S3-compatible API.`)
+  username: z.string().optional().meta({ title: camelCaseToHumanReadable("username"), description: `The username used to authenticate against the database.` }),
+  /**
+   * The password used to authenticate against the database.
+   */
+  password: secretSchema(z.string()).optional().meta({ title: camelCaseToHumanReadable("password"), description: `The password used to authenticate against the database.` })
 });
-var s3Entity = defineEntity({
-  type: "databases.s3.v1",
-  includes: {
-    endpoints: {
-      entity: l4EndpointEntity,
-      multiple: true
-    }
-  },
+var databaseNumberSchema = z.number().nonnegative().max(15);
+var connectionEntity8 = defineEntity({
+  type: "redis.connection.v1",
+  extends: { l4EndpointContainer },
   schema: z.object({
     /**
-     * The region associated with the object storage instance.
+     * The credentials for authenticating to the Redis instance.
+     */
+    credentials: credentialsSchema8.optional().meta({ title: camelCaseToHumanReadable("credentials"), description: `The credentials for authenticating to the Redis instance.` })
+  }),
+  meta: {
+    description: `Represents a connection to a Redis instance, including the endpoints and credentials.`,
+    color: "#dc382d"
+  }
+});
+var connection6 = defineUnit({
+  type: "redis.connection.existing.v1",
+  args: {
+    /**
+     * The username to authenticate with.
      */
-    region: z.string().optional().meta({ title: camelCaseToHumanReadable("region"), description: `The region associated with the object storage instance.` }),
+    username: $addArgumentDescription(z.string().optional(), `The username to authenticate with.`),
     /**
-     * The access key used to authenticate against the API.
+     * The endpoints to connect to the database in form of `host:port`.
      */
-    accessKey: z.string().meta({ title: camelCaseToHumanReadable("accessKey"), description: `The access key used to authenticate against the API.` }),
+    endpoints: $addArgumentDescription(z.string().array().default([]), `The endpoints to connect to the database in form of \`host:port\`.`)
+  },
+  inputs: {
     /**
-     * The secret key used to authenticate against the API.
+     * The endpoints to connect to the database.
      */
-    secretKey: z.string().meta({ title: camelCaseToHumanReadable("secretKey"), description: `The secret key used to authenticate against the API.` }),
+    endpoints: $addInputDescription({
+      entity: l4EndpointEntity,
+      multiple: true,
+      required: false
+    }, `The endpoints to connect to the database.`)
+  },
+  secrets: {
     /**
-     * The buckets that must exist on the instance.
+     * The password to authenticate with.
      */
-    buckets: s3BucketSchema.array().meta({ title: camelCaseToHumanReadable("buckets"), description: `The buckets that must exist on the instance.` })
-  }),
-  meta: {
-    description: `Represents an S3-compatible object storage endpoint.`,
-    color: "#ff9900"
-  }
-});
-var existingS3 = defineUnit({
-  type: "databases.s3.existing.v1",
-  args: s3Args,
-  secrets: s3Secrets,
-  inputs: s3Inputs,
+    password: $addArgumentDescription(z.string().optional(), `The password to authenticate with.`)
+  },
   outputs: {
-    s3: s3Entity
+    connection: connectionEntity8
   },
   source: {
-    package: "@highstate/common",
-    path: "units/databases/existing-s3"
+    package: "@highstate/redis",
+    path: "units/connection"
   },
   meta: {
-    description: `The existing S3-compatible object storage instance.`,
-    title: "Existing S3-Compatible Storage",
-    icon: "simple-icons:amazons3",
-    secondaryIcon: "mdi:bucket",
+    description: `The existing Redis connection hosted on a server or a managed service.`,
+    title: "Redis Connection",
+    icon: "simple-icons:redis",
+    secondaryIcon: "mdi:database",
     category: "Databases"
   }
 });
-var s3Patch = defineUnit({
-  type: "databases.s3-patch.v1",
+var namespaceEntity = defineEntity({
+  type: "redis.namespace.v1",
+  extends: { connectionEntity: connectionEntity8 },
+  schema: z.object({
+    /**
+     * The number of the database to use.
+     */
+    database: databaseNumberSchema.default(0).meta({ title: camelCaseToHumanReadable("database"), description: `The number of the database to use.` }),
+    /**
+     * The prefix of the namespace in the Redis database.
+     */
+    prefix: z.string().optional().meta({ title: camelCaseToHumanReadable("prefix"), description: `The prefix of the namespace in the Redis database.` })
+  }),
+  meta: {
+    description: `Represents a Redis namespace within a database.`,
+    color: "#0064bf"
+  }
+});
+var namespace2 = defineUnit({
+  type: "redis.database.v1",
   args: {
-    ...toPatchArgs(optionalS3Args),
-    endpoints: {
-      ...s3Args.endpoints,
-      schema: z.string().array().default([])
-    }
+    /**
+     * The number of the database to use.
+     */
+    database: $addArgumentDescription(databaseNumberSchema.default(0), `The number of the database to use.`),
+    /**
+     * The prefix of the namespace in the Redis database.
+     */
+    prefix: $addArgumentDescription(z.string().optional(), `The prefix of the namespace in the Redis database.`)
   },
   inputs: {
-    s3: s3Entity,
-    ...s3Inputs
+    /**
+     * The connection to the Redis instance.
+     */
+    connection: $addInputDescription(connectionEntity8, `The connection to the Redis instance.`)
   },
   outputs: {
-    s3: s3Entity
-  },
-  source: {
-    package: "@highstate/common",
-    path: "units/databases/s3-patch"
+    namespace: namespaceEntity
   },
   meta: {
-    description: `Patches some properties of the S3-compatible object storage and outputs the updated storage.`,
-    title: "S3 Patch",
-    icon: "simple-icons:amazons3",
-    secondaryIcon: "fluent:patch-20-filled",
+    description: `Creates a Redis namespace within an existing Redis connection.`,
+    title: "Redis Database",
+    icon: "simple-icons:redis",
+    secondaryIcon: "mdi:database",
     category: "Databases"
+  },
+  source: {
+    package: "@highstate/redis",
+    path: "units/database"
   }
 });
 
@@ -2065,7 +2780,11 @@ var resourceEntity = defineEntity({
     ])
   ),
   meta: {
-    description: `The entity which represents a Kubernetes resource.`
+    description: `The entity which represents a Kubernetes resource.`,
+    color: "#607D8B",
+    title: "Resource",
+    icon: "devicon:kubernetes",
+    iconColor: "#607D8B"
   }
 });
 var namespacedResourceEntity = defineEntity({
@@ -2075,16 +2794,23 @@ var namespacedResourceEntity = defineEntity({
     isNamespaced: z.literal(true)
   }),
   meta: {
-    description: `The entity which represents a Kubernetes resource scoped to a namespace.`
+    description: `The entity which represents a Kubernetes resource scoped to a namespace.`,
+    color: "#78909C",
+    title: "Namespaced Resource",
+    icon: "devicon:kubernetes",
+    iconColor: "#78909C"
   }
 });
-var namespaceEntity = defineEntity({
+var namespaceEntity2 = defineEntity({
   type: "k8s.namespace.v1",
   extends: { resourceEntity },
   schema: z.unknown(),
   meta: {
     description: `The entity which represents a Kubernetes namespace managed by Highstate.`,
-    color: "#9E9E9E"
+    color: "#9E9E9E",
+    title: "Namespace",
+    icon: "devicon:kubernetes",
+    iconColor: "#9E9E9E"
   }
 });
 var persistentVolumeClaimEntity = defineEntity({
@@ -2093,7 +2819,10 @@ var persistentVolumeClaimEntity = defineEntity({
   schema: z.unknown(),
   meta: {
     description: `The entity which represents a Kubernetes persistent volume claim managed by Highstate.`,
-    color: "#FFC107"
+    color: "#FFC107",
+    title: "Persistent Volume Claim",
+    icon: "devicon:kubernetes",
+    iconColor: "#FFC107"
   }
 });
 var gatewayEntity2 = defineEntity({
@@ -2102,15 +2831,21 @@ var gatewayEntity2 = defineEntity({
   schema: z.unknown(),
   meta: {
     description: `The entity which represents a Gateway resource from the Gateway API.`,
-    color: "#4CAF50"
+    color: "#4CAF50",
+    title: "Gateway",
+    icon: "devicon:kubernetes",
+    iconColor: "#4CAF50"
   }
 });
-var certificateEntity = defineEntity({
+var certificateEntity2 = defineEntity({
   type: "k8s.certificate.v1",
   extends: { namespacedResourceEntity },
   schema: z.unknown(),
   meta: {
-    color: "#3F51B5"
+    color: "#3F51B5",
+    title: "Certificate",
+    icon: "devicon:kubernetes",
+    iconColor: "#3F51B5"
   }
 });
 var configMapEntity = defineEntity({
@@ -2118,7 +2853,10 @@ var configMapEntity = defineEntity({
   extends: { namespacedResourceEntity },
   schema: z.unknown(),
   meta: {
-    color: "#FF9800"
+    color: "#FF9800",
+    title: "ConfigMap",
+    icon: "devicon:kubernetes",
+    iconColor: "#FF9800"
   }
 });
 var secretEntity = defineEntity({
@@ -2126,7 +2864,10 @@ var secretEntity = defineEntity({
   extends: { namespacedResourceEntity },
   schema: z.unknown(),
   meta: {
-    color: "#9C27B0"
+    color: "#9C27B0",
+    title: "Secret",
+    icon: "devicon:kubernetes",
+    iconColor: "#9C27B0"
   }
 });
 
@@ -2202,18 +2943,6 @@ var clusterInfoProperties = {
    * If not provided, the native Kubernetes NetworkPolicy implementation will be used.
    */
   networkPolicyImplRef: implementationReferenceSchema.optional(),
-  /**
-   * The endpoints of the API server.
-   *
-   * The entry may represent real node endpoint or virtual endpoint (like a load balancer).
-   *
-   * The same node may also be represented by multiple entries (e.g. a node with private and public IP).
-   */
-  apiEndpoints: l4EndpointEntity.schema.array(),
-  /**
-   * The external IPs of the cluster nodes allowed to be used for external access.
-   */
-  externalIps: addressEntity.schema.array(),
   /**
    * The extra quirks of the cluster to improve compatibility.
    */
@@ -2226,6 +2955,17 @@ var clusterInfoProperties = {
 var clusterEntity = defineEntity({
   type: "k8s.cluster.v1",
   includes: {
+    /**
+     * The endpoints of the API server.
+     *
+     * The entry may represent real node endpoint or virtual endpoint (like a load balancer).
+     *
+     * The same node may also be represented by multiple entries (e.g. a node with private and public IP).
+     */
+    apiEndpoints: {
+      entity: l4EndpointEntity,
+      multiple: true
+    },
     /**
      * The endpoints of the cluster nodes.
      *
@@ -2235,15 +2975,30 @@ var clusterEntity = defineEntity({
      */
     endpoints: {
       entity: l3EndpointEntity,
-      multiple: true
-    }
+      multiple: true,
+      required: false
+    },
+    /**
+     * The external IPs of the cluster nodes allowed to be used for external access.
+     */
+    externalIps: {
+      entity: addressEntity,
+      multiple: true,
+      required: false
+    },
+    /**
+     * The kubeconfig file to use for connecting to the cluster.
+     */
+    kubeconfig: fileEntity
   },
   schema: z.object({
-    ...clusterInfoProperties,
-    kubeconfig: z.string()
+    ...clusterInfoProperties
   }),
   meta: {
-    color: "#2196F3"
+    color: "#2196F3",
+    title: "K8S Cluster",
+    icon: "devicon:kubernetes",
+    iconColor: "#2196F3"
   }
 });
 var internalIpsPolicySchema = z.enum(["always", "public", "never"]);
@@ -2406,6 +3161,12 @@ var monitorWorkerParamsSchema = z.object({
    */
   resources: namespacedResourceEntity.schema.array().meta({ title: camelCaseToHumanReadable("resources"), description: `The resources to monitor in the cluster.` })
 });
+var tolerationSchema = z.object({
+  key: z.string().optional(),
+  operator: z.enum(["Exists", "Equal"]),
+  value: z.string().optional(),
+  effect: z.enum(["NoSchedule", "PreferNoSchedule", "NoExecute"]).optional()
+});
 
 // src/k3s.ts
 var packagedComponents = [
@@ -2466,6 +3227,14 @@ var cluster = defineUnit({
     agentConfig: $addArgumentDescription(z.record(z.string(), z.unknown()).optional(), `The K3S configuration to pass to each agent in the cluster.
 
  See: https://docs.k3s.io/installation/configuration`),
+    /**
+     * The map of configuration per each node in the cluster, where the key is the hostname of the node.
+     *
+     * Note: if multiple nodes have the same hostname, the configuration will be applied to all of them.
+     */
+    nodeConfig: $addArgumentDescription(z.record(z.string(), z.record(z.string(), z.unknown())).optional(), `The map of configuration per each node in the cluster, where the key is the hostname of the node.
+
+ Note: if multiple nodes have the same hostname, the configuration will be applied to all of them.`),
     /**
      * The configuration of the registries to use for the K3S cluster.
      *
@@ -2497,7 +3266,7 @@ __export(k8s_exports, {
   acessRuleSchema: () => acessRuleSchema,
   apps: () => apps_exports,
   certManager: () => certManager,
-  certificateEntity: () => certificateEntity,
+  certificateEntity: () => certificateEntity2,
   cilium: () => cilium,
   ciliumClusterMetadata: () => ciliumClusterMetadata,
   clusterEntity: () => clusterEntity,
@@ -2511,7 +3280,6 @@ __export(k8s_exports, {
   deploymentEntity: () => deploymentEntity,
   dns01TlsIssuer: () => dns01TlsIssuer,
   existingCluster: () => existingCluster,
-  exposableWorkloadEntity: () => exposableWorkloadEntity,
   externalServiceTypeSchema: () => externalServiceTypeSchema,
   fallbackKubeApiAccessSchema: () => fallbackKubeApiAccessSchema,
   gameServers: () => game_servers_exports,
@@ -2524,7 +3292,7 @@ __export(k8s_exports, {
   metadataSchema: () => metadataSchema2,
   monitorWorkerParamsSchema: () => monitorWorkerParamsSchema,
   monitorWorkerResourceGroupSchema: () => monitorWorkerResourceGroupSchema,
-  namespaceEntity: () => namespaceEntity,
+  namespaceEntity: () => namespaceEntity2,
   namespacedMetadataSchema: () => namespacedMetadataSchema,
   namespacedResourceEntity: () => namespacedResourceEntity,
   networkInterfaceEntity: () => networkInterfaceEntity,
@@ -2541,6 +3309,7 @@ __export(k8s_exports, {
   serviceTypeSchema: () => serviceTypeSchema,
   statefulSetEntity: () => statefulSetEntity,
   tlsIssuerDataSchema: () => tlsIssuerDataSchema,
+  tolerationSchema: () => tolerationSchema,
   tunDevicePolicySchema: () => tunDevicePolicySchema,
   workloadEntity: () => workloadEntity
 });
@@ -2554,25 +3323,24 @@ __export(apps_exports, {
   databaseConfigKeySchema: () => databaseConfigKeySchema,
   environmentVariableSchema: () => environmentVariableSchema,
   etcd: () => etcd,
+  grafana: () => grafana,
   grocy: () => grocy,
   hubble: () => hubble,
-  kubernetesDashboard: () => kubernetesDashboard,
   mariadb: () => mariadb,
-  mariadbDatabase: () => mariadbDatabase,
-  maybe: () => maybe,
+  matrixStack: () => matrixStack,
   minio: () => minio,
   mongodb: () => mongodb,
-  mongodbDatabase: () => mongodbDatabase,
   node: () => node,
-  optionalSharedArgs: () => optionalSharedArgs2,
+  optionalSharedArgs: () => optionalSharedArgs,
   optionalSharedInputs: () => optionalSharedInputs,
+  portal: () => portal,
   postgresql: () => postgresql,
-  postgresqlDatabase: () => postgresqlDatabase,
+  refluxdb: () => refluxdb,
   remnawave: () => remnawave,
   remnawaveEntity: () => remnawaveEntity,
-  sharedArgs: () => sharedArgs2,
-  sharedInputs: () => sharedInputs2,
-  sharedSecrets: () => sharedSecrets2,
+  sharedArgs: () => sharedArgs,
+  sharedInputs: () => sharedInputs,
+  sharedSecrets: () => sharedSecrets,
   syncthing: () => syncthing,
   traefik: () => traefik,
   valkey: () => valkey,
@@ -2624,12 +3392,16 @@ var serviceEntity = defineEntity({
   includes: {
     endpoints: {
       entity: l4EndpointEntity,
-      multiple: true
+      multiple: true,
+      required: false
     }
   },
   schema: z.unknown(),
   meta: {
-    color: "#2196F3"
+    color: "#2196F3",
+    title: "Service",
+    icon: "devicon:kubernetes",
+    iconColor: "#2196F3"
   }
 });
 var serviceTypeSchema = z.enum(["NodePort", "LoadBalancer", "ClusterIP"]);
@@ -2638,10 +3410,38 @@ var serviceTypeSchema = z.enum(["NodePort", "LoadBalancer", "ClusterIP"]);
 var workloadEntity = defineEntity({
   type: "k8s.workload.v1",
   extends: { namespacedResourceEntity },
-  schema: z.unknown(),
+  includes: {
+    service: {
+      entity: serviceEntity,
+      required: false
+    }
+  },
+  schema: z.object({
+    spec: z.object({
+      template: z.object({
+        spec: z.object({
+          containers: z.array(
+            z.object({
+              name: z.string(),
+              ports: z.array(
+                z.object({
+                  containerPort: z.number()
+                })
+              )
+            })
+          )
+        })
+      })
+    })
+  }),
   meta: {
-    description: `The entity which represents a Kubernetes workload.`,
-    color: "#9C27B0"
+    description: `The entity which represents a Kubernetes workload.
+
+ Can optionally include a service associated with the workload.`,
+    color: "#9C27B0",
+    title: "Workload",
+    icon: "devicon:kubernetes",
+    iconColor: "#9C27B0"
   }
 });
 var jobEntity = defineEntity({
@@ -2650,7 +3450,10 @@ var jobEntity = defineEntity({
   schema: z.unknown(),
   meta: {
     description: `The entity which represents a Kubernetes job managed by Highstate.`,
-    color: "#FF5722"
+    color: "#FF5722",
+    title: "Job",
+    icon: "devicon:kubernetes",
+    iconColor: "#FF5722"
   }
 });
 var cronJobEntity = defineEntity({
@@ -2659,44 +3462,29 @@ var cronJobEntity = defineEntity({
   schema: z.unknown(),
   meta: {
     description: `The entity which represents a Kubernetes cron job managed by Highstate.`,
-    color: "#FF9800"
-  }
-});
-var exposableWorkloadEntity = defineEntity({
-  type: "k8s.exposable-workload.v1",
-  extends: { workloadEntity },
-  includes: {
-    service: {
-      entity: serviceEntity,
-      required: false
-    },
-    endpoints: {
-      entity: l4EndpointEntity,
-      multiple: true
-    }
-  },
-  schema: z.unknown(),
-  meta: {
-    description: `The entity which represents a Kubernetes workload (optionally) exposed via a service.
-
- Includes both the workload and its associated service.`,
-    color: "#4CAF50"
+    color: "#FF9800",
+    title: "CronJob",
+    icon: "devicon:kubernetes",
+    iconColor: "#FF9800"
   }
 });
 var deploymentEntity = defineEntity({
   type: "k8s.deployment.v1",
-  extends: { exposableWorkloadEntity },
+  extends: { workloadEntity },
   schema: z.unknown(),
   meta: {
     description: `The entity which represents a Kubernetes deployment managed by Highstate.
 
  Also includes a service associated with the deployment.`,
-    color: "#4CAF50"
+    color: "#4CAF50",
+    title: "Deployment",
+    icon: "devicon:kubernetes",
+    iconColor: "#4CAF50"
   }
 });
 var statefulSetEntity = defineEntity({
   type: "k8s.stateful-set.v1",
-  extends: { exposableWorkloadEntity },
+  extends: { workloadEntity },
   includes: {
     service: serviceEntity
   },
@@ -2705,18 +3493,26 @@ var statefulSetEntity = defineEntity({
     description: `The entity which represents a Kubernetes stateful set managed by Highstate.
 
  Also includes a service associated with the stateful set.`,
-    color: "#FFC107"
+    color: "#FFC107",
+    title: "Stateful Set",
+    icon: "devicon:kubernetes",
+    iconColor: "#FFC107"
   }
 });
 var networkInterfaceEntity = defineEntity({
   type: "k8s.network-interface.v1",
+  includes: {
+    workload: workloadEntity
+  },
   schema: z.object({
-    name: z.string(),
-    workload: workloadEntity.schema
+    name: z.string()
   }),
   meta: {
     description: `The network interface in a network namespace of the pod which can accept and transmit network traffic.`,
-    color: "#2196F3"
+    color: "#2196F3",
+    title: "Network Interface",
+    icon: "devicon:kubernetes",
+    iconColor: "#2196F3"
   }
 });
 
@@ -2807,7 +3603,7 @@ var repository = defineUnit({
 });
 
 // src/k8s/apps/shared.ts
-var sharedArgs2 = $args({
+var sharedArgs = $args({
   /**
    * The FQDN where the application will be accessible.
    */
@@ -2827,9 +3623,17 @@ var sharedArgs2 = $args({
   /**
    * The number of replicas for the application.
    */
-  replicas: $addArgumentDescription(z.number().default(1), `The number of replicas for the application.`)
+  replicas: $addArgumentDescription(z.number().default(1), `The number of replicas for the application.`),
+  /**
+   * The name of  namespace to create for the application.
+   *
+   * If not provided, defaults to the appName.
+   */
+  namespace: $addArgumentDescription(z.string().optional(), `The name of  namespace to create for the application.
+
+ If not provided, defaults to the appName.`)
 });
-var optionalSharedArgs2 = mapValues(sharedArgs2, (arg) => ({
+var optionalSharedArgs = mapValues(sharedArgs, (arg) => ({
   ...arg,
   schema: arg.schema.optional()
 }));
@@ -2848,17 +3652,17 @@ function appName(defaultAppName) {
     }
   };
 }
-var sharedSecrets2 = $secrets({
+var sharedSecrets = $secrets({
   /**
-   * The root password for the database instance. If not provided, a random password will be generated.
+   * The admin password for the application. If not provided, a random password will be generated.
    */
-  rootPassword: $addArgumentDescription(z.string().optional(), `The root password for the database instance. If not provided, a random password will be generated.`),
+  adminPassword: $addArgumentDescription(z.string().optional(), `The admin password for the application. If not provided, a random password will be generated.`),
   /**
    * The key to use for backup encryption. If not provided, a random key will be generated.
    */
   backupKey: $addArgumentDescription(z.string().optional(), `The key to use for backup encryption. If not provided, a random key will be generated.`)
 });
-var sharedDatabaseArgs = $args({
+$args({
   /**
    * The username for the database user.
    *
@@ -2876,7 +3680,7 @@ var sharedDatabaseArgs = $args({
 
  If not provided, defaults to the username.`)
 });
-var sharedDatabaseSecrets = $secrets({
+$secrets({
   /**
    * The password for the database user.
    *
@@ -2886,12 +3690,12 @@ var sharedDatabaseSecrets = $secrets({
 
  If not provided, a random password will be generated.`)
 });
-var sharedInputs2 = $inputs({
+var sharedInputs = $inputs({
   k8sCluster: {
     entity: clusterEntity
   },
   namespace: {
-    entity: namespaceEntity
+    entity: namespaceEntity2
   },
   accessPoint: {
     entity: accessPointEntity
@@ -2906,23 +3710,23 @@ var sharedInputs2 = $inputs({
   volume: {
     entity: persistentVolumeClaimEntity
   },
-  mariadb: {
-    entity: mariadbEntity
+  mysql: {
+    entity: mysql_exports.connectionEntity
   },
   postgresql: {
-    entity: postgresqlEntity
+    entity: postgresql_exports.connectionEntity
   },
   mongodb: {
-    entity: mongodbEntity
+    entity: mongodb_exports.connectionEntity
   },
   redis: {
-    entity: redisEntity
+    entity: redis_exports.connectionEntity
   },
   etcd: {
-    entity: etcdEntity
+    entity: etcd_exports.connectionEntity
   }
 });
-var optionalSharedInputs = mapValues(sharedInputs2, (input) => ({
+var optionalSharedInputs = mapValues(sharedInputs, (input) => ({
   ...input,
   required: false
 }));
@@ -2938,15 +3742,15 @@ var codeServer = defineUnit({
   type: "k8s.apps.code-server.v1",
   args: {
     ...appName("code-server"),
-    ...pick(sharedArgs2, ["fqdn"])
+    ...pick(sharedArgs, ["fqdn"])
   },
   secrets: {
-    ...pick(sharedSecrets2, ["backupKey"]),
+    ...pick(sharedSecrets, ["backupKey"]),
     password: z.string().optional(),
     sudoPassword: z.string().optional()
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster", "accessPoint"]),
+    ...pick(sharedInputs, ["k8sCluster", "accessPoint"]),
     ...pick(optionalSharedInputs, ["resticRepo", "dnsProviders", "volume"])
   },
   outputs: {
@@ -2965,17 +3769,17 @@ var etcd = defineUnit({
   type: "k8s.apps.etcd.v1",
   args: {
     ...appName("etcd"),
-    ...pick(sharedArgs2, ["external"])
+    ...pick(sharedArgs, ["external"])
   },
   secrets: {
-    ...pick(sharedSecrets2, ["backupKey"])
+    ...pick(sharedSecrets, ["backupKey"])
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster"]),
+    ...pick(sharedInputs, ["k8sCluster"]),
     ...pick(optionalSharedInputs, ["resticRepo"])
   },
   outputs: {
-    etcd: etcdEntity
+    connection: connectionEntity2
   },
   meta: {
     description: `The etcd instance deployed on Kubernetes.`,
@@ -2985,19 +3789,57 @@ var etcd = defineUnit({
     secondaryIcon: "mdi:database",
     category: "Databases"
   },
-  source: source("etcd/app")
+  source: source("etcd")
+});
+var grafana = defineUnit({
+  type: "k8s.apps.grafana.v1",
+  args: {
+    ...appName("grafana"),
+    ...pick(sharedArgs, ["fqdn"]),
+    /**
+     * The list of plugins to install on Grafana.
+     *
+     * See https://grafana.com/grafana/plugins for available plugins and their names.
+     */
+    plugins: $addArgumentDescription(z.string().array().default([]), `The list of plugins to install on Grafana.
+
+ See https://grafana.com/grafana/plugins for available plugins and their names.`)
+  },
+  secrets: {
+    /**
+     * The admin password used for Grafana.
+     *
+     * If not provided, a random password will be generated.
+     */
+    adminPassword: $addArgumentDescription(z.string().optional(), `The admin password used for Grafana.
+
+ If not provided, a random password will be generated.`)
+  },
+  inputs: {
+    ...pick(sharedInputs, ["k8sCluster", "accessPoint"])
+  },
+  outputs: {
+    service: serviceEntity
+  },
+  meta: {
+    description: `Grafana deployed on Kubernetes.`,
+    title: "Grafana",
+    icon: "simple-icons:grafana",
+    category: "Observability"
+  },
+  source: source("grafana")
 });
 var grocy = defineUnit({
   type: "k8s.apps.grocy.v1",
   args: {
     ...appName("grocy"),
-    ...pick(sharedArgs2, ["fqdn"])
+    ...pick(sharedArgs, ["fqdn"])
   },
   secrets: {
-    ...pick(sharedSecrets2, ["backupKey"])
+    ...pick(sharedSecrets, ["backupKey"])
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster", "accessPoint"]),
+    ...pick(sharedInputs, ["k8sCluster", "accessPoint"]),
     ...pick(optionalSharedInputs, ["resticRepo"])
   },
   meta: {
@@ -3014,10 +3856,10 @@ var hubble = defineUnit({
   type: "k8s.apps.hubble.v1",
   args: {
     ...appName("hubble"),
-    ...pick(sharedArgs2, ["fqdn"])
+    ...pick(sharedArgs, ["fqdn"])
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster", "accessPoint"])
+    ...pick(sharedInputs, ["k8sCluster", "accessPoint"])
   },
   meta: {
     description: `Exposes Hubble UI to the user.
@@ -3030,40 +3872,22 @@ var hubble = defineUnit({
   },
   source: source("hubble")
 });
-var kubernetesDashboard = defineUnit({
-  type: "k8s.apps.kubernetes-dashboard.v1",
-  args: {
-    ...appName("kubernetes-dashboard"),
-    ...pick(sharedArgs2, ["fqdn"])
-  },
-  inputs: {
-    ...pick(sharedInputs2, ["k8sCluster", "accessPoint"])
-  },
-  meta: {
-    description: `The Kubernetes Dashboard deployed on Kubernetes.`,
-    title: "Kubernetes Dashboard",
-    icon: "devicon:kubernetes",
-    secondaryIcon: "material-symbols:dashboard",
-    category: "Kubernetes"
-  },
-  source: source("kubernetes-dashboard")
-});
 var mariadb = defineUnit({
   type: "k8s.apps.mariadb.v1",
   args: {
     ...appName("mariadb"),
-    ...pick(sharedArgs2, ["external"])
+    ...pick(sharedArgs, ["external"])
   },
   secrets: {
-    ...pick(sharedSecrets2, ["rootPassword", "backupKey"])
+    ...pick(sharedSecrets, ["adminPassword", "backupKey"])
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster"]),
+    ...pick(sharedInputs, ["k8sCluster"]),
     ...pick(optionalSharedInputs, ["resticRepo"])
   },
   outputs: {
-    mariadb: mariadbEntity,
-    service: serviceEntity
+    connection: connectionEntity6,
+    statefulSet: statefulSetEntity
   },
   meta: {
     description: `The MariaDB database deployed on Kubernetes.`,
@@ -3072,101 +3896,99 @@ var mariadb = defineUnit({
     secondaryIcon: "mdi:database",
     category: "Databases"
   },
-  source: source("mariadb/app")
-});
-var mariadbDatabase = defineUnit({
-  type: "k8s.apps.mariadb.database.v1",
-  args: sharedDatabaseArgs,
-  secrets: sharedDatabaseSecrets,
-  inputs: {
-    ...pick(sharedInputs2, ["k8sCluster", "mariadb"]),
-    ...pick(optionalSharedInputs, ["namespace"])
-  },
-  outputs: {
-    mariadb: mariadbEntity
-  },
-  meta: {
-    description: `The virtual MariaDB database created on the MariaDB instance.
-
- Requires a Kubernetes cluster to place init jobs and secrets.`,
-    title: "MariaDB Database",
-    icon: "simple-icons:mariadb",
-    secondaryIcon: "mdi:database-plus",
-    category: "Databases"
-  },
-  source: source("mariadb/database")
+  source: source("mariadb")
 });
-var maybe = defineUnit({
-  type: "k8s.apps.maybe.v1",
+var matrixStack = defineUnit({
+  type: "k8s.apps.matrix-stack.v1",
   args: {
-    ...appName("maybe"),
-    ...pick(sharedArgs2, ["fqdn"])
-  },
-  secrets: {
-    ...pick(sharedSecrets2, ["backupKey"]),
-    postgresqlPassword: z.string().optional(),
-    secretKey: z.string().optional()
+    ...appName("matrix-stack"),
+    /**
+     * The base domain for the Matrix stack services.
+     *
+     * Subdomains for Matrix services are generated automatically.
+     * This value cannot be changed after the first deployment.
+     */
+    fqdn: $addArgumentDescription(z.string(), `The base domain for the Matrix stack services.
+
+ Subdomains for Matrix services are generated automatically.
+ This value cannot be changed after the first deployment.`),
+    /**
+     * Whether to enable cinny web client deployment.
+     *
+     * The FQDN will be generated as `cinny.${fqdn}`.
+     */
+    enableCinny: $addArgumentDescription(z.boolean().default(false), `Whether to enable cinny web client deployment.
+
+ The FQDN will be generated as \`cinny.\${fqdn}\`.`),
+    /**
+     * The list of remote Matrix domains that are allowed for federation.
+     *
+     * Leave empty to allow federation with all domains.
+     */
+    federationDomainWhitelist: $addArgumentDescription(z.array(z.string()).default([]), `The list of remote Matrix domains that are allowed for federation.
+
+ Leave empty to allow federation with all domains.`)
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster", "accessPoint", "postgresql", "redis"]),
-    ...pick(optionalSharedInputs, ["resticRepo"])
+    ...pick(sharedInputs, ["k8sCluster", "accessPoint"]),
+    /**
+     * The PostgreSQL connection for the Synapse server.
+     */
+    synapsePostgresql: $addInputDescription(postgresql_exports.connectionEntity, `The PostgreSQL connection for the Synapse server.`),
+    /**
+     * The PostgreSQL connection for the Matrix Authentication Service.
+     */
+    masPostgresql: $addInputDescription(postgresql_exports.connectionEntity, `The PostgreSQL connection for the Matrix Authentication Service.`)
   },
+  secrets: {},
   meta: {
-    title: "Maybe",
-    description: "The OS for your personal finances.",
-    icon: "arcticons:finance-manager",
-    category: "Finance"
+    description: `The Matrix stack deployed on Kubernetes.`,
+    title: "Matrix Stack",
+    icon: "simple-icons:matrix",
+    secondaryIcon: "simple-icons:element",
+    category: "Communication"
   },
-  source: source("maybe")
-});
-var minioSecrets = $secrets({
-  /**
-   * The secret key used to authenticate with MinIO.
-   */
-  secretKey: $addArgumentDescription(z.string().optional(), `The secret key used to authenticate with MinIO.`),
-  /**
-   * The key that protects Restic backups.
-   */
-  backupKey: $addArgumentDescription(z.string().optional(), `The key that protects Restic backups.`)
+  source: source("matrix-stack")
 });
-var minio = defineUnit({
-  type: "k8s.apps.minio.v1",
-  args: {
-    ...appName("minio"),
-    ...pick(sharedArgs2, ["external"]),
-    accessKey: {
-      schema: z.string().default("admin"),
-      meta: {
-        description: text`
-          The access key used to authenticate with MinIO.
-          If not provided, defaults to "admin".
-        `
-      }
-    },
-    region: {
-      schema: z.string().optional(),
-      meta: {
-        description: text`The region associated with the MinIO deployment.`
-      }
-    },
-    buckets: {
-      schema: s3BucketSchema.array().default([]),
-      meta: {
-        description: text`
-          The buckets that must exist on the MinIO instance.
-          Each entry can optionally include a bucket policy: none, download, upload, or public.
-        `
-      }
-    }
+var minio = defineUnit({
+  type: "k8s.apps.minio.v1",
+  args: {
+    ...appName("minio"),
+    ...pick(optionalSharedArgs, ["fqdn"]),
+    ...pick(sharedArgs, ["external"]),
+    /**
+     * The FQDN of the MinIO console.
+     *
+     * If not provided, the console will not be exposed and only the S3 API will be available.
+     */
+    consoleFqdn: $addArgumentDescription(z.string().optional(), `The FQDN of the MinIO console.
+
+ If not provided, the console will not be exposed and only the S3 API will be available.`),
+    /**
+     * The name of the region to associate with the MinIO deployment.
+     *
+     * Defaults to "us-east-1".
+     */
+    region: $addArgumentDescription(z.string().default("us-east-1"), `The name of the region to associate with the MinIO deployment.
+
+ Defaults to "us-east-1".`),
+    /**
+     * Whether to use the [fork](https://github.com/huncrys/minio-console) of MinIO Console instead of the built-in console.
+     * The fork contains admin features that were removed from the original console.
+     */
+    useConsoleFork: $addArgumentDescription(z.boolean().default(false), `Whether to use the [fork](https://github.com/huncrys/minio-console) of MinIO Console instead of the built-in console.
+ The fork contains admin features that were removed from the original console.`)
+  },
+  secrets: {
+    ...pick(sharedSecrets, ["adminPassword", "backupKey"])
   },
-  secrets: minioSecrets,
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster"]),
-    ...pick(optionalSharedInputs, ["resticRepo"])
+    ...pick(sharedInputs, ["k8sCluster"]),
+    ...pick(optionalSharedInputs, ["accessPoint", "resticRepo"])
   },
   outputs: {
-    s3: s3Entity,
-    service: serviceEntity
+    connection: connectionEntity4,
+    deployment: deploymentEntity
   },
   meta: {
     description: `The MinIO object storage deployed on Kubernetes.`,
@@ -3175,24 +3997,24 @@ var minio = defineUnit({
     secondaryIcon: "mdi:bucket",
     category: "Databases"
   },
-  source: source("minio/app")
+  source: source("minio")
 });
 var mongodb = defineUnit({
   type: "k8s.apps.mongodb.v1",
   args: {
     ...appName("mongodb"),
-    ...pick(sharedArgs2, ["external"])
+    ...pick(sharedArgs, ["external"])
   },
   secrets: {
-    ...pick(sharedSecrets2, ["rootPassword", "backupKey"])
+    ...pick(sharedSecrets, ["adminPassword", "backupKey"])
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster"]),
+    ...pick(sharedInputs, ["k8sCluster"]),
     ...pick(optionalSharedInputs, ["resticRepo"])
   },
   outputs: {
-    mongodb: mongodbEntity,
-    service: serviceEntity
+    connection: connectionEntity5,
+    statefulSet: statefulSetEntity
   },
   meta: {
     description: `The MongoDB instance deployed on Kubernetes.`,
@@ -3201,46 +4023,41 @@ var mongodb = defineUnit({
     secondaryIcon: "mdi:database",
     category: "Databases"
   },
-  source: source("mongodb/app")
+  source: source("mongodb")
 });
-var mongodbDatabase = defineUnit({
-  type: "k8s.apps.mongodb.database.v1",
-  args: sharedDatabaseArgs,
-  secrets: sharedDatabaseSecrets,
-  inputs: {
-    ...pick(sharedInputs2, ["k8sCluster", "mongodb"]),
-    ...pick(optionalSharedInputs, ["namespace"])
+var portal = defineUnit({
+  type: "k8s.apps.portal.v1",
+  args: {
+    ...appName("portal"),
+    ...pick(sharedArgs, ["fqdn"])
   },
-  outputs: {
-    mongodb: mongodbEntity
+  inputs: {
+    ...pick(sharedInputs, ["k8sCluster", "accessPoint"])
   },
   meta: {
-    description: `The virtual MongoDB database created on the MongoDB instance.
-
- Requires a Kubernetes cluster to place init jobs and secrets.`,
-    title: "MongoDB Database",
-    icon: "simple-icons:mongodb",
-    secondaryIcon: "mdi:database-plus",
-    category: "Databases"
+    description: `The Portal application deployed on Kubernetes.`,
+    title: "Portal",
+    icon: "mdi:application-outline",
+    category: "Services"
   },
-  source: source("mongodb/database")
+  source: source("portal")
 });
 var postgresql = defineUnit({
   type: "k8s.apps.postgresql.v1",
   args: {
     ...appName("postgresql"),
-    ...pick(sharedArgs2, ["external"])
+    ...pick(sharedArgs, ["namespace", "external"])
   },
   secrets: {
-    ...pick(sharedSecrets2, ["rootPassword", "backupKey"])
+    ...pick(sharedSecrets, ["adminPassword", "backupKey"])
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster"]),
+    ...pick(sharedInputs, ["k8sCluster"]),
     ...pick(optionalSharedInputs, ["resticRepo"])
   },
   outputs: {
-    postgresql: postgresqlEntity,
-    service: serviceEntity
+    connection: connectionEntity7,
+    statefulSet: statefulSetEntity
   },
   meta: {
     description: `The PostgreSQL instance deployed on Kubernetes.`,
@@ -3249,31 +4066,43 @@ var postgresql = defineUnit({
     secondaryIcon: "mdi:database",
     category: "Databases"
   },
-  source: source("postgresql/app")
+  source: source("postgresql")
 });
-var postgresqlDatabase = defineUnit({
-  type: "k8s.apps.postgresql.database.v1",
-  args: sharedDatabaseArgs,
-  secrets: sharedDatabaseSecrets,
+var refluxdb = defineUnit({
+  type: "k8s.apps.refluxdb.v1",
+  args: {
+    ...appName("refluxdb"),
+    ...pick(sharedArgs, ["external"]),
+    /**
+     * The ID of the node.
+     *
+     * Defaults to "local1".
+     */
+    nodeId: $addArgumentDescription(z.string().default("local1"), `The ID of the node.
+
+ Defaults to "local1".`)
+  },
+  secrets: {
+    /**
+     * The operator token of the RefluxDB instance.
+     */
+    operatorToken: $addArgumentDescription(z.string().optional(), `The operator token of the RefluxDB instance.`)
+  },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster", "postgresql"]),
-    ...pick(optionalSharedInputs, ["namespace"])
+    ...pick(sharedInputs, ["k8sCluster"]),
+    s3Bucket: s3_exports.bucketEntity
   },
   outputs: {
-    postgresql: postgresqlEntity
+    connection: influxdb3_exports.connectionEntity,
+    deployment: deploymentEntity
   },
   meta: {
-    description: `The virtual PostgreSQL database created on the PostgreSQL instance.
-
- The provided database must be authorized to create databases and users.
-
- Requires a Kubernetes cluster to place init jobs and secrets.`,
-    title: "PostgreSQL Database",
-    icon: "simple-icons:postgresql",
-    secondaryIcon: "mdi:database-plus",
+    description: `The RefluxDB instance deployed on Kubernetes.`,
+    title: "RefluxDB (InfluxDB 3)",
+    icon: "simple-icons:influxdb",
     category: "Databases"
   },
-  source: source("postgresql/database")
+  source: source("refluxdb")
 });
 var remnawaveEntity = defineEntity({
   type: "k8s.apps.remnawave.v1",
@@ -3282,7 +4111,13 @@ var remnawaveEntity = defineEntity({
      * The ID of the Remnawave instance.
      */
     instanceId: z.string().meta({ title: camelCaseToHumanReadable("instanceId"), description: `The ID of the Remnawave instance.` })
-  })
+  }),
+  meta: {
+    color: "#0066cc",
+    title: "Remnawave",
+    icon: "mdi:waveform",
+    iconColor: "#0066cc"
+  }
 });
 var remnawave = defineUnit({
   type: "k8s.apps.remnawave.backend.v1",
@@ -3291,7 +4126,7 @@ var remnawave = defineUnit({
     jwtApiTokensSecret: z.string()
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster", "accessPoint", "postgresql", "redis"]),
+    ...pick(sharedInputs, ["k8sCluster", "accessPoint", "postgresql", "redis"]),
     ...pick(optionalSharedInputs, ["resticRepo"])
   },
   outputs: {
@@ -3310,7 +4145,7 @@ var node = defineUnit({
   type: "k8s.apps.remnawave.node.v1",
   inputs: {
     remnawave: remnawaveEntity,
-    ...pick(sharedInputs2, ["k8sCluster"])
+    ...pick(sharedInputs, ["k8sCluster"])
   },
   meta: {
     description: `The Remnawave node deployed on Kubernetes.`,
@@ -3327,7 +4162,7 @@ var syncthing = defineUnit({
   type: "k8s.apps.syncthing.v1",
   args: {
     ...appName("syncthing"),
-    ...pick(sharedArgs2, ["fqdn", "external"]),
+    ...pick(sharedArgs, ["fqdn", "external"]),
     /**
      * The FQDN of the Syncthing instance used to sync with other devices.
      *
@@ -3356,10 +4191,10 @@ var syncthing = defineUnit({
  The default is \`state\`.`)
   },
   secrets: {
-    ...pick(sharedSecrets2, ["backupKey"])
+    ...pick(sharedSecrets, ["backupKey"])
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster", "accessPoint"]),
+    ...pick(sharedInputs, ["k8sCluster", "accessPoint"]),
     ...pick(optionalSharedInputs, ["resticRepo", "volume"])
   },
   outputs: {
@@ -3382,7 +4217,7 @@ var traefik = defineUnit({
   type: "k8s.apps.traefik.v1",
   args: {
     ...appName("traefik"),
-    ...pick(sharedArgs2, ["external", "replicas"]),
+    ...pick(sharedArgs, ["external", "replicas"]),
     /**
      * The name of the class to configure for ingress and gateway resources.
      *
@@ -3391,6 +4226,10 @@ var traefik = defineUnit({
     className: $addArgumentDescription(z.string().default("traefik"), `The name of the class to configure for ingress and gateway resources.
 
  Defaults to "traefik".`),
+    /**
+     * The node selector to apply to all Traefik pods.
+     */
+    nodeSelector: $addArgumentDescription(z.record(z.string(), z.string()).default({}), `The node selector to apply to all Traefik pods.`),
     /**
      * Whether to create and enable reconciliation for Traefik CRDs.
      */
@@ -3405,7 +4244,7 @@ var traefik = defineUnit({
     enableGatewayApi: $addArgumentDescription(z.boolean().default(false), `Whether to enable reconciliation for Gateway API resources and create gateway class.`)
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster"])
+    ...pick(sharedInputs, ["k8sCluster"])
   },
   outputs: {
     gateway: gatewayEntity,
@@ -3427,18 +4266,18 @@ var valkey = defineUnit({
   type: "k8s.apps.valkey.v1",
   args: {
     ...appName("valkey"),
-    ...pick(sharedArgs2, ["external"])
+    ...pick(sharedArgs, ["external"])
   },
   secrets: {
-    ...pick(sharedSecrets2, ["backupKey"])
+    ...pick(sharedSecrets, ["backupKey"])
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster"]),
+    ...pick(sharedInputs, ["k8sCluster"]),
     ...pick(optionalSharedInputs, ["resticRepo"])
   },
   outputs: {
-    redis: databases_exports.redisEntity,
-    service: serviceEntity
+    connection: redis_exports.connectionEntity,
+    statefulSet: statefulSetEntity
   },
   meta: {
     description: `The Valkey instance deployed on Kubernetes.`,
@@ -3447,19 +4286,16 @@ var valkey = defineUnit({
     secondaryIcon: "mdi:database",
     category: "Databases"
   },
-  source: source("valkey/app")
+  source: source("valkey")
 });
 var vaultwarden = defineUnit({
   type: "k8s.apps.vaultwarden.v1",
   args: {
     ...appName("vaultwarden"),
-    ...pick(sharedArgs2, ["fqdn"])
-  },
-  secrets: {
-    mariadbPassword: z.string().optional()
+    ...pick(sharedArgs, ["fqdn"])
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster", "accessPoint", "mariadb"])
+    ...pick(sharedInputs, ["k8sCluster", "accessPoint", "mysql"])
   },
   meta: {
     description: `The Vaultwarden password manager deployed on Kubernetes.`,
@@ -3473,10 +4309,10 @@ var wgFeedServer = defineUnit({
   type: "k8s.apps.wg-feed-server.v1",
   args: {
     ...appName("wg-feed-server"),
-    ...pick(sharedArgs2, ["fqdn"])
+    ...pick(sharedArgs, ["fqdn"])
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster", "accessPoint", "etcd"])
+    ...pick(sharedInputs, ["k8sCluster", "accessPoint", "etcd"])
   },
   outputs: {
     endpoint: l4EndpointEntity
@@ -3606,6 +4442,10 @@ var workload = defineUnit({
  2. a dependency key to service configuration (e.g., \`mariadb.username\`);
  3. a config key to reference a configuration value provided via \`config\` argument;
  4. a secret key to reference a secret value provided via \`secretData\` secret.`),
+    /**
+     * The files to mount in the workload from a config map.
+     */
+    files: $addArgumentDescription(z.record(z.string(), z.string()).default({}), `The files to mount in the workload from a config map.`),
     /**
      * The configuration for the workload.
      *
@@ -3690,19 +4530,16 @@ var workload = defineUnit({
  You can reference the secret values in the environment variables using \`secretKey\`.`)
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster"]),
-    ...pick(optionalSharedInputs, [
-      "accessPoint",
-      "resticRepo",
-      "mariadb",
-      "postgresql",
-      "mongodb"
-    ])
+    ...pick(sharedInputs, ["k8sCluster"]),
+    ...pick(optionalSharedInputs, ["accessPoint", "resticRepo", "mysql", "postgresql", "mongodb"]),
+    workload: {
+      entity: workloadEntity,
+      required: false
+    }
   },
   outputs: {
-    namespace: namespaceEntity,
-    workload: exposableWorkloadEntity,
-    service: serviceEntity
+    namespace: namespaceEntity2,
+    workload: workloadEntity
   },
   meta: {
     description: `The generic Kubernetes workload with optional service and gateway routes.
@@ -3756,6 +4593,24 @@ var certManager = defineUnit({
 });
 var dns01TlsIssuer = defineUnit({
   type: "k8s.dns01-issuer.v1",
+  args: {
+    /**
+     * The ACME server to use for issuing certificates.
+     */
+    acmeServer: $addArgumentDescription(z.union([
+      z.object({
+        type: z.enum(["letsencrypt", "zerossl"])
+      }),
+      z.object({
+        type: z.literal("custom"),
+        url: z.string()
+      })
+    ]).default({ type: "letsencrypt" }), `The ACME server to use for issuing certificates.`)
+  },
+  secrets: {
+    eabKeyId: z.string().optional(),
+    eabKeySecret: z.string().optional()
+  },
   inputs: {
     k8sCluster: clusterEntity,
     dnsProvider: providerEntity
@@ -3800,7 +4655,19 @@ var cilium = defineUnit({
 
  By default, this is \`true\`.
 
- To expose the Hubble UI, you can use \`k8s.apps.hubble-ui\` unit.`)
+ To expose the Hubble UI, you can use \`k8s.apps.hubble-ui\` unit.`),
+    /**
+     * The tolerations of the cilium agent in the cluster.
+     */
+    agentTolerations: $addArgumentDescription(tolerationSchema.array().optional(), `The tolerations of the cilium agent in the cluster.`),
+    /**
+     * The tolerations of the cilium envoy in the cluster.
+     */
+    envoyTolerations: $addArgumentDescription(tolerationSchema.array().optional(), `The tolerations of the cilium envoy in the cluster.`),
+    /**
+     * The tolerations of the cilium operator in the cluster.
+     */
+    operatorTolerations: $addArgumentDescription(tolerationSchema.array().optional(), `The tolerations of the cilium operator in the cluster.`)
   },
   inputs: {
     k8sCluster: clusterEntity
@@ -3821,7 +4688,7 @@ var cilium = defineUnit({
   }
 });
 var ciliumClusterMetadata = z.object({
-  cilium: z.object({
+  "cilium.cni": z.object({
     /**
      * If set to `true`, the generated network policy will allow
      * all DNS queries to be resolved, even if they are
@@ -3847,15 +4714,15 @@ var openttd = defineUnit({
   type: "k8s.game-servers.openttd.v1",
   args: {
     ...appName("openttd-server"),
-    ...pick(sharedArgs2, ["fqdn"]),
+    ...pick(sharedArgs, ["fqdn"]),
     port: z.number().default(3979).describe("The port the game server will be exposed on.")
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster", "dnsProviders"]),
+    ...pick(sharedInputs, ["k8sCluster", "dnsProviders"]),
     ...pick(optionalSharedInputs, ["resticRepo"])
   },
   secrets: {
-    ...pick(sharedSecrets2, ["backupKey"])
+    ...pick(sharedSecrets, ["backupKey"])
   },
   source: {
     package: "@highstate/k8s.game-servers",
@@ -3871,15 +4738,15 @@ var satisfactory = defineUnit({
   type: "k8s.game-servers.satisfactory.v1",
   args: {
     ...appName("satisfactory-server"),
-    ...pick(sharedArgs2, ["fqdn"]),
+    ...pick(sharedArgs, ["fqdn"]),
     port: z.number().default(7777).describe("The port the game server will be exposed on.")
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster", "accessPoint"]),
+    ...pick(sharedInputs, ["k8sCluster", "accessPoint"]),
     ...pick(optionalSharedInputs, ["resticRepo"])
   },
   secrets: {
-    ...pick(sharedSecrets2, ["backupKey"])
+    ...pick(sharedSecrets, ["backupKey"])
   },
   source: {
     package: "@highstate/k8s.game-servers",
@@ -3899,7 +4766,7 @@ var gatewayDataSchema = z.object({
   /**
    * The namespace where the gateway controller of the class is running.
    */
-  namespace: namespaceEntity.schema.meta({ title: camelCaseToHumanReadable("namespace"), description: `The namespace where the gateway controller of the class is running.` }),
+  namespace: namespaceEntity2.schema.meta({ title: camelCaseToHumanReadable("namespace"), description: `The namespace where the gateway controller of the class is running.` }),
   /**
    * The name of the gateway class to use.
    */
@@ -4147,12 +5014,12 @@ var reducedAccessCluster = defineUnit({
     /**
      * The namespace where the ServiceAccount will be created.
      */
-    namespace: $addInputDescription(namespaceEntity, `The namespace where the ServiceAccount will be created.`),
+    namespace: $addInputDescription(namespaceEntity2, `The namespace where the ServiceAccount will be created.`),
     /**
      * The extra namespaces to bind to the ClusterRole and allow ServiceAccount to access them with specified rules.
      */
     extraNamespaces: $addInputDescription({
-      entity: namespaceEntity,
+      entity: namespaceEntity2,
       multiple: true,
       required: false
     }, `The extra namespaces to bind to the ClusterRole and allow ServiceAccount to access them with specified rules.`),
@@ -4329,7 +5196,7 @@ var system = defineUnit({
 var proxmox_exports = {};
 __export(proxmox_exports, {
   clusterEntity: () => clusterEntity2,
-  connection: () => connection,
+  connection: () => connection7,
   existingImage: () => existingImage,
   image: () => image,
   imageEntity: () => imageEntity,
@@ -4337,15 +5204,25 @@ __export(proxmox_exports, {
 });
 var clusterEntity2 = defineEntity({
   type: "proxmox.cluster.v1",
+  includes: {
+    /**
+     * The SSH configuration for the Proxmox nodes.
+     *
+     * If not specified, it will be assumed that the nodes are not accessible via SSH.
+     */
+    ssh: {
+      entity: connectionEntity,
+      required: false
+    }
+  },
   schema: z.object({
     endpoint: l7EndpointEntity.schema,
     insecure: z.boolean().optional(),
     username: z.string().optional(),
     defaultNodeName: z.string(),
     defaultDatastoreId: z.string(),
-    password: z.string().optional(),
-    apiToken: z.string().optional(),
-    ssh: connectionSchema.optional()
+    password: secretSchema(z.string()).optional(),
+    apiToken: secretSchema(z.string()).optional()
   }),
   meta: {
     color: "#e56901"
@@ -4360,7 +5237,7 @@ var imageEntity = defineEntity({
     color: "#e56901"
   }
 });
-var connection = defineUnit({
+var connection7 = defineUnit({
   type: "proxmox.connection.v1",
   args: {
     /**
@@ -4877,14 +5754,14 @@ var cluster2 = defineUnit({
 // src/third-party/cloudflare.ts
 var cloudflare_exports = {};
 __export(cloudflare_exports, {
-  connection: () => connection2,
+  connection: () => connection8,
   providerDataSchema: () => providerDataSchema
 });
 var providerDataSchema = z.object({
   /**
-   * The zone ID of the Cloudflare zone.
+   * The mapping of zone names to their corresponding Cloudflare zone IDs.
    */
-  zoneId: z.string().meta({ title: camelCaseToHumanReadable("zoneId"), description: `The zone ID of the Cloudflare zone.` }),
+  zoneIds: z.record(z.string(), z.string()).meta({ title: camelCaseToHumanReadable("zoneIds"), description: `The mapping of zone names to their corresponding Cloudflare zone IDs.` }),
   /**
    * The API token for the Cloudflare account.
    *
@@ -4895,7 +5772,7 @@ var providerDataSchema = z.object({
    * - `Zone:Read`
    * - `Zone:DNS:Edit`
    */
-  apiToken: z.string().meta({ title: camelCaseToHumanReadable("apiToken"), description: `The API token for the Cloudflare account.
+  apiToken: secretSchema(z.string()).meta({ title: camelCaseToHumanReadable("apiToken"), description: `The API token for the Cloudflare account.
 
  The API key must have permissions to manage DNS records for exactly one zone.
  If multiple zones are specified, the unit will fail.
@@ -4904,7 +5781,7 @@ var providerDataSchema = z.object({
  - \`Zone:Read\`
  - \`Zone:DNS:Edit\`` })
 });
-var connection2 = defineUnit({
+var connection8 = defineUnit({
   type: "cloudflare.connection.v1",
   secrets: {
     /**
@@ -4951,6 +5828,7 @@ __export(mullvad_exports, {
 // src/wireguard.ts
 var wireguard_exports = {};
 __export(wireguard_exports, {
+  amneziaParametersSchema: () => amneziaParametersSchema,
   backendSchema: () => backendSchema,
   config: () => config,
   configBundle: () => configBundle,
@@ -4961,22 +5839,42 @@ __export(wireguard_exports, {
   identity: () => identity,
   identityEntity: () => identityEntity,
   network: () => network,
+  networkArgs: () => networkArgs2,
   networkEntity: () => networkEntity,
   node: () => node2,
   nodeExposePolicySchema: () => nodeExposePolicySchema,
+  nodeFeedK8s: () => nodeFeedK8s,
   nodeK8s: () => nodeK8s,
   peer: () => peer,
   peerEntity: () => peerEntity,
   peerPatch: () => peerPatch
 });
 var backendSchema = z.enum(["wireguard", "amneziawg"]);
+var amneziaParametersSchema = z.object({
+  i1: z.string().optional(),
+  i2: z.string().optional(),
+  i3: z.string().optional(),
+  i4: z.string().optional(),
+  i5: z.string().optional(),
+  s1: z.number().optional(),
+  s2: z.number().optional(),
+  s3: z.number().optional(),
+  s4: z.number().optional(),
+  jc: z.number().optional(),
+  jmin: z.number().optional(),
+  jmax: z.number().optional(),
+  h1: z.string().optional(),
+  h2: z.string().optional(),
+  h3: z.string().optional(),
+  h4: z.string().optional()
+});
 var networkArgs2 = {
   /**
    * The backend to use for the WireGuard network.
    *
    * Possible values are:
    * - `wireguard` - the default backend;
-   * - `amneziawg` - the censorship-resistant fork of WireGuard (NOT SUPPORTED YET).
+   * - `amneziawg` - the censorship-resistant fork of WireGuard.
    */
   backend: backendSchema.default("wireguard"),
   /**
@@ -4992,54 +5890,156 @@ var networkArgs2 = {
    *
    * By default, IPv6 support is disabled.
    */
-  ipv6: z.boolean().default(false)
+  ipv6: z.boolean().default(false),
+  /**
+   * The extra parameters for the amneziawg backend.
+   */
+  amnezia: amneziaParametersSchema.optional()
 };
+var configSharedArgs = $args({
+  /**
+   * The filter to use when selecting endpoints for each peer.
+   *
+   * The first matching endpoint will be used.
+   *
+   * If not provided, all endpoints will be considered.
+   */
+  peerEndpointFilter: $addArgumentDescription(z.string().optional().meta({ language: "javascript" }), `The filter to use when selecting endpoints for each peer.
+
+ The first matching endpoint will be used.
+
+ If not provided, all endpoints will be considered.`),
+  /**
+   * Whether to include the `ListenPort` in the generated config.
+   *
+   * By default, is `false` because in most cases the config is used for peers which don't listen for incoming connections.
+   */
+  listen: $addArgumentDescription(z.boolean().default(false), `Whether to include the \`ListenPort\` in the generated config.
+
+ By default, is \`false\` because in most cases the config is used for peers which don't listen for incoming connections.`)
+});
 var networkEntity = defineEntity({
   type: "wireguard.network.v1",
   schema: z.object(networkArgs2),
   meta: {
     description: `The entity representing the WireGuard network configuration.
 
- It holds shared configuration for WireGuard identities, peers, and nodes.`
+ It holds shared configuration for WireGuard identities, peers, and nodes.`,
+    color: "#88171a",
+    title: "WireGuard Network",
+    icon: "simple-icons:wireguard",
+    iconColor: "#88171a",
+    secondaryIcon: "mdi:local-area-network-connect"
   }
 });
 var nodeExposePolicySchema = z.enum(["always", "when-has-endpoint", "never"]);
+var feedDisplayInfoSchema = z.object({
+  /**
+   * The display title of the tunnel.
+   */
+  title: z.string().meta({ title: camelCaseToHumanReadable("title"), description: `The display title of the tunnel.` }),
+  /**
+   * The display description of the tunnel.
+   */
+  description: z.string().optional().meta({ title: camelCaseToHumanReadable("description"), description: `The display description of the tunnel.` }),
+  /**
+   * The display icon URL of the tunnel.
+   *
+   * Must only be `data:` URL with SVG image.
+   */
+  iconUrl: z.url().optional().meta({ title: camelCaseToHumanReadable("iconUrl"), description: `The display icon URL of the tunnel.
+
+ Must only be \`data:\` URL with SVG image.` })
+});
+var feedMetadataSchema = z.object({
+  /**
+   * The ID of the tunnel in the feed.
+   */
+  id: z.string().meta({ title: camelCaseToHumanReadable("id"), description: `The ID of the tunnel in the feed.` }),
+  /**
+   * The suggested name of the interface for the tunnel.
+   */
+  name: genericNameSchema.meta({ title: camelCaseToHumanReadable("name"), description: `The suggested name of the interface for the tunnel.` }),
+  /**
+   * Whether the tunnel should be enabled by the client.
+   */
+  enabled: z.boolean().default(false).meta({ title: camelCaseToHumanReadable("enabled"), description: `Whether the tunnel should be enabled by the client.` }),
+  /**
+   * Whether the tunnel state must be forced by the client.
+   */
+  forced: z.boolean().default(false).meta({ title: camelCaseToHumanReadable("forced"), description: `Whether the tunnel state must be forced by the client.` }),
+  /**
+   * Whether the tunnel is exclusive and should not be enabled with other tunnels.
+   */
+  exclusive: z.boolean().default(false).meta({ title: camelCaseToHumanReadable("exclusive"), description: `Whether the tunnel is exclusive and should not be enabled with other tunnels.` }),
+  /**
+   * The display information of the tunnel.
+   */
+  displayInfo: feedDisplayInfoSchema.meta({ title: camelCaseToHumanReadable("displayInfo"), description: `The display information of the tunnel.` })
+});
 var peerEntity = defineEntity({
   type: "wireguard.peer.v1",
   includes: {
-    /**
-     * The endpoints where the WireGuard peer can be reached.
-     */
-    endpoints: {
-      entity: l4EndpointEntity,
-      multiple: true
-    }
-  },
-  schema: z.object({
-    /**
-     * The name of the WireGuard peer.
-     */
-    name: genericNameSchema.meta({ title: camelCaseToHumanReadable("name"), description: `The name of the WireGuard peer.` }),
     /**
      * The network to which the WireGuard peer belongs.
      *
      * Holds shared configuration for all identities, peers, and nodes.
      */
-    network: networkEntity.schema.optional().meta({ title: camelCaseToHumanReadable("network"), description: `The network to which the WireGuard peer belongs.
-
- Holds shared configuration for all identities, peers, and nodes.` }),
+    network: {
+      entity: networkEntity,
+      required: false
+    },
     /**
      * The addresses of the WireGuard interface.
      */
-    addresses: addressEntity.schema.array().meta({ title: camelCaseToHumanReadable("addresses"), description: `The addresses of the WireGuard interface.` }),
+    addresses: {
+      entity: addressEntity,
+      multiple: true,
+      required: false
+    },
+    /**
+     * The list of DNS servers to setup for the interface connected to the WireGuard peer.
+     */
+    dns: {
+      entity: addressEntity,
+      multiple: true,
+      required: false
+    },
     /**
      * The allowed subnets of the WireGuard peer.
      *
      * Will be used to configure the `AllowedIPs` of the peer.
      */
-    allowedSubnets: subnetEntity.schema.array().meta({ title: camelCaseToHumanReadable("allowedSubnets"), description: `The allowed subnets of the WireGuard peer.
-
- Will be used to configure the \`AllowedIPs\` of the peer.` }),
+    allowedSubnets: {
+      entity: subnetEntity,
+      multiple: true,
+      required: false
+    },
+    /**
+     * The endpoints where the WireGuard peer can be reached.
+     */
+    endpoints: {
+      entity: l4EndpointEntity,
+      multiple: true,
+      required: false
+    },
+    /**
+     * The peers which are relayed through this peer.
+     *
+     * All their allowed IPs will be added to this peer's allowed IPs
+     * and will be used to setup routing for all other peers except the relayed ones.
+     */
+    relayedPeers: {
+      entity: () => peerEntity,
+      multiple: true,
+      required: false
+    }
+  },
+  schema: z.object({
+    /**
+     * The name of the WireGuard peer.
+     */
+    name: genericNameSchema.meta({ title: camelCaseToHumanReadable("name"), description: `The name of the WireGuard peer.` }),
     /**
      * The public key of the WireGuard peer.
      */
@@ -5051,7 +6051,7 @@ var peerEntity = defineEntity({
      *
      * Will be ignored if both peers have `presharedKeyPart` set.
      */
-    presharedKey: z.string().optional().meta({ title: camelCaseToHumanReadable("presharedKey"), description: `The pre-shared key of the WireGuard peer.
+    presharedKey: secretSchema(z.string()).optional().meta({ title: camelCaseToHumanReadable("presharedKey"), description: `The pre-shared key of the WireGuard peer.
 
  If one of two peers has \`presharedKey\` set, the other peer must have \`presharedKey\` set too and they must be equal.
 
@@ -5061,13 +6061,9 @@ var peerEntity = defineEntity({
      *
      * If both peers have `presharedKeyPart` set, their `presharedKey` will be calculated as sha256 of the two parts.
      */
-    presharedKeyPart: z.string().optional().meta({ title: camelCaseToHumanReadable("presharedKeyPart"), description: `The pre-shared key part of the WireGuard peer.
+    presharedKeyPart: secretSchema(z.string()).optional().meta({ title: camelCaseToHumanReadable("presharedKeyPart"), description: `The pre-shared key part of the WireGuard peer.
 
  If both peers have \`presharedKeyPart\` set, their \`presharedKey\` will be calculated as sha256 of the two parts.` }),
-    /**
-     * The list of DNS servers to setup for the interface connected to the WireGuard peer.
-     */
-    dns: addressEntity.schema.array().meta({ title: camelCaseToHumanReadable("dns"), description: `The list of DNS servers to setup for the interface connected to the WireGuard peer.` }),
     /**
      * The port where the WireGuard peer is listening.
      *
@@ -5089,20 +6085,19 @@ var peerEntity = defineEntity({
 
  If set to 0, keepalive is disabled.` }),
     /**
-     * The peers which are relayed through this peer.
+     * The wg-feed metadata of the WireGuard peer.
      *
-     * All their allowed IPs will be added to this peer's allowed IPs
-     * and will be used to setup routing for all other peers except the relayed ones.
+     * Will be used in the config referencing this peer (not the peer itself).
      */
-    get relayedPeers() {
-      return peerEntity.schema.array().optional().meta({ title: camelCaseToHumanReadable("relayedPeers"), description: `The peers which are relayed through this peer.
+    feedMetadata: feedMetadataSchema.optional().meta({ title: camelCaseToHumanReadable("feedMetadata"), description: `The wg-feed metadata of the WireGuard peer.
 
- All their allowed IPs will be added to this peer's allowed IPs
- and will be used to setup routing for all other peers except the relayed ones.` });
-    }
+ Will be used in the config referencing this peer (not the peer itself).` })
   }),
   meta: {
-    color: "#673AB7"
+    color: "#673AB7",
+    icon: "simple-icons:wireguard",
+    secondaryIcon: "mdi:badge-account-horizontal",
+    iconColor: "#88171a"
   }
 });
 var identityEntity = defineEntity({
@@ -5117,44 +6112,15 @@ var identityEntity = defineEntity({
     /**
      * The private key of the WireGuard identity.
      */
-    privateKey: z.string().meta({ title: camelCaseToHumanReadable("privateKey"), description: `The private key of the WireGuard identity.` })
+    privateKey: secretSchema(z.string()).meta({ title: camelCaseToHumanReadable("privateKey"), description: `The private key of the WireGuard identity.` })
   }),
   meta: {
-    color: "#F44336"
+    color: "#F44336",
+    icon: "simple-icons:wireguard",
+    secondaryIcon: "mdi:account",
+    iconColor: "#88171a"
   }
 });
-var feedDisplayInfoSchema = z.object({
-  /**
-   * The display title of the tunnel.
-   */
-  title: z.string().meta({ title: camelCaseToHumanReadable("title"), description: `The display title of the tunnel.` }),
-  /**
-   * The display description of the tunnel.
-   */
-  description: z.string().optional().meta({ title: camelCaseToHumanReadable("description"), description: `The display description of the tunnel.` }),
-  /**
-   * The display icon URL of the tunnel.
-   *
-   * Must only be `data:` URL with SVG image.
-   */
-  iconUrl: z.url().optional().meta({ title: camelCaseToHumanReadable("iconUrl"), description: `The display icon URL of the tunnel.
-
- Must only be \`data:\` URL with SVG image.` })
-});
-var feedMetadataSchema = z.object({
-  /**
-   * The ID of the tunnel in the feed.
-   */
-  id: z.string().meta({ title: camelCaseToHumanReadable("id"), description: `The ID of the tunnel in the feed.` }),
-  /**
-   * The suggested name of the interface for the tunnel.
-   */
-  name: genericNameSchema.meta({ title: camelCaseToHumanReadable("name"), description: `The suggested name of the interface for the tunnel.` }),
-  /**
-   * The display information of the tunnel.
-   */
-  displayInfo: feedDisplayInfoSchema.meta({ title: camelCaseToHumanReadable("displayInfo"), description: `The display information of the tunnel.` })
-});
 var configEntity = defineEntity({
   type: "wireguard.config.v1",
   includes: {
@@ -5172,7 +6138,14 @@ var configEntity = defineEntity({
     feedMetadata: feedMetadataSchema.optional().meta({ title: camelCaseToHumanReadable("feedMetadata"), description: `The metadata to include in the wg-feed for this config.
 
  Must be provided for the configs uploaded to wg-feed.` })
-  })
+  }),
+  meta: {
+    color: "#455A64",
+    title: "WireGuard Config",
+    icon: "simple-icons:wireguard",
+    iconColor: "#88171a",
+    secondaryIcon: "mdi:settings"
+  }
 });
 var network = defineUnit({
   type: "wireguard.network.v1",
@@ -5192,6 +6165,32 @@ var network = defineUnit({
     path: "network"
   }
 });
+var sharedFeedArgs = $args({
+  /**
+   * The metadata to include in the wg-feed for this config.
+   */
+  feedMetadata: $addArgumentDescription(z.discriminatedUnion("provided", [
+    z.object({
+      /**
+       * Whether this config is enabled for upload to wg-feed.
+       *
+       * You must fill the metadata fields.
+       */
+      provided: z.literal("yes").meta({ title: camelCaseToHumanReadable("provided"), description: `Whether this config is enabled for upload to wg-feed.
+
+ You must fill the metadata fields.` }),
+      ...pick(feedMetadataSchema.shape, ["id", "name", "enabled", "forced", "exclusive"]),
+      // Highstate does not support nested objects in UI
+      ...feedDisplayInfoSchema.shape
+    }),
+    z.object({
+      /**
+       * Whether this config is enabled for upload to wg-feed.
+       */
+      provided: z.literal("no").meta({ title: camelCaseToHumanReadable("provided"), description: `Whether this config is enabled for upload to wg-feed.` })
+    })
+  ]).prefault({ provided: "no" }), `The metadata to include in the wg-feed for this config.`)
+});
 var sharedPeerArgs = $args({
   /**
    * The name of the WireGuard peer.
@@ -5294,7 +6293,8 @@ var sharedPeerArgs = $args({
    */
   persistentKeepalive: $addArgumentDescription(z.number().int().nonnegative().default(0), `The keepalive interval in seconds that will be used by all nodes connecting to this peer.
 
- If set to 0, keepalive is disabled.`)
+ If set to 0, keepalive is disabled.`),
+  ...sharedFeedArgs
 });
 var sharedPeerInputs = $inputs({
   /**
@@ -5504,7 +6504,11 @@ var nodeK8s = defineUnit({
       entity: workloadEntity,
       required: false
     },
-    interface: {
+    downstreamInterface: {
+      entity: networkInterfaceEntity,
+      required: false
+    },
+    fallbackInterface: {
       entity: networkInterfaceEntity,
       required: false
     },
@@ -5538,6 +6542,111 @@ var nodeK8s = defineUnit({
     path: "node.k8s"
   }
 });
+var nodeFeedK8s = defineUnit({
+  type: "wireguard.node.feed.k8s.v1",
+  args: {
+    /**
+     * The name of the namespace/deployment/statefulset where the daemon will be deployed.
+     *
+     * By default, the name is `wg-${identity.name}`.
+     */
+    appName: $addArgumentDescription(z.string().optional(), `The name of the namespace/deployment/statefulset where the daemon will be deployed.
+
+ By default, the name is \`wg-\${identity.name}\`.`),
+    /**
+     * Whether to expose the WireGuard node to the outside world.
+     */
+    external: $addArgumentDescription(z.boolean().default(false), `Whether to expose the WireGuard node to the outside world.`),
+    /**
+     * Whether to create a Service and allow ingress.
+     */
+    expose: $addArgumentDescription(z.boolean().default(false), `Whether to create a Service and allow ingress.`),
+    /**
+     * The UDP port that will be exposed by the Service.
+     *
+     * This is required for consumers that need to know the port ahead of time.
+     */
+    listenPort: $addArgumentDescription(z.number().default(51820), `The UDP port that will be exposed by the Service.
+
+ This is required for consumers that need to know the port ahead of time.`),
+    /**
+     * The name of the WireGuard interface to export as `interface` output.
+     *
+     * Note: wg-feed may manage multiple tunnels.
+     * This output is a convenience handle for downstream units.
+     */
+    interfaceName: $addArgumentDescription(z.string().default("wg0"), `The name of the WireGuard interface to export as \`interface\` output.
+
+ Note: wg-feed may manage multiple tunnels.
+ This output is a convenience handle for downstream units.`),
+    /**
+     * List of CIDR blocks that should be blocked from forwarding through this WireGuard node.
+     *
+     * This prevents other peers from reaching these destination CIDRs while still allowing
+     * the peers in those CIDRs to access the internet and other allowed endpoints.
+     *
+     * Useful for peer isolation where you want to prevent cross-peer communication.
+     */
+    forwardRestrictedSubnets: $addArgumentDescription(z.string().array().default([]), `List of CIDR blocks that should be blocked from forwarding through this WireGuard node.
+
+ This prevents other peers from reaching these destination CIDRs while still allowing
+ the peers in those CIDRs to access the internet and other allowed endpoints.
+
+ Useful for peer isolation where you want to prevent cross-peer communication.`),
+    /**
+     * The extra specification of the container which runs the wg-feed daemon.
+     *
+     * Will override any overlapping fields.
+     */
+    containerSpec: $addArgumentDescription(z.record(z.string(), z.unknown()).optional(), `The extra specification of the container which runs the wg-feed daemon.
+
+ Will override any overlapping fields.`)
+  },
+  inputs: {
+    k8sCluster: clusterEntity,
+    endpoints: {
+      entity: l7EndpointEntity,
+      multiple: true,
+      required: false
+    },
+    peer: {
+      entity: peerEntity,
+      required: false
+    },
+    workload: {
+      entity: workloadEntity,
+      required: false
+    },
+    interface: {
+      entity: networkInterfaceEntity,
+      required: false
+    }
+  },
+  outputs: {
+    workload: {
+      entity: workloadEntity
+    },
+    interface: {
+      entity: networkInterfaceEntity
+    },
+    peer: {
+      entity: peerEntity,
+      required: false
+    }
+  },
+  meta: {
+    title: "WireGuard Feed Kubernetes Node",
+    description: "The wg-feed daemon deployed in the Kubernetes cluster.",
+    icon: "simple-icons:wireguard",
+    iconColor: "#88171a",
+    secondaryIcon: "devicon:kubernetes",
+    category: "VPN"
+  },
+  source: {
+    package: "@highstate/wireguard",
+    path: "node.feed.k8s"
+  }
+});
 var node2 = defineUnit({
   type: "wireguard.node.v1",
   args: {
@@ -5571,6 +6680,7 @@ var node2 = defineUnit({
     enableMasquerade: $addArgumentDescription(z.boolean().default(true), `Whether to enable IP masquerading (NAT) for outgoing traffic.
 
  By default, IP masquerading is enabled.`),
+    ...configSharedArgs,
     /**
      * Script to run before bringing up the interface.
      */
@@ -5604,11 +6714,6 @@ var node2 = defineUnit({
     peer: {
       entity: peerEntity,
       required: false
-    },
-    endpoints: {
-      entity: l4EndpointEntity,
-      required: false,
-      multiple: true
     }
   },
   meta: {
@@ -5624,48 +6729,11 @@ var node2 = defineUnit({
     path: "node"
   }
 });
-var sharedArgs3 = $args({
-  /**
-   * The filter to use when selecting endpoints for each peer.
-   *
-   * The first matching endpoint will be used.
-   *
-   * If not provided, all endpoints will be considered.
-   */
-  peerEndpointFilter: $addArgumentDescription(z.string().optional().meta({ language: "javascript" }), `The filter to use when selecting endpoints for each peer.
-
- The first matching endpoint will be used.
-
- If not provided, all endpoints will be considered.`)
-});
 var config = defineUnit({
   type: "wireguard.config.v1",
   args: {
-    ...sharedArgs3,
-    /**
-     * The metadata to include in the wg-feed for this config.
-     */
-    feedMetadata: $addArgumentDescription(z.discriminatedUnion("enabled", [
-      z.object({
-        /**
-         * Whether this config is enabled for upload to wg-feed.
-         *
-         * You must fill the metadata fields.
-         */
-        enabled: z.literal("true").meta({ title: camelCaseToHumanReadable("enabled"), description: `Whether this config is enabled for upload to wg-feed.
-
- You must fill the metadata fields.` }),
-        ...pick(feedMetadataSchema.shape, ["id", "name"]),
-        // Highstate does not support nested objects in UI
-        ...feedDisplayInfoSchema.shape
-      }),
-      z.object({
-        /**
-         * Whether this config is enabled for upload to wg-feed.
-         */
-        enabled: z.literal("false").meta({ title: camelCaseToHumanReadable("enabled"), description: `Whether this config is enabled for upload to wg-feed.` })
-      })
-    ]).prefault({ enabled: "false" }), `The metadata to include in the wg-feed for this config.`)
+    ...configSharedArgs,
+    ...sharedFeedArgs
   },
   inputs: {
     identity: identityEntity,
@@ -5673,6 +6741,10 @@ var config = defineUnit({
       entity: peerEntity,
       multiple: true,
       required: false
+    },
+    network: {
+      entity: networkEntity,
+      required: false
     }
   },
   outputs: {
@@ -5694,7 +6766,7 @@ var config = defineUnit({
 var configBundle = defineUnit({
   type: "wireguard.config-bundle.v1",
   args: {
-    ...sharedArgs3
+    ...configSharedArgs
   },
   inputs: {
     identity: identityEntity,
@@ -5790,7 +6862,7 @@ var feed = defineUnit({
  If not provided and \`publicKey\` is not provided, a new key pair will be generated.`)
   },
   inputs: {
-    etcd: etcdEntity,
+    etcd: etcd_exports.connectionEntity,
     serverEndpoints: {
       entity: l4EndpointEntity,
       required: false,
@@ -5865,18 +6937,24 @@ var peer2 = defineUnit({
 // src/third-party/timeweb.ts
 var timeweb_exports = {};
 __export(timeweb_exports, {
-  connection: () => connection3,
-  connectionEntity: () => connectionEntity,
+  connection: () => connection9,
+  connectionEntity: () => connectionEntity9,
   virtualMachine: () => virtualMachine2
 });
-var connectionEntity = defineEntity({
+var connectionEntity9 = defineEntity({
   type: "timeweb.connection.v1",
   schema: z.object({
     name: z.string(),
-    apiToken: z.string()
-  })
+    apiToken: secretSchema(z.string())
+  }),
+  meta: {
+    color: "#0078FF",
+    title: "Timeweb Connection",
+    icon: "material-symbols:cloud",
+    iconColor: "#0078FF"
+  }
 });
-var connection3 = defineUnit({
+var connection9 = defineUnit({
   type: "timeweb.connection.v1",
   secrets: {
     /**
@@ -5889,7 +6967,7 @@ var connection3 = defineUnit({
  Can be obtained from the Timeweb control panel.`)
   },
   outputs: {
-    connection: connectionEntity
+    connection: connectionEntity9
   },
   meta: {
     description: `The Timeweb connection for a single account.`,
@@ -5943,7 +7021,7 @@ var virtualMachine2 = defineUnit({
     ssh: $addArgumentDescription(vmSshArgs, `The SSH arguments to use for the virtual machine.`)
   },
   inputs: {
-    connection: connectionEntity,
+    connection: connectionEntity9,
     ...inputs
   },
   secrets: vmSecrets,
@@ -5966,22 +7044,24 @@ var virtualMachine2 = defineUnit({
 // src/third-party/yandex.ts
 var yandex_exports = {};
 __export(yandex_exports, {
-  connection: () => connection4,
-  connectionEntity: () => connectionEntity2,
+  connection: () => connection10,
+  connectionEntity: () => connectionEntity10,
   disk: () => disk,
   diskEntity: () => diskEntity,
   diskSchema: () => diskSchema,
   existingImage: () => existingImage2,
   imageEntity: () => imageEntity2,
+  instanceGroup: () => instanceGroup,
+  platformIdSchema: () => platformIdSchema,
   virtualMachine: () => virtualMachine3
 });
-var connectionEntity2 = defineEntity({
+var connectionEntity10 = defineEntity({
   type: "yandex.connection.v1",
   schema: z.object({
     /**
-     * The service account key file content (JSON).
+     * The JSON of the authorized key for the service account.
      */
-    serviceAccountKeyFile: z.string().optional().meta({ title: camelCaseToHumanReadable("serviceAccountKeyFile"), description: `The service account key file content (JSON).` }),
+    authorizedKeyJson: secretSchema(z.string()).meta({ title: camelCaseToHumanReadable("authorizedKeyJson"), description: `The JSON of the authorized key for the service account.` }),
     /**
      * The ID of the cloud.
      */
@@ -5997,13 +7077,20 @@ var connectionEntity2 = defineEntity({
     /**
      * The region ID.
      */
-    regionId: z.string().optional().meta({ title: camelCaseToHumanReadable("regionId"), description: `The region ID.` })
+    regionId: z.string().optional().meta({ title: camelCaseToHumanReadable("regionId"), description: `The region ID.` }),
+    /**
+     * The ID of the service account used for authentication.
+     */
+    serviceAccountId: z.string().meta({ title: camelCaseToHumanReadable("serviceAccountId"), description: `The ID of the service account used for authentication.` })
   }),
   meta: {
-    color: "#0080ff"
+    color: "#0080ff",
+    title: "YC Connection",
+    icon: "simple-icons:yandexcloud",
+    iconColor: "#0080ff"
   }
 });
-var connection4 = defineUnit({
+var connection10 = defineUnit({
   type: "yandex.connection.v1",
   args: {
     /**
@@ -6038,18 +7125,18 @@ var connection4 = defineUnit({
   },
   secrets: {
     /**
-     * The service account key file content (JSON).
+     * The JSON of the authorized key for the service account.
      *
      * Important: service account must have `iam.serviceAccounts.user` role to work properly.
      *
      * See [Creating an authorized key](https://yandex.cloud/en/docs/iam/operations/authentication/manage-authorized-keys#create-authorized-key) for details.
      */
-    serviceAccountKeyFile: $addArgumentDescription({
+    authorizedKeyJson: $addArgumentDescription({
       schema: z.string().meta({ language: "json" }),
       meta: {
-        title: "Service Account Key File"
+        title: "Authorized Key JSON"
       }
-    }, `The service account key file content (JSON).
+    }, `The JSON of the authorized key for the service account.
 
  Important: service account must have \`iam.serviceAccounts.user\` role to work properly.
 
@@ -6062,7 +7149,7 @@ var connection4 = defineUnit({
     /**
      * The Yandex Cloud connection.
      */
-    connection: $addInputDescription(connectionEntity2, `The Yandex Cloud connection.`)
+    connection: $addInputDescription(connectionEntity10, `The Yandex Cloud connection.`)
   },
   meta: {
     description: `The connection to a Yandex Cloud account.`,
@@ -6098,7 +7185,15 @@ var diskSchema = z.object({
    */
   size: z.number().default(20).meta({ title: camelCaseToHumanReadable("size"), description: `The disk size in GB.
 
- For \`network-ssd-nonreplicated\` and \`network-ssd-io-m3\` must be multiple of 93.` })
+ For \`network-ssd-nonreplicated\` and \`network-ssd-io-m3\` must be multiple of 93.` }),
+  /**
+   * Whether the disk should be encrypted by separate key in KMS.
+   *
+   * If `true`, a new key will be created for the disk.
+   */
+  encrypted: z.boolean().default(true).meta({ title: camelCaseToHumanReadable("encrypted"), description: `Whether the disk should be encrypted by separate key in KMS.
+
+ If \`true\`, a new key will be created for the disk.` })
 });
 var diskEntity = defineEntity({
   type: "yandex.disk.v1",
@@ -6127,7 +7222,7 @@ var disk = defineUnit({
     ...diskSchema.shape
   },
   inputs: {
-    connection: connectionEntity2
+    connection: connectionEntity10
   },
   outputs: {
     /**
@@ -6157,7 +7252,7 @@ var imageEntity2 = defineEntity({
     id: z.string().meta({ title: camelCaseToHumanReadable("id"), description: `The global ID of the image.` })
   }),
   meta: {
-    title: "Yandex Cloud Image",
+    title: "YC Image",
     icon: "simple-icons:yandexcloud",
     iconColor: "#0080ff",
     secondaryIcon: "mage:compact-disk-fill"
@@ -6178,7 +7273,7 @@ var existingImage2 = defineUnit({
  You can also use user images by specifying their IDs.`)
   },
   inputs: {
-    connection: connectionEntity2
+    connection: connectionEntity10
   },
   outputs: {
     /**
@@ -6199,99 +7294,123 @@ var existingImage2 = defineUnit({
     path: "existing-image"
   }
 });
-var virtualMachine3 = defineUnit({
-  type: "yandex.virtual-machine.v1",
-  args: {
-    /**
-     * The name of the virtual machine.
-     * If not specified, the name of the unit will be used.
-     */
-    vmName: $addArgumentDescription(z.string().optional(), `The name of the virtual machine.
- If not specified, the name of the unit will be used.`),
-    /**
-     * The platform ID for the instance.
-     *
-     * See [Platforms](https://yandex.cloud/en/docs/compute/concepts/vm-platforms) for details.
-     */
-    platformId: $addArgumentDescription(z.enum([
-      // standard platforms
-      "standard-v1",
-      "standard-v2",
-      "standard-v3",
-      "amd-v1",
-      "standard-v4a",
-      // high-performance platforms
-      "highfreq-v3",
-      "highfreq-v4a",
-      // with gpu
-      "gpu-standard-v1",
-      "gpu-standard-v2",
-      "gpu-standard-v3",
-      "gpu-standard-v3i",
-      "standard-v3-t4",
-      "standard-v3-t4i",
-      "gpu-platform-v4"
-    ]).default("standard-v3"), `The platform ID for the instance.
+var platformIdSchema = z.enum([
+  // standard platforms
+  "standard-v1",
+  "standard-v2",
+  "standard-v3",
+  "amd-v1",
+  "standard-v4a",
+  // high-performance platforms
+  "highfreq-v3",
+  "highfreq-v4a",
+  // with gpu
+  "gpu-standard-v1",
+  "gpu-standard-v2",
+  "gpu-standard-v3",
+  "gpu-standard-v3i",
+  "standard-v3-t4",
+  "standard-v3-t4i",
+  "gpu-platform-v4"
+]);
+var vmArgs = $args({
+  /**
+   * The platform ID for the instance.
+   *
+   * See [Platforms](https://yandex.cloud/en/docs/compute/concepts/vm-platforms) for details.
+   */
+  platformId: $addArgumentDescription(platformIdSchema.default("standard-v3"), `The platform ID for the instance.
 
  See [Platforms](https://yandex.cloud/en/docs/compute/concepts/vm-platforms) for details.`),
+  /**
+   * The resources to allocate to the virtual machine.
+   */
+  resources: $addArgumentDescription(z.object({
     /**
-     * The resources to allocate to the virtual machine.
+     * The number of CPU cores.
      */
-    resources: $addArgumentDescription(z.object({
-      /**
-       * The number of CPU cores.
-       */
-      cores: z.number().default(2).meta({ title: camelCaseToHumanReadable("cores"), description: `The number of CPU cores.` }),
-      /**
-       * The amount of memory in GB.
-       */
-      memory: z.number().default(4).meta({ title: camelCaseToHumanReadable("memory"), description: `The amount of memory in GB.` }),
-      /**
-       * The guaranteed CPU core performance (10-100).
-       */
-      coreFraction: z.number().min(10).max(100).optional().meta({ title: camelCaseToHumanReadable("coreFraction"), description: `The guaranteed CPU core performance (10-100).` })
-    }).prefault({}), `The resources to allocate to the virtual machine.`),
+    cores: z.number().default(2).meta({ title: camelCaseToHumanReadable("cores"), description: `The number of CPU cores.` }),
     /**
-     * The boot disk configuration.
+     * The amount of memory in GB.
      */
-    bootDisk: $addArgumentDescription(diskSchema.prefault({}), `The boot disk configuration.`),
+    memory: z.number().default(4).meta({ title: camelCaseToHumanReadable("memory"), description: `The amount of memory in GB.` }),
     /**
-     * The network configuration.
+     * The guaranteed CPU core performance (10-100).
      */
-    network: $addArgumentDescription(z.object({
-      /**
-       * The subnet ID to connect to.
-       * If not specified, will auto-discover the default subnet for the zone.
-       */
-      subnetId: z.string().optional().meta({ title: camelCaseToHumanReadable("subnetId"), description: `The subnet ID to connect to.
+    coreFraction: z.number().min(10).max(100).default(100).meta({ title: camelCaseToHumanReadable("coreFraction"), description: `The guaranteed CPU core performance (10-100).` })
+  }).prefault({}), `The resources to allocate to the virtual machine.`),
+  /**
+   * The boot disk configuration.
+   */
+  bootDisk: $addArgumentDescription(diskSchema.prefault({}), `The boot disk configuration.`),
+  /**
+   * The network configuration.
+   */
+  network: $addArgumentDescription(z.object({
+    /**
+     * The subnet ID to connect to.
+     * If not specified, will auto-discover the default subnet for the zone.
+     */
+    subnetId: z.string().optional().meta({ title: camelCaseToHumanReadable("subnetId"), description: `The subnet ID to connect to.
  If not specified, will auto-discover the default subnet for the zone.` }),
-      /**
-       * Whether to assign a public IP.
-       */
-      assignPublicIp: z.boolean().default(true).meta({ title: camelCaseToHumanReadable("assignPublicIp"), description: `Whether to assign a public IP.` }),
-      /**
-       * Whether to reserve the public IP permanently.
-       *
-       * If not set, the public IP can be changed when the VM is stopped and started again.
-       *
-       * Makes no sense if `assignPublicIp` is false.
-       */
-      reservePublicIp: z.boolean().default(true).meta({ title: camelCaseToHumanReadable("reservePublicIp"), description: `Whether to reserve the public IP permanently.
+    /**
+     * Whether to assign a public IP.
+     */
+    assignPublicIp: z.boolean().default(true).meta({ title: camelCaseToHumanReadable("assignPublicIp"), description: `Whether to assign a public IP.` }),
+    /**
+     * Whether to reserve the public IP permanently.
+     *
+     * If not set, the public IP can be changed when the VM is stopped and started again.
+     *
+     * Makes no sense if `assignPublicIp` is false.
+     */
+    reservePublicIp: z.boolean().default(true).meta({ title: camelCaseToHumanReadable("reservePublicIp"), description: `Whether to reserve the public IP permanently.
 
  If not set, the public IP can be changed when the VM is stopped and started again.
 
  Makes no sense if \`assignPublicIp\` is false.` })
-    }).prefault({}), `The network configuration.`),
+  }).prefault({}), `The network configuration.`),
+  /**
+   * The SSH configuration.
+   */
+  ssh: $addArgumentDescription(vmSshArgs, `The SSH configuration.`),
+  /**
+   * Whether the virtual machine is preemptible.
+   *
+   * See [Preemptible VMs](https://yandex.cloud/en/docs/compute/concepts/preemptible-vms) for details.
+   */
+  preemptible: $addArgumentDescription(z.boolean().default(false), `Whether the virtual machine is preemptible.
+
+ See [Preemptible VMs](https://yandex.cloud/en/docs/compute/concepts/preemptible-vms) for details.`)
+});
+var virtualMachine3 = defineUnit({
+  type: "yandex.virtual-machine.v1",
+  args: {
+    /**
+     * The name of the virtual machine.
+     * If not specified, the name of the unit will be used.
+     */
+    vmName: $addArgumentDescription(z.string().optional(), `The name of the virtual machine.
+ If not specified, the name of the unit will be used.`),
     /**
-     * The SSH configuration.
+     * The ID of the cloud to create the VM in.
+     * If not specified, will use the cloud from the connection.
      */
-    ssh: $addArgumentDescription(vmSshArgs, `The SSH configuration.`)
+    cloudId: $addArgumentDescription(z.string().optional(), `The ID of the cloud to create the VM in.
+ If not specified, will use the cloud from the connection.`),
+    /**
+     * The ID of the folder to create the VM in.
+     * If not specified, will use the default folder from the connection.
+     */
+    folderId: $addArgumentDescription(z.string().optional(), `The ID of the folder to create the VM in.
+ If not specified, will use the default folder from the connection.`),
+    ...vmArgs
   },
   secrets: {
     ...vmSecrets
   },
   inputs: {
-    connection: connectionEntity2,
+    connection: connectionEntity10,
     image: imageEntity2,
     ...inputs
   },
@@ -6309,7 +7428,61 @@ var virtualMachine3 = defineUnit({
     path: "virtual-machine"
   }
 });
+var instanceGroup = defineUnit({
+  type: "yandex.instance-group.v1",
+  args: {
+    /**
+     * The name of the instance group.
+     * If not specified, the name of the unit will be used.
+     */
+    groupName: $addArgumentDescription(z.string().optional(), `The name of the instance group.
+ If not specified, the name of the unit will be used.`),
+    /**
+     * The ID of the cloud to create the instance group in.
+     * If not specified, will use the cloud from the connection.
+     */
+    cloudId: $addArgumentDescription(z.string().optional(), `The ID of the cloud to create the instance group in.
+ If not specified, will use the cloud from the connection.`),
+    /**
+     * The ID of the folder to create the instance group in.
+     * If not specified, will use the default folder from the connection.
+     */
+    folderId: $addArgumentDescription(z.string().optional(), `The ID of the folder to create the instance group in.
+ If not specified, will use the default folder from the connection.`),
+    /**
+     * The number of instances to create in the group.
+     */
+    size: $addArgumentDescription(z.number().default(1), `The number of instances to create in the group.`),
+    ...vmArgs
+  },
+  secrets: {
+    ...vmSecrets
+  },
+  inputs: {
+    connection: connectionEntity10,
+    image: imageEntity2,
+    ...inputs
+  },
+  outputs: {
+    servers: {
+      entity: serverEntity,
+      multiple: true
+    }
+  },
+  meta: {
+    description: `The instance group on Yandex Cloud.`,
+    title: "YC Instance Group",
+    category: "Yandex Cloud",
+    icon: "simple-icons:yandexcloud",
+    iconColor: "#0080ff",
+    secondaryIcon: "mdi:group"
+  },
+  source: {
+    package: "@highstate/yandex",
+    path: "instance-group"
+  }
+});
 
-export { booleanPatchSchema, cloudflare_exports as cloudflare, common_exports as common, databases_exports as databases, distributions_exports as distributions, dns_exports as dns, git_exports as git, implementationReferenceSchema, k3s_exports as k3s, k8s_exports as k8s, metadataKeySchema, metadataSchema, mullvad_exports as mullvad, network_exports as network, nixos_exports as nixos, prefixKeysWith, proxmox_exports as proxmox, restic_exports as restic, sops_exports as sops, ssh_exports as ssh, talos_exports as talos, timeweb_exports as timeweb, toPatchArgs, wireguard_exports as wireguard, yandex_exports as yandex };
+export { booleanPatchSchema, cloudflare_exports as cloudflare, common_exports as common, distributions_exports as distributions, dns_exports as dns, etcd_exports as etcd, git_exports as git, implementationReferenceSchema, influxdb3_exports as influxdb3, k3s_exports as k3s, k8s_exports as k8s, metadataKeySchema, metadataSchema, minio_exports as minio, mongodb_exports as mongodb, mullvad_exports as mullvad, mysql_exports as mysql, network_exports as network, nixos_exports as nixos, postgresql_exports as postgresql, prefixKeysWith, proxmox_exports as proxmox, redis_exports as redis, restic_exports as restic, s3_exports as s3, sops_exports as sops, ssh_exports as ssh, talos_exports as talos, timeweb_exports as timeweb, toPatchArgs, wireguard_exports as wireguard, yandex_exports as yandex };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map