@ornncompute/cli 0.2.23 → 1.0.25

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

@@ -1,51 +0,0 @@
-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";
-        cpu: "cpu";
-        node: "node";
-    }>>;
-    gpu: z.ZodOptional<z.ZodString>;
-    cpu: z.ZodOptional<z.ZodString>;
-    site: z.ZodOptional<z.ZodString>;
-    fabric: z.ZodOptional<z.ZodString>;
-    min_nodes: z.ZodOptional<z.ZodNumber>;
-    starts_after: z.ZodOptional<z.ZodString>;
-    starts_before: z.ZodOptional<z.ZodString>;
-    ends_after: z.ZodOptional<z.ZodString>;
-    ends_before: z.ZodOptional<z.ZodString>;
-    gpu_type: z.ZodOptional<z.ZodString>;
-    node_model: z.ZodOptional<z.ZodString>;
-    fabric_type: z.ZodOptional<z.ZodString>;
-    node_count: z.ZodOptional<z.ZodNumber>;
-    gpus_per_node: z.ZodOptional<z.ZodNumber>;
-    site_nickname: z.ZodOptional<z.ZodString>;
-    site_operator: z.ZodOptional<z.ZodString>;
-    ram: z.ZodOptional<z.ZodString>;
-    storage: z.ZodOptional<z.ZodString>;
-    internet: z.ZodOptional<z.ZodString>;
-    network_hardware: z.ZodOptional<z.ZodString>;
-    available_start_at: z.ZodOptional<z.ZodString>;
-    available_end_at: z.ZodOptional<z.ZodString>;
-    available_from: z.ZodOptional<z.ZodString>;
-    available_to: z.ZodOptional<z.ZodString>;
-    buy_now_price_per_gpu_hour: z.ZodOptional<z.ZodNumber>;
-    cost_per_gpu_hour: z.ZodOptional<z.ZodNumber>;
-    deposit_percent: z.ZodOptional<z.ZodNumber>;
-    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>;
-export declare const forecastListingsCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const createListingCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const listingCapabilities: import("../capability.ts").Capability<unknown, unknown>[];
-/** @deprecated Use createListingCapability. */
-export declare const proposeListingCapability: import("../capability.ts").Capability<unknown, unknown>;

package/vendor/capabilities/capabilities/observability.d.ts

@@ -1,5 +0,0 @@
-export declare const telemetryLatestCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const logsLatestCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const telemetryTailCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const logsTailCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const observabilityCapabilities: import("../capability.ts").Capability<unknown, unknown>[];

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

