@homeflare/alchemy 0.1.0

package/dist/proxmox/ha-resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ha-resource.d.ts","sourceRoot":"","sources":["../../src/proxmox/ha-resource.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAe,MAAM,eAAe,CAAC;AAGnF;;;;;;;GAOG;AACH,MAAM,MAAM,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC;AAErE,MAAM,WAAW,eAAgB,SAAQ,UAAU;IACjD,0FAA0F;IAC1F,GAAG,EAAE,MAAM,CAAC;IACZ,6EAA6E;IAC7E,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2FAA2F;IAC3F,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0EAA0E;IAC1E,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,oBAAoB;IACnC,0CAA0C;IAC1C,GAAG,EAAE,MAAM,CAAC;IACZ,8FAA8F;IAC9F,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,iBAAkB,SAAQ,QAAQ,CACjD,oBAAoB,EACpB,eAAe,EACf,oBAAoB,EACpB,KAAK,EACL,eAAe,CAChB;CAAG;AAEJ,eAAO,MAAM,iBAAiB,oDAAoD,CAAC;AAsDnF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,yBAAyB,uIACuD,CAAC"}

package/dist/proxmox/ha-rule-form.d.ts

@@ -0,0 +1,103 @@
+/**
+ * An HA rule's props as the form PVE wants, and the two lists PVE re-spells on the way back.
+ *
+ * ★ SPLIT OUT OF ha-rule.ts TO KEEP BOTH FILES UNDER THE 250-LINE CAP, and the seam is the same
+ *   one metric-server-form.ts and node-network-form.ts cut: this file answers "how does a
+ *   declaration become a PVE form, and what shape does PVE hand back", ha-rule.ts answers "what is
+ *   an HA rule and when has it changed". Nothing here reads the cluster or decides a diff.
+ *
+ * ⚠️ THE `import type` BACK TO ha-rule.ts IS A CYCLE ON PAPER ONLY. It is type-only, so it is
+ *   erased before anything runs, and `HaRuleProps` stays public in the file declaring the resource.
+ */
+import type { HaRuleProps } from './ha-rule.ts';
+/**
+ * A `<node>[:<pri>]` list, spelled the way PVE gives it back.
+ *
+ * ⛔ THIS IS NOT `csv`, AND THE DIFFERENCE IS A FOREVER-DIFF. MEASURED by reading
+ *   `/usr/share/perl5/PVE/HA/Rules/NodeAffinity.pm` on n2 (2026-09-13): `decode_plugin_value`
+ *   turns the list into a HASH keyed by node name, and `encode_plugin_value` rebuilds it with
+ *   `for my $node (sort keys %$value)` — sorted by NODE NAME, never by the token — emitting the
+ *   bare name whenever the priority is falsy, because `PVE::HA::Tools::parse_node_priority` reads
+ *   a missing priority as 0. So a declared `n3:1,n2:0` is handed back as `n2,n3:1`: re-ordered AND
+ *   re-spelled. Compare the raw strings and every plan reports an update, forever.
+ *
+ * ⚠️ SORTED BY NAME, NOT BY TOKEN, AND THE TWO GENUINELY DIVERGE. `csv` sorts whole tokens. Node
+ *   names may contain `-` — `parse_node_priority`'s own regex is
+ *   `[a-zA-Z0-9]([a-zA-Z0-9\-]*[a-zA-Z0-9])?` — and `-` (0x2D) sorts before `:` (0x3A), so `n2-a`
+ *   and `n2:5` come out in one order by token and the other by name. PVE sorts by the name, so
+ *   this does too.
+ *
+ * ⚠️ LAST ENTRY WINS FOR A REPEATED NODE, because PVE's decode is a hash assignment and a hash
+ *   keeps one value per key. A declaration saying `n2:1,n2:5` is stored as `n2:5`; matching that
+ *   is what a Map gives for free.
+ */
+export declare const nodeList: (value: readonly string[] | string | undefined) => string;
+/**
+ * PVE's own verdict on whether the rule can be satisfied, flattened to one reportable string.
+ *
+ * ⚠️ COMPUTED, NEVER DECLARED, AND NEVER COMPARED. `PVE::API2::HA::Rules` runs `check_feasibility`
+ *   over the WHOLE rule set on every read and attaches whatever it finds to each rule as
+ *   `errors => { <option> => "<message>, <message>" }`. It therefore changes when somebody else's
+ *   rule changes, and none of it is a parameter any write accepts. It belongs in attributes so a
+ *   plan can show that PVE considers this rule unsatisfiable, and nowhere near `matches`.
+ */
+export declare const problems: (value: unknown) => string;
+/**
+ * A comment as PVE will actually STORE it, which is not always the string it was handed.
+ *
+ * ⛔ PVE DECODES `%XX` OUT OF EVERY COMMENT ON THE WAY IN AND NEVER PUTS IT BACK. MEASURED:
+ *   `PVE::SectionConfig::check_config` runs `decode_value` over each submitted field (line 1625 on
+ *   this node), the base rule plugin's `decode_value` sends `comment` through
+ *   `PVE::ParseUtils::decode_text` — `uri_unescape` then a utf8 decode — and `$get_api_ha_rule`
+ *   hands the comment straight back WITHOUT re-encoding it (only `resources` and `nodes` are
+ *   re-encoded there). So a declared `deploy%20window` is stored and returned as `deploy window`,
+ *   and a `matches` comparing the declared string would report an update on every plan forever
+ *   while every PUT wrote exactly what was already there.
+ *
+ * ★ SO THE COMPARISON MIRRORS THE DECODE RATHER THAN FIGHTING IT. Both sides then say what the
+ *   cluster will really hold, which is the same move `nodeList` above makes for a re-sorted list.
+ * ⚠️ GROUPS OF `%XX` ARE DECODED TOGETHER so a multi-byte utf8 sequence survives; a lone `%` or a
+ *   malformed sequence is left alone, as `uri_unescape` leaves it. The one place this differs from
+ *   Perl is a sequence that is valid percent-encoding but invalid utf8: Perl substitutes U+FFFD,
+ *   this leaves the escape. Nothing in a comment should be reaching for that.
+ */
+export declare const commentText: (raw: string) => string;
+/**
+ * Every managed optional, per type: the value to send, or undefined for "clear it".
+ *
+ * ⛔ `disable=0` DOES NOT CLEAR A DISABLED RULE, AND THAT IS THE WORST TRAP IN THIS FAMILY.
+ *   MEASURED in `/usr/share/perl5/PVE/API2/HA/Rules.pm`: both `create_rule` and `update_rule` run
+ *   `delete $param->{disable} if !$param->{disable};` BEFORE the plugin sees the form. A PUT
+ *   carrying `disable=0` is therefore a PUT carrying nothing — PVE answers 200, the rule stays
+ *   disabled, `matches` reports an update on the next plan, and the loop never settles. The only
+ *   way back on is `delete=disable`, which is why `disable` is in this table rather than in
+ *   `required` below.
+ *
+ * ⛔ AND THE BRANCHES CANNOT BE ONE SHARED MAP. `PVE::SectionConfig::delete_from_config` dies
+ *   `no such option '<k>'` for an option the plugin does not declare and `unable to delete
+ *   required option '<k>'` for one it requires — so `delete=strict` against a resource-affinity
+ *   rule is a hard failure, and `delete=nodes` or `delete=resources` would be one against either.
+ *   Only `comment`, `disable` and (node-affinity only) `strict` are clearable at all.
+ *
+ * ⚠️ AN EMPTY `comment` IS A CLEARED ONE. PVE stores whatever string it is given, so writing `''`
+ *   would leave the option present and empty rather than absent; `matches` reads both as `''`, but
+ *   only the delete actually removes the line.
+ */
+export declare const optional: (props: HaRuleProps) => Record<string, string | undefined>;
+export declare const body: (props: HaRuleProps) => Record<string, string>;
+/**
+ * The options an update must explicitly remove.
+ *
+ * ⛔ A PUT THAT OMITS A FIELD DOES NOT CLEAR IT — `update_rule` merges the form into the stored
+ *   rule (`$rule->{$_} = $opts->{$_} for keys $opts->%*`) — so a managed optional needs a matching
+ *   `delete=` the moment its prop goes away. Both halves come off the one table above, which makes
+ *   "managed but not clearable" impossible to write here.
+ * ⚠️ NEVER BOTH AT ONCE: `delete_from_config` dies `cannot set and delete property '<k>' at the
+ *   same time!`. The table answers a value or `undefined`, never both, so the two lists are
+ *   disjoint by construction.
+ * ⚠️ THE CREATE FORM CANNOT USE THIS. `POST /cluster/ha/rules` has no `delete` parameter at all
+ *   (MEASURED from the cluster's own schema), and it needs none: an omitted optional on a brand
+ *   new rule is simply absent.
+ */
+export declare const clearList: (props: HaRuleProps) => string[];
+//# sourceMappingURL=ha-rule-form.d.ts.map

