@astrogate/sdk 0.0.0-stage → 0.1.0

package/dist/management.d.ts

@@ -0,0 +1,347 @@
+import { type PageOptions } from "./inventory.js";
+export { AstrogateError } from "./http.js";
+import type { components } from "./wire.gen.js";
+type Schemas = components["schemas"];
+export type Project = Schemas["Project"];
+export type CreateProject = Schemas["CreateProject"];
+export type Repository = Schemas["Repository"];
+export type CreateRepository = Schemas["CreateRepository"];
+export type BuildingBlock = Schemas["BuildingBlock"];
+export type CreateBuildingBlock = Schemas["CreateBuildingBlock"];
+export type Schedule = Schemas["Schedule"];
+export type UpdateSchedule = Schemas["UpdateSchedule"];
+export type CreateSchedule = Pick<CreateBuildingBlock, "expectedRevision" | "expectedEnvironmentKind"> & {
+    profileId: CreateBuildingBlock["spec"]["profileId"];
+    spec: UpdateSchedule["spec"];
+};
+export type PlacementState = Schemas["PlacementState"];
+export type PlacementLocation = Schemas["PlacementLocation"];
+export type ChangePlacement = Schemas["ChangePlacement"];
+export type Accepted = Schemas["Accepted"];
+export type Operation = Schemas["Operation"];
+export type OperationLog = Schemas["OperationLog"];
+export type DeploymentState = Schemas["DeploymentState"];
+export type CreateDatabase = Schemas["CreateDatabase"];
+export type DatabaseBinding = Schemas["DatabaseBinding"];
+export type CreateReleasePlan = Schemas["CreateReleasePlan"];
+export type ReleasePlan = Schemas["ReleasePlan"];
+export type DomainRegistration = Schemas["DomainRegistration"];
+export type CreateDomainRegistration = Schemas["CreateDomainRegistration"];
+export type CreateHostnameBinding = Schemas["CreateHostnameBinding"];
+export type HostnameBinding = Schemas["HostnameBinding"];
+export type Workspace = Schemas["Workspace"];
+export type StartWorkspace = Schemas["StartWorkspace"];
+export type WriteWorkspace = Schemas["WriteWorkspace"];
+export type ExpectedRevision = Schemas["ExpectedRevision"];
+export type CreateDeployment = Schemas["CreateDeployment"];
+export type CreateSourceDeployment = Schemas["CreateSourceDeployment"];
+export interface RequestOptions {
+    signal?: AbortSignal;
+    idempotencyKey: string;
+}
+export interface ManagementOptions {
+    endpoint: string;
+    tenant: string;
+    token: string;
+    deadlineMs: number;
+    maxAttempts: number;
+}
+export declare function createManagement(options: ManagementOptions): {
+    projects: {
+        create: (input: CreateProject, controls: RequestOptions) => Promise<{
+            operationId: string;
+            resourceId: string;
+            statusUrl: string;
+        }>;
+        list: (page?: PageOptions, signal?: AbortSignal) => Promise<import("./inventory.js").InventoryPage<{
+            id: string;
+            name: string;
+            revision: number;
+        }>>;
+        get: (resource: string, signal?: AbortSignal) => Promise<{
+            id: string;
+            name: string;
+            revision: number;
+        }>;
+    };
+    repositories: {
+        create: (project: string, input: CreateRepository, controls: RequestOptions) => Promise<{
+            operationId: string;
+            resourceId: string;
+            statusUrl: string;
+        }>;
+        get: (project: string, signal?: AbortSignal) => Promise<{
+            id: string;
+            projectId: string;
+            profileId: string;
+            revision: number;
+            state: "pending" | "ready" | "retained" | "failed";
+            nativeId: number;
+            cloneUrl: string;
+        }>;
+    };
+    services: {
+        get: (project: string, environment: string, signal?: AbortSignal) => Promise<{
+            identity?: components["schemas"]["ServiceBinding"];
+            storage?: components["schemas"]["ServiceBinding"];
+            jobs?: components["schemas"]["ServiceBinding"];
+        }>;
+    };
+    jobRuns: {
+        create: (project: string, environment: string, input: components['schemas']['CreateJobRun'], controls: RequestOptions) => Promise<{
+            operationId: string;
+            resourceId: string;
+            statusUrl: string;
+        }>;
+    };
+    schedules: {
+        create: (project: string, environment: string, input: CreateSchedule, controls: RequestOptions) => Promise<{
+            operationId: string;
+            resourceId: string;
+            statusUrl: string;
+        }>;
+        get: (project: string, environment: string, resource: string, signal?: AbortSignal) => Promise<{
+            id: string;
+            revision: number;
+            state: "pending" | "ready" | "retained" | "failed";
+            spec: components["schemas"]["ScheduleBlockSpec"];
+        }>;
+        update: (project: string, environment: string, resource: string, input: UpdateSchedule, controls: RequestOptions) => Promise<{
+            operationId: string;
+            resourceId: string;
+            statusUrl: string;
+        }>;
+    };
+    buildingBlocks: {
+        list: (project: string, environment: string, page?: PageOptions, signal?: AbortSignal) => Promise<import("./inventory.js").InventoryPage<{
+            id: string;
+            kind: "identity" | "storage" | "jobs" | "schedule";
+            profileId: string;
+            state: "pending" | "ready" | "retained" | "failed";
+            revision: number;
+            binding: components["schemas"]["BuildingBlockBinding"];
+        }>>;
+        create: (project: string, environment: string, input: CreateBuildingBlock, controls: RequestOptions) => Promise<{
+            operationId: string;
+            resourceId: string;
+            statusUrl: string;
+        }>;
+        get: (project: string, environment: string, resource: string, signal?: AbortSignal) => Promise<{
+            id: string;
+            kind: "identity" | "storage" | "jobs" | "schedule";
+            profileId: string;
+            state: "pending" | "ready" | "retained" | "failed";
+            revision: number;
+            binding: components["schemas"]["BuildingBlockBinding"];
+        }>;
+        getByKind: (project: string, environment: string, kind: 'identity' | 'storage' | 'jobs', signal?: AbortSignal) => Promise<{
+            id: string;
+            kind: "identity" | "storage" | "jobs" | "schedule";
+            profileId: string;
+            state: "pending" | "ready" | "retained" | "failed";
+            revision: number;
+            binding: components["schemas"]["BuildingBlockBinding"];
+        }>;
+    };
+    domains: {
+        delete: (registration: string, input: ExpectedRevision, controls: RequestOptions) => Promise<undefined>;
+        register: (input: CreateDomainRegistration, controls: RequestOptions) => Promise<{
+            id: string;
+            domain: string;
+            state: "pending" | "verified";
+            revision: number;
+            challengeName: string;
+            challengeValue: string;
+        }>;
+        get: (registration: string, signal?: AbortSignal) => Promise<{
+            id: string;
+            domain: string;
+            state: "pending" | "verified";
+            revision: number;
+            challengeName: string;
+            challengeValue: string;
+        }>;
+        verify: (registration: string, input: ExpectedRevision, controls: RequestOptions) => Promise<{
+            id: string;
+            domain: string;
+            state: "pending" | "verified";
+            revision: number;
+            challengeName: string;
+            challengeValue: string;
+        }>;
+    };
+    hostnames: {
+        list: (project: string, environment: string, page?: PageOptions, signal?: AbortSignal) => Promise<import("./inventory.js").InventoryPage<{
+            id: string;
+            hostname: string;
+            primary: boolean;
+            state: "pending" | "ready" | "failed" | "retiring" | "retired";
+            revision: number;
+            reason: string;
+        }>>;
+        retire: (project: string, environment: string, binding: string, input: ExpectedRevision, controls: RequestOptions) => Promise<{
+            operationId: string;
+            resourceId: string;
+            statusUrl: string;
+        }>;
+        bind: (project: string, environment: string, input: CreateHostnameBinding, controls: RequestOptions) => Promise<{
+            operationId: string;
+            resourceId: string;
+            statusUrl: string;
+        }>;
+        get: (project: string, environment: string, binding: string, signal?: AbortSignal) => Promise<{
+            id: string;
+            hostname: string;
+            primary: boolean;
+            state: "pending" | "ready" | "failed" | "retiring" | "retired";
+            revision: number;
+            reason: string;
+        }>;
+    };
+    workspaces: {
+        write: (project: string, environment: string, input: WriteWorkspace, controls: RequestOptions) => Promise<{
+            operationId: string;
+            resourceId: string;
+            statusUrl: string;
+        }>;
+        start: (project: string, environment: string, input: StartWorkspace, controls: RequestOptions) => Promise<{
+            operationId: string;
+            resourceId: string;
+            statusUrl: string;
+        }>;
+        stop: (project: string, environment: string, input: ExpectedRevision, controls: RequestOptions) => Promise<{
+            operationId: string;
+            resourceId: string;
+            statusUrl: string;
+        }>;
+        get: (project: string, environment: string, signal?: AbortSignal) => Promise<{
+            id: string;
+            state: "pending" | "starting" | "ready" | "stopped" | "failed";
+            sourceRevision: string;
+            url: string;
+            operationId: string;
+        }>;
+    };
+    databases: {
+        create: (project: string, environment: string, input: CreateDatabase, controls: RequestOptions) => Promise<{
+            operationId: string;
+            resourceId: string;
+            statusUrl: string;
+        }>;
+        get: (project: string, environment: string, signal?: AbortSignal) => Promise<{
+            appId: string;
+            environmentId: string;
+            state: string;
+            apiURI: string;
+            websocketURI: string;
+            cellId: string;
+            locationId: string;
+            revision: number;
+            environmentKind: "preview" | "staging" | "production";
+            initializationRef: string;
+            schemaRevision: string;
+            datasetRevision: string;
+        }>;
+    };
+    releasePlans: {
+        create: (project: string, environment: string, input: CreateReleasePlan, controls: RequestOptions) => Promise<{
+            operationId: string;
+            resourceId: string;
+            statusUrl: string;
+        }>;
+        get: (project: string, environment: string, plan: string, signal?: AbortSignal) => Promise<{
+            id: string;
+            state: "pending" | "reviewed";
+            databaseAppId: string;
+            digest: string;
+            plan: {
+                [key: string]: unknown;
+            };
+        }>;
+    };
+    deployments: {
+        fromSource: (project: string, environment: string, input: CreateSourceDeployment, controls: RequestOptions) => Promise<{
+            operationId: string;
+            resourceId: string;
+            statusUrl: string;
+        }>;
+        create: (project: string, environment: string, input: CreateDeployment, controls: RequestOptions) => Promise<{
+            operationId: string;
+            resourceId: string;
+            statusUrl: string;
+        }>;
+    };
+    environments: {
+        list: (project: string, page?: PageOptions, signal?: AbortSignal) => Promise<import("./inventory.js").InventoryPage<{
+            id: string;
+            projectId: string;
+            name: string;
+            kind: "preview" | "staging" | "production";
+            revision: number;
+        }>>;
+        get: (project: string, resource: string, signal?: AbortSignal) => Promise<{
+            id: string;
+            projectId: string;
+            name: string;
+            kind: "preview" | "staging" | "production";
+            revision: number;
+        }>;
+        getPlacement: (project: string, environment: string, signal?: AbortSignal) => Promise<{
+            revision: number;
+            epoch: number;
+            desired: components["schemas"]["PlacementDesired"];
+            effectiveCell: string;
+            effectiveLocation: string;
+            effectiveProfile: string;
+            operationId: string;
+            phase: "pending" | "ready" | "draining" | "fenced" | "copying" | "verified" | "committed" | "routing" | "waiting";
+            reason: string;
+            standbyCell: string;
+            protection: "none" | "pending" | "snapshot-ready" | "degraded";
+            reserved: components["schemas"]["PlacementResources"];
+            recoveryPoint?: components["schemas"]["PlacementRecoveryPoint"];
+            capacity?: components["schemas"]["PlacementCapacity"];
+        }>;
+        listLocations: (project: string, environment: string, signal?: AbortSignal) => Promise<{
+            id: string;
+            name: string;
+            geographicGroup: string;
+            profiles: string[];
+            healthy: boolean;
+        }[]>;
+        changePlacement: (project: string, environment: string, input: ChangePlacement, controls: RequestOptions) => Promise<{
+            operationId: string;
+            resourceId: string;
+            statusUrl: string;
+        }>;
+        getDeploymentState: (project: string, environment: string, signal?: AbortSignal) => Promise<{
+            revision: number;
+            bindingRevision: number;
+            activeRelease: string | null;
+        }>;
+    };
+    operations: {
+        list: (project: string, page?: PageOptions, signal?: AbortSignal) => Promise<import("./inventory.js").InventoryPage<{
+            id: string;
+            resourceId: string;
+            state: "queued" | "running" | "waiting" | "succeeded" | "failed";
+            step: "accepted" | "provisioning" | "verifying" | "complete";
+            attempts: number;
+            errorCode: string;
+        }>>;
+        logs: (operationId: string, kind: OperationLog["kind"], signal?: AbortSignal) => Promise<{
+            operationId: string;
+            kind: components["schemas"]["OperationLogKind"];
+            available: boolean;
+            text: string;
+        }>;
+        get: (operationId: string, signal?: AbortSignal) => Promise<{
+            id: string;
+            resourceId: string;
+            state: "queued" | "running" | "waiting" | "succeeded" | "failed";
+            step: "accepted" | "provisioning" | "verifying" | "complete";
+            attempts: number;
+            errorCode: string;
+        }>;
+    };
+};

