@ornncompute/cli 0.2.9 → 0.2.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ornncompute/cli",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "description": "Command-line interface for Ornn compute access workflows.",
   "type": "module",
   "bin": {

package/vendor/capabilities/capabilities/listings.d.ts

@@ -1,5 +1,9 @@
 import { z } from "zod";
 export declare const listingCreateInput: z.ZodObject<{
+    operatorId: z.ZodOptional<z.ZodString>;
+    operator_id: z.ZodOptional<z.ZodString>;
+    facilityId: z.ZodOptional<z.ZodString>;
+    facility_id: z.ZodOptional<z.ZodString>;
     kind: z.ZodOptional<z.ZodEnum<{
         link: "link";
         gpu: "gpu";
@@ -36,6 +40,7 @@ export declare const listingCreateInput: z.ZodObject<{
     price_omitted: z.ZodOptional<z.ZodBoolean>;
     announce: z.ZodOptional<z.ZodBoolean>;
     text: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const listCatalogTermsCapability: import("../capability.ts").Capability<unknown, unknown>;
 export declare const listListingsCapability: import("../capability.ts").Capability<unknown, unknown>;

package/vendor/capabilities/capabilities/listings.js

@@ -2,6 +2,10 @@ import { z } from "zod";
 import { defineCapability, preview } from "../capability.js";
 import { bindHardwareFields, HARDWARE_LISTING_FIELDS, HARDWARE_LISTING_FILTERS, loadHardwareCatalog, projectCatalogTerms, } from "../spec-catalog.js";
 export const listingCreateInput = z.object({
+    operatorId: z.string().optional(),
+    operator_id: z.string().optional(),
+    facilityId: z.string().optional(),
+    facility_id: z.string().optional(),
     kind: z.enum(["gpu", "cpu", "node", "link"]).optional(),
     gpu: z.string().optional(),
     cpu: z.string().optional(),
@@ -23,16 +27,23 @@ export const listingCreateInput = z.object({
     storage: z.string().optional(),
     internet: z.string().optional(),
     network_hardware: z.string().optional(),
-    available_start_at: z.string().optional(),
-    available_end_at: z.string().optional(),
-    available_from: z.string().optional(),
-    available_to: z.string().optional(),
+    available_start_at: z
+        .string()
+        .optional()
+        .describe("Start of the availability window. YYYY-MM-DD or RFC3339."),
+    available_end_at: z
+        .string()
+        .optional()
+        .describe("End of the availability window. YYYY-MM-DD or RFC3339."),
+    available_from: z.string().optional().describe("Alias for available_start_at."),
+    available_to: z.string().optional().describe("Alias for available_end_at."),
     buy_now_price_per_gpu_hour: z.number().optional(),
     cost_per_gpu_hour: z.number().optional(),
     deposit_percent: z.number().optional(),
     price_omitted: z.boolean().optional(),
     announce: z.boolean().optional(),
     text: z.string().optional(),
+    confirm: z.boolean().optional(),
 });
 const catalogTermsInput = z.object({ kind: z.enum(["gpu", "cpu", "node", "link"]).optional() });
 const slackListingCreateParams = {
@@ -124,6 +135,38 @@ export const listListingsCapability = defineCapability({
         return ctx.fetch("/listings/available", { method: "GET", body: bound.payload });
     },
 });
+/** Commerce parses listing windows as RFC3339 timestamps, not bare dates. */
+function rfc3339(value) {
+    const trimmed = value.trim();
+    if (!trimmed.includes("T"))
+        return `${trimmed}T00:00:00Z`;
+    return trimmed.endsWith("Z") || /[+-]\d{2}:\d{2}$/.test(trimmed) ? trimmed : `${trimmed}Z`;
+}
+// Keys the schema accepts for the caller's convenience but that are never part
+// of the create body: window aliases (resolved into startAt/endAt below), the
+// browse-side filters this input shares with listings.available, and the
+// confirm flag. They used to ride along into the POST verbatim, which is why
+// naming a window with available_from/available_to looked like a dead
+// parameter — the alias was passed through unresolved and unnormalized instead
+// of becoming the startAt commerce actually reads.
+const LISTING_CREATE_INPUT_ONLY_KEYS = [
+    "available_start_at",
+    "available_end_at",
+    "available_from",
+    "available_to",
+    "starts_after",
+    "starts_before",
+    "ends_after",
+    "ends_before",
+    "min_nodes",
+    "site",
+    "kind",
+    "confirm",
+    "operatorId",
+    "operator_id",
+    "facilityId",
+    "facility_id",
+];
 export const createListingCapability = defineCapability({
     id: "listings.create",
     domain: "listings",
@@ -145,7 +188,126 @@ export const createListingCapability = defineCapability({
         const bound = bindHardwareFields(hardware.terms, normalized, HARDWARE_LISTING_FIELDS);
         if (!bound.ok)
             return bound;
-        const payload = { backing_mode: "forward", ...bound.payload };
+        let operatorId = parsed.operatorId ?? parsed.operator_id;
+        let facilityId = parsed.facilityId ?? parsed.facility_id;
+        if (ctx.confirmed || parsed.site_operator || parsed.site_nickname || parsed.site) {
+            if (!operatorId) {
+                try {
+                    const opsResp = (await ctx.fetch("/provisioning/operators", { method: "GET" }));
+                    const ops = opsResp?.operators ?? [];
+                    const query = (parsed.site_operator ?? parsed.site ?? "").trim().toLowerCase();
+                    if (query) {
+                        const match = ops.find((o) => o.operatorId.toLowerCase() === query ||
+                            o.slug.toLowerCase() === query ||
+                            o.displayName.toLowerCase() === query);
+                        if (match)
+                            operatorId = match.operatorId;
+                    }
+                    if (!operatorId && ops.length > 0) {
+                        operatorId = ops[0].operatorId;
+                    }
+                }
+                catch {
+                    // Ignore fetch failure (e.g. in unit tests)
+                }
+            }
+            if (!facilityId) {
+                try {
+                    const facsResp = (await ctx.fetch("/provisioning/facilities", { method: "GET" }));
+                    const facs = facsResp?.facilities ?? [];
+                    const query = (parsed.site_nickname ?? parsed.site ?? "").trim().toLowerCase();
+                    if (query) {
+                        const match = facs.find((f) => f.facilityId.toLowerCase() === query ||
+                            f.slug.toLowerCase() === query ||
+                            f.displayName.toLowerCase() === query);
+                        if (match)
+                            facilityId = match.facilityId;
+                    }
+                    if (!facilityId && operatorId) {
+                        const match = facs.find((f) => f.operatorId === operatorId);
+                        if (match)
+                            facilityId = match.facilityId;
+                    }
+                    if (!facilityId && facs.length > 0) {
+                        facilityId = facs[0].facilityId;
+                    }
+                }
+                catch {
+                    // Ignore fetch failure
+                }
+            }
+        }
+        // Every window alias resolves to the same pair, and both are normalized:
+        // commerce decodes startAt/endAt as time.Time, so a bare "2026-09-01"
+        // fails the whole request body rather than the one field.
+        const startAt = rfc3339(parsed.available_start_at ??
+            parsed.available_from ??
+            parsed.starts_after ??
+            new Date().toISOString());
+        // `ends_before` is the window's closing bound and the counterpart of the
+        // `starts_after` the opening bound already accepts. Only `ends_after` was
+        // consulted here, so naming an end with `ends_before` was silently dropped
+        // and endAt fell back to the +30d default.
+        const endAt = rfc3339(parsed.available_end_at ??
+            parsed.available_to ??
+            parsed.ends_before ??
+            parsed.ends_after ??
+            new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString());
+        const capacityNodes = parsed.node_count ?? parsed.min_nodes ?? 1;
+        const gpusPerNode = parsed.gpus_per_node ?? 8;
+        const buyNowPrice = parsed.buy_now_price_per_gpu_hour;
+        const costPrice = parsed.cost_per_gpu_hour;
+        // `deposit_percent` and `price_omitted` were both declared on the schema and
+        // then never read, so they rode into the body under their own names and
+        // commerce ignored them: a deposit plan never took, and a listing whose
+        // source quoted no price still got the invented 1.00 floor below.
+        const depositPercent = parsed.deposit_percent;
+        const priceOmitted = parsed.price_omitted === true;
+        const floorRate = costPrice != null ? String(costPrice) : priceOmitted ? null : "1.00";
+        const { buy_now_price_per_gpu_hour: _, cost_per_gpu_hour: __, deposit_percent: ___, price_omitted: ____, ...boundPayload } = bound.payload;
+        const cleanPayload = Object.fromEntries(Object.entries(boundPayload).filter(([key]) => !LISTING_CREATE_INPUT_ONLY_KEYS.includes(key)));
+        const payload = {
+            backing_mode: "forward",
+            ...cleanPayload,
+            ...(operatorId ? { operatorId, operator_id: operatorId } : {}),
+            ...(facilityId ? { facilityId, facility_id: facilityId } : {}),
+            ...(operatorId
+                ? {
+                    startAt,
+                    start_at: startAt,
+                    endAt,
+                    end_at: endAt,
+                    capacityNodes,
+                    capacity_nodes: capacityNodes,
+                    gpusPerNode,
+                    gpus_per_node: gpusPerNode,
+                    currency: "USD",
+                    buyNowEnabled: buyNowPrice != null,
+                    buy_now_enabled: buyNowPrice != null,
+                    ...(buyNowPrice != null
+                        ? {
+                            buyNowRatePerGpuHour: String(buyNowPrice),
+                            buy_now_rate_per_gpu_hour: String(buyNowPrice),
+                        }
+                        : {}),
+                    ...(depositPercent != null
+                        ? {
+                            allowsDepositPlan: true,
+                            allows_deposit_plan: true,
+                            downPaymentPct: String(depositPercent),
+                            down_payment_pct: String(depositPercent),
+                        }
+                        : {}),
+                    bidEnabled: true,
+                    bid_enabled: true,
+                    // Commerce takes a null floor rate; only a stated cost becomes one.
+                    // The old 1.00 fallback published a floor nobody had quoted.
+                    ...(floorRate != null
+                        ? { floorRatePerGpuHour: floorRate, floor_rate_per_gpu_hour: floorRate }
+                        : {}),
+                }
+                : {}),
+        };
         if (!ctx.confirmed) {
             return preview("create_listing", payload);
         }

package/vendor/capabilities/capabilities/staff-access.d.ts

@@ -13,8 +13,10 @@ export declare const sshKeyAddInput: z.ZodObject<{
     reservationId: z.ZodString;
     tenantId: z.ZodString;
     authUserId: z.ZodString;
-    publicKey: z.ZodString;
+    publicKey: z.ZodOptional<z.ZodString>;
     label: z.ZodOptional<z.ZodString>;
+    sshKeyId: z.ZodOptional<z.ZodString>;
+    push: z.ZodOptional<z.ZodBoolean>;
     confirm: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const sshKeyAddCapability: import("../capability.ts").Capability<unknown, unknown>;

package/vendor/capabilities/capabilities/staff-access.js

@@ -17,6 +17,16 @@ import { mapBody, seg, statusOf } from "./staff-shared.js";
 // `assertReservationOwnedByTenantUser` below so every surface runs them.
 /** Acts as the caller for a write the tenant's own user is nominally making. */
 const AUTH_USER_HEADER = "X-Auth-User-Id";
+/** Live keys only: a revoked or inactive key must never reach a machine. */
+function activePublicKeys(keys, wanted) {
+    return keys
+        .filter((key) => key.id &&
+        wanted(key.id) &&
+        key.status === "active" &&
+        !key.revoked_at &&
+        Boolean(key.public_key?.trim()))
+        .map((key) => key.public_key.trim());
+}
 async function assertReservationOwnedByTenantUser(ctx, options) {
     let reservation;
     try {
@@ -52,6 +62,45 @@ async function assertMachineBelongsToReservation(ctx, options) {
         throw new Error("Machine does not belong to that reservation.");
     }
 }
+/** A VM's keys live on its pod; a bare-metal node's live on the node itself. */
+async function keyTargetPath(ctx, instanceId) {
+    try {
+        const pod = (await ctx.fetch(`/internal/pods/${seg(instanceId)}`, { method: "GET" }));
+        if (pod.kind === "virtual-machine") {
+            return `/internal/pods/${seg(instanceId)}/keys`;
+        }
+    }
+    catch {
+        // instanceId is a host node
+    }
+    return `/internal/nodes/${seg(instanceId)}/keys`;
+}
+/**
+ * Push every key currently attached to a reservation onto its machines.
+ *
+ * Mirrors the staff web workflow (gateway `sync_reservation_keys`). Attaching
+ * a key in commerce only records the grant; without this the key is invisible
+ * on the machine until someone runs ssh_key_push by hand.
+ */
+async function syncReservationKeys(ctx, options) {
+    const attached = (await ctx.fetch(`/internal/v1/reservations/${seg(options.reservationId)}/ssh-keys`, { method: "GET" }));
+    const selected = new Set((attached.sshKeys ?? []).map((row) => row.sshKeyId ?? row.ssh_key_id).filter(Boolean));
+    const listed = (await ctx.fetch(`/v1/organizations/${seg(options.tenantId)}/ssh-keys`, {
+        method: "GET",
+    }));
+    const sshAuthorizedKeys = activePublicKeys(listed.ssh_keys ?? [], (id) => selected.has(id));
+    const listedNodes = (await ctx.fetch(`/internal/nodes?reservation_id=${seg(options.reservationId)}`, { method: "GET" }));
+    const instanceIds = (listedNodes.nodes ?? [])
+        .map((node) => node.node_id ?? node.id)
+        .filter((id) => Boolean(id));
+    for (const instanceId of instanceIds) {
+        await ctx.fetch(await keyTargetPath(ctx, instanceId), {
+            method: "PATCH",
+            body: { ssh_authorized_keys: sshAuthorizedKeys },
+        });
+    }
+    return { machinesSynced: instanceIds.length, keysApplied: sshAuthorizedKeys.length };
+}
 export const sshKeyPushInput = z.object({
     instanceId: z.string(),
     reservationId: z.string(),
@@ -95,29 +144,12 @@ export const sshKeyPushCapability = defineStaffMcpCapability({
             method: "GET",
         }));
         const wanted = new Set(parsed.sshKeyIds);
-        const sshAuthorizedKeys = (listed.ssh_keys ?? [])
-            .filter((key) => key.id &&
-            wanted.has(key.id) &&
-            key.status === "active" &&
-            !key.revoked_at &&
-            Boolean(key.public_key?.trim()))
-            .map((key) => key.public_key.trim());
+        const sshAuthorizedKeys = activePublicKeys(listed.ssh_keys ?? [], (id) => wanted.has(id));
         const body = {
             ssh_authorized_keys: sshAuthorizedKeys,
             ...mapBody(parsed, { requestId: "request_id" }),
         };
-        let keysPath = `/internal/nodes/${seg(parsed.instanceId)}/keys`;
-        try {
-            const pod = (await ctx.fetch(`/internal/pods/${seg(parsed.instanceId)}`, {
-                method: "GET",
-            }));
-            if (pod.kind === "virtual-machine") {
-                keysPath = `/internal/pods/${seg(parsed.instanceId)}/keys`;
-            }
-        }
-        catch {
-            // instanceId is a host node
-        }
+        const keysPath = await keyTargetPath(ctx, parsed.instanceId);
         return ctx.fetch(keysPath, {
             method: "PATCH",
             body,
@@ -129,37 +161,77 @@ export const sshKeyAddInput = z.object({
     reservationId: z.string(),
     tenantId: z.string(),
     authUserId: z.string(),
-    publicKey: z.string().min(1),
+    publicKey: z.string().min(1).optional(),
     label: z.string().optional(),
+    sshKeyId: z.string().optional(),
+    push: z.boolean().optional(),
     confirm: z.boolean().optional(),
 });
 export const sshKeyAddCapability = defineStaffMcpCapability({
     id: "ssh-key.add",
     domain: "access",
     roles: ["admin"],
-    description: "Internal staff only: register an SSH public key on a reservation for a tenant user. Requires confirm: true.",
+    description: "Internal staff only: attach an SSH key to a reservation for a tenant user. " +
+        "Pass sshKeyId to attach a key the organization already has, or publicKey (with label) " +
+        "to register a new organization key and attach it. The reservation's machines are resynced " +
+        "afterwards so the key works immediately; pass push: false to attach without touching them. " +
+        "Requires confirm: true.",
     mutation: "preview-confirm",
     http: { method: "POST", path: "/internal/v1/reservations/{reservationId}/ssh-keys" },
     input: sshKeyAddInput,
     execute: async (ctx, input) => {
         const parsed = sshKeyAddInput.parse(input);
-        const body = {
-            public_key: parsed.publicKey,
-            ...mapBody(parsed, { label: "label" }),
-        };
+        if (!parsed.sshKeyId && !parsed.publicKey) {
+            throw new Error("Pass sshKeyId to attach an existing organization key, or publicKey to register a new one.");
+        }
         if (!ctx.confirmed) {
-            return preview("ssh-key.add", { reservationId: parsed.reservationId, ...body });
+            return preview("ssh-key.add", {
+                reservationId: parsed.reservationId,
+                ...(parsed.sshKeyId ? { sshKeyId: parsed.sshKeyId } : { publicKey: parsed.publicKey, label: parsed.label }),
+            });
         }
         await assertReservationOwnedByTenantUser(ctx, {
             reservationId: parsed.reservationId,
             tenantId: parsed.tenantId,
             authUserId: parsed.authUserId,
         });
-        return ctx.fetch(`/internal/v1/reservations/${seg(parsed.reservationId)}/ssh-keys`, {
+        // Commerce attaches an existing authorization key by id; it has no notion
+        // of a public key blob. Registering first mirrors the staff web workflow
+        // (gateway `add_reservation_key`), which this tool previously bypassed by
+        // posting `public_key` into a body that only reads `sshKeyId`/`userId`.
+        let sshKeyId = parsed.sshKeyId;
+        if (!sshKeyId) {
+            const registered = (await ctx.fetch(`/v1/organizations/${seg(parsed.tenantId)}/ssh-keys`, {
+                method: "POST",
+                body: { public_key: parsed.publicKey, ...mapBody(parsed, { label: "label" }) },
+            }));
+            if (!registered.id) {
+                throw new Error("Authorization did not return an SSH key id.");
+            }
+            sshKeyId = registered.id;
+        }
+        const attached = await ctx.fetch(`/internal/v1/reservations/${seg(parsed.reservationId)}/ssh-keys`, {
             method: "POST",
-            body,
+            body: { sshKeyId, userId: parsed.authUserId },
             headers: { [AUTH_USER_HEADER]: parsed.authUserId },
         });
+        if (parsed.push === false) {
+            return { attached, pushed: false };
+        }
+        // The attach only records the grant. The staff web workflow resyncs the
+        // reservation's machines in the same action, so a key added here is
+        // usable immediately rather than only after a separate ssh_key_push.
+        try {
+            return { attached, pushed: true, ...(await syncReservationKeys(ctx, parsed)) };
+        }
+        catch (error) {
+            return {
+                attached,
+                pushed: false,
+                pushError: error instanceof Error ? error.message : String(error),
+                detail: "The key is attached to the reservation but was not pushed to its machines. Run ssh_key_push to retry.",
+            };
+        }
     },
 });
 export const sshKeyRevokeInput = z.object({

package/vendor/capabilities/capabilities/staff-commerce.d.ts

@@ -7,8 +7,6 @@ export declare const reservationCancelCapability: import("../capability.ts").Cap
 export declare const reservationTransferInput: z.ZodObject<{
     reservationId: z.ZodString;
     targetTenantId: z.ZodString;
-    targetAuthUserId: z.ZodOptional<z.ZodString>;
-    nodeId: z.ZodOptional<z.ZodString>;
     reservedStrategy: z.ZodEnum<{
         reject: "reject";
         park: "park";
@@ -24,10 +22,12 @@ export declare const reservationMachinesListInput: z.ZodObject<{
 export declare const reservationMachinesListCapability: import("../capability.ts").Capability<unknown, unknown>;
 export declare const reservationSshKeyAddInput: z.ZodObject<{
     reservationId: z.ZodString;
+    tenantId: z.ZodString;
     userId: z.ZodString;
-    publicKey: z.ZodString;
+    sshKeyId: z.ZodOptional<z.ZodString>;
+    keyId: z.ZodOptional<z.ZodString>;
+    publicKey: z.ZodOptional<z.ZodString>;
     label: z.ZodOptional<z.ZodString>;
-    nodeId: z.ZodOptional<z.ZodString>;
     confirm: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const reservationSshKeyAddCapability: import("../capability.ts").Capability<unknown, unknown>;
@@ -35,18 +35,36 @@ export declare const reservationSshKeyRemoveInput: z.ZodObject<{
     reservationId: z.ZodString;
     keyId: z.ZodString;
     userId: z.ZodString;
-    nodeId: z.ZodOptional<z.ZodString>;
     confirm: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const reservationSshKeyRemoveCapability: import("../capability.ts").Capability<unknown, unknown>;
 export declare const reservationPublishInput: z.ZodObject<{
-    reservationId: z.ZodString;
+    reservationId: z.ZodOptional<z.ZodString>;
+    reservation_id: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodNumber>;
+    awaitDownPayment: z.ZodOptional<z.ZodBoolean>;
+    await_down_payment: z.ZodOptional<z.ZodBoolean>;
     confirm: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const reservationPublishCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const reservationShowInput: z.ZodObject<{
+    reservationId: z.ZodString;
+}, z.core.$strip>;
+export declare const reservationShowCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const reservationListInput: z.ZodObject<{
+    organizationId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const reservationListCapability: import("../capability.ts").Capability<unknown, unknown>;
 export declare const bidAcceptInput: z.ZodObject<{
-    bidId: z.ZodString;
+    bidId: z.ZodOptional<z.ZodString>;
+    bid_id: z.ZodOptional<z.ZodString>;
     acceptedGpuCount: z.ZodOptional<z.ZodNumber>;
+    accepted_gpu_count: z.ZodOptional<z.ZodNumber>;
+    fillNodeCount: z.ZodOptional<z.ZodNumber>;
+    fill_node_count: z.ZodOptional<z.ZodNumber>;
     confirm: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const bidAcceptCapability: import("../capability.ts").Capability<unknown, unknown>;
@@ -55,23 +73,28 @@ export declare const bidRejectInput: z.ZodObject<{
     confirm: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const bidRejectCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const bidShowInput: z.ZodObject<{
+    bidId: z.ZodOptional<z.ZodString>;
+    bid_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const bidShowCapability: import("../capability.ts").Capability<unknown, unknown>;
 export declare const inventoryUpdateInput: z.ZodObject<{
     inventoryId: z.ZodString;
-    siteOperator: z.ZodOptional<z.ZodString>;
-    siteNickname: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodNumber>;
+    operatorId: z.ZodOptional<z.ZodString>;
+    facilityId: z.ZodOptional<z.ZodString>;
     gpuType: z.ZodOptional<z.ZodString>;
     nodeCount: z.ZodOptional<z.ZodNumber>;
     gpusPerNode: z.ZodOptional<z.ZodNumber>;
-    availableFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    availableTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    availableStartAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    availableEndAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    availableFrom: z.ZodOptional<z.ZodString>;
+    availableTo: z.ZodOptional<z.ZodString>;
+    availableStartAt: z.ZodOptional<z.ZodString>;
+    availableEndAt: z.ZodOptional<z.ZodString>;
     cpu: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     ram: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     fabricType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     storage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     internet: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    networkHardware: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     buyNowPricePerGpuHour: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     confirm: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
@@ -80,4 +103,58 @@ export declare const tenantCreditProfileShowInput: z.ZodObject<{
     tenantId: z.ZodString;
 }, z.core.$strip>;
 export declare const tenantCreditProfileShowCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const reservationDraftCreateInput: z.ZodObject<{
+    organizationId: z.ZodString;
+    nodeCount: z.ZodNumber;
+    startAt: z.ZodString;
+    endAt: z.ZodString;
+    billingMode: z.ZodDefault<z.ZodString>;
+    pricePerGpuHr: z.ZodString;
+    listingId: z.ZodOptional<z.ZodString>;
+    accessMode: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const reservationDraftCreateCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const reservationUpdateInput: z.ZodObject<{
+    reservationId: z.ZodString;
+    startAt: z.ZodOptional<z.ZodString>;
+    endAt: z.ZodOptional<z.ZodString>;
+    nodeCount: z.ZodOptional<z.ZodNumber>;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    expectedStatus: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const reservationUpdateCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const reservationActivateInput: z.ZodObject<{
+    reservationId: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const reservationActivateCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const reservationCompleteInput: z.ZodObject<{
+    reservationId: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const reservationCompleteCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const inventoryDelistInput: z.ZodObject<{
+    inventoryId: z.ZodString;
+    version: z.ZodOptional<z.ZodNumber>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const inventoryDelistCapability: import("../capability.ts").Capability<unknown, unknown>;
+export declare const billingInvoicesListInput: z.ZodObject<{
+    status: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        void: "void";
+        due: "due";
+        open: "open";
+        paid: "paid";
+        draft: "draft";
+        uncollectible: "uncollectible";
+    }>>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const billingInvoicesListCapability: import("../capability.ts").Capability<unknown, unknown>;
 export declare const staffCommerceCapabilities: import("../capability.ts").Capability<unknown, unknown>[];