package/dist/proxmox/ha-rule-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ha-rule-form.d.ts","sourceRoot":"","sources":["../../src/proxmox/ha-rule-form.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,QAAQ,UAAW,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,WAerE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,UAAW,OAAO,WAM/B,CAAC;AAET;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,WAAW,QAAS,MAAM,WAOnC,CAAC;AAEL;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,QAAQ,UAAW,WAAW,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAI7E,CAAC;AAqCH,eAAO,MAAM,IAAI,UAAW,WAAW,2BAMtC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS,UAAW,WAAW,aAGd,CAAC"}

package/dist/proxmox/ha-rule.d.ts

@@ -0,0 +1,156 @@
+/**
+ * `Proxmox.HaRule` — where the CRM may place a guest, and which guests must not share a node.
+ *
+ * ★ THIS IS THE PVE 9 SUCCESSOR TO HA GROUPS, AND THE GROUPS ENDPOINT IS GONE. MEASURED on n2
+ *   (pve-manager/9.2.11, 2026-09-13): `pvesh get /cluster/ha/groups` answers `cannot index groups:
+ *   ha groups have been migrated to rules`, and `/etc/pve/ha/` holds `rules.cfg` with no
+ *   `groups.cfg` beside it. The published schema still documents groups and still offers a `group`
+ *   parameter on `Proxmox.HaResource`; both are dead. Do not port them back.
+ *
+ * ★ ONE RESOURCE FOR BOTH RULE TYPES, ON THE ceph-daemon.ts ARGUMENT AND AFTER READING BOTH
+ *   PLUGINS. `PVE::HA::Rules::NodeAffinity` and `::ResourceAffinity` share `resources`, `affinity`,
+ *   `disable` and `comment`; node-affinity adds `nodes` and `strict` and nothing else diverges. The
+ *   endpoint, the path, the create/update/delete calls, the `order` and `digest` traps below and
+ *   the list normalisation are identical for both. Two files would have carried every one of those
+ *   traps twice and let them drift.
+ *   ⛔ `type` IS CREATE-ONLY. MEASURED in `/usr/share/perl5/PVE/API2/HA/Rules.pm`: `update_rule`
+ *     takes the plugin from the STORED rule (`my $type = $rule->{type};`) and never rewrites it. So
+ *     `attributes` reports a rule of the other type as ABSENT, which sends reconcile down the
+ *     create branch and makes PVE refuse with `HA rule '<id>' already defined` — a loud, accurate
+ *     error rather than a PUT pushing node-affinity fields at a resource-affinity rule.
+ *     ⛔ AND YET IT IS SENT ON THE UPDATE ANYWAY, because the PUT is validated against a `oneOf`
+ *       keyed on it and refuses the whole body without it. That one is worth reading in full: it
+ *       is the ⛔ on `required` in ha-rule-form.ts.
+ *
+ * ⛔ THREE FIELDS PVE RETURNS AND NO WRITE ACCEPTS, EACH ONE A FOREVER-UPDATE IF COMPARED.
+ *   `order` is an ORDINAL PVE ASSIGNS ITSELF (`$rules->{order}->{$ruleid} =
+ *   PVE::HA::Rules::get_next_ordinal($rules)`) and it appears in no create or update schema at all;
+ *   it is reported in attributes and never compared. `digest` is the digest of the WHOLE rules
+ *   file, so it moves when a rule written for somebody else's guests moves — it is not even an
+ *   attribute, for the reason ha-resource.ts gives. `errors` is PVE's own feasibility verdict,
+ *   recomputed across every rule on every read; reported, never compared. See `problems` in
+ *   ha-rule-form.ts.
+ *
+ * ⚠️ IT COMPOSES WITH `Proxmox.HaResource`, AND THE EDGE IS REAL RATHER THAN TIDY. MEASURED:
+ *   `create_rule` runs `$assert_valid_resources_param`, which calls
+ *   `PVE::HA::Config::service_is_configured($resource)` for every sid and dies `cannot use
+ *   unmanaged resource(s) <sid>` if one is not already an HA resource. A rule naming a sid nothing
+ *   has put under HA is a HARD 400, not a warning — so `resources` should be written as the
+ *   HaResource's own attribute (`resources: [web.sid, db.sid]`) and let Alchemy order the deploy,
+ *   not as a bare string that happens to match. `$assert_valid_nodes_param` refuses a non-existent
+ *   node the same way.
+ *   ⛔ AND THE EDGE RUNS BACK THE OTHER WAY, WHERE ALCHEMY CANNOT SEE IT. Destroying an
+ *     `HaResource` deletes with PVE's default `purge=1`, which strips that sid out of every rule
+ *     and DELETES any rule left with no members. So a plan that only removes a guest can remove
+ *     this resource's object from under it; the next plan then reads absent and recreates it, or
+ *     fails on the `unmanaged resource` check if the guest is gone for good.
+ *
+ * ⚠️ BOTH LANES ALREADY HAVE THE PRIVILEGES, WHICH IS NEW. MEASURED 2026-09-13:
+ *   GET (collection and item) checks `Sys.Audit` on `/` and the built-in `PVEAuditor` holds it, so
+ *   `readRole` stays the default `read` lease — unlike storage.ts and the SDN families. POST, PUT
+ *   and DELETE all check `Sys.Console` on `/`, and `pvesh get /access/roles/LXCProvisioner` now
+ *   returns `Sys.Console` among its 27 privileges. The warning in ha-resource.ts's header — that
+ *   `Sys.Console` is missing — is stale; the role was widened, and the price it named still stands:
+ *   `Sys.Console` is also what opens a root shell on every node.
+ *
+ * ⚠️ REMOVAL IS THE PLAIN DEFAULT, DELIBERATELY, AND `delete` IS THE FACTORY'S. An HA rule is
+ *   exactly a line of TypeScript — nothing in it is irreplaceable the way a Ceph pool or a ZFS
+ *   vdev is — so the `retain` default that resource.ts explains does not apply. Read the plan for
+ *   what it is, though: while a negative resource-affinity rule is absent, nothing stops the CRM
+ *   putting both halves of a pair on one node.
+ *
+ * ⚠️ A READ GOES THROUGH THE GROUPS MIGRATION. Every GET calls `migrate_groups_to_rules`, so on a
+ *   cluster that still has `groups.cfg` the answer includes SYNTHETIC rules nobody declared. This
+ *   cluster has none, so nothing is injected here; a rule id colliding with an old group name on a
+ *   cluster that does would read back something this provider never wrote.
+ *
+ * ⚠️ A CHANGED `type` READS AS `update` IN THE PLAN AND FAILS AS "already defined" ON THE APPLY,
+ *   AND THOSE TWO WORDS POINT AWAY FROM THE CAUSE. `attributes` answers undefined when the live
+ *   rule's type disagrees, so `diff` takes resource.ts's `live === undefined` branch and says
+ *   update; reconcile then reads undefined, POSTs, and PVE refuses because the rule is plainly
+ *   there. The cause is that `type` is create-only. metric-server.ts has the same shape, so this
+ *   is the package's consistent behaviour rather than a quirk of this file — but it is worth
+ *   knowing before reading the error. Delete the declaration and write a new one to change a type.
+ */
+import { Resource } from 'alchemy';
+import * as Provider from 'alchemy/Provider';
+import { type PveRequirements, type WithTarget } from './resource.ts';
+export type HaRuleType = 'node-affinity' | 'resource-affinity';
+/**
+ * ⛔ REQUIRED ON BOTH TYPES, AND THAT IS A DELIBERATE NARROWING OF PVE'S SCHEMA. PVE makes it
+ *   optional for node-affinity (defaulting to `positive`) and mandatory for resource-affinity. A
+ *   provider that mirrored that has two bad options when a declaration omits it: guess `positive`,
+ *   which silently flips a live `negative` rule — the one keeping two guests APART — into one that
+ *   pins them together; or leave it out of the write, which makes `matches` disagree with a live
+ *   `negative` rule forever while every PUT changes nothing. Requiring one word from the caller
+ *   removes both.
+ */
+export type HaAffinity = 'positive' | 'negative';
+interface HaRuleBase extends WithTarget {
+    /** A `pve-configid`: a letter, then letters, digits, `-` and `_`. Identity — renaming is a new
+     *  rule, and the old one stays behind exactly as `sid` does in ha-resource.ts. */
+    rule: string;
+    /**
+     * The HA resources this rule constrains, as prefixed sids — `ct:101`, `vm:100`.
+     * ⚠️ EVERY ONE MUST ALREADY BE UNDER HA. See the composition ⚠️ in the header: this is an
+     *   ordering edge, and the honest way to express it is the HaResource's own `sid` attribute.
+     */
+    resources: readonly string[] | string;
+    affinity: HaAffinity;
+    /** Keep the rule in the file but stop the CRM applying it. ⛔ Clearing it needs `delete=disable`
+     *  — see the ⛔ in `optional` in ha-rule-form.ts. */
+    disable?: boolean;
+    /** Free text shown in the HA panel. Max 4096 characters. */
+    comment?: string;
+}
+export interface NodeAffinityRuleProps extends HaRuleBase {
+    type: 'node-affinity';
+    /**
+     * Cluster nodes, each optionally `<node>:<priority>`. Higher priority wins; the numbers are
+     * relative and nothing else. ⚠️ REQUIRED BY THE TYPE, not merely by PVE — an optional `nodes`
+     * would let a declaration that cannot describe any live rule sit in a permanent update loop.
+     */
+    nodes: readonly string[] | string;
+    /** `false` (PVE's default) makes the nodes a PREFERENCE; `true` makes them the only nodes the
+     *  resources may run on, and the resources STOP when none of them is available. */
+    strict?: boolean;
+}
+export interface ResourceAffinityRuleProps extends HaRuleBase {
+    type: 'resource-affinity';
+}
+/**
+ * ⚠️ A UNION, NOT ONE FLAT INTERFACE WITH OPTIONAL EXTRAS, because `nodes` and `strict` are not
+ *   merely unused on a resource-affinity rule — PVE's oneOf declares `additionalProperties: 0`, so
+ *   sending either is a 400, and comparing either would be a diff no write could ever settle. The
+ *   union makes both unwritable rather than ignored.
+ */
+export type HaRuleProps = NodeAffinityRuleProps | ResourceAffinityRuleProps;
+export interface HaRuleAttributes {
+    rule: string;
+    type: HaRuleType;
+    /** ⚠️ NORMALISED, NOT RAW. PVE returns `join(',', sort keys %$hash)` — a re-sorted SET. */
+    resources: string;
+    /** ⚠️ Normalised by `nodeList`; always `''` on a resource-affinity rule, which has no nodes. */
+    nodes: string;
+    affinity: string;
+    strict: boolean;
+    disable: boolean;
+    comment: string;
+    /** ⛔ PVE-ASSIGNED AND UNWRITABLE. Reported so a plan can show it; never compared. */
+    order: number;
+    /** ⛔ PVE's feasibility verdict for this rule. Reported; never compared. */
+    errors: string;
+}
+export interface ProxmoxHaRule extends Resource<'Proxmox.HaRule', HaRuleProps, HaRuleAttributes, never, PveRequirements> {
+}
+export declare const ProxmoxHaRule: import("alchemy").ResourceClass<ProxmoxHaRule>;
+/**
+ * ⛔ THE EMPTY `list` FROM `pveHandlers` STANDS, AND IT COSTS NOTHING HERE TODAY.
+ *   `GET /cluster/ha/rules` MEASURED `[]` on this cluster on 2026-09-13 — but the same call on a
+ *   cluster somebody has used returns every rule an operator ever clicked, plus the synthetic ones
+ *   the groups migration invents on read. Adopting either is how a later `alchemy destroy` removes
+ *   a separation rule nobody declared. Adoption stays an explicit act.
+ */
+export declare const ProxmoxHaRuleProvider: () => import("effect/Layer").Layer<Provider.Provider<ProxmoxHaRule>, never, import("effect/unstable/http/HttpClient").HttpClient>;
+export {};
+//# sourceMappingURL=ha-rule.d.ts.map