package/dist/management.js

@@ -0,0 +1,137 @@
+import { AstrogateError, requestJSON } from "./http.js";
+import { project, environment, placementState, placementLocations, operation, operationLog, buildingBlock, hostnameBinding } from "./management-read.js";
+import { listQuery, pageOf } from "./inventory.js";
+import { managementAuthority } from "./http.js";
+import { serviceBindings } from "./services.js";
+export { AstrogateError } from "./http.js";
+function object(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function accepted(value) {
+    return (object(value) &&
+        typeof value.operationId === "string" &&
+        typeof value.resourceId === "string" &&
+        typeof value.statusUrl === "string");
+}
+function releasePlan(value) {
+    return object(value) && typeof value.id === "string" && typeof value.databaseAppId === "string" && typeof value.digest === "string" && (value.state === "pending" || value.state === "reviewed") && object(value.plan);
+}
+function repository(value) {
+    return object(value) && ["id", "projectId", "profileId", "cloneUrl"].every(key => typeof value[key] === "string") && Number.isSafeInteger(value.revision) && Number.isSafeInteger(value.nativeId) && typeof value.state === "string" && ["pending", "ready", "retained", "failed"].includes(value.state);
+}
+function schedule(value) {
+    if (!object(value) || !object(value.spec))
+        return false;
+    const spec = value.spec;
+    return typeof value.id === "string" && Number.isSafeInteger(value.revision) &&
+        typeof value.state === "string" && ["pending", "ready", "retained", "failed"].includes(value.state) &&
+        ["jobsResourceId", "taskDefinitionRef", "cron", "timeZone"].every(key => typeof spec[key] === "string") &&
+        typeof spec.enabled === "boolean" && spec.concurrencyPolicy === "forbid" && spec.missedRunPolicy === "skip";
+}
+function databaseBinding(value) {
+    return object(value) && ["appId", "environmentId", "state", "apiURI", "websocketURI", "cellId", "locationId"].every(key => typeof value[key] === "string") && Number.isSafeInteger(value.revision) && typeof value.environmentKind === "string" && ["preview", "staging", "production"].includes(value.environmentKind);
+}
+function domainRegistration(value) {
+    return object(value) && ["id", "domain", "challengeName", "challengeValue"].every(key => typeof value[key] === "string") && Number.isSafeInteger(value.revision) && (value.state === "pending" || value.state === "verified");
+}
+function workspace(value) {
+    return object(value) && ["id", "sourceRevision", "url", "operationId"].every(key => typeof value[key] === "string") && typeof value.state === "string" && ["pending", "starting", "ready", "stopped", "failed"].includes(value.state);
+}
+function deploymentState(value) {
+    return (object(value) &&
+        Number.isSafeInteger(value.revision) &&
+        Number.isSafeInteger(value.bindingRevision) &&
+        (value.activeRelease === null || typeof value.activeRelease === "string"));
+}
+function id(value) {
+    if (!/^[A-Za-z0-9_-]+$/.test(value))
+        throw new AstrogateError("invalid_resource_reference", 0, "", false);
+    return value;
+}
+// Management credentials are for trusted services/operators. No app, browser,
+// Git branch or project manifest can construct a server-verified principal.
+export function createManagement(options) {
+    const endpoint = managementAuthority(options);
+    const base = `/v1/tenants/${id(options.tenant)}`;
+    async function request(path, validate, input, controls, signal, method) {
+        if (input !== undefined &&
+            (!controls?.idempotencyKey || controls.idempotencyKey.length > 128))
+            throw new AstrogateError("idempotency_key_required", 0, "", false);
+        const body = input === undefined ? undefined : JSON.stringify(input);
+        const headers = { authorization: `Bearer ${options.token}` };
+        if (body !== undefined) {
+            headers["content-type"] = "application/json";
+            headers["idempotency-key"] = controls.idempotencyKey;
+        }
+        return requestJSON(new URL(base + path, endpoint), options, { method: method ?? (body === undefined ? "GET" : "POST"), headers, body }, validate, controls?.signal ?? signal);
+    }
+    return {
+        projects: { create: (input, controls) => request(`/projects`, accepted, input, controls), list: (page = {}, signal) => request(`/projects${listQuery(page)}`, pageOf(project), undefined, undefined, signal), get: (resource, signal) => request(`/projects/${id(resource)}`, project, undefined, undefined, signal) },
+        repositories: {
+            create: (project, input, controls) => request(`/projects/${id(project)}/repository`, accepted, input, controls),
+            get: (project, signal) => request(`/projects/${id(project)}/repository`, repository, undefined, undefined, signal),
+        },
+        services: { get: (project, environment, signal) => request(`/projects/${id(project)}/environments/${id(environment)}/service-bindings`, serviceBindings, undefined, undefined, signal) },
+        jobRuns: {
+            create: (project, environment, input, controls) => request(`/projects/${id(project)}/environments/${id(environment)}/job-runs`, accepted, input, controls),
+        },
+        schedules: {
+            create: (project, environment, input, controls) => request(`/projects/${id(project)}/environments/${id(environment)}/building-blocks`, accepted, {
+                expectedRevision: input.expectedRevision,
+                expectedEnvironmentKind: input.expectedEnvironmentKind,
+                spec: { kind: "schedule", profileId: input.profileId, schedule: input.spec },
+            }, controls),
+            get: (project, environment, resource, signal) => request(`/projects/${id(project)}/environments/${id(environment)}/schedules/${id(resource)}`, schedule, undefined, undefined, signal),
+            update: (project, environment, resource, input, controls) => request(`/projects/${id(project)}/environments/${id(environment)}/schedules/${id(resource)}`, accepted, input, controls),
+        },
+        buildingBlocks: {
+            list: (project, environment, page = {}, signal) => request(`/projects/${id(project)}/environments/${id(environment)}/building-blocks${listQuery(page)}`, pageOf(buildingBlock), undefined, undefined, signal),
+            create: (project, environment, input, controls) => request(`/projects/${id(project)}/environments/${id(environment)}/building-blocks`, accepted, input, controls),
+            get: (project, environment, resource, signal) => request(`/projects/${id(project)}/environments/${id(environment)}/building-blocks/${id(resource)}`, buildingBlock, undefined, undefined, signal),
+            getByKind: (project, environment, kind, signal) => request(`/projects/${id(project)}/environments/${id(environment)}/building-blocks/by-kind/${kind}`, buildingBlock, undefined, undefined, signal),
+        },
+        domains: {
+            delete: (registration, input, controls) => request(`/domains/${id(registration)}`, (value) => value === undefined, input, controls, undefined, "DELETE"),
+            register: (input, controls) => request('/domains', domainRegistration, input, controls),
+            get: (registration, signal) => request(`/domains/${id(registration)}`, domainRegistration, undefined, undefined, signal),
+            verify: (registration, input, controls) => request(`/domains/${id(registration)}/verify`, domainRegistration, input, controls),
+        },
+        hostnames: {
+            list: (project, environment, page = {}, signal) => request(`/projects/${id(project)}/environments/${id(environment)}/hostnames${listQuery(page)}`, pageOf(hostnameBinding), undefined, undefined, signal),
+            retire: (project, environment, binding, input, controls) => request(`/projects/${id(project)}/environments/${id(environment)}/hostnames/${id(binding)}/retire`, accepted, input, controls),
+            bind: (project, environment, input, controls) => request(`/projects/${id(project)}/environments/${id(environment)}/hostnames`, accepted, input, controls),
+            get: (project, environment, binding, signal) => request(`/projects/${id(project)}/environments/${id(environment)}/hostnames/${id(binding)}`, hostnameBinding, undefined, undefined, signal),
+        },
+        workspaces: {
+            write: (project, environment, input, controls) => request(`/projects/${id(project)}/environments/${id(environment)}/workspace/files`, accepted, input, controls),
+            start: (project, environment, input, controls) => request(`/projects/${id(project)}/environments/${id(environment)}/workspace`, accepted, input, controls),
+            stop: (project, environment, input, controls) => request(`/projects/${id(project)}/environments/${id(environment)}/workspace/stop`, accepted, input, controls),
+            get: (project, environment, signal) => request(`/projects/${id(project)}/environments/${id(environment)}/workspace`, workspace, undefined, undefined, signal),
+        },
+        databases: {
+            create: (project, environment, input, controls) => request(`/projects/${id(project)}/environments/${id(environment)}/database`, accepted, input, controls),
+            get: (project, environment, signal) => request(`/projects/${id(project)}/environments/${id(environment)}/database`, databaseBinding, undefined, undefined, signal),
+        },
+        releasePlans: {
+            create: (project, environment, input, controls) => request(`/projects/${id(project)}/environments/${id(environment)}/release-plans`, accepted, input, controls),
+            get: (project, environment, plan, signal) => request(`/projects/${id(project)}/environments/${id(environment)}/release-plans/${id(plan)}`, releasePlan, undefined, undefined, signal),
+        },
+        deployments: {
+            fromSource: (project, environment, input, controls) => request(`/projects/${id(project)}/environments/${id(environment)}/source-deployments`, accepted, input, controls),
+            create: (project, environment, input, controls) => request(`/projects/${id(project)}/environments/${id(environment)}/deployments`, accepted, input, controls),
+        },
+        environments: {
+            list: (project, page = {}, signal) => request(`/projects/${id(project)}/environments${listQuery(page)}`, pageOf(environment), undefined, undefined, signal),
+            get: (project, resource, signal) => request(`/projects/${id(project)}/environments/${id(resource)}`, environment, undefined, undefined, signal),
+            getPlacement: (project, environment, signal) => request(`/projects/${id(project)}/environments/${id(environment)}/placement`, placementState, undefined, undefined, signal),
+            listLocations: (project, environment, signal) => request(`/projects/${id(project)}/environments/${id(environment)}/locations`, placementLocations, undefined, undefined, signal),
+            changePlacement: (project, environment, input, controls) => request(`/projects/${id(project)}/environments/${id(environment)}/placement-operations`, accepted, input, controls),
+            getDeploymentState: (project, environment, signal) => request(`/projects/${id(project)}/environments/${id(environment)}/deployment-state`, deploymentState, undefined, undefined, signal),
+        },
+        operations: {
+            list: (project, page = {}, signal) => request(`/projects/${id(project)}/operations${listQuery(page)}`, pageOf(operation), undefined, undefined, signal),
+            logs: (operationId, kind, signal) => request(`/operations/${id(operationId)}/logs/${kind}`, operationLog, undefined, undefined, signal),
+            get: (operationId, signal) => request(`/operations/${id(operationId)}`, operation, undefined, undefined, signal),
+        },
+    };
+}

package/dist/operator.d.ts

@@ -0,0 +1,136 @@
+import { type TransportBudget } from "./http.js";
+import { type PageOptions } from "./inventory.js";
+import type { components } from "./wire.gen.js";
+export { AstrogateError } from "./http.js";
+export type OperatorOptions = TransportBudget & {
+    endpoint: string;
+    token: string;
+};
+export type { PageOptions } from "./inventory.js";
+type EnvironmentTopology = components["schemas"]["EnvironmentTopology"];
+export declare function createOperator(options: OperatorOptions): {
+    products: {
+        list: (page?: PageOptions, signal?: AbortSignal) => Promise<import("./inventory.js").InventoryPage<{
+            id: string;
+        }>>;
+    };
+    tenants: {
+        list: (product: string, page?: PageOptions, signal?: AbortSignal) => Promise<import("./inventory.js").InventoryPage<{
+            id: string;
+        }>>;
+    };
+    projects: {
+        list: (product: string, tenant: string, page?: PageOptions, signal?: AbortSignal) => Promise<import("./inventory.js").InventoryPage<{
+            id: string;
+            name: string;
+            revision: number;
+        }>>;
+        get: (product: string, tenant: string, id: string, signal?: AbortSignal) => Promise<{
+            id: string;
+            name: string;
+            revision: number;
+        }>;
+    };
+    buildingBlocks: {
+        list: (product: string, tenant: string, project: string, environment: string, page?: PageOptions, signal?: AbortSignal) => Promise<import("./inventory.js").InventoryPage<{
+            id: string;
+            kind: "identity" | "storage" | "jobs" | "schedule";
+            profileId: string;
+            state: "pending" | "ready" | "retained" | "failed";
+            revision: number;
+            binding: components["schemas"]["BuildingBlockBinding"];
+        }>>;
+        get: (product: string, tenant: string, project: string, environment: string, id: string, signal?: AbortSignal) => Promise<{
+            id: string;
+            kind: "identity" | "storage" | "jobs" | "schedule";
+            profileId: string;
+            state: "pending" | "ready" | "retained" | "failed";
+            revision: number;
+            binding: components["schemas"]["BuildingBlockBinding"];
+        }>;
+    };
+    hostnames: {
+        list: (product: string, tenant: string, project: string, environment: string, page?: PageOptions, signal?: AbortSignal) => Promise<import("./inventory.js").InventoryPage<{
+            id: string;
+            hostname: string;
+            primary: boolean;
+            state: "pending" | "ready" | "failed" | "retiring" | "retired";
+            revision: number;
+            reason: string;
+        }>>;
+    };
+    operations: {
+        list: (product: string, tenant: string, project: string, page?: PageOptions, signal?: AbortSignal) => Promise<import("./inventory.js").InventoryPage<{
+            id: string;
+            resourceId: string;
+            state: "queued" | "running" | "waiting" | "succeeded" | "failed";
+            step: "accepted" | "provisioning" | "verifying" | "complete";
+            attempts: number;
+            errorCode: string;
+        }>>;
+        get: (product: string, tenant: string, project: string, id: string, signal?: AbortSignal) => Promise<{
+            operation: components["schemas"]["Operation"];
+            logKinds: components["schemas"]["OperationLogKind"][];
+        }>;
+        logs: (product: string, tenant: string, project: string, id: string, kind: components["schemas"]["OperationLog"]["kind"], signal?: AbortSignal) => Promise<{
+            operationId: string;
+            kind: components["schemas"]["OperationLogKind"];
+            available: boolean;
+            text: string;
+        }>;
+    };
+    environments: {
+        getTopology: (product: string, tenant: string, project: string, id: string, signal?: AbortSignal) => Promise<{
+            cell: string;
+            epoch: number;
+            hosts: components["schemas"]["TopologyHost"][];
+            targets: components["schemas"]["TopologyTarget"][];
+            observedAt: string;
+            validUntil: string;
+            fresh: boolean;
+        }>;
+        list: (product: string, tenant: string, project: string, page?: PageOptions, signal?: AbortSignal) => Promise<import("./inventory.js").InventoryPage<{
+            id: string;
+            projectId: string;
+            name: string;
+            kind: "preview" | "staging" | "production";
+            revision: number;
+        }>>;
+        get: (product: string, tenant: string, project: string, id: string, signal?: AbortSignal) => Promise<{
+            id: string;
+            projectId: string;
+            name: string;
+            kind: "preview" | "staging" | "production";
+            revision: number;
+        }>;
+        getPlacement: (product: string, tenant: string, project: string, id: string, signal?: AbortSignal) => Promise<{
+            revision: number;
+            epoch: number;
+            desired: components["schemas"]["PlacementDesired"];
+            effectiveCell: string;
+            effectiveLocation: string;
+            effectiveProfile: string;
+            operationId: string;
+            phase: "pending" | "ready" | "draining" | "fenced" | "copying" | "verified" | "committed" | "routing" | "waiting";
+            reason: string;
+            standbyCell: string;
+            protection: "none" | "pending" | "snapshot-ready" | "degraded";
+            reserved: components["schemas"]["PlacementResources"];
+            recoveryPoint?: components["schemas"]["PlacementRecoveryPoint"];
+            capacity?: components["schemas"]["PlacementCapacity"];
+        }>;
+    };
+};
+export type Project = components["schemas"]["Project"];
+export type Environment = components["schemas"]["Environment"];
+export type PlacementState = components["schemas"]["PlacementState"];
+export type CatalogEntryPage = components["schemas"]["CatalogEntryPage"];
+export type ProjectPage = components["schemas"]["ProjectPage"];
+export type EnvironmentPage = components["schemas"]["EnvironmentPage"];
+export type BuildingBlock = components["schemas"]["BuildingBlock"];
+export type BuildingBlockPage = components["schemas"]["BuildingBlockPage"];
+export type OperationPage = components["schemas"]["OperationPage"];
+export type Operation = components["schemas"]["Operation"];
+export type OperationLog = components["schemas"]["OperationLog"];
+export type HostnameBindingPage = components["schemas"]["HostnameBindingPage"];
+export type { EnvironmentTopology };