@highstate/library 0.11.7 → 0.12.1

package/dist/index.js

@@ -907,20 +907,20 @@ var secrets = $secrets({
   /**
    * The SSH private key in PEM format.
    */
-  sshPrivateKey: z.string().optional().meta({ multiline: true }),
+  sshPrivateKey: $addArgumentDescription(z.string().optional().meta({ multiline: true }), `The SSH private key in PEM format.`),
   /**
    * The SSH password to use for authentication.
    */
-  sshPassword: z.string().optional()
+  sshPassword: $addArgumentDescription(z.string().optional(), `The SSH password to use for authentication.`)
 });
 var inputs2 = $inputs({
   /**
    * The SSH key pair to use for authentication.
    */
-  sshKeyPair: {
+  sshKeyPair: $addInputDescription({
     entity: keyPairEntity,
     required: false
-  }
+  }, `The SSH key pair to use for authentication.`)
 });
 var keyPair = defineUnit({
   type: "ssh.key-pair.v1",
@@ -974,14 +974,14 @@ var serverOutputs = $outputs({
   /**
    * The server entity representing the server.
    */
-  server: serverEntity,
+  server: $addInputDescription(serverEntity, `The server entity representing the server.`),
   /**
    * The L3 endpoints of the server.
    */
-  endpoints: {
+  endpoints: $addInputDescription({
     entity: l3EndpointEntity,
     multiple: true
-  }
+  }, `The L3 endpoints of the server.`)
 });
 var vmSshArgs = argsSchema.omit({ user: true }).prefault({});
 var vmSecrets = $secrets({
@@ -990,13 +990,17 @@ var vmSecrets = $secrets({
    *
    * If not specified, will be generated automatically.
    */
-  rootPassword: z.string().optional(),
+  rootPassword: $addArgumentDescription(z.string().optional(), `The root password for the virtual machine.
+
+ If not specified, will be generated automatically.`),
   /**
    * The SSH private for the `root` user of the virtual machine in PEM format.
    *
    * If not specified or provided via `keyPair`, will be generated automatically.
    */
-  sshPrivateKey: secrets.sshPrivateKey
+  sshPrivateKey: $addArgumentDescription(secrets.sshPrivateKey, `The SSH private for the \`root\` user of the virtual machine in PEM format.
+
+ If not specified or provided via \`keyPair\`, will be generated automatically.`)
 });
 var existingServer = defineUnit({
   type: "common.existing-server.v1",
@@ -1145,9 +1149,15 @@ __export(databases_exports, {
   existingMariadb: () => existingMariadb,
   existingMongodb: () => existingMongodb,
   existingPostgresql: () => existingPostgresql,
+  existingRedis: () => existingRedis,
+  existingS3: () => existingS3,
   mariadbEntity: () => mariadbEntity,
   mongodbEntity: () => mongodbEntity,
   postgresqlEntity: () => postgresqlEntity,
+  redisEntity: () => redisEntity,
+  s3BucketPolicySchema: () => s3BucketPolicySchema,
+  s3BucketSchema: () => s3BucketSchema,
+  s3Entity: () => s3Entity,
   sharedArgs: () => sharedArgs,
   sharedInputs: () => sharedInputs,
   sharedSchema: () => sharedSchema,
@@ -1175,33 +1185,35 @@ var sharedArgs = $args({
   /**
    * The endpoints to connect to the database in form of `host:port`.
    */
-  endpoints: z.string().array().min(1),
+  endpoints: $addArgumentDescription(z.string().array().min(1), `The endpoints to connect to the database in form of \`host:port\`.`),
   /**
    * The username to connect to the database with.
    *
    * If not provided, defaults to `root`.
    */
-  username: z.string().default("root"),
+  username: $addArgumentDescription(z.string().default("root"), `The username to connect to the database with.
+
+ If not provided, defaults to \`root\`.`),
   /**
    * The name of the database to connect to.
    */
-  database: z.string().optional()
+  database: $addArgumentDescription(z.string().optional(), `The name of the database to connect to.`)
 });
 var sharedSecrets = $secrets({
   /**
    * The password to connect to the database with.
    */
-  password: z.string().optional()
+  password: $addArgumentDescription(z.string().optional(), `The password to connect to the database with.`)
 });
 var sharedInputs = $inputs({
   /**
    * The endpoints to connect to the database.
    */
-  endpoints: {
+  endpoints: $addInputDescription({
     entity: l4EndpointEntity,
     multiple: true,
     required: false
-  }
+  }, `The endpoints to connect to the database.`)
 });
 
 // src/databases/mariadb.ts
@@ -1289,6 +1301,132 @@ var existingPostgresql = defineUnit({
     category: "Databases"
   }
 });
+var redisEntity = defineEntity({
+  type: "databases.redis.v1",
+  schema: sharedSchema.pick({ endpoints: true }).extend({
+    /**
+     * The number of the database to use.
+     */
+    database: z.number().default(0)
+  }),
+  meta: {
+    description: `Represents the Redis database or virtual database behind it.`,
+    color: "#dc382d"
+  }
+});
+var existingRedis = defineUnit({
+  type: "databases.redis.existing.v1",
+  args: sharedArgs,
+  inputs: sharedInputs,
+  outputs: {
+    redis: redisEntity
+  },
+  source: {
+    package: "@highstate/common",
+    path: "units/databases/existing-redis"
+  },
+  meta: {
+    description: `The existing Redis database or virtual database behind it.`,
+    title: "Existing Redis Database",
+    icon: "simple-icons:redis",
+    secondaryIcon: "mdi:database",
+    category: "Databases"
+  }
+});
+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 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.`)
+});
+var s3Inputs = $inputs({
+  /**
+   * The endpoints to connect to the S3-compatible API.
+   */
+  endpoints: $addInputDescription({
+    entity: l4EndpointEntity,
+    multiple: true,
+    required: false
+  }, `The endpoints to connect to the S3-compatible API.`)
+});
+var s3Entity = defineEntity({
+  type: "databases.s3.v1",
+  schema: z.object({
+    /**
+     * The endpoints that expose the S3-compatible API.
+     */
+    endpoints: l4EndpointEntity.schema.array().meta({ title: camelCaseToHumanReadable("endpoints"), description: `The endpoints that expose the S3-compatible API.` }),
+    /**
+     * The region associated with the object storage instance.
+     */
+    region: z.string().optional().meta({ title: camelCaseToHumanReadable("region"), description: `The region associated with the object storage instance.` }),
+    /**
+     * The access key used to authenticate against the API.
+     */
+    accessKey: z.string().meta({ title: camelCaseToHumanReadable("accessKey"), description: `The access key used to authenticate against the API.` }),
+    /**
+     * The secret key used to authenticate against the API.
+     */
+    secretKey: z.string().meta({ title: camelCaseToHumanReadable("secretKey"), description: `The secret key used to authenticate against the API.` }),
+    /**
+     * The buckets that must exist on the instance.
+     */
+    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,
+  outputs: {
+    s3: s3Entity
+  },
+  source: {
+    package: "@highstate/common",
+    path: "units/databases/existing-s3"
+  },
+  meta: {
+    description: `The existing S3-compatible object storage instance.`,
+    title: "Existing S3-Compatible Storage",
+    icon: "simple-icons:amazons3",
+    secondaryIcon: "mdi:bucket",
+    category: "Databases"
+  }
+});
 
 // src/distributions/index.ts
 var distributions_exports = {};
@@ -1571,7 +1709,11 @@ var scheduleOnMastersPolicyArgs = $args({
    * - `when-no-workers`: schedule workloads on master nodes only if there are no workers (default);
    * - `never`: never schedule workloads on master nodes.
    */
-  scheduleOnMastersPolicy: scheduleOnMastersPolicySchema.default("when-no-workers")
+  scheduleOnMastersPolicy: $addArgumentDescription(scheduleOnMastersPolicySchema.default("when-no-workers"), `The policy for scheduling workloads on master nodes.
+
+ - \`always\`: always schedule workloads on master nodes regardless of the number of workers;
+ - \`when-no-workers\`: schedule workloads on master nodes only if there are no workers (default);
+ - \`never\`: never schedule workloads on master nodes.`)
 });
 var clusterInputs = {
   masters: {
@@ -1800,6 +1942,22 @@ var cluster = defineUnit({
      */
     config: $addArgumentDescription(z.record(z.string(), z.unknown()).optional(), `The K3S configuration to pass to each server or agent in the cluster.
 
+ See: https://docs.k3s.io/installation/configuration`),
+    /**
+     * The K3S configuration to pass to each server in the cluster.
+     *
+     * See: https://docs.k3s.io/installation/configuration
+     */
+    serverConfig: $addArgumentDescription(z.record(z.string(), z.unknown()).optional(), `The K3S configuration to pass to each server in the cluster.
+
+ See: https://docs.k3s.io/installation/configuration`),
+    /**
+     * The K3S configuration to pass to each agent in the cluster.
+     *
+     * See: https://docs.k3s.io/installation/configuration
+     */
+    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 configuration of the registries to use for the K3S cluster.
@@ -1888,6 +2046,7 @@ __export(apps_exports, {
   mariadb: () => mariadb,
   mariadbDatabase: () => mariadbDatabase,
   maybe: () => maybe,
+  minio: () => minio,
   mongodb: () => mongodb,
   mongodbDatabase: () => mongodbDatabase,
   optionalSharedArgs: () => optionalSharedArgs,
@@ -1899,6 +2058,7 @@ __export(apps_exports, {
   sharedSecrets: () => sharedSecrets2,
   syncthing: () => syncthing,
   traefik: () => traefik,
+  valkey: () => valkey,
   vaultwarden: () => vaultwarden,
   workload: () => workload
 });
@@ -2091,21 +2251,23 @@ var sharedArgs2 = $args({
   /**
    * The FQDN where the application will be accessible.
    */
-  fqdn: z.string(),
+  fqdn: $addArgumentDescription(z.string(), `The FQDN where the application will be accessible.`),
   /**
    * The endpoints where the application will or should be accessible.
    *
    * Can be both L3 (IP addresses) or L4 (IP:port) endpoints and the interpretation is up to the application.
    */
-  endpoints: z.string().array().default([]),
+  endpoints: $addArgumentDescription(z.string().array().default([]), `The endpoints where the application will or should be accessible.
+
+ Can be both L3 (IP addresses) or L4 (IP:port) endpoints and the interpretation is up to the application.`),
   /**
    * Whether the application should be exposed externally by NodePort or LoadBalancer service.
    */
-  external: z.boolean().default(false),
+  external: $addArgumentDescription(z.boolean().default(false), `Whether the application should be exposed externally by NodePort or LoadBalancer service.`),
   /**
    * The number of replicas for the application.
    */
-  replicas: z.number().default(1)
+  replicas: $addArgumentDescription(z.number().default(1), `The number of replicas for the application.`)
 });
 var optionalSharedArgs = mapValues(sharedArgs2, (arg) => ({
   ...arg,
@@ -2130,11 +2292,11 @@ var sharedSecrets2 = $secrets({
   /**
    * The root password for the database instance. If not provided, a random password will be generated.
    */
-  rootPassword: z.string().optional(),
+  rootPassword: $addArgumentDescription(z.string().optional(), `The root password for the database instance. 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: z.string().optional()
+  backupKey: $addArgumentDescription(z.string().optional(), `The key to use for backup encryption. If not provided, a random key will be generated.`)
 });
 var sharedDatabaseArgs = $args({
   /**
@@ -2142,13 +2304,17 @@ var sharedDatabaseArgs = $args({
    *
    * If not provided, defaults to the name of the instance.
    */
-  username: z.string().optional(),
+  username: $addArgumentDescription(z.string().optional(), `The username for the database user.
+
+ If not provided, defaults to the name of the instance.`),
   /**
    * The name of the database to create.
    *
    * If not provided, defaults to the username.
    */
-  database: z.string().optional()
+  database: $addArgumentDescription(z.string().optional(), `The name of the database to create.
+
+ If not provided, defaults to the username.`)
 });
 var sharedDatabaseSecrets = $secrets({
   /**
@@ -2156,7 +2322,9 @@ var sharedDatabaseSecrets = $secrets({
    *
    * If not provided, a random password will be generated.
    */
-  password: z.string().optional()
+  password: $addArgumentDescription(z.string().optional(), `The password for the database user.
+
+ If not provided, a random password will be generated.`)
 });
 var sharedInputs2 = $inputs({
   k8sCluster: {
@@ -2186,6 +2354,9 @@ var sharedInputs2 = $inputs({
   },
   mongodb: {
     entity: mongodbEntity
+  },
+  redis: {
+    entity: redisEntity
   }
 });
 var optionalSharedInputs = mapValues(sharedInputs2, (input) => ({
@@ -2352,7 +2523,7 @@ var maybe = defineUnit({
     secretKey: z.string().optional()
   },
   inputs: {
-    ...pick(sharedInputs2, ["k8sCluster", "accessPoint", "postgresql"]),
+    ...pick(sharedInputs2, ["k8sCluster", "accessPoint", "postgresql", "redis"]),
     ...pick(optionalSharedInputs, ["resticRepo"])
   },
   meta: {
@@ -2363,6 +2534,68 @@ var maybe = defineUnit({
   },
   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.`)
+});
+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.
+        `
+      }
+    }
+  },
+  secrets: minioSecrets,
+  inputs: {
+    ...pick(sharedInputs2, ["k8sCluster"]),
+    ...pick(optionalSharedInputs, ["resticRepo"])
+  },
+  outputs: {
+    s3: s3Entity,
+    service: serviceEntity,
+    endpoints: {
+      entity: l4EndpointEntity,
+      multiple: true
+    }
+  },
+  meta: {
+    description: `The MinIO object storage deployed on Kubernetes.`,
+    title: "MinIO",
+    icon: "simple-icons:minio",
+    secondaryIcon: "mdi:bucket",
+    category: "Databases"
+  },
+  source: source("minio/app")
+});
 var mongodb = defineUnit({
   type: "k8s.apps.mongodb.v1",
   args: {
@@ -2530,7 +2763,14 @@ var traefik = defineUnit({
   args: {
     ...appName("traefik"),
     ...pick(sharedArgs2, ["external", "replicas", "endpoints"]),
-    className: z.string().optional()
+    /**
+     * The name of the class to configure for ingress and gateway resources.
+     *
+     * Defaults to "traefik".
+     */
+    className: $addArgumentDescription(z.string().default("traefik"), `The name of the class to configure for ingress and gateway resources.
+
+ Defaults to "traefik".`)
   },
   inputs: {
     ...pick(sharedInputs2, ["k8sCluster"])
@@ -2551,6 +2791,36 @@ var traefik = defineUnit({
   },
   source: source("traefik")
 });
+var valkey = defineUnit({
+  type: "k8s.apps.valkey.v1",
+  args: {
+    ...appName("valkey"),
+    ...pick(sharedArgs2, ["external"])
+  },
+  secrets: {
+    ...pick(sharedSecrets2, ["backupKey"])
+  },
+  inputs: {
+    ...pick(sharedInputs2, ["k8sCluster"]),
+    ...pick(optionalSharedInputs, ["resticRepo"])
+  },
+  outputs: {
+    redis: databases_exports.redisEntity,
+    service: serviceEntity,
+    endpoints: {
+      entity: l4EndpointEntity,
+      multiple: true
+    }
+  },
+  meta: {
+    description: `The Valkey instance deployed on Kubernetes.`,
+    title: "Valkey (Redis)",
+    icon: "simple-icons:redis",
+    secondaryIcon: "mdi:database",
+    category: "Databases"
+  },
+  source: source("valkey/app")
+});
 var vaultwarden = defineUnit({
   type: "k8s.apps.vaultwarden.v1",
   args: {
@@ -3630,6 +3900,14 @@ var existingImage = defineUnit({
 var virtualMachine = defineUnit({
   type: "proxmox.virtual-machine.v1",
   args: {
+    /**
+     * The name of the virtual machine.
+     *
+     * If not specified, the unit name will be used.
+     */
+    vmName: $addArgumentDescription(z.string().optional(), `The name of the virtual machine.
+
+ If not specified, the unit name will be used.`),
     /**
      * The name of the node to create the virtual machine on.
      *
@@ -4776,6 +5054,14 @@ var connection3 = defineUnit({
 var virtualMachine2 = defineUnit({
   type: "timeweb.virtual-machine.v1",
   args: {
+    /**
+     * The name of the virtual machine.
+     *
+     * If not provided, the name of the unit will be used.
+     */
+    vmName: $addArgumentDescription(z.string().optional(), `The name of the virtual machine.
+
+ If not provided, the name of the unit will be used.`),
     /**
      * The ID of the preset to use for the virtual machine.
      *
@@ -4829,46 +5115,94 @@ var virtualMachine2 = defineUnit({
 // src/third-party/yandex.ts
 var yandex_exports = {};
 __export(yandex_exports, {
-  cloudEntity: () => cloudEntity,
   connection: () => connection4,
+  connectionEntity: () => connectionEntity2,
+  disk: () => disk,
+  diskEntity: () => diskEntity,
+  diskSchema: () => diskSchema,
+  existingImage: () => existingImage2,
+  imageEntity: () => imageEntity2,
   virtualMachine: () => virtualMachine3
 });
-var cloudEntity = defineEntity({
-  type: "yandex.cloud.v0",
+var connectionEntity2 = defineEntity({
+  type: "yandex.connection.v1",
   schema: z.object({
-    token: z.string().optional(),
-    serviceAccountKeyFile: z.string().optional(),
-    cloudId: z.string(),
-    defaultFolderId: z.string(),
-    defaultZone: z.string(),
-    regionId: z.string().optional()
+    /**
+     * The service account key file content (JSON).
+     */
+    serviceAccountKeyFile: z.string().optional().meta({ title: camelCaseToHumanReadable("serviceAccountKeyFile"), description: `The service account key file content (JSON).` }),
+    /**
+     * The ID of the cloud.
+     */
+    cloudId: z.string().meta({ title: camelCaseToHumanReadable("cloudId"), description: `The ID of the cloud.` }),
+    /**
+     * The default folder ID.
+     */
+    defaultFolderId: z.string().meta({ title: camelCaseToHumanReadable("defaultFolderId"), description: `The default folder ID.` }),
+    /**
+     * The default availability zone.
+     */
+    defaultZone: z.string().meta({ title: camelCaseToHumanReadable("defaultZone"), description: `The default availability zone.` }),
+    /**
+     * The region ID.
+     */
+    regionId: z.string().optional().meta({ title: camelCaseToHumanReadable("regionId"), description: `The region ID.` })
   }),
   meta: {
     color: "#0080ff"
   }
 });
 var connection4 = defineUnit({
-  type: "yandex.connection.v0",
+  type: "yandex.connection.v1",
   args: {
     /**
-     * The availability zone for resources.
-     */
-    defaultZone: $addArgumentDescription(z.string().default("ru-central1-d"), `The availability zone for resources.`),
-    /**
-     * The region ID for resources.
+     * The region to create connection for.
+     *
+     * See [Regions](https://yandex.cloud/en/docs/overview/concepts/region) for details.
      */
-    regionId: $addArgumentDescription(z.string().default("ru-central1"), `The region ID for resources.`)
+    region: $addArgumentDescription(z.discriminatedUnion("id", [
+      z.object({
+        /**
+         * The ID of the region.
+         */
+        id: z.literal("ru-central1").meta({ title: camelCaseToHumanReadable("id"), description: `The ID of the region.` }),
+        /**
+         * The default availability zone in ru-central1 to place resources in.
+         */
+        defaultZone: z.enum(["ru-central1-a", "ru-central1-b", "ru-central1-d"]).default("ru-central1-d").meta({ title: camelCaseToHumanReadable("defaultZone"), description: `The default availability zone in ru-central1 to place resources in.` })
+      }),
+      z.object({
+        /**
+         * The ID of the region.
+         */
+        id: z.literal("kz1").meta({ title: camelCaseToHumanReadable("id"), description: `The ID of the region.` }),
+        /**
+         * The default availability zone in kz1 to place resources in.
+         */
+        defaultZone: z.enum(["kz1-a"]).default("kz1-a").meta({ title: camelCaseToHumanReadable("defaultZone"), description: `The default availability zone in kz1 to place resources in.` })
+      })
+    ]).prefault({ id: "ru-central1" }), `The region to create connection for.
+
+ See [Regions](https://yandex.cloud/en/docs/overview/concepts/region) for details.`)
   },
   secrets: {
     /**
      * The service account key file content (JSON).
+     *
+     * 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({
       schema: z.string().meta({ language: "json" }),
       meta: {
         title: "Service Account Key File"
       }
-    }, `The service account key file content (JSON).`)
+    }, `The service account key file content (JSON).
+
+ 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.`)
   },
   inputs: {
     ...inputs2
@@ -4877,11 +5211,11 @@ var connection4 = defineUnit({
     /**
      * The Yandex Cloud connection.
      */
-    yandexCloud: $addInputDescription(cloudEntity, `The Yandex Cloud connection.`)
+    connection: $addInputDescription(connectionEntity2, `The Yandex Cloud connection.`)
   },
   meta: {
     description: `The connection to a Yandex Cloud account.`,
-    title: "Yandex Cloud Connection",
+    title: "YC Connection",
     category: "Yandex Cloud",
     icon: "simple-icons:yandexcloud",
     iconColor: "#0080ff"
@@ -4891,13 +5225,164 @@ var connection4 = defineUnit({
     path: "connection"
   }
 });
+var diskSchema = z.object({
+  /**
+   * The disk type.
+   *
+   * - Network SSD (network-ssd): Fast network drive; SSD network block storage.
+   * - Network HDD (network-hdd): Standard network drive; HDD network block storage.
+   * - Non-replicated SSD (network-ssd-nonreplicated): Enhanced performance network drive without redundancy.
+   * - Ultra high-speed network storage with three replicas (SSD) (network-ssd-io-m3): High-performance SSD offering the same speed as network-ssd-nonreplicated, plus redundancy.
+   */
+  type: z.enum(["network-ssd", "network-hdd", "network-ssd-nonreplicated", "network-ssd-io-m3"]).default("network-ssd").meta({ title: camelCaseToHumanReadable("type"), description: `The disk type.
+
+ - Network SSD (network-ssd): Fast network drive; SSD network block storage.
+ - Network HDD (network-hdd): Standard network drive; HDD network block storage.
+ - Non-replicated SSD (network-ssd-nonreplicated): Enhanced performance network drive without redundancy.
+ - Ultra high-speed network storage with three replicas (SSD) (network-ssd-io-m3): High-performance SSD offering the same speed as network-ssd-nonreplicated, plus redundancy.` }),
+  /**
+   * The disk size in GB.
+   *
+   * For `network-ssd-nonreplicated` and `network-ssd-io-m3` must be multiple of 93.
+   */
+  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.` })
+});
+var diskEntity = defineEntity({
+  type: "yandex.disk.v1",
+  schema: z.object({
+    /**
+     * The global ID of the disk.
+     */
+    id: z.string().meta({ title: camelCaseToHumanReadable("id"), description: `The global ID of the disk.` })
+  }),
+  meta: {
+    title: "YC Disk",
+    icon: "simple-icons:yandexcloud",
+    iconColor: "#0080ff",
+    secondaryIcon: "icon-park-outline:disk"
+  }
+});
+var disk = defineUnit({
+  type: "yandex.disk.v1",
+  args: {
+    /**
+     * The name of the disk in the folder.
+     * If not specified, the name of the unit will be used.
+     */
+    diskName: $addArgumentDescription(z.string().optional(), `The name of the disk in the folder.
+ If not specified, the name of the unit will be used.`),
+    ...diskSchema.shape
+  },
+  inputs: {
+    connection: connectionEntity2
+  },
+  outputs: {
+    /**
+     * The disk entity.
+     */
+    disk: $addInputDescription(diskEntity, `The disk entity.`)
+  },
+  meta: {
+    description: `The disk on Yandex Cloud.`,
+    title: "YC Disk",
+    category: "Yandex Cloud",
+    icon: "icon-park-outline:disk",
+    iconColor: "#0080ff",
+    secondaryIcon: "mage:compact-disk-fill"
+  },
+  source: {
+    package: "@highstate/yandex",
+    path: "disk"
+  }
+});
+var imageEntity2 = defineEntity({
+  type: "yandex.image.v1",
+  schema: z.object({
+    /**
+     * The global ID of the image.
+     */
+    id: z.string().meta({ title: camelCaseToHumanReadable("id"), description: `The global ID of the image.` })
+  }),
+  meta: {
+    title: "Yandex Cloud Image",
+    icon: "simple-icons:yandexcloud",
+    iconColor: "#0080ff",
+    secondaryIcon: "mage:compact-disk-fill"
+  }
+});
+var existingImage2 = defineUnit({
+  type: "yandex.existing-image.v1",
+  args: {
+    /**
+     * The ID of the image.
+     *
+     * See [Yandex Cloud Marketplace Images](https://yandex.cloud/en/marketplace) to find available images and their IDs.
+     * You can also use user images by specifying their IDs.
+     */
+    id: $addArgumentDescription(z.string(), `The ID of the image.
+
+ See [Yandex Cloud Marketplace Images](https://yandex.cloud/en/marketplace) to find available images and their IDs.
+ You can also use user images by specifying their IDs.`)
+  },
+  inputs: {
+    connection: connectionEntity2
+  },
+  outputs: {
+    /**
+     * The image entity.
+     */
+    image: $addInputDescription(imageEntity2, `The image entity.`)
+  },
+  meta: {
+    description: `The existing image from Yandex Cloud Marketplace or user images.`,
+    title: "YC Existing Image",
+    category: "Yandex Cloud",
+    icon: "simple-icons:yandexcloud",
+    iconColor: "#0080ff",
+    secondaryIcon: "mage:compact-disk-fill"
+  },
+  source: {
+    package: "@highstate/yandex",
+    path: "existing-image"
+  }
+});
 var virtualMachine3 = defineUnit({
-  type: "yandex.virtual-machine.v0",
+  type: "yandex.virtual-machine.v1",
   args: {
     /**
-     * The platform ID for the instance.
+     * The name of the virtual machine.
+     * If not specified, the name of the unit will be used.
      */
-    platformId: $addArgumentDescription(z.string().default("standard-v3"), `The platform ID for the instance.`),
+    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.
+
+ See [Platforms](https://yandex.cloud/en/docs/compute/concepts/vm-platforms) for details.`),
     /**
      * The resources to allocate to the virtual machine.
      */
@@ -4911,31 +5396,14 @@ var virtualMachine3 = defineUnit({
        */
       memory: z.number().default(4).meta({ title: camelCaseToHumanReadable("memory"), description: `The amount of memory in GB.` }),
       /**
-       * The core fraction (10-100).
+       * The guaranteed CPU core performance (10-100).
        */
-      coreFraction: z.number().min(10).max(100).optional().meta({ title: camelCaseToHumanReadable("coreFraction"), description: `The core fraction (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.`),
     /**
      * The boot disk configuration.
      */
-    disk: $addArgumentDescription(z.object({
-      /**
-       * The disk size in GB.
-       *
-       * For `network-ssd-nonreplicated` must be multiple of 93.
-       */
-      size: z.number().default(20).meta({ title: camelCaseToHumanReadable("size"), description: `The disk size in GB.
-
- For \`network-ssd-nonreplicated\` must be multiple of 93.` }),
-      /**
-       * The disk type.
-       */
-      type: z.string().default("network-ssd-nonreplicated").meta({ title: camelCaseToHumanReadable("type"), description: `The disk type.` }),
-      /**
-       * The image family to use.
-       */
-      imageFamily: z.string().default("ubuntu-2204-lts").meta({ title: camelCaseToHumanReadable("imageFamily"), description: `The image family to use.` })
-    }).prefault({}), `The boot disk configuration.`),
+    bootDisk: $addArgumentDescription(diskSchema.prefault({}), `The boot disk configuration.`),
     /**
      * The network configuration.
      */
@@ -4951,44 +5419,35 @@ var virtualMachine3 = defineUnit({
        */
       assignPublicIp: z.boolean().default(true).meta({ title: camelCaseToHumanReadable("assignPublicIp"), description: `Whether to assign a public IP.` }),
       /**
-       * The list of DNS servers.
+       * 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.
        */
-      dns: ipv46Schema.array().default([]).meta({ title: camelCaseToHumanReadable("dns"), description: `The list of DNS servers.` })
+      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.`),
-    /**
-     * The IPv4 address configuration.
-     */
-    ipv4: $addArgumentDescription(z.discriminatedUnion("type", [
-      z.object({
-        type: z.literal("dhcp")
-      }),
-      z.object({
-        type: z.literal("static"),
-        address: z.string(),
-        prefix: ipv4PrefixSchema.default(24),
-        gateway: z.string().optional()
-      })
-    ]).default({ type: "dhcp" }), `The IPv4 address configuration.`),
     /**
      * The SSH configuration.
      */
-    ssh: $addArgumentDescription(vmSshArgs, `The SSH configuration.`),
-    /**
-     * Additional metadata for cloud-init.
-     */
-    metadata: $addArgumentDescription(z.record(z.string(), z.string()).default({}), `Additional metadata for cloud-init.`)
+    ssh: $addArgumentDescription(vmSshArgs, `The SSH configuration.`)
   },
   secrets: {
     ...vmSecrets
   },
   inputs: {
-    yandexCloud: cloudEntity,
+    connection: connectionEntity2,
+    image: imageEntity2,
     ...inputs2
   },
   outputs: serverOutputs,
   meta: {
     description: `The virtual machine on Yandex Cloud.`,
-    title: "Yandex Cloud Virtual Machine",
+    title: "YC Virtual Machine",
     category: "Yandex Cloud",
     icon: "simple-icons:yandexcloud",
     iconColor: "#0080ff",