package/dist/proxmox/ha-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ha-rule.d.ts","sourceRoot":"","sources":["../../src/proxmox/ha-rule.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAG7C,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAe,MAAM,eAAe,CAAC;AAGnF,MAAM,MAAM,UAAU,GAAG,eAAe,GAAG,mBAAmB,CAAC;AAE/D;;;;;;;;GAQG;AACH,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,UAAU,CAAC;AAEjD,UAAU,UAAW,SAAQ,UAAU;IACrC;sFACkF;IAClF,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC;IACtC,QAAQ,EAAE,UAAU,CAAC;IACrB;wDACoD;IACpD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,qBAAsB,SAAQ,UAAU;IACvD,IAAI,EAAE,eAAe,CAAC;IACtB;;;;OAIG;IACH,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC;IAClC;uFACmF;IACnF,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,yBAA0B,SAAQ,UAAU;IAC3D,IAAI,EAAE,mBAAmB,CAAC;CAC3B;AAED;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,qBAAqB,GAAG,yBAAyB,CAAC;AAE5E,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,CAAC;IACjB,2FAA2F;IAC3F,SAAS,EAAE,MAAM,CAAC;IAClB,gGAAgG;IAChG,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAC;IACd,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,aAAc,SAAQ,QAAQ,CAC7C,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,KAAK,EACL,eAAe,CAChB;CAAG;AAEJ,eAAO,MAAM,aAAa,gDAA4C,CAAC;AAqEvE;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,mIACmD,CAAC"}

