@homeflare/alchemy 0.1.0

package/dist/proxmox/index.js

@@ -0,0 +1,2322 @@
+// src/proxmox/acl.ts
+import { Resource } from "alchemy";
+import { isResolved as isResolved2 } from "alchemy/Diff";
+import * as Provider from "alchemy/Provider";
+import * as Effect6 from "effect/Effect";
+
+// src/proxmox/client.ts
+import * as Effect4 from "effect/Effect";
+import * as HttpClient5 from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest2 from "effect/unstable/http/HttpClientRequest";
+
+// src/proxmox/credentials.ts
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as Headers from "effect/unstable/http/Headers";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+var baoVariable = (env, name) => env[`BAO_${name}`] ?? env[`VAULT_${name}`] ?? "";
+var mint = (target, role, env = process.env) => Effect.gen(function* () {
+  const path = `${target.mount}/creds/${role}`;
+  const refuse = (status2, detail) => new Error(`OpenBao GET /v1/${path} -> ${status2 === 0 ? "no response" : status2}: ${detail}`);
+  const address = baoVariable(env, "AGENT_ADDR") || baoVariable(env, "ADDR") || "https://127.0.0.1:8200";
+  const socket = address.startsWith("unix://") ? address.slice("unix://".length) : undefined;
+  const base = socket === undefined ? address.replace(/\/+$/, "") : "http://localhost";
+  const headers = { "X-Vault-Request": "true" };
+  const namespace = baoVariable(env, "NAMESPACE");
+  if (namespace !== "")
+    headers["X-Vault-Namespace"] = namespace;
+  const token = baoVariable(env, "TOKEN");
+  if (token !== "")
+    headers["X-Vault-Token"] = token;
+  if (socket !== undefined && !("Bun" in globalThis)) {
+    return yield* Effect.fail(refuse(0, "a unix:// address needs Bun fetch; this is not Bun"));
+  }
+  const client = yield* HttpClient.HttpClient;
+  const redacted = yield* Headers.CurrentRedactedNames;
+  const defaults = Option.getOrElse(yield* Effect.serviceOption(FetchHttpClient.RequestInit), () => ({}));
+  const request = HttpClientRequest.get(`${base}/v1/${path}`).pipe(HttpClientRequest.setHeaders(headers));
+  const exchange = client.execute(request).pipe(Effect.flatMap((response) => Effect.map(response.text, (text2) => ({ status: response.status, text: text2 }))), Effect.timeout("60 seconds"), Effect.provideService(Headers.CurrentRedactedNames, [...redacted, "x-vault-token"]));
+  const init = { ...defaults, unix: socket };
+  const { status, text } = yield* (socket === undefined ? exchange : Effect.provideService(exchange, FetchHttpClient.RequestInit, init)).pipe(Effect.mapError((cause) => refuse(0, cause.message)));
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    parsed = undefined;
+  }
+  if (status < 200 || status >= 300) {
+    const errors = parsed?.errors;
+    const detail = Array.isArray(errors) ? errors.map(String).join("; ") : "not an OpenBao error body";
+    return yield* Effect.fail(refuse(status, detail || "(no errors given)"));
+  }
+  const tokenId = parsed?.data?.token_id;
+  const secret = parsed?.data?.secret;
+  if (typeof tokenId !== "string" || typeof secret !== "string") {
+    return yield* Effect.fail(new Error(`${target.mount}/creds/${role} returned no token_id/secret. Either this approle lacks ` + `the grant, or the mount is not ${target.mount}. Say which mount and role you needed ` + `than falling back to a stored credential -- every stored PVE token is read-only.`));
+  }
+  const lease = parsed?.lease_duration;
+  const leaseSeconds = typeof lease === "number" ? lease : 0;
+  return { leaseSeconds, secret, tokenId };
+});
+var authorization = (credential, target) => target.scheme === "pbs" ? `PBSAPIToken=${credential.tokenId}:${credential.secret}` : `PVEAPIToken=${credential.tokenId}=${credential.secret}`;
+
+// src/proxmox/lease-cache.ts
+import * as Cache from "effect/Cache";
+import * as Duration from "effect/Duration";
+import * as Effect2 from "effect/Effect";
+import * as Exit from "effect/Exit";
+var REMINT_MARGIN_SECONDS = 60;
+var keyOf = (target, role) => ({
+  mount: target.mount,
+  role,
+  scheme: target.scheme
+});
+var timeToLive = (exit) => Exit.isSuccess(exit) && exit.value.leaseSeconds > REMINT_MARGIN_SECONDS ? Duration.seconds(exit.value.leaseSeconds - REMINT_MARGIN_SECONDS) : Duration.zero;
+var makeLeases = (mintFor) => Cache.makeWith(mintFor, { capacity: 64, requireServicesAt: "lookup", timeToLive });
+var targetForKey = (key) => key.scheme === "pbs" ? { api: "https://pbs.invalid/api2/json", mount: key.mount, scheme: "pbs" } : { members: [], mount: key.mount, scheme: "pve" };
+var leases = Effect2.runSync(makeLeases((key) => mint(targetForKey(key), key.role)));
+var leased = (target, role) => Cache.get(leases, keyOf(target, role));
+
+// src/proxmox/members.ts
+import * as Effect3 from "effect/Effect";
+import * as Result from "effect/Result";
+import * as HttpClient3 from "effect/unstable/http/HttpClient";
+import * as HttpClientError from "effect/unstable/http/HttpClientError";
+var PVE_API_PORT = 8006;
+var pveApiBase = (member) => `https://${member}:${String(PVE_API_PORT)}/api2/json`;
+var lastGoodByMount = new Map;
+var noteGoodMember = (target, member) => {
+  lastGoodByMount.set(target.mount, member);
+};
+var orderedMembers = (target) => {
+  const preferred = lastGoodByMount.get(target.mount);
+  if (preferred === undefined || !target.members.includes(preferred))
+    return target.members;
+  return [preferred, ...target.members.filter((member) => member !== preferred)];
+};
+var errorCode = (cause) => {
+  if (cause !== null && typeof cause === "object") {
+    if ("code" in cause && typeof cause.code === "string")
+      return cause.code;
+    if ("cause" in cause)
+      return errorCode(cause.cause);
+  }
+  return;
+};
+var isTimeoutCause = (cause) => {
+  const code = errorCode(cause);
+  if (code === "AbortError" || code === "ETIMEDOUT" || code === "UND_ERR_CONNECT_TIMEOUT") {
+    return true;
+  }
+  return cause instanceof Error && /timed out|timeout/i.test(cause.message);
+};
+var PRE_SEND_CODES = new Set(["ConnectionRefused", "ECONNREFUSED", "ENOTFOUND", "EAI_AGAIN"]);
+var isCertificateCode = (code) => /^(ERR_TLS_CERT_|CERT_|UNABLE_TO_VERIFY_|DEPTH_ZERO_SELF_SIGNED|SELF_SIGNED_CERT)/.test(code);
+var isPreSendCause = (cause) => {
+  const code = errorCode(cause);
+  return code !== undefined && (PRE_SEND_CODES.has(code) || isCertificateCode(code));
+};
+var isTransportFailure = (cause) => {
+  if (!HttpClientError.isHttpClientError(cause))
+    return false;
+  const tag = cause.reason._tag;
+  return tag === "TransportError" || tag === "InvalidUrlError" || tag === "EncodeError";
+};
+var isPreSendTransport = (cause) => {
+  if (!HttpClientError.isHttpClientError(cause))
+    return false;
+  const { reason } = cause;
+  if (reason._tag === "InvalidUrlError" || reason._tag === "EncodeError")
+    return true;
+  if (reason._tag === "TransportError") {
+    if (isTimeoutCause(reason.cause))
+      return false;
+    return isPreSendCause(reason.cause);
+  }
+  return false;
+};
+var describeTransport = (cause) => {
+  if (HttpClientError.isHttpClientError(cause))
+    return cause.message;
+  return String(cause);
+};
+var executeOnCluster = (target, method, path, build) => Effect3.gen(function* () {
+  const client = yield* HttpClient3.HttpClient;
+  const isWrite = method !== "GET";
+  const attempts = [];
+  for (const member of orderedMembers(target)) {
+    const outcome = yield* client.execute(build(pveApiBase(member))).pipe(Effect3.result);
+    if (Result.isSuccess(outcome)) {
+      noteGoodMember(target, member);
+      return outcome.success;
+    }
+    const why = describeTransport(outcome.failure);
+    attempts.push({ member, why });
+    const mayRetry = isWrite ? isPreSendTransport(outcome.failure) : isTransportFailure(outcome.failure);
+    if (!mayRetry) {
+      return yield* Effect3.fail({ attempts, method, path, tag: "cluster" });
+    }
+  }
+  return yield* Effect3.fail({ attempts, method, path, tag: "cluster" });
+});
+
+// src/proxmox/client.ts
+class PveError extends Error {
+  status;
+  method;
+  path;
+  constructor(status, method, path, detail) {
+    super(`PVE ${method} ${path} -> ${String(status)}: ${detail}`);
+    this.status = status;
+    this.method = method;
+    this.path = path;
+    this.name = "PveError";
+  }
+}
+var clusterExhausted = (method, path, attempts) => new PveError(0, method, path, `all members failed: ${attempts.map((a) => `${a.member} (${a.why})`).join("; ")}`);
+var encode = (form) => {
+  const params = new URLSearchParams;
+  for (const [key, value] of Object.entries(form)) {
+    if (typeof value === "string")
+      params.append(key, value);
+    else
+      for (const item of value)
+        params.append(key, item);
+  }
+  return params.toString();
+};
+var buildRequest = (method, apiBase, path, credential, target, form) => {
+  const url = `${apiBase}/${path}`;
+  return HttpClientRequest2.make(method)(url).pipe(HttpClientRequest2.setHeaders({ Authorization: authorization(credential, target) }), form === undefined ? (self) => self : HttpClientRequest2.bodyText(encode(form), "application/x-www-form-urlencoded"));
+};
+var executeOne = (target, credential, method, path, form, apiBase) => Effect4.gen(function* () {
+  const client = yield* HttpClient5.HttpClient;
+  const request = buildRequest(method, apiBase, path, credential, target, form);
+  return yield* client.execute(request).pipe(Effect4.mapError((cause) => new PveError(0, method, path, String(cause))));
+});
+var readResponse = (response, method, path) => Effect4.gen(function* () {
+  if (response.status < 200 || response.status >= 300) {
+    const detail = yield* response.text.pipe(Effect4.orElseSucceed(() => ""));
+    return yield* Effect4.fail(new PveError(response.status, method, path, detail.slice(0, 300)));
+  }
+  const body = yield* response.json.pipe(Effect4.mapError((cause) => new PveError(0, method, path, String(cause))));
+  return body.data;
+});
+var pveWith = (target, credential, method, path, form) => Effect4.gen(function* () {
+  const response = target.scheme === "pve" ? yield* executeOnCluster(target, method, path, (apiBase) => buildRequest(method, apiBase, path, credential, target, form)).pipe(Effect4.mapError((failure) => failure.tag === "cluster" ? clusterExhausted(failure.method, failure.path, failure.attempts) : new PveError(0, method, path, String(failure)))) : yield* executeOne(target, credential, method, path, form, target.api);
+  return yield* readResponse(response, method, path);
+});
+var pveEnvelopeWith = (target, credential, method, path) => Effect4.gen(function* () {
+  const response = yield* executeOnCluster(target, method, path, (apiBase) => buildRequest(method, apiBase, path, credential, target)).pipe(Effect4.mapError((failure) => failure.tag === "cluster" ? clusterExhausted(failure.method, failure.path, failure.attempts) : new PveError(0, method, path, String(failure))));
+  if (response.status < 200 || response.status >= 300) {
+    const detail = yield* response.text.pipe(Effect4.orElseSucceed(() => ""));
+    return yield* Effect4.fail(new PveError(response.status, method, path, detail.slice(0, 300)));
+  }
+  return yield* response.json.pipe(Effect4.mapError((cause) => new PveError(0, method, path, String(cause))));
+});
+var pve = (target, role, method, path, form) => Effect4.gen(function* () {
+  const credential = yield* leased(target, role);
+  return yield* pveWith(target, credential, method, path, form);
+});
+
+// src/proxmox/resource.ts
+import { isResolved } from "alchemy/Diff";
+import * as Effect5 from "effect/Effect";
+var pveOperations = (spec) => {
+  const read = (props) => pve(props.target, spec.readRole ?? "read", "GET", spec.path(props)).pipe(Effect5.map((data) => data === undefined ? undefined : spec.attributes(data, props)), Effect5.orElseSucceed(() => {
+    return;
+  }));
+  return {
+    read,
+    diff: (news, output) => Effect5.gen(function* () {
+      if (output === undefined || !isResolved(news))
+        return;
+      const live = yield* read(news);
+      if (live === undefined)
+        return { action: "update" };
+      if (spec.matches(live, news))
+        return { action: "noop" };
+      return spec.updateForm === undefined ? { action: "replace" } : { action: "update" };
+    }),
+    reconcile: (news) => Effect5.gen(function* () {
+      const live = yield* read(news);
+      if (live === undefined) {
+        yield* pve(news.target, "provision", "POST", spec.collection(news), spec.createForm(news));
+      } else if (spec.updateForm !== undefined && !spec.matches(live, news)) {
+        const form = spec.updateForm(news);
+        if (Object.keys(form).length > 0) {
+          yield* pve(news.target, "provision", "PUT", spec.path(news), form);
+        }
+      }
+      const after = yield* read(news);
+      if (after === undefined) {
+        return yield* Effect5.die(new Error(`${spec.path(news)}: the write returned no error but the object is still absent. ` + 'PVE wraps every answer in {"data":...} and can report success on a call that did ' + "nothing -- read back rather than trusting the status code."));
+      }
+      return after;
+    }),
+    destroy: (olds) => pve(olds.target, "provision", "DELETE", spec.path(olds))
+  };
+};
+var pveHandlers = (spec) => {
+  const ops = pveOperations(spec);
+  return {
+    list: () => Effect5.succeed([]),
+    read: ({ olds }) => ops.read(olds),
+    diff: ({ news, output }) => ops.diff(news, output),
+    reconcile: ({ news }) => ops.reconcile(news),
+    delete: ({ olds }) => ops.destroy(olds)
+  };
+};
+
+// src/proxmox/acl.ts
+var ProxmoxAcl = Resource("Proxmox.Acl");
+var normalize = (raw) => `/${raw.split("/").filter(Boolean).join("/")}`;
+var SUBJECT_FIELD = { group: "groups", token: "tokens", user: "users" };
+var tuple = (props) => ({
+  path: normalize(props.path),
+  roles: props.roleid,
+  [SUBJECT_FIELD[props.type]]: props.ugid
+});
+var bind = (props) => ({
+  propagate: props.propagate === false ? "0" : "1",
+  ...tuple(props)
+});
+var identity = (grant) => [normalize(grant.path), grant.type, grant.ugid, grant.roleid].join(" ");
+var find = (live, props) => (Array.isArray(live) ? live : []).filter((row) => typeof row === "object" && row !== null).find((row) => row["path"] === normalize(props.path) && row["type"] === props.type && row["ugid"] === props.ugid && row["roleid"] === props.roleid);
+var propagates = (row) => {
+  const value = row["propagate"];
+  return value === undefined || value === 1 || value === true || value === "1";
+};
+var ops = pveOperations({
+  attributes: (live, props) => {
+    const row = find(live, props);
+    return {
+      bound: row !== undefined,
+      path: normalize(props.path),
+      propagate: row !== undefined && propagates(row),
+      roleid: props.roleid,
+      type: props.type,
+      ugid: props.ugid
+    };
+  },
+  readRole: "provision",
+  collection: () => "access/acl",
+  createForm: bind,
+  matches: (attributes, props) => attributes.bound && attributes.propagate === (props.propagate !== false),
+  path: () => "access/acl",
+  updateForm: bind
+});
+var ProxmoxAclProvider = () => Provider.effect(ProxmoxAcl, Effect6.succeed(ProxmoxAcl.Provider.of({
+  list: () => Effect6.succeed([]),
+  read: Effect6.fn(function* ({ olds }) {
+    return yield* ops.read(olds);
+  }),
+  diff: Effect6.fn(function* ({ news, output }) {
+    if (output !== undefined && isResolved2(news) && identity(news) !== identity(output)) {
+      return { action: "replace" };
+    }
+    return yield* ops.diff(news, output);
+  }),
+  reconcile: Effect6.fn(function* ({ news }) {
+    const after = yield* ops.reconcile(news);
+    if (!after.bound) {
+      return yield* Effect6.die(new Error(`access/acl: the write returned no error but ${identity(news)} is still not ` + "bound. Either the PUT did nothing, or the read credential cannot see the " + "grant -- GET /access/acl is filtered to paths you may MODIFY permissions on, " + "so a read-only role is answered [] rather than 403."));
+    }
+    return after;
+  }),
+  delete: Effect6.fn(function* ({ olds }) {
+    const removal = { delete: "1", ...tuple(olds) };
+    yield* pve(olds.target, "provision", "PUT", "access/acl", removal);
+  })
+})));
+// src/proxmox/api-token.ts
+import { Resource as Resource2 } from "alchemy";
+import * as Provider2 from "alchemy/Provider";
+import * as Effect7 from "effect/Effect";
+
+// src/proxmox/values.ts
+var num = (value, fallback) => typeof value === "number" ? value : fallback;
+var text = (value, fallback = "") => typeof value === "string" ? value : fallback;
+var bool = (value, fallback = false) => value === undefined || value === null || value === "" ? fallback : value === 1 || value === true || value === "1";
+var flag = (value) => value === undefined ? undefined : value ? "1" : "0";
+var csv = (value) => (typeof value === "string" ? value.split(",") : value ?? []).map((part) => part.trim()).filter((part) => part !== "").sort().join(",");
+var guestList = (value) => {
+  const parts = typeof value === "string" ? value.split(",") : Array.isArray(value) ? value.map((entry) => String(entry)) : [];
+  return parts.map((part) => Number(part.trim())).filter((id) => Number.isFinite(id)).sort((left, right) => left - right).map((id) => String(id)).join(",");
+};
+var canonicalToken = (raw) => {
+  const lowered = raw.trim().toLowerCase();
+  if (["1", "yes", "true", "on"].includes(lowered))
+    return "1";
+  if (["0", "no", "false", "off"].includes(lowered))
+    return "0";
+  return lowered;
+};
+var propertyString = (value, defaultKey) => {
+  const pairs = typeof value === "string" ? value.split(",").map((part) => {
+    const [key, ...rest] = part.split("=");
+    return rest.length === 0 && defaultKey !== undefined ? [defaultKey, key ?? ""] : [key ?? "", rest.join("=")];
+  }) : typeof value === "object" && value !== null ? Object.entries(value).map(([key, entry]) => [key, String(entry)]) : [];
+  return pairs.map(([key, entry]) => [key.trim(), canonicalToken(entry)]).filter(([key]) => key !== "").map(([key, entry]) => `${key}=${entry}`).sort().join(",");
+};
+var int = (value, fallback) => {
+  if (typeof value === "number")
+    return value;
+  const parsed = Number.parseInt(text(value), 10);
+  return Number.isNaN(parsed) ? fallback : parsed;
+};
+var withClears = (fields, clear) => {
+  const cleared = new Set(clear);
+  const kept = {};
+  for (const [key, value] of Object.entries(fields)) {
+    if (value !== undefined && !cleared.has(key))
+      kept[key] = value;
+  }
+  return cleared.size === 0 ? kept : { ...kept, delete: [...cleared].join(",") };
+};
+
+// src/proxmox/api-token-form.ts
+var fullTokenid = (props) => `${props.userid}!${props.tokenid}`;
+var shape = (props) => ({
+  comment: props.comment ?? "",
+  expire: String(props.expire),
+  privsep: props.privsep ? "1" : "0"
+});
+var apiTokenSpec = {
+  readRole: "provision",
+  attributes: (live, props) => {
+    const expire = live["expire"];
+    const privsep = live["privsep"];
+    if (expire === undefined && privsep === undefined)
+      return;
+    return {
+      comment: text(live["comment"]),
+      expire: int(expire, 0),
+      fullTokenid: fullTokenid(props),
+      privsep: bool(privsep, true),
+      tokenid: props.tokenid,
+      userid: props.userid
+    };
+  },
+  collection: (props) => `access/users/${props.userid}/token/${props.tokenid}`,
+  createForm: shape,
+  matches: (attributes, props) => attributes.comment === (props.comment ?? "") && attributes.expire === props.expire && attributes.privsep === props.privsep,
+  path: (props) => `access/users/${props.userid}/token/${props.tokenid}`,
+  updateForm: shape
+};
+
+// src/proxmox/api-token.ts
+var ProxmoxApiToken = Resource2("Proxmox.ApiToken", {
+  defaultRemovalPolicy: "retain"
+});
+var ops2 = pveOperations(apiTokenSpec);
+var handlers = {
+  ...pveHandlers(apiTokenSpec),
+  reconcile: Effect7.fn(function* ({ news }) {
+    const live = yield* ops2.read(news);
+    if (live === undefined) {
+      return yield* Effect7.die(new Error(`${news.userid}!${news.tokenid}: this resource does not create API tokens. PVE returns ` + "the secret only in the create response and it cannot be stored, so a token made here " + "would be a live credential nobody holds. Create it with `pveum user token add` and " + "capture the value, or mint a short-lived one from the OpenBao proxmox mount " + "(`bao read proxmox-tb4/creds/<role>`) -- then declare it here to manage it."));
+    }
+    return yield* ops2.reconcile(news);
+  })
+};
+var ProxmoxApiTokenProvider = () => Provider2.effect(ProxmoxApiToken, Effect7.succeed(ProxmoxApiToken.Provider.of(handlers)));
+// src/proxmox/backup-job.ts
+import { Resource as Resource3 } from "alchemy";
+import * as Provider3 from "alchemy/Provider";
+import * as Effect8 from "effect/Effect";
+var ProxmoxBackupJob = Resource3("Proxmox.BackupJob");
+var shape2 = (props) => ({
+  all: props.all === true ? "1" : "0",
+  enabled: props.enabled === false ? "0" : "1",
+  mode: props.mode ?? "snapshot",
+  "notification-mode": props["notification-mode"] ?? "auto",
+  "repeat-missed": props["repeat-missed"] === true ? "1" : "0",
+  schedule: props.schedule,
+  ...props.comment === undefined ? {} : { comment: props.comment },
+  ...props.exclude === undefined ? {} : { exclude: guestList(props.exclude) },
+  ...props.fleecing === undefined ? {} : { fleecing: props.fleecing },
+  ...props["notes-template"] === undefined ? {} : { "notes-template": props["notes-template"] },
+  ...props.pool === undefined ? {} : { pool: props.pool },
+  ...props["prune-backups"] === undefined ? {} : { "prune-backups": props["prune-backups"] },
+  ...props.storage === undefined ? {} : { storage: props.storage },
+  ...props.vmid === undefined ? {} : { vmid: guestList(props.vmid) }
+});
+var handlers2 = pveHandlers({
+  attributes: (live, props) => ({
+    all: bool(live["all"], false),
+    comment: text(live["comment"], ""),
+    enabled: bool(live["enabled"], true),
+    exclude: guestList(live["exclude"]),
+    fleecing: propertyString(live["fleecing"], "enabled"),
+    id: props.id,
+    mode: text(live["mode"], "snapshot"),
+    "next-run": typeof live["next-run"] === "number" ? live["next-run"] : 0,
+    "notes-template": text(live["notes-template"], ""),
+    "notification-mode": text(live["notification-mode"], "auto"),
+    pool: text(live["pool"], ""),
+    "prune-backups": propertyString(live["prune-backups"]),
+    "repeat-missed": bool(live["repeat-missed"], false),
+    schedule: text(live["schedule"], ""),
+    storage: text(live["storage"], ""),
+    vmid: guestList(live["vmid"])
+  }),
+  collection: () => "cluster/backup",
+  createForm: (props) => ({ ...shape2(props), id: props.id }),
+  matches: (attributes, props) => attributes.schedule === props.schedule && attributes.enabled === (props.enabled !== false) && attributes.all === (props.all === true) && attributes.mode === (props.mode ?? "snapshot") && attributes["notification-mode"] === (props["notification-mode"] ?? "auto") && attributes["repeat-missed"] === (props["repeat-missed"] === true) && (props.storage === undefined || attributes.storage === props.storage) && (props.pool === undefined || attributes.pool === props.pool) && (props.comment === undefined || attributes.comment === props.comment) && (props.vmid === undefined || attributes.vmid === guestList(props.vmid)) && (props.exclude === undefined || attributes.exclude === guestList(props.exclude)) && (props["notes-template"] === undefined || attributes["notes-template"] === props["notes-template"]) && (props["prune-backups"] === undefined || attributes["prune-backups"] === propertyString(props["prune-backups"])) && (props.fleecing === undefined || attributes.fleecing === propertyString(props.fleecing, "enabled")),
+  path: (props) => `cluster/backup/${props.id}`,
+  updateForm: shape2
+});
+var ProxmoxBackupJobProvider = () => Provider3.effect(ProxmoxBackupJob, Effect8.succeed(ProxmoxBackupJob.Provider.of(handlers2)));
+// src/proxmox/ceph-daemon.ts
+import { Resource as Resource4 } from "alchemy";
+import * as Provider4 from "alchemy/Provider";
+import * as Effect9 from "effect/Effect";
+
+// src/proxmox/ceph-daemon-form.ts
+var daemonId = (props) => props.name ?? props.node;
+var collectionPath = (props) => `nodes/${props.node}/ceph/${props.kind}`;
+var daemonPath = (props) => `${collectionPath(props)}/${daemonId(props)}`;
+var createForm = (props) => {
+  if (props.kind === "mon" && props["mon-address"] !== undefined) {
+    return { "mon-address": props["mon-address"] };
+  }
+  const hotstandby = props.kind === "mds" ? flag(props.hotstandby) : undefined;
+  return hotstandby === undefined ? {} : { hotstandby };
+};
+var findRow = (live, props) => (Array.isArray(live) ? live : []).filter((row) => typeof row === "object" && row !== null).find((row) => row["name"] === daemonId(props));
+
+// src/proxmox/ceph-daemon.ts
+var ProxmoxCephDaemon = Resource4("Proxmox.CephDaemon", {
+  defaultRemovalPolicy: "retain"
+});
+var handlers3 = pveHandlers({
+  attributes: (live, props) => {
+    const row = findRow(live, props);
+    if (row === undefined)
+      return;
+    return {
+      addr: text(row["addr"]),
+      fsName: text(row["fs_name"]),
+      host: text(row["host"]),
+      kind: props.kind,
+      name: daemonId(props),
+      node: props.node,
+      quorum: bool(row["quorum"]),
+      rank: num(row["rank"], -1),
+      service: bool(row["service"]),
+      standbyReplay: bool(row["standby_replay"]),
+      state: text(row["state"]),
+      version: text(row["ceph_version_short"])
+    };
+  },
+  collection: daemonPath,
+  createForm,
+  matches: () => true,
+  path: collectionPath
+});
+var ProxmoxCephDaemonProvider = () => Provider4.effect(ProxmoxCephDaemon, Effect9.succeed(ProxmoxCephDaemon.Provider.of({
+  ...handlers3,
+  delete: ({ olds }) => pve(olds.target, "provision", "DELETE", daemonPath(olds))
+})));
+// src/proxmox/ceph-flag.ts
+import { Resource as Resource5 } from "alchemy";
+import * as Provider5 from "alchemy/Provider";
+import * as Effect10 from "effect/Effect";
+var ProxmoxCephFlag = Resource5("Proxmox.CephFlag");
+var handlers4 = pveHandlers({
+  attributes: (live, props) => ({ flag: props.flag, value: bool(live) }),
+  collection: () => "cluster/ceph/flags",
+  createForm: (props) => ({ [props.flag]: flag(props.value) ?? "0" }),
+  matches: (attributes, props) => attributes.value === props.value,
+  path: (props) => `cluster/ceph/flags/${props.flag}`,
+  updateForm: (props) => ({ value: flag(props.value) ?? "0" })
+});
+var ProxmoxCephFlagProvider = () => Provider5.effect(ProxmoxCephFlag, Effect10.succeed(ProxmoxCephFlag.Provider.of({
+  ...handlers4,
+  delete: () => Effect10.void,
+  reconcile: Effect10.fn(function* ({ news }) {
+    const after = yield* handlers4.reconcile({ news });
+    if (after.value !== news.value) {
+      return yield* Effect10.die(new Error(`cluster/ceph/flags/${news.flag}: the PUT returned no error but ceph still ` + `reports the flag ${after.value ? "set" : "clear"} rather than ` + `${news.value ? "set" : "clear"}. This endpoint's success is documented as a ` + "null body, so the status code proves nothing -- check `ceph osd dump | " + "head -1` and the cluster log. `pause` in particular is two ceph flags read " + "as one; see the header."));
+    }
+    return after;
+  })
+})));
+// src/proxmox/ceph-fs.ts
+import { Resource as Resource6 } from "alchemy";
+import { isResolved as isResolved3 } from "alchemy/Diff";
+import * as Provider6 from "alchemy/Provider";
+import * as Effect12 from "effect/Effect";
+
+// src/proxmox/ceph-fs-wire.ts
+import * as Effect11 from "effect/Effect";
+var readRow = (live, props) => {
+  const row = (Array.isArray(live) ? live : []).filter((entry) => typeof entry === "object" && entry !== null).find((entry) => entry["name"] === props.name);
+  if (row === undefined)
+    return;
+  return {
+    data_pool: text(row["data_pool"]),
+    data_pools: csv(Array.isArray(row["data_pools"]) ? row["data_pools"].map((entry) => String(entry)) : []),
+    metadata_pool: text(row["metadata_pool"]),
+    metadata_pool_id: int(row["metadata_pool_id"], -1),
+    name: props.name
+  };
+};
+var POLL_SECONDS = 2;
+var POLL_ATTEMPTS = 45;
+var objectPath = (props) => `nodes/${props.node}/ceph/fs/${props.name}`;
+var field = (name, value) => value === undefined ? {} : { [name]: value };
+var createForm2 = (props) => ({
+  ...field("add-storage", flag(props["add-storage"])),
+  ...field("pg_num", props.pg_num === undefined ? undefined : String(props.pg_num))
+});
+var destroyPath = (props) => {
+  const query = [
+    props["remove-pools"] === true ? "remove-pools=1" : undefined,
+    props["remove-storages"] === true ? "remove-storages=1" : undefined
+  ].filter((part) => part !== undefined);
+  return query.length === 0 ? objectPath(props) : `${objectPath(props)}?${query.join("&")}`;
+};
+var settle = (target, node, upid, what) => Effect11.gen(function* () {
+  for (let attempt = 0;attempt < POLL_ATTEMPTS; attempt += 1) {
+    const status = yield* pve(target, "read", "GET", `nodes/${node}/tasks/${encodeURIComponent(upid)}/status`).pipe(Effect11.orElseSucceed(() => {
+      return;
+    }));
+    if (status?.status === "stopped") {
+      const exit = text(status.exitstatus);
+      if (exit === "OK")
+        return;
+      return yield* Effect11.die(new Error(`${what}: PVE task ${upid} finished with "${exit === "" ? "no exit status" : exit}". ` + "The write returned HTTP 200 because it only forked the worker -- the real error is " + `in \`pvesh get /nodes/${node}/tasks/${upid}/log\`.`));
+    }
+    yield* Effect11.sleep(POLL_SECONDS * 1000);
+  }
+  return yield* Effect11.die(new Error(`${what}: PVE task ${upid} was still running after ` + `${String(POLL_ATTEMPTS * POLL_SECONDS)}s, or its ` + "status could not be read. Check the task log, and check that the `read` role holds " + `Sys.Audit on /nodes/${node} -- each call mints a new token, so the poller is never the ` + "task owner and is answered 403 rather than told to wait."));
+});
+var createFs = (props) => Effect11.gen(function* () {
+  const upid = text(yield* pve(props.target, "provision", "POST", objectPath(props), createForm2(props)));
+  if (upid === "") {
+    return yield* Effect11.die(new Error(`${objectPath(props)}: POST returned no task id. PVE wraps every answer in ` + '{"data":...} and can report success on a call that did nothing.'));
+  }
+  yield* settle(props.target, props.node, upid, objectPath(props));
+});
+var destroyFs = (props) => Effect11.gen(function* () {
+  const upid = text(yield* pve(props.target, "provision", "DELETE", destroyPath(props)));
+  if (upid !== "")
+    yield* settle(props.target, props.node, upid, destroyPath(props));
+});
+var notCreated = (props) => new Error(`${objectPath(props)}: the create task finished but the filesystem is not in ` + `GET nodes/${props.node}/ceph/fs. Check the task log -- a PVE worker can exit having ` + "rolled back the pools it had just made.");
+var notDestroyed = (props) => new Error(`${objectPath(props)}: the destroy task finished but the filesystem is still in ` + `GET nodes/${props.node}/ceph/fs. PVE refuses to destroy a CephFS while a PVE storage entry ` + "of type cephfs still references it and is not disabled.");
+
+// src/proxmox/ceph-fs.ts
+var ProxmoxCephFs = Resource6("Proxmox.CephFs", {
+  defaultRemovalPolicy: "retain"
+});
+var ops3 = pveOperations({
+  attributes: readRow,
+  collection: objectPath,
+  createForm: createForm2,
+  matches: () => true,
+  path: (props) => `nodes/${props.node}/ceph/fs`
+});
+var ProxmoxCephFsProvider = () => Provider6.effect(ProxmoxCephFs, Effect12.succeed(ProxmoxCephFs.Provider.of({
+  list: () => Effect12.succeed([]),
+  read: Effect12.fn(function* ({ olds }) {
+    return yield* ops3.read(olds);
+  }),
+  diff: Effect12.fn(function* ({ news, output }) {
+    if (output !== undefined && isResolved3(news) && news.name !== output.name) {
+      return { action: "replace" };
+    }
+    return yield* ops3.diff(news, output);
+  }),
+  reconcile: Effect12.fn(function* ({ news }) {
+    const live = yield* ops3.read(news);
+    if (live !== undefined)
+      return live;
+    yield* createFs(news);
+    const after = yield* ops3.read(news);
+    if (after === undefined)
+      return yield* Effect12.die(notCreated(news));
+    return after;
+  }),
+  delete: Effect12.fn(function* ({ olds }) {
+    if ((yield* ops3.read(olds)) === undefined)
+      return;
+    yield* destroyFs(olds);
+    const after = yield* ops3.read(olds);
+    if (after !== undefined)
+      return yield* Effect12.die(notDestroyed(olds));
+  })
+})));
+// src/proxmox/ceph-osd.ts
+import { Resource as Resource7 } from "alchemy";
+import { isResolved as isResolved4 } from "alchemy/Diff";
+import * as Provider7 from "alchemy/Provider";
+import * as Effect15 from "effect/Effect";
+
+// src/proxmox/ceph-osd-tree.ts
+import * as Effect13 from "effect/Effect";
+var branches = (node) => (Array.isArray(node["children"]) ? node["children"] : []).filter((child) => typeof child === "object" && child !== null);
+var osdLeaves = (tree) => {
+  const root = tree["root"];
+  const start = typeof root === "object" && root !== null ? root : {};
+  const walk = (node) => [
+    ...node["type"] === "osd" ? [node] : [],
+    ...branches(node).flatMap(walk)
+  ];
+  return walk(start);
+};
+var findOsd = (tree, osdid) => osdLeaves(tree).find((leaf) => int(leaf["id"], Number.NaN) === osdid);
+var osdAttributes = (leaf, props) => ({
+  ceph_version: text(leaf["ceph_version_short"]),
+  crush_weight: num(leaf["crush_weight"], 0),
+  device_class: text(leaf["device_class"]),
+  host: text(leaf["host"]),
+  in: bool(leaf["in"]),
+  name: text(leaf["name"], `osd.${String(props.osdid)}`),
+  osdid: int(leaf["id"], props.osdid),
+  osdtype: text(leaf["osdtype"]),
+  pgs: num(leaf["pgs"], 0),
+  reweight: num(leaf["reweight"], 0),
+  status: text(leaf["status"]),
+  total_space: num(leaf["total_space"], 0)
+});
+var readOsd = (props) => pve(props.target, "read", "GET", `nodes/${props.node}/ceph/osd`).pipe(Effect13.map((t) => {
+  const leaf = t === undefined ? undefined : findOsd(t, props.osdid);
+  return leaf === undefined ? undefined : osdAttributes(leaf, props);
+}));
+
+// src/proxmox/ceph-osd-write.ts
+import * as Effect14 from "effect/Effect";
+var describe = (props) => `osd.${String(props.osdid)} on ${props.node}`;
+var createOsd = Effect14.fn(function* (news) {
+  if (news.dev === undefined) {
+    return yield* Effect14.die(new Error(`${describe(news)}: no such OSD in the CRUSH tree, and no \`dev\` was declared. ` + "Without a device this resource is an ASSERTION over an OSD that must already " + "exist. Declare `dev` to let it create one -- which WIPES that device -- or fix " + "the declaration; if the disk was there yesterday, a replica is missing and Ceph " + "is degraded."));
+  }
+  yield* pve(news.target, "provision", "POST", `nodes/${news.node}/ceph/osd`, {
+    dev: news.dev,
+    ...news.device_class === undefined ? {} : { "crush-device-class": news.device_class }
+  });
+  const created = yield* readOsd(news);
+  if (created === undefined) {
+    return yield* Effect14.die(new Error(`${describe(news)}: the create returned no error but osd.${String(news.osdid)} is ` + "still absent. Ceph allocates OSD ids and cannot be told which to use, so it most " + "likely assigned a different number -- check `ceph osd tree`, and declare the id it " + "actually gave the device rather than deploying again."));
+  }
+  return created;
+});
+var destroyOsd = (olds) => pve(olds.target, "provision", "DELETE", `nodes/${olds.node}/ceph/osd/${String(olds.osdid)}`, olds.cleanup === true ? { cleanup: "1" } : {});
+
+// src/proxmox/ceph-osd.ts
+var ProxmoxCephOsd = Resource7("Proxmox.CephOsd", {
+  defaultRemovalPolicy: "retain"
+});
+var settled = (live, props) => (props.host === undefined || props.host === live.host) && (props.device_class === undefined || props.device_class === live.device_class);
+var describe2 = (props) => `osd.${String(props.osdid)} (read via nodes/${props.node}/ceph/osd)`;
+var handlers5 = {
+  list: () => Effect15.succeed([]),
+  read: Effect15.fn(function* ({ olds }) {
+    return yield* readOsd(olds);
+  }),
+  diff: Effect15.fn(function* ({
+    news,
+    output
+  }) {
+    if (output === undefined || !isResolved4(news))
+      return;
+    const live = yield* readOsd(news);
+    if (live === undefined)
+      return { action: "update" };
+    if (output.osdid !== news.osdid)
+      return { action: "update" };
+    return settled(live, news) ? { action: "noop" } : { action: "update" };
+  }),
+  reconcile: Effect15.fn(function* ({ news }) {
+    const live = yield* readOsd(news);
+    if (live === undefined) {
+      return yield* createOsd(news);
+    }
+    if (!settled(live, news)) {
+      return yield* Effect15.die(new Error(`${describe2(news)}: exists but not as declared -- live host=${live.host} ` + `device_class=${live.device_class}. Nothing here moves an OSD between hosts or ` + "reclassifies it; fix the declaration, or move it deliberately with `ceph osd crush " + "move` / `ceph osd crush set-device-class` and deploy again."));
+    }
+    return live;
+  }),
+  delete: Effect15.fn(function* ({ olds }) {
+    yield* destroyOsd(olds);
+  })
+};
+var ProxmoxCephOsdProvider = () => Provider7.effect(ProxmoxCephOsd, Effect15.succeed(ProxmoxCephOsd.Provider.of(handlers5)));
+// src/proxmox/ceph-pool.ts
+import { Resource as Resource8 } from "alchemy";
+import * as Provider8 from "alchemy/Provider";
+import * as Effect17 from "effect/Effect";
+
+// src/proxmox/ceph-pool-form.ts
+var object = (props) => `nodes/${props.node}/ceph/pool/${props.name}`;
+var collection = (props) => `nodes/${props.node}/ceph/pool`;
+var UNSET = -1;
+var applications = (value) => csv(Array.isArray(value) ? value.map((entry) => String(entry)) : []);
+var same = (declared, live, frozen = false) => declared === undefined || frozen || declared === live;
+var hint = (value) => value === 0 ? undefined : value;
+var field2 = (name, value) => value === undefined ? {} : { [name]: value };
+var numeric = (value) => value === undefined ? undefined : String(value);
+var updateBody = (props) => ({
+  ...field2("crush_rule", props.crush_rule),
+  ...field2("min_size", numeric(props.min_size)),
+  ...field2("pg_autoscale_mode", props.pg_autoscale_mode),
+  ...field2("pg_num_min", numeric(props.pg_num_min)),
+  ...field2("size", numeric(props.size)),
+  ...field2("target_size", numeric(props.target_size)),
+  ...field2("target_size_ratio", numeric(props.target_size_ratio))
+});
+var createBody = (props) => ({
+  ...updateBody(props),
+  ...field2("application", props.application),
+  ...field2("pg_num", numeric(props.pg_num)),
+  add_storages: "0",
+  name: props.name
+});
+
+// src/proxmox/ceph-pool-settle.ts
+import * as Effect16 from "effect/Effect";
+var confirmAbsent = (props, collection2, describe3) => pve(props.target, "read", "GET", collection2).pipe(Effect16.flatMap((rows) => (rows ?? []).some((row) => row.pool_name === props.name) ? Effect16.die(new Error(`${describe3}: the cluster lists this pool but its status could not be read, ` + "so this deploy will NOT create over it. Check that the node is up and that the " + "read role holds Sys.Audit or Datastore.Audit on / -- a create here would apply " + "pg_num to a live pool and start a PG merge.")) : Effect16.void));
+var settle2 = (props, read, done) => Effect16.gen(function* () {
+  for (let attempt = 0;attempt < 30; attempt += 1) {
+    const live = yield* read(props);
+    if (done(live))
+      return live;
+    yield* Effect16.sleep("2 seconds");
+  }
+  return yield* read(props);
+});
+
+// src/proxmox/ceph-pool.ts
+var ProxmoxCephPool = Resource8("Proxmox.CephPool", {
+  defaultRemovalPolicy: "retain"
+});
+var spec = {
+  attributes: (live, props) => {
+    if (typeof live["name"] !== "string")
+      return;
+    return {
+      applications: applications(live["application_list"]),
+      crush_rule: text(live["crush_rule"]),
+      id: int(live["id"], UNSET),
+      min_size: int(live["min_size"], UNSET),
+      name: props.name,
+      node: props.node,
+      nodelete: bool(live["nodelete"]),
+      nopgchange: bool(live["nopgchange"]),
+      nosizechange: bool(live["nosizechange"]),
+      pg_autoscale_mode: text(live["pg_autoscale_mode"]),
+      pg_num: int(live["pg_num"], UNSET),
+      pg_num_min: int(live["pg_num_min"], UNSET),
+      size: int(live["size"], UNSET),
+      target_size: int(live["target_size"], UNSET),
+      target_size_ratio: num(live["target_size_ratio"], UNSET)
+    };
+  },
+  collection,
+  createForm: createBody,
+  matches: (attributes, props) => same(props.size, attributes.size, attributes.nosizechange) && same(props.min_size, attributes.min_size, attributes.nosizechange) && same(props.pg_autoscale_mode, attributes.pg_autoscale_mode) && same(hint(props.pg_num_min), attributes.pg_num_min, attributes.nopgchange) && same(props.crush_rule, attributes.crush_rule, attributes.crush_rule === "") && same(hint(props.target_size), attributes.target_size),
+  path: (props) => `${object(props)}/status?verbose=1`,
+  updateForm: updateBody
+};
+var ops4 = pveOperations(spec);
+var ProxmoxCephPoolProvider = () => Provider8.effect(ProxmoxCephPool, Effect17.succeed(ProxmoxCephPool.Provider.of({
+  list: () => Effect17.succeed([]),
+  read: ({ olds }) => ops4.read(olds),
+  diff: ({ news, output }) => ops4.diff(news, output),
+  reconcile: Effect17.fn(function* ({ news }) {
+    const live = yield* ops4.read(news);
+    let upid;
+    if (live === undefined) {
+      yield* confirmAbsent(news, spec.collection(news), object(news));
+      upid = yield* pve(news.target, "provision", "POST", collection(news), createBody(news));
+    } else {
+      const form = updateBody(news);
+      if (Object.keys(form).length > 0) {
+        upid = yield* pve(news.target, "provision", "PUT", object(news), form);
+      }
+    }
+    const after = yield* settle2(news, ops4.read, (row) => row !== undefined && spec.matches(row, news));
+    if (after === undefined || !spec.matches(after, news)) {
+      return yield* Effect17.die(new Error(`${object(news)}: the write returned no error but the pool still does not match ` + `the declaration after 60s. PVE answered with task ${upid ?? "(none)"} -- read ` + "its log with `pvesh get /nodes/<node>/tasks/<upid>/log` to see what Ceph " + "refused."));
+    }
+    return after;
+  }),
+  delete: Effect17.fn(function* ({ olds }) {
+    yield* pve(olds.target, "provision", "DELETE", object(olds));
+    const left = yield* settle2(olds, ops4.read, (row) => row === undefined);
+    if (left !== undefined) {
+      return yield* Effect17.die(new Error(`${object(olds)}: the DELETE returned no error but the pool is still there after ` + "60s. Either a storage on it still holds RBD images, or the mons are running " + "with mon_allow_pool_delete false."));
+    }
+  })
+})));
+// src/proxmox/firewall-alias.ts
+import { Resource as Resource9 } from "alchemy";
+import { isResolved as isResolved5 } from "alchemy/Diff";
+import * as Provider9 from "alchemy/Provider";
+import * as Effect18 from "effect/Effect";
+
+// src/proxmox/firewall-alias-form.ts
+var fold = (name) => name.trim().toLowerCase();
+var cidr = (value) => {
+  const raw = text(value).trim();
+  const host = raw.includes(":") ? "/128" : "/32";
+  return raw.endsWith(host) ? raw.slice(0, -host.length) : raw;
+};
+var comment = (value) => {
+  const trimmed = text(value).trim();
+  return trimmed === "0" ? "" : trimmed;
+};
+var body = (props) => {
+  const note = comment(props.comment);
+  return { cidr: cidr(props.cidr), ...note === "" ? {} : { comment: note } };
+};
+
+// src/proxmox/firewall-alias.ts
+var ProxmoxFirewallAlias = Resource9("Proxmox.FirewallAlias");
+var handlers6 = pveHandlers({
+  attributes: (live, props) => {
+    const address = cidr(live["cidr"]);
+    return address === "" ? undefined : {
+      cidr: address,
+      comment: comment(live["comment"]),
+      ipversion: int(live["ipversion"], 0),
+      name: text(live["name"], props.name)
+    };
+  },
+  collection: () => "cluster/firewall/aliases",
+  createForm: (props) => ({ ...body(props), name: props.name }),
+  matches: (attributes, props) => attributes.cidr === cidr(props.cidr) && attributes.comment === comment(props.comment),
+  path: (props) => `cluster/firewall/aliases/${props.name}`,
+  updateForm: body
+});
+var ProxmoxFirewallAliasProvider = () => Provider9.effect(ProxmoxFirewallAlias, Effect18.succeed(ProxmoxFirewallAlias.Provider.of({
+  ...handlers6,
+  diff: Effect18.fn(function* ({ news, output }) {
+    if (output !== undefined && isResolved5(news) && fold(news.name) !== fold(output.name)) {
+      return { action: "replace" };
+    }
+    return yield* handlers6.diff({ news, output });
+  })
+})));
+// src/proxmox/group.ts
+import { Resource as Resource10 } from "alchemy";
+import * as Provider10 from "alchemy/Provider";
+import * as Effect19 from "effect/Effect";
+var ProxmoxGroup = Resource10("Proxmox.Group", {
+  defaultRemovalPolicy: "retain"
+});
+var storedComment = (comment2) => {
+  const value = comment2 ?? "";
+  return value === "0" ? "" : value;
+};
+var memberList = (live) => {
+  const joined = csv((Array.isArray(live) ? live : []).map((member) => text(member)));
+  return joined === "" ? [] : joined.split(",");
+};
+var handlers7 = pveHandlers({
+  attributes: (live, props) => ({
+    comment: text(live["comment"]),
+    groupid: props.groupid,
+    members: memberList(live["members"])
+  }),
+  collection: () => "access/groups",
+  createForm: (props) => ({ comment: storedComment(props.comment), groupid: props.groupid }),
+  matches: (attributes, props) => attributes.comment === storedComment(props.comment),
+  path: (props) => `access/groups/${props.groupid}`,
+  updateForm: (props) => ({ comment: storedComment(props.comment) })
+});
+var ProxmoxGroupProvider = () => Provider10.effect(ProxmoxGroup, Effect19.succeed(ProxmoxGroup.Provider.of(handlers7)));
+// src/proxmox/ha-resource.ts
+import { Resource as Resource11 } from "alchemy";
+import * as Provider11 from "alchemy/Provider";
+import * as Effect20 from "effect/Effect";
+var ProxmoxHaResource = Resource11("Proxmox.HaResource");
+var kind = (sid) => sid.split(":")[0] ?? "";
+var shape3 = (props) => ({
+  comment: props.comment ?? "",
+  max_relocate: String(props.max_relocate ?? 1),
+  max_restart: String(props.max_restart ?? 1),
+  state: props.state ?? "started"
+});
+var handlers8 = pveHandlers({
+  attributes: (live, props) => ({
+    comment: typeof live["comment"] === "string" ? live["comment"] : "",
+    max_relocate: num(live["max_relocate"], 1),
+    max_restart: num(live["max_restart"], 1),
+    sid: typeof live["sid"] === "string" ? live["sid"] : props.sid,
+    state: typeof live["state"] === "string" ? live["state"] : "started",
+    type: typeof live["type"] === "string" ? live["type"] : kind(props.sid)
+  }),
+  collection: () => "cluster/ha/resources",
+  createForm: (props) => ({ ...shape3(props), sid: props.sid }),
+  matches: (attributes, props) => attributes.state === (props.state ?? "started") && attributes.comment === (props.comment ?? "") && attributes.max_restart === (props.max_restart ?? 1) && attributes.max_relocate === (props.max_relocate ?? 1),
+  path: (props) => `cluster/ha/resources/${props.sid}`,
+  updateForm: shape3
+});
+var ProxmoxHaResourceProvider = () => Provider11.effect(ProxmoxHaResource, Effect20.succeed(ProxmoxHaResource.Provider.of(handlers8)));
+// src/proxmox/ha-rule.ts
+import { Resource as Resource12 } from "alchemy";
+import * as Provider12 from "alchemy/Provider";
+import * as Effect21 from "effect/Effect";
+
+// src/proxmox/ha-rule-form.ts
+var nodeList = (value) => {
+  const ranked = new Map;
+  for (const entry of typeof value === "string" ? value.split(",") : value ?? []) {
+    const [node, priority] = entry.trim().split(":");
+    if (node === undefined || node === "")
+      continue;
+    const rank = Number.parseInt(priority ?? "0", 10);
+    ranked.set(node, Number.isNaN(rank) ? 0 : rank);
+  }
+  return [...ranked.keys()].sort().map((node) => {
+    const rank = ranked.get(node) ?? 0;
+    return rank === 0 ? node : `${node}:${String(rank)}`;
+  }).join(",");
+};
+var problems = (value) => typeof value === "object" && value !== null ? Object.entries(value).map(([option, message]) => `${option}: ${String(message)}`).sort().join("; ") : "";
+var commentText = (raw) => raw.replace(/(?:%[0-9a-fA-F]{2})+/g, (escaped) => {
+  try {
+    return decodeURIComponent(escaped);
+  } catch {
+    return escaped;
+  }
+});
+var optional = (props) => ({
+  comment: props.comment === undefined || props.comment === "" ? undefined : props.comment,
+  disable: props.disable === true ? "1" : undefined,
+  ...props.type === "node-affinity" ? { strict: props.strict === true ? "1" : undefined } : {}
+});
+var required = (props) => ({
+  affinity: props.affinity,
+  resources: csv(props.resources),
+  type: props.type,
+  ...props.type === "node-affinity" ? { nodes: nodeList(props.nodes) } : {}
+});
+var body2 = (props) => {
+  const fields = required(props);
+  for (const [option, value] of Object.entries(optional(props))) {
+    if (value !== undefined)
+      fields[option] = value;
+  }
+  return fields;
+};
+var clearList = (props) => Object.entries(optional(props)).filter(([, value]) => value === undefined).map(([option]) => option);
+
+// src/proxmox/ha-rule.ts
+var ProxmoxHaRule = Resource12("Proxmox.HaRule");
+var handlers9 = pveHandlers({
+  attributes: (live, props) => {
+    const liveType = text(live["type"]);
+    if (liveType !== "" && liveType !== props.type)
+      return;
+    return {
+      affinity: text(live["affinity"]),
+      comment: text(live["comment"]),
+      disable: bool(live["disable"], false),
+      errors: problems(live["errors"]),
+      nodes: nodeList(typeof live["nodes"] === "string" ? live["nodes"] : undefined),
+      order: int(live["order"], 0),
+      resources: csv(typeof live["resources"] === "string" ? live["resources"] : undefined),
+      rule: text(live["rule"], props.rule),
+      strict: bool(live["strict"], false),
+      type: props.type
+    };
+  },
+  collection: () => "cluster/ha/rules",
+  createForm: (props) => ({ ...body2(props), rule: props.rule }),
+  matches: (attributes, props) => attributes.resources === csv(props.resources) && attributes.affinity === props.affinity && attributes.comment === commentText(props.comment ?? "") && attributes.disable === (props.disable === true) && (props.type !== "node-affinity" || attributes.nodes === nodeList(props.nodes) && attributes.strict === (props.strict === true)),
+  path: (props) => `cluster/ha/rules/${props.rule}`,
+  updateForm: (props) => {
+    const clear = clearList(props);
+    const fields = body2(props);
+    return withClears(fields, clear);
+  }
+});
+var ProxmoxHaRuleProvider = () => Provider12.effect(ProxmoxHaRule, Effect21.succeed(ProxmoxHaRule.Provider.of(handlers9)));
+// src/proxmox/lxc.ts
+import { Resource as Resource13 } from "alchemy";
+import * as Provider13 from "alchemy/Provider";
+import * as Effect22 from "effect/Effect";
+var ProxmoxLxc = Resource13("Proxmox.Lxc");
+var handlers10 = pveHandlers({
+  attributes: (live, props) => ({
+    cores: num(live["cores"], 1),
+    hostname: typeof live["hostname"] === "string" ? live["hostname"] : "",
+    memory: num(live["memory"], 512),
+    node: props.node,
+    onboot: live["onboot"] === 1 || live["onboot"] === true,
+    status: typeof live["status"] === "string" ? live["status"] : "unknown",
+    vmid: props.vmid
+  }),
+  collection: (props) => `nodes/${props.node}/lxc`,
+  createForm: (props) => ({
+    cores: String(props.cores ?? 1),
+    hostname: props.hostname ?? `ct${String(props.vmid)}`,
+    memory: String(props.memory ?? 512),
+    onboot: props.onboot === true ? "1" : "0",
+    ostemplate: props.ostemplate,
+    storage: props.storage,
+    vmid: String(props.vmid),
+    ...props.net0 === undefined ? {} : { net0: props.net0 }
+  }),
+  matches: (attributes, props) => attributes.hostname === (props.hostname ?? `ct${String(props.vmid)}`) && attributes.memory === (props.memory ?? 512) && attributes.cores === (props.cores ?? 1) && attributes.onboot === (props.onboot === true),
+  path: (props) => `nodes/${props.node}/lxc/${String(props.vmid)}/config`,
+  updateForm: (props) => ({
+    cores: String(props.cores ?? 1),
+    hostname: props.hostname ?? `ct${String(props.vmid)}`,
+    memory: String(props.memory ?? 512),
+    onboot: props.onboot === true ? "1" : "0",
+    ...props.net0 === undefined ? {} : { net0: props.net0 }
+  })
+});
+var ProxmoxLxcProvider = () => Provider13.effect(ProxmoxLxc, Effect22.succeed(ProxmoxLxc.Provider.of(handlers10)));
+// src/proxmox/metric-server.ts
+import { Resource as Resource14 } from "alchemy";
+import * as Provider14 from "alchemy/Provider";
+import * as Effect23 from "effect/Effect";
+
+// src/proxmox/metric-server-form.ts
+var UNSET2 = -1;
+var str = (value) => value === undefined ? undefined : String(value);
+var optional2 = (props) => {
+  switch (props.type) {
+    case "graphite":
+      return { mtu: str(props.mtu), path: props.path, timeout: str(props.timeout) };
+    case "influxdb":
+      return {
+        "api-path-prefix": props["api-path-prefix"],
+        bucket: props.bucket,
+        influxdbproto: props.influxdbproto,
+        "max-body-size": str(props["max-body-size"]),
+        mtu: str(props.mtu),
+        organization: props.organization,
+        timeout: str(props.timeout)
+      };
+    case "opentelemetry":
+      return {
+        "otel-compression": props["otel-compression"],
+        "otel-max-body-size": str(props["otel-max-body-size"]),
+        "otel-path": props["otel-path"],
+        "otel-protocol": props["otel-protocol"],
+        "otel-timeout": str(props["otel-timeout"])
+      };
+  }
+};
+var verification = (props) => {
+  switch (props.type) {
+    case "graphite":
+      return {};
+    case "influxdb":
+      return { "verify-certificate": props["verify-certificate"] === false ? "0" : "1" };
+    case "opentelemetry":
+      return { "otel-verify-ssl": props["otel-verify-ssl"] === false ? "0" : "1" };
+  }
+};
+var required2 = (props) => ({
+  disable: props.disable === true ? "1" : "0",
+  port: String(props.port),
+  server: props.server,
+  ...verification(props)
+});
+var body3 = (props) => {
+  const fields = required2(props);
+  for (const [option, value] of Object.entries(optional2(props))) {
+    if (value !== undefined)
+      fields[option] = value;
+  }
+  return fields;
+};
+var update = (props) => {
+  const clear = Object.entries(optional2(props)).filter(([, value]) => value === undefined).map(([option]) => option);
+  return withClears(body3(props), clear);
+};
+
+// src/proxmox/metric-server-otel.ts
+var otelAttributes = (live) => ({
+  "otel-compression": text(live["otel-compression"]),
+  "otel-max-body-size": int(live["otel-max-body-size"], UNSET2),
+  "otel-path": text(live["otel-path"]),
+  "otel-protocol": text(live["otel-protocol"]),
+  "otel-timeout": int(live["otel-timeout"], UNSET2),
+  "otel-verify-ssl": bool(live["otel-verify-ssl"], true)
+});
+var otelMatches = (attributes, props) => attributes["otel-compression"] === (props["otel-compression"] ?? "") && attributes["otel-max-body-size"] === (props["otel-max-body-size"] ?? UNSET2) && attributes["otel-path"] === (props["otel-path"] ?? "") && attributes["otel-protocol"] === (props["otel-protocol"] ?? "") && attributes["otel-timeout"] === (props["otel-timeout"] ?? UNSET2) && attributes["otel-verify-ssl"] === (props["otel-verify-ssl"] !== false);
+
+// src/proxmox/metric-server.ts
+var ProxmoxMetricServer = Resource14("Proxmox.MetricServer");
+var matchesType = (attributes, props) => {
+  if (props.type === "opentelemetry")
+    return otelMatches(attributes, props);
+  const socket = attributes.mtu === (props.mtu ?? UNSET2) && attributes.timeout === (props.timeout ?? UNSET2);
+  if (props.type === "graphite")
+    return socket && attributes.path === (props.path ?? "");
+  return socket && attributes.influxdbproto === (props.influxdbproto ?? "") && attributes.organization === (props.organization ?? "") && attributes.bucket === (props.bucket ?? "") && attributes["api-path-prefix"] === (props["api-path-prefix"] ?? "") && attributes["max-body-size"] === (props["max-body-size"] ?? UNSET2) && attributes["verify-certificate"] === (props["verify-certificate"] !== false);
+};
+var handlers11 = pveHandlers({
+  attributes: (live, props) => {
+    const liveType = text(live["type"]);
+    if (liveType !== "" && liveType !== props.type)
+      return;
+    return {
+      ...otelAttributes(live),
+      "api-path-prefix": text(live["api-path-prefix"]),
+      bucket: text(live["bucket"]),
+      disable: bool(live["disable"], false),
+      id: props.id,
+      influxdbproto: text(live["influxdbproto"]),
+      "max-body-size": int(live["max-body-size"], UNSET2),
+      mtu: int(live["mtu"], UNSET2),
+      organization: text(live["organization"]),
+      path: text(live["path"]),
+      port: int(live["port"], 0),
+      server: text(live["server"]),
+      timeout: int(live["timeout"], UNSET2),
+      type: props.type,
+      "verify-certificate": bool(live["verify-certificate"], true)
+    };
+  },
+  collection: (props) => `cluster/metrics/server/${props.id}`,
+  createForm: (props) => ({ ...body3(props), type: props.type }),
+  matches: (attributes, props) => attributes.server === props.server && attributes.port === props.port && attributes.disable === (props.disable === true) && matchesType(attributes, props),
+  path: (props) => `cluster/metrics/server/${props.id}`,
+  updateForm: update
+});
+var ProxmoxMetricServerProvider = () => Provider14.effect(ProxmoxMetricServer, Effect23.succeed(ProxmoxMetricServer.Provider.of(handlers11)));
+// src/proxmox/network-apply.ts
+import { Resource as Resource15 } from "alchemy";
+import { isResolved as isResolved6 } from "alchemy/Diff";
+import * as Provider15 from "alchemy/Provider";
+import * as Effect25 from "effect/Effect";
+
+// src/proxmox/network-apply-read.ts
+import * as Effect24 from "effect/Effect";
+var stagedDiff = (target, node) => Effect24.gen(function* () {
+  const path = `nodes/${node}/network`;
+  const credential = yield* leased(target, "read");
+  const envelope = yield* pveEnvelopeWith(target, credential, "GET", path);
+  return text(envelope.changes);
+});
+var pendingLines = (diff) => {
+  if (diff === "")
+    return 0;
+  const changed = diff.split(`
+`).filter((line) => (line.startsWith("+") || line.startsWith("-")) && !line.startsWith("+++") && !line.startsWith("---")).length;
+  return Math.max(changed, 1);
+};
+var pendingCount = (target, node) => stagedDiff(target, node).pipe(Effect24.map(pendingLines));
+var clusterHealth = (target) => pve(target, "read", "GET", "cluster/status").pipe(Effect24.map((rows) => {
+  const all = rows ?? [];
+  const cluster = all.find((row) => row.type === "cluster");
+  return {
+    offline: all.filter((row) => row.type === "node" && !bool(row.online)).map((row) => text(row.name, "<unnamed>")),
+    quorate: cluster === undefined ? true : bool(cluster.quorate)
+  };
+}));
+var degradedReason = (target) => clusterHealth(target).pipe(Effect24.map((health) => health.quorate && health.offline.length === 0 ? undefined : `quorate=${String(health.quorate)} offline=[${health.offline.join(", ")}]`));
+var UNREACHABLE = "the task could not be read -- the node stopped answering, or this lease cannot see it";
+var STILL_RUNNING = "still running when this provider stopped waiting";
+var ATTEMPTS = 30;
+var awaitTask = (target, credential, node, upid) => Effect24.gen(function* () {
+  const path = `nodes/${node}/tasks/${upid}/status`;
+  for (let attempt = 0;attempt < ATTEMPTS; attempt += 1) {
+    const status = yield* pveWith(target, credential, "GET", path).pipe(Effect24.orElseSucceed(() => {
+      return;
+    }));
+    if (status === undefined)
+      return UNREACHABLE;
+    if (status.status === "stopped")
+      return text(status.exitstatus, "stopped with no exitstatus");
+    yield* Effect24.sleep("1 second");
+  }
+  return STILL_RUNNING;
+});
+
+// src/proxmox/network-apply.ts
+var ProxmoxNetworkApply = Resource15("Proxmox.NetworkApply");
+var read = (props) => pendingCount(props.target, props.node).pipe(Effect25.map((pending) => ({ node: props.node, pending })));
+var diff = (news) => Effect25.gen(function* () {
+  if (!isResolved6(news))
+    return;
+  const { pending } = yield* read(news);
+  return pending === 0 ? { action: "noop" } : { action: "update" };
+});
+var refuse = (node, why) => Effect25.die(new Error(`Proxmox.NetworkApply ${node}: ${why}`));
+var apply = (props) => Effect25.gen(function* () {
+  const node = props.node;
+  const staged = yield* pendingCount(props.target, node);
+  if (staged === 0)
+    return { node, pending: 0 };
+  const before = yield* degradedReason(props.target);
+  if (before !== undefined) {
+    return yield* refuse(node, `refusing to reload networking on a cluster that is already degraded (${before}). ` + "Ceph spans these nodes -- fix the cluster first, then re-run the deploy.");
+  }
+  const credential = yield* mint(props.target, "provision");
+  const upid = yield* pveWith(props.target, credential, "PUT", `nodes/${node}/network`);
+  if (upid === undefined) {
+    return yield* refuse(node, 'the apply returned no UPID. PVE wraps every answer in {"data":...} and can report success ' + "on a call that did nothing -- the reload cannot be confirmed, so it is not claimed.");
+  }
+  const exitstatus = yield* awaitTask(props.target, credential, node, upid);
+  if (exitstatus !== "OK") {
+    return yield* refuse(node, `the reload ended "${exitstatus}" (${upid}). Read it from ANOTHER node -- ` + `\`pvesh get /nodes/${node}/tasks/${upid}/log\` -- and do not apply the next node until ` + "this one is understood.");
+  }
+  const after = yield* degradedReason(props.target);
+  if (after !== undefined) {
+    return yield* refuse(node, `the reload reported OK but the cluster is now degraded (${after}). The next ` + "node has NOT been applied. Restore this one before continuing -- Ceph runs over these " + "links and a second reload now would take pools below min_size.");
+  }
+  const left = yield* pendingCount(props.target, node);
+  if (left !== 0) {
+    return yield* refuse(node, `the reload reported OK but ${String(left)} staged line(s) remain. The running config does ` + "not match the declared one, and saying otherwise is the lie this resource exists to stop.");
+  }
+  return { node, pending: left };
+});
+var handlers12 = {
+  delete: () => Effect25.void,
+  diff: ({ news }) => diff(news),
+  list: () => Effect25.succeed([]),
+  read: ({ olds }) => read(olds),
+  reconcile: ({ news }) => apply(news)
+};
+var ProxmoxNetworkApplyProvider = () => Provider15.effect(ProxmoxNetworkApply, Effect25.succeed(ProxmoxNetworkApply.Provider.of(handlers12)));
+// src/proxmox/node-network.ts
+import { Resource as Resource16 } from "alchemy";
+import * as Provider16 from "alchemy/Provider";
+import * as Effect26 from "effect/Effect";
+
+// src/proxmox/node-network-form.ts
+var UNSET3 = -1;
+var ifaceList = (value) => text(value).split(/[\s,;]+/).filter((part) => part !== "").sort().join(" ");
+var comment2 = (value) => text(value).replace(/\s+$/, "");
+var same2 = (declared, live) => declared === undefined || declared === live;
+var sameList = (declared, live) => declared === undefined || ifaceList(declared) === live;
+var sameComment = (declared, live) => declared === undefined || comment2(declared) === live;
+var field3 = (name, value) => value === undefined ? {} : { [name]: value };
+var body4 = (props) => ({
+  ...field3("autostart", flag(props.autostart)),
+  ...field3("bond-primary", props["bond-primary"]),
+  ...field3("bond_mode", props.bond_mode),
+  ...field3("bond_xmit_hash_policy", props.bond_xmit_hash_policy),
+  ...field3("bridge_ports", props.bridge_ports),
+  ...field3("bridge_vids", props.bridge_vids),
+  ...field3("bridge_vlan_aware", props.bridge_vlan_aware === true ? "1" : undefined),
+  ...field3("cidr", props.cidr),
+  ...field3("comments", props.comments),
+  ...field3("gateway", props.gateway),
+  ...field3("mtu", props.mtu === undefined ? undefined : String(props.mtu)),
+  ...field3("slaves", props.slaves),
+  ...field3("vlan-id", props["vlan-id"] === undefined ? undefined : String(props["vlan-id"])),
+  ...field3("vlan-raw-device", props["vlan-raw-device"]),
+  type: props.type
+});
+var updateBody2 = (props) => {
+  const clear = [
+    ...props.cidr === undefined ? ["cidr"] : [],
+    ...props.bridge_vlan_aware === false ? ["bridge_vlan_aware"] : []
+  ];
+  const fields = body4(props);
+  return withClears(fields, clear);
+};
+var readAttributes = (live, props) => {
+  const liveType = text(live["type"]);
+  if (liveType !== "" && liveType !== props.type)
+    return;
+  return {
+    active: bool(live["active"]),
+    autostart: bool(live["autostart"]),
+    "bond-primary": text(live["bond-primary"]),
+    bond_miimon: text(live["bond_miimon"]),
+    bond_mode: text(live["bond_mode"]),
+    bond_xmit_hash_policy: text(live["bond_xmit_hash_policy"]),
+    bridge_fd: text(live["bridge_fd"]),
+    bridge_ports: ifaceList(live["bridge_ports"]),
+    bridge_stp: text(live["bridge_stp"]),
+    bridge_vids: ifaceList(live["bridge_vids"]),
+    bridge_vlan_aware: bool(live["bridge_vlan_aware"]),
+    cidr: text(live["cidr"]),
+    comments: comment2(live["comments"]),
+    exists: bool(live["exists"]),
+    families: Array.isArray(live["families"]) ? live["families"].join(",") : "",
+    gateway: text(live["gateway"]),
+    iface: props.iface,
+    method: text(live["method"]),
+    mtu: int(live["mtu"], UNSET3),
+    node: props.node,
+    priority: int(live["priority"], UNSET3),
+    slaves: ifaceList(live["slaves"]),
+    type: liveType === "" ? props.type : liveType,
+    "vlan-id": int(live["vlan-id"], UNSET3),
+    "vlan-raw-device": text(live["vlan-raw-device"])
+  };
+};
+
+// src/proxmox/node-network.ts
+var ProxmoxNodeNetwork = Resource16("Proxmox.NodeNetwork", {
+  defaultRemovalPolicy: "retain"
+});
+var handlers13 = pveHandlers({
+  attributes: readAttributes,
+  collection: (props) => `nodes/${props.node}/network`,
+  createForm: body4,
+  matches: (attributes, props) => attributes.cidr === (props.cidr ?? "") && same2(props.gateway, attributes.gateway) && same2(props.autostart, attributes.autostart) && same2(props.mtu, attributes.mtu) && sameComment(props.comments, attributes.comments) && sameList(props.bridge_ports, attributes.bridge_ports) && sameList(props.bridge_vids, attributes.bridge_vids) && same2(props.bridge_vlan_aware, attributes.bridge_vlan_aware) && sameList(props.slaves, attributes.slaves) && same2(props.bond_mode, attributes.bond_mode) && same2(props.bond_xmit_hash_policy, attributes.bond_xmit_hash_policy) && same2(props["bond-primary"], attributes["bond-primary"]) && same2(props["vlan-id"], attributes["vlan-id"]) && same2(props["vlan-raw-device"], attributes["vlan-raw-device"]),
+  path: (props) => `nodes/${props.node}/network/${props.iface}`,
+  updateForm: updateBody2
+});
+var ProxmoxNodeNetworkProvider = () => Provider16.effect(ProxmoxNodeNetwork, Effect26.succeed(ProxmoxNodeNetwork.Provider.of(handlers13)));
+// src/proxmox/notification-target.ts
+import { Resource as Resource17 } from "alchemy";
+import * as Provider17 from "alchemy/Provider";
+import * as Effect27 from "effect/Effect";
+
+// src/proxmox/notification-target-form.ts
+var REPEATED_KEY = "\x00";
+var portOf = (value) => {
+  const parsed = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
+  return Number.isNaN(parsed) ? 0 : parsed;
+};
+var sorted = (parts) => parts.map((part) => part.trim()).filter((part) => part !== "").sort().join(",");
+var addressList = (value) => sorted(Array.isArray(value) ? value.map((item) => String(item)) : typeof value === "string" ? value.split(/[\s,;]+/) : []);
+var headerList = (value) => sorted(Array.isArray(value) ? value.map((item) => String(item)) : [text(value)]);
+var set = (key, value) => value === undefined ? {} : { [key]: value };
+var shape4 = (props) => ({
+  disable: props.disable === true ? "1" : "0",
+  ...set("author", props.author),
+  ...set("body", props.body),
+  ...set("comment", props.comment),
+  ...set("from-address", props["from-address"]),
+  ...set("header", props.header === undefined ? undefined : props.header.join(REPEATED_KEY)),
+  ...set("mailto", props.mailto === undefined ? undefined : addressList(props.mailto)),
+  ...set("mailto-user", props["mailto-user"] === undefined ? undefined : addressList(props["mailto-user"])),
+  ...set("method", props.method),
+  ...set("mode", props.mode),
+  ...set("port", props.port === undefined ? undefined : String(props.port)),
+  ...set("server", props.server),
+  ...set("url", props.url),
+  ...set("username", props.username)
+});
+
+// src/proxmox/notification-target.ts
+var ProxmoxNotificationTarget = Resource17("Proxmox.NotificationTarget");
+var handlers14 = pveHandlers({
+  attributes: (live, props) => ({
+    author: text(live["author"]),
+    body: text(live["body"]),
+    comment: text(live["comment"]),
+    disable: live["disable"] === 1 || live["disable"] === true,
+    "from-address": text(live["from-address"]),
+    header: headerList(live["header"]),
+    mailto: addressList(live["mailto"]),
+    "mailto-user": addressList(live["mailto-user"]),
+    method: text(live["method"]),
+    mode: text(live["mode"]),
+    name: props.name,
+    port: portOf(live["port"]),
+    server: text(live["server"]),
+    type: props.type,
+    url: text(live["url"]),
+    username: text(live["username"])
+  }),
+  collection: (props) => `cluster/notifications/endpoints/${props.type}`,
+  createForm: (props) => ({ ...shape4(props), name: props.name }),
+  matches: (attributes, props) => attributes.disable === (props.disable === true) && (props.comment === undefined || attributes.comment === props.comment) && (props.server === undefined || attributes.server === props.server) && (props.port === undefined || attributes.port === props.port) && (props.mode === undefined || attributes.mode === props.mode) && (props.username === undefined || attributes.username === props.username) && (props["from-address"] === undefined || attributes["from-address"] === props["from-address"]) && (props.author === undefined || attributes.author === props.author) && (props.url === undefined || attributes.url === props.url) && (props.method === undefined || attributes.method === props.method) && (props.body === undefined || attributes.body === props.body) && (props.mailto === undefined || attributes.mailto === addressList(props.mailto)) && (props["mailto-user"] === undefined || attributes["mailto-user"] === addressList(props["mailto-user"])) && (props.header === undefined || attributes.header === headerList(props.header)),
+  path: (props) => `cluster/notifications/endpoints/${props.type}/${props.name}`,
+  updateForm: shape4
+});
+var ProxmoxNotificationTargetProvider = () => Provider17.effect(ProxmoxNotificationTarget, Effect27.succeed(ProxmoxNotificationTarget.Provider.of(handlers14)));
+// src/proxmox/pbs-datastore.ts
+import { Resource as Resource18 } from "alchemy";
+import { isResolved as isResolved7 } from "alchemy/Diff";
+import * as Provider18 from "alchemy/Provider";
+import * as Effect30 from "effect/Effect";
+
+// src/proxmox/pbs-datastore-form.ts
+import * as Effect28 from "effect/Effect";
+var attributes = (live, props) => ({
+  backend: propertyString(live["backend"]),
+  comment: text(live["comment"]),
+  "counter-reset-schedule": text(live["counter-reset-schedule"]).trim(),
+  "gc-schedule": text(live["gc-schedule"]).trim(),
+  "keep-daily": int(live["keep-daily"], 0),
+  "keep-hourly": int(live["keep-hourly"], 0),
+  "keep-last": int(live["keep-last"], 0),
+  "keep-monthly": int(live["keep-monthly"], 0),
+  "keep-weekly": int(live["keep-weekly"], 0),
+  "keep-yearly": int(live["keep-yearly"], 0),
+  "maintenance-mode": propertyString(live["maintenance-mode"], "type"),
+  name: props.name,
+  "notification-thresholds": propertyString(live["notification-thresholds"]),
+  notify: propertyString(live["notify"]),
+  "notify-user": text(live["notify-user"]),
+  path: text(live["path"]),
+  "prune-schedule": text(live["prune-schedule"]).trim(),
+  tuning: propertyString(live["tuning"]),
+  "verify-new": bool(live["verify-new"])
+});
+var same3 = (declared, live) => declared === undefined || declared === live;
+var matches = (live, props) => same3(props.comment, live.comment) && same3(props["gc-schedule"]?.trim(), live["gc-schedule"]) && same3(props["prune-schedule"]?.trim(), live["prune-schedule"]) && same3(props["keep-last"], live["keep-last"]) && same3(props["keep-hourly"], live["keep-hourly"]) && same3(props["keep-daily"], live["keep-daily"]) && same3(props["keep-weekly"], live["keep-weekly"]) && same3(props["keep-monthly"], live["keep-monthly"]) && same3(props["keep-yearly"], live["keep-yearly"]) && same3(props["notify-user"], live["notify-user"]) && same3(props["counter-reset-schedule"]?.trim(), live["counter-reset-schedule"]) && (props["notification-thresholds"] === undefined || propertyString(props["notification-thresholds"]) === live["notification-thresholds"]) && same3(props["verify-new"], live["verify-new"]) && (props.notify === undefined || propertyString(props.notify) === live.notify) && (props.tuning === undefined || propertyString(props.tuning) === live.tuning) && (props["maintenance-mode"] === undefined || propertyString(props["maintenance-mode"], "type") === live["maintenance-mode"]);
+var set2 = (key, value) => value === undefined ? {} : { [key]: value };
+var count = (value) => value === undefined ? undefined : String(value);
+var mutable = (props) => ({
+  ...set2("comment", props.comment),
+  ...set2("gc-schedule", props["gc-schedule"]?.trim()),
+  ...set2("keep-daily", count(props["keep-daily"])),
+  ...set2("keep-hourly", count(props["keep-hourly"])),
+  ...set2("keep-last", count(props["keep-last"])),
+  ...set2("keep-monthly", count(props["keep-monthly"])),
+  ...set2("keep-weekly", count(props["keep-weekly"])),
+  ...set2("keep-yearly", count(props["keep-yearly"])),
+  ...set2("counter-reset-schedule", props["counter-reset-schedule"]),
+  ...set2("maintenance-mode", props["maintenance-mode"]),
+  ...set2("notification-thresholds", props["notification-thresholds"]),
+  ...set2("notify", props.notify),
+  ...set2("notify-user", props["notify-user"]),
+  ...set2("prune-schedule", props["prune-schedule"]?.trim()),
+  ...set2("tuning", props.tuning),
+  ...set2("verify-new", flag(props["verify-new"]))
+});
+var createForm3 = (props) => ({
+  ...mutable(props),
+  name: props.name,
+  path: props.path,
+  ...props.backend === undefined ? {} : { backend: props.backend }
+});
+var updateForm = (props) => mutable(props);
+var object2 = (props) => `config/datastore/${props.name}`;
+var readOne = (props) => pve(props.target, "read", "GET", object2(props)).pipe(Effect28.map((live) => live === undefined || typeof live["name"] !== "string" ? undefined : attributes(live, props)), Effect28.orElseSucceed(() => {
+  return;
+}));
+
+// src/proxmox/pbs-datastore-guard.ts
+import * as Effect29 from "effect/Effect";
+var samePath = (left, right) => {
+  const trim = (value) => value.length > 1 ? value.replace(/\/+$/, "") : value;
+  return trim(left) === trim(right);
+};
+var guardPath = (live, props) => live.path === "" || samePath(live.path, props.path) ? Effect29.void : Effect29.die(new Error(`${object2(props)}: declared path ${props.path} but PBS holds ${live.path}. \`path\` ` + "is create-only, so this cannot be reconciled and will NOT be planned as a silent " + "noop: backups would keep landing in the old directory behind a green plan. Correct " + "the declaration, or remove the datastore and declare a new one -- the contents live, " + "because `destroy-data` is never sent."));
+var guardBackend = (live, props) => props.backend === undefined || propertyString(props.backend) === live.backend ? Effect29.void : Effect29.die(new Error(`${object2(props)}: declared backend ${props.backend} but PBS holds ` + `${live.backend === "" ? "(none — a local datastore)" : live.backend}. \`backend\` ` + "is create-only: PBS has no update for it, so this cannot be reconciled and will NOT " + "be planned as a silent noop. Correct the declaration to match what is really there, " + "or remove the datastore and declare a new one -- the contents live, because " + "`destroy-data` is never sent."));
+var settle3 = (read2, done) => Effect29.gen(function* () {
+  for (let attempt = 0;attempt < 60; attempt += 1) {
+    const live = yield* read2;
+    if (done(live))
+      return live;
+    yield* Effect29.sleep("2 seconds");
+  }
+  return yield* read2;
+});
+
+// src/proxmox/pbs-datastore.ts
+var PbsDatastore = Resource18("Pbs.Datastore", {
+  defaultRemovalPolicy: "retain"
+});
+var PbsDatastoreProvider = () => Provider18.effect(PbsDatastore, Effect30.succeed(PbsDatastore.Provider.of({
+  list: () => Effect30.succeed([]),
+  read: ({ olds }) => readOne(olds),
+  diff: ({ news, output }) => Effect30.gen(function* () {
+    if (output === undefined || !isResolved7(news))
+      return;
+    const live = yield* readOne(news);
+    if (live === undefined)
+      return { action: "update" };
+    yield* guardPath(live, news);
+    yield* guardBackend(live, news);
+    return matches(live, news) ? { action: "noop" } : { action: "update" };
+  }),
+  reconcile: Effect30.fn(function* ({ news }) {
+    const live = yield* readOne(news);
+    let upid;
+    if (live === undefined) {
+      upid = yield* pve(news.target, "provision", "POST", "config/datastore", createForm3(news));
+    } else {
+      yield* guardPath(live, news);
+      yield* guardBackend(live, news);
+      const form = updateForm(news);
+      if (!matches(live, news) && Object.keys(form).length > 0) {
+        yield* pve(news.target, "provision", "PUT", object2(news), form);
+      }
+    }
+    const after = yield* settle3(readOne(news), (row) => row !== undefined && matches(row, news));
+    if (after === undefined || !matches(after, news)) {
+      return yield* Effect30.die(new Error(`${object2(news)}: the write returned no error but the datastore still does not ` + `match the declaration after 120s. PBS answered with task ${upid ?? "(none)"} ` + "-- read it with `proxmox-backup-manager task log <upid>`. A slow disk is a " + "plausible cause (see `settle`); a create over an existing chunk store is not, " + "because PBS refuses that outright rather than timing out."));
+    }
+    return after;
+  }),
+  delete: Effect30.fn(function* ({ olds }) {
+    yield* pve(olds.target, "provision", "DELETE", object2(olds));
+    const left = yield* settle3(readOne(olds), (row) => row === undefined);
+    if (left !== undefined) {
+      return yield* Effect30.die(new Error(`${object2(olds)}: the DELETE returned no error but the datastore is still in ` + "datastore.cfg after 120s. Either a backup, verify or GC task still holds it, " + "or the provision role lacks Datastore.Allocate on /datastore/" + `${olds.name}. Read the task log with \`proxmox-backup-manager task log <upid>\`.`));
+    }
+  })
+})));
+// src/proxmox/pbs-prune-job.ts
+import { Resource as Resource19 } from "alchemy";
+import * as Provider19 from "alchemy/Provider";
+import * as Effect31 from "effect/Effect";
+
+// src/proxmox/pbs-prune-job-form.ts
+var KEEP_KEYS = [
+  "keep-last",
+  "keep-hourly",
+  "keep-daily",
+  "keep-weekly",
+  "keep-monthly",
+  "keep-yearly"
+];
+var keepForm = (props) => {
+  const form = {};
+  for (const key of KEEP_KEYS) {
+    const value = props[key];
+    if (value !== undefined)
+      form[key] = String(value);
+  }
+  return form;
+};
+var keepAttributes = (live) => ({
+  "keep-daily": int(live["keep-daily"], 0),
+  "keep-hourly": int(live["keep-hourly"], 0),
+  "keep-last": int(live["keep-last"], 0),
+  "keep-monthly": int(live["keep-monthly"], 0),
+  "keep-weekly": int(live["keep-weekly"], 0),
+  "keep-yearly": int(live["keep-yearly"], 0)
+});
+var keepsMatch = (attributes2, props) => KEEP_KEYS.every((key) => props[key] === undefined || props[key] === attributes2[key]);
+var keepsSomething = (props) => KEEP_KEYS.some((key) => props[key] !== undefined);
+var requireKeeps = (props) => {
+  if (keepsSomething(props))
+    return;
+  throw new Error(`Pbs.PruneJob ${props.id}: declares no keep-* window, which tells PBS to keep NOTHING on ` + `datastore '${props.store}'. Every keep-* is optional on the wire, so an omission and a ` + 'deliberate "retain nothing" are indistinguishable; declare at least one window (keep-last, ' + "keep-hourly, keep-daily, keep-weekly, keep-monthly or keep-yearly) or delete the job.");
+};
+var field4 = (name, value) => value === undefined ? {} : { [name]: value };
+var integer = (value) => value === undefined ? undefined : String(value);
+var shape5 = (props) => ({
+  ...keepForm(props),
+  ...field4("comment", props.comment),
+  ...field4("disable", flag(props.disable)),
+  ...field4("max-depth", integer(props["max-depth"])),
+  ...field4("ns", props.ns),
+  schedule: props.schedule,
+  store: props.store
+});
+var createBody2 = (props) => {
+  requireKeeps(props);
+  return { ...shape5(props), id: props.id };
+};
+var updateBody3 = (props) => {
+  requireKeeps(props);
+  return shape5(props);
+};
+
+// src/proxmox/pbs-prune-job.ts
+var PbsPruneJob = Resource19("Pbs.PruneJob");
+var same4 = (declared, live) => declared === undefined || declared === live;
+var handlers15 = pveHandlers({
+  attributes: (live, props) => ({
+    comment: text(live["comment"], ""),
+    disable: bool(live["disable"], false),
+    id: props.id,
+    ...keepAttributes(live),
+    "max-depth": int(live["max-depth"], -1),
+    ns: text(live["ns"], ""),
+    schedule: text(live["schedule"], ""),
+    store: text(live["store"], props.store)
+  }),
+  collection: () => "config/prune",
+  createForm: createBody2,
+  matches: (attributes2, props) => attributes2.schedule === props.schedule && attributes2.store === props.store && same4(props.ns, attributes2.ns) && same4(props["max-depth"], attributes2["max-depth"]) && same4(props.disable, attributes2.disable) && same4(props.comment, attributes2.comment) && keepsMatch(attributes2, props),
+  path: (props) => `config/prune/${props.id}`,
+  updateForm: updateBody3
+});
+var PbsPruneJobProvider = () => Provider19.effect(PbsPruneJob, Effect31.succeed(PbsPruneJob.Provider.of(handlers15)));
+// src/proxmox/pbs-sync-job.ts
+import { Resource as Resource20 } from "alchemy";
+import * as Provider20 from "alchemy/Provider";
+import * as Effect32 from "effect/Effect";
+
+// src/proxmox/pbs-sync-job-form.ts
+var UNSET4 = -1;
+var UNITS = {
+  "": 1,
+  B: 1,
+  GB: 1e9,
+  GiB: 1073741824,
+  KB: 1000,
+  KiB: 1024,
+  MB: 1e6,
+  MiB: 1048576,
+  TB: 1000000000000,
+  TiB: 1099511627776
+};
+var bytes = (value) => {
+  if (typeof value === "number")
+    return value;
+  const raw = text(value).trim();
+  const match = /^([0-9]+(?:\.[0-9]+)?)\s*([A-Za-z]*)$/.exec(raw);
+  if (match === null)
+    return UNSET4;
+  const unit = UNITS[match[2] ?? ""];
+  return unit === undefined ? UNSET4 : Math.round(Number(match[1] ?? "0") * unit);
+};
+var filters = (value) => Array.isArray(value) ? value.map((entry) => String(entry)).join(" | ") : text(value);
+var shape6 = (props) => ({
+  "remote-store": props["remote-store"],
+  "remove-vanished": props["remove-vanished"] === true ? "1" : "0",
+  store: props.store,
+  ...props.comment === undefined ? {} : { comment: props.comment },
+  ...props["max-depth"] === undefined ? {} : { "max-depth": String(props["max-depth"]) },
+  ...props.ns === undefined ? {} : { ns: props.ns },
+  ...props.owner === undefined ? {} : { owner: props.owner },
+  ...props["rate-in"] === undefined ? {} : { "rate-in": String(props["rate-in"]) },
+  ...props.remote === undefined ? {} : { remote: props.remote },
+  ...props["remote-ns"] === undefined ? {} : { "remote-ns": props["remote-ns"] },
+  ...props.schedule === undefined ? {} : { schedule: props.schedule },
+  ...props["verified-only"] === undefined ? {} : { "verified-only": props["verified-only"] ? "1" : "0" },
+  ...props["transfer-last"] === undefined ? {} : { "transfer-last": String(props["transfer-last"]) }
+});
+var createBody3 = (props) => ({
+  ...shape6(props),
+  id: props.id,
+  ...props["sync-direction"] === undefined ? {} : { "sync-direction": props["sync-direction"] }
+});
+var updateBody4 = (props) => shape6(props);
+var handlers16 = pveHandlers({
+  attributes: (live, props) => ({
+    comment: text(live["comment"], ""),
+    "group-filter": filters(live["group-filter"]),
+    id: props.id,
+    "max-depth": int(live["max-depth"], UNSET4),
+    ns: text(live["ns"], ""),
+    owner: text(live["owner"], ""),
+    "rate-in": bytes(live["rate-in"]),
+    remote: text(live["remote"], ""),
+    "remote-ns": text(live["remote-ns"], ""),
+    "remote-store": text(live["remote-store"], ""),
+    "remove-vanished": bool(live["remove-vanished"], false),
+    schedule: text(live["schedule"], ""),
+    "verified-only": bool(live["verified-only"], false),
+    store: text(live["store"], ""),
+    "sync-direction": text(live["sync-direction"], "pull"),
+    "transfer-last": int(live["transfer-last"], UNSET4)
+  }),
+  collection: () => "config/sync",
+  createForm: createBody3,
+  matches: (attributes2, props) => attributes2["remove-vanished"] === (props["remove-vanished"] === true) && attributes2.store === props.store && attributes2["remote-store"] === props["remote-store"] && (props.remote === undefined || attributes2.remote === props.remote) && (props.ns === undefined || attributes2.ns === props.ns) && (props["remote-ns"] === undefined || attributes2["remote-ns"] === props["remote-ns"]) && (props.schedule === undefined || attributes2.schedule === props.schedule) && (props.comment === undefined || attributes2.comment === props.comment) && (props.owner === undefined || attributes2.owner === props.owner) && (props["verified-only"] === undefined || attributes2["verified-only"] === props["verified-only"]) && (props["rate-in"] === undefined || attributes2["rate-in"] === props["rate-in"]) && (props["max-depth"] === undefined || attributes2["max-depth"] === props["max-depth"]) && (props["transfer-last"] === undefined || attributes2["transfer-last"] === props["transfer-last"]),
+  path: (props) => `config/sync/${props.id}`,
+  updateForm: updateBody4
+});
+
+// src/proxmox/pbs-sync-job.ts
+var PbsSyncJob = Resource20("Pbs.SyncJob");
+var PbsSyncJobProvider = () => Provider20.effect(PbsSyncJob, Effect32.succeed(PbsSyncJob.Provider.of(handlers16)));
+// src/proxmox/pbs-verify-job.ts
+import { Resource as Resource21 } from "alchemy";
+import * as Provider21 from "alchemy/Provider";
+import * as Effect33 from "effect/Effect";
+
+// src/proxmox/pbs-verify-job-form.ts
+var rechecks = (ignoreVerified, outdatedAfter) => {
+  if (!ignoreVerified)
+    return "every snapshot on every run";
+  if (outdatedAfter < 0)
+    return "never: each snapshot is checked once and then skipped forever";
+  return `once the last check is more than ${String(outdatedAfter)} day(s) old`;
+};
+var shape7 = (props) => ({
+  "ignore-verified": props["ignore-verified"] === false ? "0" : "1",
+  store: props.store,
+  ...props.schedule === null ? {} : { schedule: props.schedule },
+  ...props.comment === undefined ? {} : { comment: props.comment },
+  ...props["max-depth"] === undefined ? {} : { "max-depth": String(props["max-depth"]) },
+  ...props.ns === undefined || props.ns === "" ? {} : { ns: props.ns },
+  ...props["outdated-after"] === undefined ? {} : { "outdated-after": String(props["outdated-after"]) }
+});
+
+// src/proxmox/pbs-verify-job.ts
+var PbsVerifyJob = Resource21("Pbs.VerifyJob");
+var handlers17 = pveHandlers({
+  attributes: (live, props) => {
+    const ignoreVerified = bool(live["ignore-verified"], true);
+    const outdatedAfter = int(live["outdated-after"], -1);
+    return {
+      comment: text(live["comment"], ""),
+      id: props.id,
+      "ignore-verified": ignoreVerified,
+      "max-depth": int(live["max-depth"], -1),
+      ns: text(live["ns"], ""),
+      "outdated-after": outdatedAfter,
+      rechecks: rechecks(ignoreVerified, outdatedAfter),
+      schedule: text(live["schedule"], ""),
+      store: text(live["store"], props.store)
+    };
+  },
+  collection: () => "config/verify",
+  createForm: (props) => ({ ...shape7(props), id: props.id }),
+  matches: (attributes2, props) => attributes2.store === props.store && attributes2.schedule === (props.schedule ?? "") && attributes2["ignore-verified"] === (props["ignore-verified"] !== false) && (props["outdated-after"] === undefined || attributes2["outdated-after"] === props["outdated-after"]) && (props["max-depth"] === undefined || attributes2["max-depth"] === props["max-depth"]) && (props.ns === undefined || attributes2.ns === props.ns) && (props.comment === undefined || attributes2.comment === props.comment),
+  path: (props) => `config/verify/${props.id}`,
+  updateForm: shape7
+});
+var PbsVerifyJobProvider = () => Provider21.effect(PbsVerifyJob, Effect33.succeed(PbsVerifyJob.Provider.of(handlers17)));
+// src/proxmox/pool.ts
+import { Resource as Resource22 } from "alchemy";
+import * as Provider22 from "alchemy/Provider";
+import * as Effect34 from "effect/Effect";
+var ProxmoxPool = Resource22("Proxmox.Pool");
+var poolCreateForm = (props) => ({
+  comment: props.comment ?? "",
+  poolid: props.poolid
+});
+var poolUpdateForm = (props) => ({
+  comment: props.comment ?? ""
+});
+var handlers18 = pveHandlers({
+  attributes: (live, props) => {
+    const row = live;
+    return {
+      comment: typeof row.comment === "string" ? row.comment : "",
+      members: Array.isArray(row.members) ? row.members.length : 0,
+      poolid: props.poolid
+    };
+  },
+  collection: () => "pools",
+  createForm: poolCreateForm,
+  matches: (attributes2, props) => attributes2.comment === (props.comment ?? ""),
+  path: (props) => `pools/${props.poolid}`,
+  updateForm: poolUpdateForm
+});
+var ProxmoxPoolProvider = () => Provider22.effect(ProxmoxPool, Effect34.succeed(ProxmoxPool.Provider.of(handlers18)));
+// src/proxmox/qemu.ts
+import { Resource as Resource23 } from "alchemy";
+import * as Provider23 from "alchemy/Provider";
+import * as Effect35 from "effect/Effect";
+var ProxmoxVm = Resource23("Proxmox.Vm");
+var shape8 = (props) => ({
+  cores: String(props.cores ?? 1),
+  memory: String(props.memory ?? 512),
+  name: props.name ?? `vm${String(props.vmid)}`,
+  onboot: props.onboot === true ? "1" : "0",
+  sockets: String(props.sockets ?? 1),
+  ...props.net0 === undefined ? {} : { net0: props.net0 }
+});
+var handlers19 = pveHandlers({
+  attributes: (live, props) => ({
+    cores: num(live["cores"], 1),
+    memory: num(live["memory"], 512),
+    name: typeof live["name"] === "string" ? live["name"] : "",
+    node: props.node,
+    onboot: live["onboot"] === 1 || live["onboot"] === true,
+    sockets: num(live["sockets"], 1),
+    vmid: props.vmid
+  }),
+  collection: (props) => `nodes/${props.node}/qemu`,
+  createForm: (props) => ({ ...shape8(props), vmid: String(props.vmid) }),
+  matches: (attributes2, props) => attributes2.name === (props.name ?? `vm${String(props.vmid)}`) && attributes2.memory === (props.memory ?? 512) && attributes2.cores === (props.cores ?? 1) && attributes2.sockets === (props.sockets ?? 1) && attributes2.onboot === (props.onboot === true),
+  path: (props) => `nodes/${props.node}/qemu/${String(props.vmid)}/config`,
+  updateForm: shape8
+});
+var ProxmoxVmProvider = () => Provider23.effect(ProxmoxVm, Effect35.succeed(ProxmoxVm.Provider.of(handlers19)));
+// src/proxmox/replication-job.ts
+import { Resource as Resource24 } from "alchemy";
+import * as Provider24 from "alchemy/Provider";
+import * as Effect36 from "effect/Effect";
+
+// src/proxmox/replication-job-form.ts
+var DEFAULT_SCHEDULE = "*/15";
+var jobId = (props) => `${String(props.guest)}-${String(props.jobnum)}`;
+var shape9 = (props) => ({
+  comment: props.comment ?? "",
+  disable: props.disable === true ? "1" : "0",
+  schedule: props.schedule ?? DEFAULT_SCHEDULE,
+  ...props.rate === undefined ? {} : { rate: String(props.rate) }
+});
+var createBody4 = (props) => ({
+  ...shape9(props),
+  id: jobId(props),
+  target: props.targetNode,
+  type: "local"
+});
+var updateBody5 = (props) => ({
+  ...shape9(props),
+  delete: "remove_job"
+});
+
+// src/proxmox/replication-job.ts
+var ProxmoxReplicationJob = Resource24("Proxmox.ReplicationJob");
+var rateOf = (value) => {
+  if (typeof value === "number")
+    return value;
+  const parsed = Number.parseFloat(text(value));
+  return Number.isFinite(parsed) ? parsed : 0;
+};
+var handlers20 = pveHandlers({
+  attributes: (live, props) => ({
+    comment: text(live["comment"], ""),
+    disable: bool(live["disable"], false),
+    guest: int(live["guest"], props.guest),
+    id: text(live["id"], jobId(props)),
+    jobnum: int(live["jobnum"], props.jobnum),
+    rate: rateOf(live["rate"]),
+    remove_job: text(live["remove_job"], ""),
+    schedule: text(live["schedule"], DEFAULT_SCHEDULE),
+    source: text(live["source"], ""),
+    targetNode: text(live["target"], props.targetNode),
+    type: text(live["type"], "local")
+  }),
+  collection: () => "cluster/replication",
+  createForm: createBody4,
+  matches: (attributes2, props) => attributes2.remove_job === "" && attributes2.schedule === (props.schedule ?? DEFAULT_SCHEDULE) && attributes2.disable === (props.disable === true) && attributes2.comment === (props.comment ?? "") && (props.rate === undefined || attributes2.rate === props.rate),
+  path: (props) => `cluster/replication/${jobId(props)}`,
+  updateForm: updateBody5
+});
+var ProxmoxReplicationJobProvider = () => Provider24.effect(ProxmoxReplicationJob, Effect36.succeed(ProxmoxReplicationJob.Provider.of(handlers20)));
+// src/proxmox/role.ts
+import { Resource as Resource25 } from "alchemy";
+import * as Provider25 from "alchemy/Provider";
+import * as Effect37 from "effect/Effect";
+var ProxmoxRole = Resource25("Proxmox.Role");
+var canonical = (privs) => [...new Set(privs.map((priv) => priv.trim()).filter((priv) => priv.length > 0))].sort();
+var livePrivs = (live) => {
+  const listed = live["privs"];
+  if (typeof listed === "string")
+    return canonical(listed.split(","));
+  return canonical(Object.keys(live).filter((key) => key.includes(".")));
+};
+var handlers21 = pveHandlers({
+  attributes: (live, props) => ({ privs: livePrivs(live), roleid: props.roleid }),
+  collection: () => "access/roles",
+  createForm: (props) => ({ privs: canonical(props.privs).join(","), roleid: props.roleid }),
+  matches: (attributes2, props) => canonical(attributes2.privs).join(",") === canonical(props.privs).join(","),
+  path: (props) => `access/roles/${props.roleid}`,
+  updateForm: (props) => ({ privs: canonical(props.privs).join(",") })
+});
+var ProxmoxRoleProvider = () => Provider25.effect(ProxmoxRole, Effect37.succeed(ProxmoxRole.Provider.of(handlers21)));
+// src/proxmox/sdn-apply.ts
+import { Resource as Resource26 } from "alchemy";
+import { isResolved as isResolved8 } from "alchemy/Diff";
+import * as Provider26 from "alchemy/Provider";
+import * as Effect39 from "effect/Effect";
+
+// src/proxmox/sdn-apply-read.ts
+import * as Effect38 from "effect/Effect";
+var MARKED = [
+  "cluster/sdn/zones",
+  "cluster/sdn/vnets",
+  "cluster/sdn/controllers",
+  "cluster/sdn/prefix-lists",
+  "cluster/sdn/route-maps"
+];
+var subsystemAbsent = (error) => error instanceof PveError && error.status === 501;
+var markedPending = (target) => Effect38.all(MARKED.map((collection2) => pve(target, "read", "GET", `${collection2}?pending=1`).pipe(Effect38.map((rows) => (rows ?? []).filter((row) => row.state !== undefined).length), Effect38.catchIf(subsystemAbsent, () => Effect38.succeed(0)))), { concurrency: "unbounded" }).pipe(Effect38.map((counts) => counts.reduce((total, count2) => total + count2, 0)));
+var fabricStaged = (staged, running) => {
+  if (staged === undefined && running === undefined)
+    return 0;
+  if (staged === undefined || running === undefined)
+    return "inconsistent";
+  return staged === running ? 0 : 1;
+};
+var fabricPending = (target) => Effect38.all(["pending", "running"].map((view) => pve(target, "read", "GET", `cluster/sdn/fabrics/all?${view}=1`).pipe(Effect38.map(canonical2), Effect38.catchIf(subsystemAbsent, () => Effect38.succeed(undefined)))), { concurrency: "unbounded" }).pipe(Effect38.flatMap(([staged, running]) => {
+  const verdict = fabricStaged(staged, running);
+  return verdict === "inconsistent" ? Effect38.die(new Error("cluster/sdn/fabrics/all answered 501 for one of ?pending=1 and ?running=1 and not " + "the other. Refusing to read that as a staged fabric change.")) : Effect38.succeed(verdict);
+}));
+var canonical2 = (value) => JSON.stringify(sortDeep(value));
+var sortDeep = (value) => {
+  if (Array.isArray(value)) {
+    return value.map(sortDeep).sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+  }
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value).filter(([key]) => key !== "digest").sort(([left], [right]) => left.localeCompare(right));
+    return Object.fromEntries(entries.map(([key, inner]) => [key, sortDeep(inner)]));
+  }
+  return value;
+};
+var sdnPendingCount = (target) => Effect38.all([markedPending(target), fabricPending(target)], { concurrency: "unbounded" }).pipe(Effect38.map(([marked, fabric]) => marked + fabric));
+
+// src/proxmox/sdn-apply.ts
+var ProxmoxSdnApply = Resource26("Proxmox.SdnApply");
+var read2 = (props) => sdnPendingCount(props.target).pipe(Effect39.map((pending) => ({ pending })));
+var ProxmoxSdnApplyProvider = () => Provider26.effect(ProxmoxSdnApply, Effect39.succeed(ProxmoxSdnApply.Provider.of({
+  list: () => Effect39.succeed([]),
+  read: Effect39.fn(function* ({ olds }) {
+    return yield* read2(olds);
+  }),
+  diff: Effect39.fn(function* ({ news }) {
+    if (!isResolved8(news))
+      return;
+    const { pending } = yield* read2(news);
+    return pending === 0 ? { action: "noop" } : { action: "update" };
+  }),
+  reconcile: Effect39.fn(function* ({ news }) {
+    const staged = yield* read2(news);
+    if (staged.pending === 0)
+      return staged;
+    yield* pve(news.target, "provision", "PUT", "cluster/sdn");
+    const after = yield* read2(news);
+    if (after.pending !== 0) {
+      return yield* Effect39.die(new Error(`PUT /cluster/sdn returned no error but ${String(after.pending)} SDN object(s) ` + "are still staged. The running config does not match the declared one -- check " + "`pvesh get /cluster/sdn/zones --pending 1` for the objects PVE refused."));
+    }
+    return after;
+  }),
+  delete: () => Effect39.void
+})));
+// src/proxmox/sdn-subnet.ts
+import { Resource as Resource27 } from "alchemy";
+import * as Provider27 from "alchemy/Provider";
+import * as Effect40 from "effect/Effect";
+
+// src/proxmox/sdn-subnet-form.ts
+var subnetId = (props) => `${props.zone}-${props.cidr.replace("/", "-")}`;
+var rangeString = (range) => `start-address=${range.start},end-address=${range.end}`;
+var dhcpRanges = (value) => (Array.isArray(value) ? value : []).map((entry) => propertyString(entry)).filter((entry) => entry !== "").sort().join(";");
+var declaredRanges = (range) => range === undefined ? "" : dhcpRanges([rangeString(range)]);
+var unset = (value) => value === undefined || value === "" ? undefined : value;
+var optional3 = (props) => ({
+  "dhcp-dns-server": unset(props.dhcpDnsServer),
+  "dhcp-range": props.dhcpRange === undefined ? undefined : rangeString(props.dhcpRange),
+  dnszoneprefix: unset(props.dnszoneprefix),
+  gateway: unset(props.gateway)
+});
+var body5 = (props) => ({
+  snat: props.snat === true ? "1" : "0",
+  vnet: props.vnet,
+  ...Object.fromEntries(Object.entries(optional3(props)).filter((entry) => entry[1] !== undefined))
+});
+var createForm4 = (props) => ({
+  ...body5(props),
+  subnet: props.cidr,
+  type: "subnet"
+});
+var updateForm2 = (props) => {
+  const clear = Object.entries(optional3(props)).filter(([, value]) => value === undefined).map(([key]) => key);
+  return withClears(body5(props), clear);
+};
+
+// src/proxmox/sdn-subnet.ts
+var ProxmoxSdnSubnet = Resource27("Proxmox.SdnSubnet");
+var handlers22 = pveHandlers({
+  attributes: (live, props) => {
+    const liveVnet = text(live["vnet"]);
+    if (liveVnet !== "" && liveVnet !== props.vnet)
+      return;
+    return {
+      cidr: text(live["cidr"]),
+      dhcpDnsServer: text(live["dhcp-dns-server"]),
+      dhcpRange: dhcpRanges(live["dhcp-range"]),
+      dnszoneprefix: text(live["dnszoneprefix"]),
+      gateway: text(live["gateway"]),
+      mask: int(live["mask"], 0),
+      snat: bool(live["snat"]),
+      staged: true,
+      subnetId: subnetId(props),
+      vnet: props.vnet,
+      zone: text(live["zone"])
+    };
+  },
+  collection: (props) => `cluster/sdn/vnets/${props.vnet}/subnets`,
+  createForm: createForm4,
+  matches: (attributes2, props) => attributes2.gateway === (props.gateway ?? "") && attributes2.snat === (props.snat === true) && attributes2.dnszoneprefix === (props.dnszoneprefix ?? "") && attributes2.dhcpDnsServer === (props.dhcpDnsServer ?? "") && attributes2.dhcpRange === declaredRanges(props.dhcpRange),
+  path: (props) => `cluster/sdn/vnets/${props.vnet}/subnets/${subnetId(props)}`,
+  updateForm: updateForm2
+});
+var ProxmoxSdnSubnetProvider = () => Provider27.effect(ProxmoxSdnSubnet, Effect40.succeed(ProxmoxSdnSubnet.Provider.of(handlers22)));
+// src/proxmox/sdn-vnet.ts
+import { Resource as Resource28 } from "alchemy";
+import * as Provider28 from "alchemy/Provider";
+import * as Effect41 from "effect/Effect";
+var ProxmoxSdnVnet = Resource28("Proxmox.SdnVnet");
+var tagOf = (value) => typeof value === "number" ? value : undefined;
+var shape10 = (props) => {
+  const alias = props.alias ?? "";
+  return {
+    "isolate-ports": props.isolatePorts === true ? "1" : "0",
+    vlanaware: props.vlanaware === true ? "1" : "0",
+    zone: props.zone,
+    ...alias === "" ? {} : { alias },
+    ...props.tag === undefined ? {} : { tag: String(props.tag) }
+  };
+};
+var updateForm3 = (props) => {
+  const unset2 = [
+    ...(props.alias ?? "") === "" ? ["alias"] : [],
+    ...props.tag === undefined ? ["tag"] : []
+  ];
+  return withClears(shape10(props), unset2);
+};
+var handlers23 = pveHandlers({
+  readRole: "provision",
+  attributes: (live, props) => ({
+    alias: typeof live["alias"] === "string" ? live["alias"] : "",
+    bridge: props.vnet,
+    isolatePorts: bool(live["isolate-ports"]),
+    tag: tagOf(live["tag"]),
+    vlanaware: bool(live["vlanaware"]),
+    vnet: props.vnet,
+    zone: typeof live["zone"] === "string" ? live["zone"] : ""
+  }),
+  collection: () => "cluster/sdn/vnets",
+  createForm: (props) => ({ ...shape10(props), vnet: props.vnet }),
+  matches: (attributes2, props) => attributes2.zone === props.zone && attributes2.alias === (props.alias ?? "") && attributes2.tag === props.tag && attributes2.vlanaware === (props.vlanaware === true) && attributes2.isolatePorts === (props.isolatePorts === true),
+  path: (props) => `cluster/sdn/vnets/${props.vnet}`,
+  updateForm: updateForm3
+});
+var ProxmoxSdnVnetProvider = () => Provider28.effect(ProxmoxSdnVnet, Effect41.succeed(ProxmoxSdnVnet.Provider.of(handlers23)));
+// src/proxmox/sdn-zone.ts
+import { Resource as Resource29 } from "alchemy";
+import * as Provider29 from "alchemy/Provider";
+import * as Effect42 from "effect/Effect";
+var ProxmoxSdnZone = Resource29("Proxmox.SdnZone");
+var sameIpam = (live, declared) => (live === "" ? "pve" : live) === (declared === undefined || declared === "" ? "pve" : declared);
+var body6 = (props) => ({
+  ...props.bridge === undefined ? {} : { bridge: props.bridge },
+  ...props.dns === undefined ? {} : { dns: props.dns },
+  ...props.dnszone === undefined ? {} : { dnszone: props.dnszone },
+  ...props.ipam === undefined ? {} : { ipam: props.ipam },
+  ...props.mtu === undefined ? {} : { mtu: String(props.mtu) },
+  ...props.nodes === undefined ? {} : { nodes: csv(props.nodes) },
+  ...props.peers === undefined ? {} : { peers: csv(props.peers) },
+  ...props.tag === undefined ? {} : { tag: String(props.tag) },
+  ...props["vrf-vxlan"] === undefined ? {} : { "vrf-vxlan": String(props["vrf-vxlan"]) }
+});
+var clearable = {
+  evpn: ["dns", "dnszone", "mtu", "nodes"],
+  qinq: ["dns", "dnszone", "ipam", "mtu", "nodes"],
+  simple: ["dns", "dnszone", "ipam", "mtu", "nodes"],
+  vlan: ["dns", "dnszone", "ipam", "mtu", "nodes"],
+  vxlan: ["dns", "dnszone", "ipam", "mtu", "nodes"]
+};
+var handlers24 = pveHandlers({
+  readRole: "provision",
+  attributes: (live, props) => {
+    const liveType = text(live["type"]);
+    if (liveType !== "" && liveType !== props.type)
+      return;
+    return {
+      bridge: text(live["bridge"]),
+      dns: text(live["dns"]),
+      dnszone: text(live["dnszone"]),
+      ipam: text(live["ipam"]) === "" ? "pve" : text(live["ipam"]),
+      mtu: int(live["mtu"], 0),
+      nodes: csv(text(live["nodes"])),
+      peers: csv(text(live["peers"])),
+      staged: true,
+      tag: int(live["tag"], 0),
+      type: props.type,
+      "vrf-vxlan": int(live["vrf-vxlan"], 0),
+      zone: props.zone
+    };
+  },
+  collection: () => "cluster/sdn/zones",
+  createForm: (props) => ({ ...body6(props), type: props.type, zone: props.zone }),
+  matches: (attributes2, props) => attributes2.mtu === (props.mtu ?? 0) && attributes2.nodes === csv(props.nodes) && sameIpam(attributes2.ipam, props.ipam) && attributes2.dns === (props.dns ?? "") && attributes2.dnszone === (props.dnszone ?? "") && attributes2.peers === csv(props.peers) && attributes2["vrf-vxlan"] === (props["vrf-vxlan"] ?? 0) && attributes2.tag === (props.tag ?? 0) && attributes2.bridge === (props.bridge ?? ""),
+  path: (props) => `cluster/sdn/zones/${props.zone}`,
+  updateForm: (props) => {
+    const fields = body6(props);
+    const clear = clearable[props.type].filter((option) => fields[option] === undefined);
+    return withClears(fields, clear);
+  }
+});
+var ProxmoxSdnZoneProvider = () => Provider29.effect(ProxmoxSdnZone, Effect42.succeed(ProxmoxSdnZone.Provider.of(handlers24)));
+// src/proxmox/storage.ts
+import { Resource as Resource30 } from "alchemy";
+import * as Provider30 from "alchemy/Provider";
+import * as Effect43 from "effect/Effect";
+var ProxmoxStorage = Resource30("Proxmox.Storage", {
+  defaultRemovalPolicy: "retain"
+});
+var str2 = (value, fallback = "") => typeof value === "string" ? value : fallback;
+var field5 = (name, value) => value === undefined ? {} : { [name]: value };
+var locatorForm = (locator) => ({ ...locator });
+var tokens = (value) => value.split(",").map((part) => part.trim()).filter((part) => part !== "").sort().join(",");
+var sameList2 = (declared, live) => declared === undefined || tokens(declared) === tokens(live);
+var same5 = (declared, live) => declared === undefined || declared === live;
+var mutable2 = (props) => ({
+  ...field5("comment", props.comment),
+  ...field5("content", props.content),
+  ...field5("disable", flag(props.disable)),
+  ...field5("maxfiles", props.maxfiles === undefined ? undefined : String(props.maxfiles)),
+  ...field5("nodes", props.nodes),
+  ...field5("preallocation", props.preallocation),
+  ...field5("prune-backups", props["prune-backups"]),
+  ...field5("shared", flag(props.shared))
+});
+var handlers25 = pveHandlers({
+  readRole: "provision",
+  attributes: (live, props) => ({
+    comment: str2(live["comment"]),
+    content: str2(live["content"]),
+    disable: bool(live["disable"]),
+    maxfiles: typeof live["maxfiles"] === "number" ? live["maxfiles"] : -1,
+    nodes: str2(live["nodes"]),
+    preallocation: str2(live["preallocation"]),
+    "prune-backups": str2(live["prune-backups"]),
+    shared: bool(live["shared"]),
+    storage: props.storage,
+    type: str2(live["type"], props.type)
+  }),
+  collection: () => "storage",
+  createForm: (props) => ({
+    ...locatorForm(props.locator),
+    ...mutable2(props),
+    storage: props.storage,
+    type: props.type
+  }),
+  matches: (attributes2, props) => sameList2(props.content, attributes2.content) && sameList2(props.nodes, attributes2.nodes) && sameList2(props["prune-backups"], attributes2["prune-backups"]) && same5(props.disable, attributes2.disable) && same5(props.shared, attributes2.shared) && same5(props.preallocation, attributes2.preallocation) && same5(props.comment, attributes2.comment) && same5(props.maxfiles, attributes2.maxfiles),
+  path: (props) => `storage/${props.storage}`,
+  updateForm: mutable2
+});
+var ProxmoxStorageProvider = () => Provider30.effect(ProxmoxStorage, Effect43.succeed(ProxmoxStorage.Provider.of(handlers25)));
+// src/proxmox/user.ts
+import { Resource as Resource31 } from "alchemy";
+import * as Provider31 from "alchemy/Provider";
+import * as Effect44 from "effect/Effect";
+var ProxmoxUser = Resource31("Proxmox.User");
+var str3 = (value) => typeof value === "string" ? value : "";
+var int2 = (value) => {
+  const parsed = typeof value === "number" ? value : Number(value ?? 0);
+  return Number.isFinite(parsed) ? parsed : 0;
+};
+var groupSet = (value) => {
+  const raw = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [];
+  const names = raw.map((group) => str3(group).trim()).filter((group) => group !== "");
+  return [...new Set(names)].sort();
+};
+var tokenNames = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? Object.keys(value).sort() : [];
+var shape11 = (props) => ({
+  comment: props.comment ?? "",
+  email: props.email ?? "",
+  enable: props.enable === false ? "0" : "1",
+  expire: String(props.expire ?? 0),
+  firstname: props.firstname ?? "",
+  groups: groupSet(props.groups).join(","),
+  lastname: props.lastname ?? ""
+});
+var handlers26 = pveHandlers({
+  attributes: (live, props) => ({
+    comment: str3(live["comment"]),
+    email: str3(live["email"]),
+    enable: bool(live["enable"], true),
+    expire: int2(live["expire"]),
+    firstname: str3(live["firstname"]),
+    groups: groupSet(live["groups"]),
+    lastname: str3(live["lastname"]),
+    tokens: tokenNames(live["tokens"]),
+    userid: props.userid
+  }),
+  collection: () => "access/users",
+  createForm: (props) => ({ ...shape11(props), userid: props.userid }),
+  matches: (attributes2, props) => attributes2.comment === (props.comment ?? "") && attributes2.email === (props.email ?? "") && attributes2.enable === (props.enable !== false) && attributes2.expire === (props.expire ?? 0) && attributes2.firstname === (props.firstname ?? "") && attributes2.lastname === (props.lastname ?? "") && attributes2.groups.join(",") === groupSet(props.groups).join(","),
+  path: (props) => `access/users/${props.userid}`,
+  updateForm: shape11
+});
+var ProxmoxUserProvider = () => Provider31.effect(ProxmoxUser, Effect44.succeed(ProxmoxUser.Provider.of(handlers26)));
+// src/proxmox/zfs-pool.ts
+import { Resource as Resource32 } from "alchemy";
+import * as Provider32 from "alchemy/Provider";
+import * as Effect46 from "effect/Effect";
+
+// src/proxmox/zfs-pool-write.ts
+import * as Effect45 from "effect/Effect";
+var createForm5 = (props) => ({
+  devices: props.devices.join(","),
+  name: props.name,
+  raidlevel: props.raidlevel,
+  ...props.ashift === undefined ? {} : { ashift: String(props.ashift) },
+  ...props.compression === undefined ? {} : { compression: props.compression },
+  ...props["draid-config"] === undefined ? {} : { "draid-config": props["draid-config"] }
+});
+var SETTLE_ATTEMPTS = 30;
+var createPool = (props, collection2, path, read3) => Effect45.gen(function* () {
+  const existing = yield* read3(props);
+  if (existing !== undefined)
+    return existing;
+  const upid = yield* pve(props.target, "provision", "POST", collection2, createForm5(props));
+  const settle4 = (attempts) => Effect45.gen(function* () {
+    const live = yield* read3(props);
+    if (live !== undefined || attempts <= 0)
+      return live;
+    yield* Effect45.sleep("2 seconds");
+    return yield* settle4(attempts - 1);
+  });
+  const after = yield* settle4(SETTLE_ATTEMPTS);
+  if (after === undefined) {
+    return yield* Effect45.die(new Error(`${path}: POST returned ${text(upid, "(no UPID)")} but the pool has not appeared. That ` + "POST only forks a `zfscreate` worker, so the task holds the real error -- read it " + `with \`pvesh get /nodes/${props.node}/tasks/<upid>/log\`. NOTHING WAS RETRIED AND ` + "NOTHING WAS CLEANED UP: if the worker reached `zpool create`, the declared devices " + "have already been written to."));
+  }
+  return after;
+});
+var destroyPool = (olds, path) => pve(olds.target, "provision", "DELETE", path);
+
+// src/proxmox/zfs-pool.ts
+var ProxmoxZfsPool = Resource32("Proxmox.ZfsPool", {
+  defaultRemovalPolicy: "retain"
+});
+var leafDevices = (children) => Array.isArray(children) ? children.flatMap((entry) => {
+  const vdev = entry;
+  const nested = leafDevices(vdev.children);
+  return nested.length > 0 ? nested : [text(vdev.name)].filter((name) => name !== "");
+}) : [];
+var spec2 = {
+  attributes: (live, props) => {
+    if (text(live["name"]) === "")
+      return;
+    return {
+      devices: leafDevices(live["children"]).join(","),
+      errors: text(live["errors"], "unknown"),
+      name: props.name,
+      node: props.node,
+      state: text(live["state"], "unknown")
+    };
+  },
+  collection: (props) => `nodes/${props.node}/disks/zfs`,
+  createForm: createForm5,
+  matches: () => true,
+  path: (props) => `nodes/${props.node}/disks/zfs/${props.name}`
+};
+var ops5 = pveOperations(spec2);
+var handlers27 = {
+  ...pveHandlers(spec2),
+  delete: Effect46.fn(function* ({ olds }) {
+    yield* destroyPool(olds, spec2.path(olds));
+  }),
+  reconcile: ({ news }) => createPool(news, spec2.collection(news), spec2.path(news), ops5.read)
+};
+var ProxmoxZfsPoolProvider = () => Provider32.effect(ProxmoxZfsPool, Effect46.succeed(ProxmoxZfsPool.Provider.of(handlers27)));
+export {
+  PbsDatastoreProvider,
+  PbsPruneJobProvider,
+  PbsSyncJobProvider,
+  PbsVerifyJobProvider,
+  ProxmoxAclProvider,
+  ProxmoxApiTokenProvider,
+  ProxmoxBackupJobProvider,
+  ProxmoxCephDaemonProvider,
+  ProxmoxCephFlagProvider,
+  ProxmoxCephFsProvider,
+  ProxmoxCephOsdProvider,
+  ProxmoxCephPool,
+  ProxmoxCephPoolProvider,
+  ProxmoxFirewallAliasProvider,
+  ProxmoxGroupProvider,
+  ProxmoxHaResourceProvider,
+  ProxmoxHaRuleProvider,
+  ProxmoxLxcProvider,
+  ProxmoxMetricServerProvider,
+  ProxmoxNetworkApplyProvider,
+  ProxmoxNodeNetworkProvider,
+  ProxmoxNotificationTargetProvider,
+  ProxmoxPool,
+  ProxmoxPoolProvider,
+  ProxmoxReplicationJobProvider,
+  ProxmoxRoleProvider,
+  ProxmoxSdnApplyProvider,
+  ProxmoxSdnSubnetProvider,
+  ProxmoxSdnVnetProvider,
+  ProxmoxSdnZoneProvider,
+  ProxmoxStorageProvider,
+  ProxmoxUserProvider,
+  ProxmoxVmProvider,
+  ProxmoxZfsPoolProvider
+};
+
+//# debugId=DDFA46749A442EED64756E2164756E21
+//# sourceMappingURL=index.js.map