@@ -1,29 +0,0 @@
-import { z } from "zod";
-export declare const sshKeyPushInput: z.ZodObject<{
-    instanceId: z.ZodString;
-    reservationId: z.ZodString;
-    tenantId: z.ZodString;
-    authUserId: z.ZodString;
-    sshKeyIds: z.ZodArray<z.ZodString>;
-    requestId: z.ZodOptional<z.ZodString>;
-    confirm: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const sshKeyPushCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const sshKeyAddInput: z.ZodObject<{
-    reservationId: z.ZodString;
-    tenantId: z.ZodString;
-    authUserId: 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>;
-export declare const sshKeyRevokeInput: z.ZodObject<{
-    tenantId: z.ZodString;
-    keyId: z.ZodString;
-    confirm: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const sshKeyRevokeCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const staffAccessCapabilities: import("../capability.ts").Capability<unknown, unknown>[];

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

@@ -1,278 +0,0 @@
-import { z } from "zod";
-import { defineStaffMcpCapability, preview } from "../capability.js";
-import { mapBody, seg, statusOf } from "./staff-shared.js";
-// Staff SSH-access verbs. MCP-only — see `defineStaffMcpCapability`.
-//
-// Field contracts from the internal SSH-key routes:
-// - push: PATCH /internal/nodes/{instanceId}/keys (or /internal/pods/... for a VM)
-//   body { ssh_authorized_keys, request_id? }
-// - add: POST /internal/v1/reservations/{reservationId}/ssh-keys
-//   body { public_key, label? }, after authorization owns the public key
-// - revoke: DELETE /v1/organizations/{tenantId}/ssh-keys/{keyId}
-//
-// The routes never forward tenantId/authUserId to the orchestrator as-is — they use them to
-// verify the reservation actually belongs to that organization, and that authUserId is a member
-// of it (commerce GET /internal/v1/reservations/{id} + authorization GET
-// /internal/organizations/{id}/members). Those two checks live in
-// `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 {
-        reservation = (await ctx.fetch(`/internal/v1/reservations/${seg(options.reservationId)}`, {
-            method: "GET",
-        }));
-    }
-    catch (error) {
-        if (statusOf(error) === 404) {
-            throw new Error("Reservation not found.");
-        }
-        throw error;
-    }
-    if (!reservation?.reservationId) {
-        throw new Error("Reservation not found.");
-    }
-    const organizationId = reservation.organizationId ?? reservation.tenantId;
-    if (organizationId !== options.tenantId) {
-        throw new Error("Reservation does not belong to that tenant.");
-    }
-    const members = (await ctx.fetch(`/internal/organizations/${seg(options.tenantId)}/members`, {
-        method: "GET",
-    }));
-    if (!members.some((member) => member.user_id === options.authUserId)) {
-        throw new Error("Selected SSH key owner is not a member of this tenant.");
-    }
-}
-async function assertMachineBelongsToReservation(ctx, options) {
-    const listed = (await ctx.fetch(`/internal/nodes?reservation_id=${seg(options.reservationId)}`, {
-        method: "GET",
-    }));
-    if (!(listed.nodes ?? []).some((node) => node.node_id === options.instanceId || node.id === options.instanceId)) {
-        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(),
-    tenantId: z.string(),
-    authUserId: z.string(),
-    sshKeyIds: z.array(z.string()).min(1),
-    requestId: z.string().optional(),
-    confirm: z.boolean().optional(),
-});
-export const sshKeyPushCapability = defineStaffMcpCapability({
-    id: "ssh-key.push",
-    domain: "access",
-    roles: ["admin"],
-    description: "Internal staff only: push selected reservation SSH keys onto a live machine. " +
-        "This grants remote access to a live machine. Requires confirm: true.",
-    mutation: "preview-confirm",
-    http: { method: "PATCH", path: "/internal/nodes/{instanceId}/keys" },
-    input: sshKeyPushInput,
-    execute: async (ctx, input) => {
-        const parsed = sshKeyPushInput.parse(input);
-        if (!ctx.confirmed) {
-            return preview("ssh-key.push", {
-                instanceId: parsed.instanceId,
-                reservationId: parsed.reservationId,
-                sshKeyIds: parsed.sshKeyIds,
-            });
-        }
-        // Sequential, not Promise.all: this is a fail-fast authorization gate, not an independent
-        // read pair. If the reservation doesn't belong to this tenant/user, there's no reason to
-        // spend a second round trip checking machine membership.
-        await assertReservationOwnedByTenantUser(ctx, {
-            reservationId: parsed.reservationId,
-            tenantId: parsed.tenantId,
-            authUserId: parsed.authUserId,
-        });
-        await assertMachineBelongsToReservation(ctx, {
-            reservationId: parsed.reservationId,
-            instanceId: parsed.instanceId,
-        });
-        const listed = (await ctx.fetch(`/v1/organizations/${seg(parsed.tenantId)}/ssh-keys`, {
-            method: "GET",
-        }));
-        const wanted = new Set(parsed.sshKeyIds);
-        const sshAuthorizedKeys = activePublicKeys(listed.ssh_keys ?? [], (id) => wanted.has(id));
-        const body = {
-            ssh_authorized_keys: sshAuthorizedKeys,
-            ...mapBody(parsed, { requestId: "request_id" }),
-        };
-        const keysPath = await keyTargetPath(ctx, parsed.instanceId);
-        return ctx.fetch(keysPath, {
-            method: "PATCH",
-            body,
-            headers: { [AUTH_USER_HEADER]: parsed.authUserId },
-        });
-    },
-});
-export const sshKeyAddInput = z.object({
-    reservationId: z.string(),
-    tenantId: z.string(),
-    authUserId: z.string(),
-    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: 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);
-        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,
-                ...(parsed.sshKeyId ? { sshKeyId: parsed.sshKeyId } : { publicKey: parsed.publicKey, label: parsed.label }),
-            });
-        }
-        await assertReservationOwnedByTenantUser(ctx, {
-            reservationId: parsed.reservationId,
-            tenantId: parsed.tenantId,
-            authUserId: parsed.authUserId,
-        });
-        // 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) {
-            // Commerce stores the id as a soft key without checking authorization,
-            // so gate it here the way gateway `add_reservation_key` does.
-            const listed = (await ctx.fetch(`/v1/organizations/${seg(parsed.tenantId)}/ssh-keys`, {
-                method: "GET",
-            }));
-            const key = (listed.ssh_keys ?? []).find((candidate) => candidate.id === sshKeyId);
-            if (!key) {
-                throw new Error("SSH key not found.");
-            }
-            if (key.status !== "active" || key.revoked_at) {
-                throw new Error("SSH key is not active.");
-            }
-        }
-        else {
-            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: { 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({
-    tenantId: z.string(),
-    keyId: z.string(),
-    confirm: z.boolean().optional(),
-});
-export const sshKeyRevokeCapability = defineStaffMcpCapability({
-    id: "ssh-key.revoke",
-    domain: "access",
-    roles: ["admin"],
-    description: "Internal staff only: revoke (delete) a tenant-scoped SSH key. Requires confirm: true.",
-    mutation: "preview-confirm",
-    http: { method: "DELETE", path: "/v1/organizations/{tenantId}/ssh-keys/{keyId}" },
-    input: sshKeyRevokeInput,
-    execute: async (ctx, input) => {
-        const parsed = sshKeyRevokeInput.parse(input);
-        if (!ctx.confirmed) {
-            return preview("ssh-key.revoke", { tenantId: parsed.tenantId, keyId: parsed.keyId });
-        }
-        return ctx.fetch(`/v1/organizations/${seg(parsed.tenantId)}/ssh-keys/${seg(parsed.keyId)}`, {
-            method: "DELETE",
-        });
-    },
-});
-export const staffAccessCapabilities = [
-    sshKeyPushCapability,
-    sshKeyAddCapability,
-    sshKeyRevokeCapability,
-];

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

@@ -1,160 +0,0 @@
-import { z } from "zod";
-export declare const reservationCancelInput: z.ZodObject<{
-    reservationId: z.ZodString;
-    confirm: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const reservationCancelCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const reservationTransferInput: z.ZodObject<{
-    reservationId: z.ZodString;
-    targetTenantId: z.ZodString;
-    reservedStrategy: z.ZodEnum<{
-        reject: "reject";
-        park: "park";
-    }>;
-    confirmReservedTransfer: z.ZodOptional<z.ZodBoolean>;
-    notes: z.ZodOptional<z.ZodString>;
-    confirm: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const reservationTransferCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const reservationMachinesListInput: z.ZodObject<{
-    reservationId: z.ZodString;
-}, z.core.$strip>;
-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;
-    sshKeyId: z.ZodOptional<z.ZodString>;
-    keyId: z.ZodOptional<z.ZodString>;
-    publicKey: z.ZodOptional<z.ZodString>;
-    label: z.ZodOptional<z.ZodString>;
-    confirm: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const reservationSshKeyAddCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const reservationSshKeyRemoveInput: z.ZodObject<{
-    reservationId: z.ZodString;
-    keyId: z.ZodString;
-    userId: 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.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.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>;
-export declare const bidRejectInput: z.ZodObject<{
-    bidId: z.ZodString;
-    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;
-    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.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>>;
-    buyNowPricePerGpuHour: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    confirm: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const inventoryUpdateCapability: import("../capability.ts").Capability<unknown, unknown>;
-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>[];