package/dist/proxmox/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Proxmox providers for Alchemy.
+ *
+ * ⛔ THIS BARREL IS THE PUBLIC API, AND IT IS DELIBERATELY SMALLER THAN THE DIRECTORY.
+ *   These are the symbols a real stack consumes; the rest of the files are internals a
+ *   provider needs but a consumer should not depend on. An `export *` here would publish
+ *   every helper as API and make the next refactor a breaking change.
+ * ★ Anything unlisted is still reachable by path if you genuinely need it — that is a
+ *   deliberate, visible act rather than an accident of barrelling.
+ */
+export { ProxmoxAclProvider } from './acl.ts';
+export { ProxmoxApiTokenProvider } from './api-token.ts';
+export { ProxmoxBackupJobProvider } from './backup-job.ts';
+export { ProxmoxCephDaemonProvider } from './ceph-daemon.ts';
+export { ProxmoxCephFlagProvider } from './ceph-flag.ts';
+export { ProxmoxCephFsProvider } from './ceph-fs.ts';
+export { ProxmoxCephOsdProvider } from './ceph-osd.ts';
+export { ProxmoxCephPool, ProxmoxCephPoolProvider } from './ceph-pool.ts';
+export { ProxmoxFirewallAliasProvider } from './firewall-alias.ts';
+export { ProxmoxGroupProvider } from './group.ts';
+export { ProxmoxHaResourceProvider } from './ha-resource.ts';
+export { ProxmoxHaRuleProvider } from './ha-rule.ts';
+export { ProxmoxLxcProvider } from './lxc.ts';
+export { ProxmoxMetricServerProvider } from './metric-server.ts';
+export { ProxmoxNetworkApplyProvider } from './network-apply.ts';
+export { ProxmoxNodeNetworkProvider } from './node-network.ts';
+export { ProxmoxNotificationTargetProvider } from './notification-target.ts';
+export { PbsDatastoreProvider } from './pbs-datastore.ts';
+export { PbsPruneJobProvider } from './pbs-prune-job.ts';
+export { PbsSyncJobProvider } from './pbs-sync-job.ts';
+export { PbsVerifyJobProvider } from './pbs-verify-job.ts';
+export { ProxmoxPool, ProxmoxPoolProvider } from './pool.ts';
+export { ProxmoxVmProvider } from './qemu.ts';
+export { ProxmoxReplicationJobProvider } from './replication-job.ts';
+export { ProxmoxRoleProvider } from './role.ts';
+export { ProxmoxSdnApplyProvider } from './sdn-apply.ts';
+export { ProxmoxSdnSubnetProvider } from './sdn-subnet.ts';
+export { ProxmoxSdnVnetProvider } from './sdn-vnet.ts';
+export { ProxmoxSdnZoneProvider } from './sdn-zone.ts';
+export { ProxmoxStorageProvider } from './storage.ts';
+export { ProxmoxUserProvider } from './user.ts';
+export { ProxmoxZfsPoolProvider } from './zfs-pool.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/proxmox/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/proxmox/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAC1E,OAAO,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,iCAAiC,EAAE,MAAM,0BAA0B,CAAC;AAC7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,6BAA6B,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC"}