@runlot/api 0.1.0-rc.20 → 0.1.0-rc.201

package/dist/index.d.ts

@@ -1,12 +1,16 @@
 import type { components, operations } from "./schema.js";
 export type { components, paths, operations } from "./schema.js";
 export declare const API_VERSION: "v1";
+/** The shared query for browsing. Empty values are not carried — the server reads "empty means default". */
+/** base64url of the UTF-8 JSON, no padding — the `draft` parameter's encoding. */
+export declare function base64urlJson(v: unknown): string;
 type Schemas = components["schemas"];
 /**
- * 오퍼레이션의 성공 응답 본문.
+ * The success response body of an operation.
  *
- * 메서드 반환형을 손으로 적지 않는 이유는, 손으로 적으면 스펙이 바뀌어도
- * 컴파일이 통과하기 때문이다 — 그 어긋남은 런타임에 `undefined` 로 나타난다.
+ * We do not write the method return types by hand because a hand-written type
+ * still compiles after the spec changes — and that drift shows up at runtime as
+ * `undefined`.
  */
 type Ok<K extends keyof operations> = operations[K]["responses"] extends {
     200: {
@@ -29,12 +33,141 @@ type Ok<K extends keyof operations> = operations[K]["responses"] extends {
 } ? B : never;
 export type Session = Schemas["Session"];
 export type User = Schemas["User"];
+export type AuthEmailAccepted = Schemas["AuthEmailAccepted"];
+export type TotpStatus = Schemas["TotpStatus"];
+export type TotpEnrollment = Schemas["TotpEnrollment"];
 export type Org = Schemas["Org"];
 export type Project = Schemas["Project"];
 export type ProjectDetail = Schemas["ProjectDetail"];
 export type Placement = Schemas["Placement"];
 export type Deployment = Schemas["Deployment"];
+export type Preview = Schemas["Preview"];
+export type PreviewState = NonNullable<Preview["state"]>;
+export type PreviewDbMode = NonNullable<Preview["dbMode"]>;
+/**
+ * What `createDeployment` answers to a `?preview=` upload.
+ *
+ * The extra field is written here rather than in the 201 response schema because
+ * the schema is `Deployment` — shared with `listDeployments`, `rollback` and the
+ * overview, none of which have a preview to report. Widening it there would put an
+ * optional `preview` on every deployment a reader ever sees, which reads as "a
+ * deployment may belong to a preview" instead of "this one call returns the
+ * preview it just made". `proto/openapi.yaml` `createDeployment` says the same
+ * thing in prose.
+ */
+export type DeployedPreview = Deployment & {
+    preview?: Preview;
+};
+export type ProjectOverview = Schemas["ProjectOverview"];
+export type OverviewDeployment = Schemas["OverviewDeployment"];
 export type Manifest = Schemas["Manifest"];
+export type CronOverview = Schemas["CronOverview"];
+export type ErrorIssue = Schemas["ErrorIssue"];
+export type ErrorIssuePage = Schemas["ErrorIssuePage"];
+export type ErrorIssueDetail = Schemas["ErrorIssueDetail"];
+export type ErrorIssueUpdate = Schemas["ErrorIssueUpdate"];
+export type ErrorEvent = Schemas["ErrorEvent"];
+export type ErrorEventSummary = Schemas["ErrorEventSummary"];
+export type ErrorEventPage = Schemas["ErrorEventPage"];
+export type ErrorFrame = Schemas["ErrorFrame"];
+export type ErrorException = Schemas["ErrorException"];
+export type ErrorBreadcrumb = Schemas["ErrorBreadcrumb"];
+export type ErrorActivity = Schemas["ErrorActivity"];
+export type ErrorOwnershipPolicy = Schemas["ErrorOwnershipPolicy"];
+export type ErrorOwnershipPinInput = Schemas["ErrorOwnershipPinInput"];
+export type ErrorOwnershipPin = Schemas["ErrorOwnershipPin"];
+export type ErrorSettings = Schemas["ErrorSettings"];
+export type RelatedErrorEvents = Schemas["RelatedErrorEvents"];
+export type ErrorHistory = Schemas["ErrorHistory"];
+export type UptimeCheck = Schemas["UptimeCheck"];
+export type ObservabilityPermission = Schemas["ObservabilityPermission"];
+export type ObservabilityCaps = Schemas["ObservabilityCaps"];
+export type ObservabilityExport = Schemas["ObservabilityExport"];
+export type ObservabilityRehydration = Schemas["ObservabilityRehydration"];
+export type ObservabilityAuditEntry = Schemas["ObservabilityAuditEntry"];
+export type ObservabilityData = Schemas["ObservabilityData"];
+export type BugReport = Schemas["BugReport"];
+export type UptimeCheckInput = Schemas["UptimeCheckInput"];
+export type UptimeCheckList = Schemas["UptimeCheckList"];
+export type ObsProfilerSettings = Schemas["ObsProfilerSettings"];
+export type ObsSampling = Schemas["ObsSampling"];
+export type ObsProfileList = Schemas["ObsProfileList"];
+export type ObsFlamegraph = Schemas["ObsFlamegraph"];
+export type ObsFlameNode = Schemas["ObsFlameNode"];
+export type ObsProfileTop = Schemas["ObsProfileTop"];
+export type ObsProfileCompare = Schemas["ObsProfileCompare"];
+export type ObsHeapSnapshot = Schemas["ObsHeapSnapshot"];
+export type ObsHeapSnapshotList = Schemas["ObsHeapSnapshotList"];
+export type ObsRUMAggregate = Schemas["ObsRUMAggregate"];
+export type ObsRUMOverview = Schemas["ObsRUMOverview"];
+export type ObsRUMPages = Schemas["ObsRUMPages"];
+export type ObsRUMDevices = Schemas["ObsRUMDevices"];
+export type ObsRUMViewList = Schemas["ObsRUMViewList"];
+export type ObsRUMView = Schemas["ObsRUMView"];
+export type ObsRUMViewSummary = Schemas["ObsRUMViewSummary"];
+export type ObsRUMTiming = Schemas["ObsRUMTiming"];
+/** Filters of the RUM reads (customer-observability.md §17.12). */
+export interface ObsRUMQuery {
+    from?: string;
+    to?: string;
+    step?: string;
+    template?: string;
+    device?: "mobile" | "tablet" | "desktop";
+}
+/** The window and filters of a profile read (customer-observability.md §17.13). */
+export interface ObsProfileQuery {
+    from?: string;
+    to?: string;
+    version?: number;
+    route?: string;
+    limit?: number;
+}
+export type UptimeRun = Schemas["UptimeRun"];
+export type ErrorPerformanceThresholds = Schemas["ErrorPerformanceThresholds"];
+export type ErrorCapturePolicy = Schemas["ErrorCapturePolicy"];
+export type ErrorCapturePolicyView = Schemas["ErrorCapturePolicyView"];
+export type ErrorComment = Schemas["ErrorComment"];
+export type ErrorCommentPage = Schemas["ErrorCommentPage"];
+export type ErrorSimilar = Schemas["ErrorSimilar"];
+export type ErrorFingerprintRule = Schemas["ErrorFingerprintRule"];
+export type ErrorFingerprintRules = Schemas["ErrorFingerprintRules"];
+export type ErrorInsights = Schemas["ErrorInsights"];
+export type ErrorInsightSourceContext = Schemas["ErrorInsightSourceContext"];
+export type ErrorSuspectCommit = Schemas["ErrorSuspectCommit"];
+export type ErrorInsightOwners = Schemas["ErrorInsightOwners"];
+export type ErrorDiagnosis = Schemas["ErrorDiagnosis"];
+export type ErrorFixProposal = Schemas["ErrorFixProposal"];
+export type ErrorFixPreview = Schemas["ErrorFixPreview"];
+export type ErrorFixPreviewVerification = Schemas["ErrorFixPreviewVerification"];
+export type ErrorFixPreviewApproval = Schemas["ErrorFixPreviewApproval"];
+export type ErrorFixPreviewVerificationApproval = Schemas["ErrorFixPreviewVerificationApproval"];
+export type ErrorFixApplyResult = Schemas["ErrorFixApplyResult"];
+/** Masked structural replay (not a pixel recording): settings, metadata and one batch. */
+export type ErrorErasureResult = Schemas["ErrorErasureResult"];
+export type BrowserTelemetrySummary = Schemas["BrowserTelemetrySummary"];
+export type BrowserFeedback = Schemas["BrowserFeedback"];
+export type ErrorReplaySettings = Schemas["ErrorReplaySettings"];
+export type ErrorReplay = Schemas["ErrorReplay"];
+export type ErrorReplayBatch = Schemas["ErrorReplayBatch"];
+export type CronSchedule = Schemas["CronSchedule"];
+export type CronMonitor = Schemas["CronMonitor"];
+export type CronMonitorIncident = Schemas["CronMonitorIncident"];
+export type CronRun = Schemas["CronRun"];
+export type CronSummary = Schemas["CronSummary"];
+export type QueueOverview = Schemas["QueueOverview"];
+export type QueueStatus = Schemas["QueueStatus"];
+export type QueueRun = Schemas["QueueRun"];
+export type QueueDepth = Schemas["QueueDepth"];
+export type QueueMessage = Schemas["QueueMessage"];
+export type AppUser = Schemas["AppUser"];
+export type AppUserPage = Schemas["AppUserPage"];
+export type AILedgerRow = Schemas["AILedgerRow"];
+/** The body of one development-lane `env.ai.run` (`devAIRun`). */
+export type DevAIRunRequest = operations["devAIRun"]["requestBody"]["content"]["application/json"];
+export type DevAIRunResult = Ok<"devAIRun">;
+export type DurableObjectUsage = Schemas["DurableObjectUsage"];
+export type VectorOverview = Schemas["VectorOverview"];
+export type VectorNamespace = Schemas["VectorNamespace"];
 export type DatabaseConnect = Schemas["DatabaseConnect"];
 export type DatabaseEndpoint = Schemas["DatabaseEndpoint"];
 export type DatabaseToken = Schemas["DatabaseToken"];
@@ -47,35 +180,211 @@ export type GenerationRow = Schemas["GenerationRow"];
 export type OperationStarted = Schemas["OperationStarted"];
 export type Operation = Schemas["Operation"];
 export type ErrorEnvelope = Schemas["Error"];
+export type License = Schemas["License"];
+export type LicenseState = License["state"];
 export type Role = Schemas["Role"];
 export type Member = Schemas["Member"];
+export type Invite = Schemas["Invite"];
+export type OrgHolding = Schemas["OrgHolding"];
+export type InviteView = Schemas["InviteView"];
+export type InviteState = Schemas["InviteState"];
 export type SecretMeta = Schemas["SecretMeta"];
 export type SecretList = Schemas["SecretList"];
 export type LogEvent = Schemas["LogEvent"];
+export type LogRecord = Schemas["LogRecord"];
+export type ObsQuery = Schemas["ObsQuery"];
+export type ObsFilter = Schemas["ObsFilter"];
+export type ObsQueryResult = Schemas["ObsQueryResult"];
+export type ObsInvocation = Schemas["ObsInvocation"];
+export type ObsEvent = Schemas["ObsEvent"];
+export type ObsRequestView = Schemas["ObsRequestView"];
+export type SavedQuery = Schemas["SavedQuery"];
+export type SavedQueryInput = Schemas["SavedQueryInput"];
+export type ObsProcessor = Schemas["ObsProcessor"];
+export type ObsScannerConfig = Schemas["ObsScannerConfig"];
+export type ObsLogMetric = Schemas["ObsLogMetric"];
+export type ObsLogsConfig = Schemas["ObsLogsConfig"];
+/** Live-tail filters, applied on the node before a line is sent. */
+export type LogTailFilter = {
+    level?: "debug" | "log" | "info" | "warn" | "error";
+    source?: "stdout" | "stderr" | "runlot";
+    q?: string;
+    requestId?: string;
+};
+export type LogHistoryLine = {
+    ts: string;
+    seq: number;
+    epoch?: number;
+    generation?: number;
+    stream: "stdout" | "stderr" | "runlot";
+    line: string;
+};
+export type LogHistoryPage = {
+    lines: LogHistoryLine[];
+    /** Absent means there is nothing older. */
+    cursor?: string | undefined;
+    keepDays: number;
+    linesPerDay: number;
+};
 export type Usage = Schemas["Usage"];
+export type ExecuteResult = Schemas["ExecuteResult"];
 export type StorageStatus = Schemas["StorageStatus"];
+export type StorageObject = Schemas["StorageObject"];
+export type StorageObjectPage = Schemas["StorageObjectPage"];
+export type StorageObjectSigned = Schemas["StorageObjectSigned"];
+export type BillingStatus = Schemas["BillingStatus"];
+export type PlanLimits = Schemas["PlanLimits"];
+export type EmailStatus = Schemas["EmailStatus"];
+export type EmailDomain = Schemas["EmailDomain"];
+export type EmailDNSRecord = Schemas["EmailDNSRecord"];
+export type EmailDomainState = NonNullable<EmailDomain["state"]>;
+export type MailLogEntry = Schemas["MailLogEntry"];
+export type MailLogPage = Schemas["MailLogPage"];
+export type Repo = Schemas["Repo"];
+export type RepoVisibility = NonNullable<Repo["visibility"]>;
+export type DeployHook = Schemas["DeployHook"];
+export type Build = Schemas["Build"];
+export type BuildState = NonNullable<Build["state"]>;
+export type RefUpdate = Schemas["RefUpdate"];
+export type SSHKey = Schemas["SSHKey"];
+export type AccessToken = Schemas["AccessToken"];
+export type AccessTokenCreated = Schemas["AccessTokenCreated"];
+export type TokenScope = NonNullable<AccessToken["scope"]>;
+/**
+ * One name from the REST scope vocabulary (0067).
+ *
+ * `TokenScope` above is the **git** verdict and stays two-valued; this is the
+ * set a token actually carries. Keeping the two names apart is what stops the
+ * git front end and the REST middleware from drifting into one another.
+ */
+export type ApiScope = Schemas["ApiScope"];
+export declare const API_SCOPES: readonly ApiScope[];
+export type RepoRefs = Schemas["RepoRefs"];
+export type RepoRef = RepoRefs["refs"][number];
+export type RepoTree = Schemas["RepoTree"];
+export type RepoTreeEntry = Schemas["RepoTreeEntry"];
+export type RepoBlob = Schemas["RepoBlob"];
+export type RepoCommit = Schemas["RepoCommit"];
 export type AccessPolicy = Schemas["AccessPolicy"];
 export type AccessBypass = Schemas["AccessBypass"];
 export type AccessAuthorize = Schemas["AccessAuthorize"];
-/** 정책 셋. 라디오 셋이 이 유니온에 붙는다 (docs/access.md §3.1). */
+/** The four policies (`app` is docs/auth-access-unify.md §3). The radio buttons hang off this union (docs/access.md §3.1). */
 export type AccessMode = NonNullable<AccessPolicy["mode"]>;
 export type UsageRow = Schemas["UsageRow"];
 export type Notification = Schemas["Notification"];
-/** 알림 종류. 대시보드의 라벨 표가 이 유니온에 붙는다 (§3.1). */
+/** The notification kinds. The dashboard's label table hangs off this union (§3.1). */
 export type NotificationKind = NonNullable<Notification["kind"]>;
 export type AuthStatus = Schemas["AuthStatus"];
 export type AuthSettings = Schemas["AuthSettings"];
 export type AuthBrand = Schemas["AuthBrand"];
+/**
+ * One provider row (docs/auth-access-unify.md §5, §5A): `builtin` is the
+ * project's own GitHub or Google app, `oidc` a generic OpenID Connect provider
+ * under a project-chosen id, `runlot` Runlot's sign-in.
+ */
 export type AuthProviderMeta = Schemas["AuthProviderMeta"];
-/** 프로바이더 셋. 화면의 행과 CLI 의 인자가 이 유니온에 붙는다. */
+export type AuthProviderKind = AuthProviderMeta["kind"];
+/** The PUT body; its shape depends on `kind` (see `AuthProviderPut`). */
+export type AuthProviderPut = Schemas["AuthProviderPut"];
+/** Provider ids with a built-in meaning; any other id is an OIDC provider. */
+export type BuiltinAuthProvider = "github" | "google";
+export declare const BUILTIN_AUTH_PROVIDERS: readonly BuiltinAuthProvider[];
+export declare const RESERVED_AUTH_PROVIDER_IDS: readonly string[];
+/** The id pattern for an OIDC provider (`^[a-z][a-z0-9-]{1,30}$`). */
+export declare const AUTH_PROVIDER_ID: RegExp;
+/**
+ * `GET …/auth/schema`: the statements that install `runlot_auth` idempotently,
+ * one transaction from `BEGIN` to `COMMIT`. A migration that references
+ * `runlot_auth` runs them first.
+ */
+export interface AuthSchema {
+    version: number;
+    statements: string[];
+}
+/** A provider id: `github`, `google`, `runlot`, or an OIDC id. */
 export type AuthProvider = Schemas["AuthProvider"];
-/** PATCH 의 본문 — `AuthSettings` 의 부분집합. 준 칸만 바뀐다. */
-export type AuthSettingsInput = NonNullable<Schemas["AuthSettingsPatch"]["settings"]>;
+/** The PATCH body — a subset of `AuthSettings`. Only the fields given change. */
+export type AuthSettingsInput = Omit<NonNullable<Schemas["AuthSettingsPatch"]["settings"]>, "brand"> & {
+    /** §12.3: attach a `runlot` identity to an existing user with the same verified email. Default true. */
+    linkByEmail?: boolean;
+    brand?: Partial<AuthBranding>;
+};
+export type AuthTheme = "light" | "dark" | "system";
+export type AuthLayout = "centered" | "split" | "minimal";
+export type AuthButtonShape = "rounded" | "pill" | "square";
+export type AuthBackgroundKind = "none" | "color" | "gradient" | "image";
+export type AuthBrandLang = "ko" | "en" | "ja";
+export type AuthRunlotMethod = "password" | "google" | "github" | "passkey";
+export declare const AUTH_RUNLOT_METHODS: readonly AuthRunlotMethod[];
+export interface AuthBrandCopy {
+    /** ≤ 80 characters. */
+    title: string;
+    /** ≤ 200 characters. */
+    subtitle: string;
+    /** ≤ 200 characters. */
+    footer: string;
+}
+/** The whole branding object (`project_auth.settings.brand`, §12.3). */
+export interface AuthBranding {
+    name: string;
+    logo: string;
+    color: string;
+    /** https URL or "". */
+    logoDark: string;
+    theme: AuthTheme;
+    layout: AuthLayout;
+    buttonShape: AuthButtonShape;
+    background: {
+        kind: AuthBackgroundKind;
+        value: string;
+    };
+    copy: Partial<Record<AuthBrandLang, AuthBrandCopy>>;
+    links: {
+        terms: string;
+        privacy: string;
+        support: string;
+    };
+    defaultLang: AuthBrandLang | "";
+    /** Empty = every method the deployment can broker. */
+    methods: AuthRunlotMethod[];
+}
+/** GET/PUT /auth/branding answer. */
+export interface AuthBrandingAnswer {
+    brand: AuthBranding;
+    effectiveMethods: AuthRunlotMethod[];
+}
+/** `400 invalid_branding` carries one entry per bad field. */
+export interface AuthBrandingFieldError {
+    path: string;
+    message: string;
+}
+export type AuthPreviewState = "password" | "passkey" | `error:${string}`;
+export interface AuthPreviewOpts {
+    lang?: AuthBrandLang;
+    theme?: AuthTheme;
+    state?: AuthPreviewState;
+    /** Unsaved branding to render instead of the stored one. */
+    draft?: Partial<AuthBranding>;
+}
+/** One counter of `app_auth_funnel` (§12.2): per day, event and key. */
+export interface AuthFunnelRow {
+    /** YYYY-MM-DD. */
+    day: string;
+    /** e.g. `start`, `chooser_view`, `method`, `success`, `error`. */
+    event: string;
+    /** The idp, method or error code the event is about; "" when none. */
+    key: string;
+    n: number;
+}
+export interface AuthFunnel {
+    days: number;
+    rows: AuthFunnelRow[];
+}
 export type Hostname = Schemas["Hostname"];
 export type HostnameList = Schemas["HostnameList"];
 export type HostnameVerify = Schemas["HostnameVerify"];
 export type HostnameRecord = Schemas["HostnameRecord"];
-/** 상태 넷. 화면의 배지가 이 값에 붙는다 (docs/domains.md §3.3). */
+/** The four states. The badge on screen hangs off this value (docs/domains.md §3.3). */
 export type HostnameState = NonNullable<Hostname["state"]>;
 export type Zone = Schemas["Zone"];
 export type ZoneDetail = Schemas["ZoneDetail"];
@@ -86,10 +395,41 @@ export type DomainDetail = Schemas["DomainDetail"];
 export type DomainList = Schemas["DomainList"];
 export type DomainAvailability = Schemas["DomainAvailability"];
 export type DomainContact = Schemas["DomainContact"];
+export type DomainCharge = Schemas["DomainCharge"];
+/**
+ * A purchase or renewal answers with the domain once it is paid and done, or with
+ * the charge while payment is still on its way (a checkout to pay in, or a charge
+ * settling). The charge is the one with a `chargeId`.
+ */
+export declare function isDomainCharge(v: Domain | DomainCharge): v is DomainCharge;
 export type DomainEvent = Schemas["DomainEvent"];
-/** `Domain["state"]` 을 따로 내보낸다 — 화면이 배지 표를 이 유니온으로 못박는다. */
+/** `Domain["state"]` is exported separately — the screen pins its badge table to this union. */
 export type DomainState = Domain["state"];
-/** 서버가 돌려준 오류 봉투를 그대로 들고 있는 예외. */
+/**
+ * A status the edge in front of cp-public can produce on its own: 502–504, and
+ * Cloudflare's 520–527 (524 is its 100 s origin timeout). With no JSON body these
+ * are the edge's words, not the server's, and are raised as `edge_<status>`.
+ */
+export declare function isEdgeStatus(status: number): boolean;
+/** True for the `edge_<status>` ApiError `isEdgeStatus` produces. */
+export declare function isEdgeError(err: unknown): boolean;
+/** One entry of an incremental upload's list, in tar order (docs/incremental-deploy-upload.md §1.1). */
+export type DeploymentUploadEntry = {
+    path: string;
+    sha256: string;
+    size: number;
+    type?: "file";
+} | {
+    path: string;
+    type: "dir";
+};
+export type DeploymentUpload = Schemas["DeploymentUpload"];
+export interface PreviewTarget {
+    preview: string;
+    db?: string | undefined;
+    from?: string | undefined;
+}
+/** The exception that carries the server's error envelope unchanged. */
 export declare class ApiError extends Error {
     readonly status: number;
     readonly code: string;
@@ -99,258 +439,1284 @@ export declare class ApiError extends Error {
 export interface ClientOptions {
     baseUrl: string;
     token?: string | undefined;
+    /**
+     * Sends a GET or HEAD again when the edge answered for the server (`edge_<status>`)
+     * or `transport` says the connection failed in a way worth another try. Never a
+     * write: after a cut its effect is unknown, and the caller has to check (the CLI's
+     * upload does, docs/incremental-deploy-upload.md §3). The delay doubles from
+     * `backoffMs`. Off when absent, so a screen shows a failure at once.
+     */
+    retry?: {
+        attempts: number;
+        backoffMs: number;
+        transport: (err: unknown) => boolean;
+    } | undefined;
 }
 export declare class Client {
     private readonly opts;
     constructor(opts: ClientOptions);
     private headers;
+    /** Runs one attempt again under `opts.retry`, for a safe method only. */
+    private retrying;
     private request;
+    private requestOnce;
+    /** A body that is not JSON (the raw mail). Error handling is the same as request. */
+    private text;
+    private textOnce;
     private json;
     devLogin(subject: string): Promise<Ok<"devLogin">>;
-    /** 켜진 로그인 방식. 로그인 화면이 버튼을 그리는 데 쓴다. */
-    authProviders(): Promise<Ok<"listAuthProviders">>;
     /**
-     * GitHub OAuth 시작 URL. 브라우저가 따라가는 302 라 fetch 로 부르지 않고
-     * `window.location` 에 넣는다. `redirect` 는 서버 허용 목록에 있어야 한다.
+     * Takes the sign-up and sends the confirmation mail. Neither a session nor a
+     * password is created here — the password is chosen in `verifyEmail` by
+     * whoever opens the mailbox.
+     */
+    passwordSignUp(email: string, name?: string): Promise<Ok<"passwordSignUp">>;
+    passwordSignIn(email: string, password: string): Promise<Ok<"passwordSignIn">>;
+    /** The same accepted response comes back whether or not the email exists. */
+    passwordForgot(email: string): Promise<Ok<"passwordForgot">>;
+    passwordReset(token: string, password: string): Promise<Ok<"passwordReset">>;
+    /** Uses the confirmation link and sets the account's first password. */
+    verifyEmail(token: string, password: string): Promise<Ok<"verifyEmail">>;
+    /**
+     * Finishes a sign-in that came back `{mfa:"totp"}`.
+     *
+     * Callable without a token: `pending` is the credential, and it is not a
+     * session — no other endpoint accepts it.
+     */
+    completeTotpLogin(pending: string, factor: {
+        code: string;
+    } | {
+        recovery: string;
+    }): Promise<Ok<"completeTotpLogin">>;
+    /** This account's two-factor state, including which orgs require it. */
+    getTotp(): Promise<Ok<"getTotp">>;
+    /**
+     * Draws a secret to scan. It does **not** turn the factor on — `confirmTotp`
+     * does, after the app has proved it can produce a code.
+     */
+    enrollTotp(): Promise<Ok<"enrollTotp">>;
+    /** Turns the factor on and hands back the ten recovery codes. They are shown once. */
+    confirmTotp(code: string): Promise<Ok<"confirmTotp">>;
+    /** Turns it off. A code or a recovery code is required — the session alone is not. */
+    disableTotp(factor: {
+        code: string;
+    } | {
+        recovery: string;
+    }): Promise<void>;
+    /**
+     * The GitHub OAuth start URL. It is a 302 the browser follows, so it goes into
+     * `window.location` rather than being called with fetch. `redirect` has to be
+     * on the server's allow-list.
      */
     githubStartUrl(redirect: string): string;
+    /** The Google OAuth start URL. Uses the same dashboard callback shape as GitHub. */
+    googleStartUrl(redirect: string): string;
+    /**
+     * The generic OIDC start URL (docs/onprem-delivery.md §7.7). Same 302-and-fragment
+     * shape as the other two; which provider is behind it is the installation's choice.
+     */
+    oidcStartUrl(redirect: string): string;
+    /**
+     * Does this deployment federate an identity provider?
+     *
+     * **There is no endpoint that answers "which logins are on"** — one existed and was
+     * deleted, because its only reader was the login screen and it put a round trip in
+     * front of every login button (cp/internal/public/public.go). This is not that
+     * endpoint coming back: cp-public **does not register** the two OIDC routes when no
+     * issuer is configured, so the mux's own 404 is the answer, and the probe is a HEAD
+     * that no handler runs.
+     *
+     * Any other status means the route is there — a 400 (this probe carries no
+     * `redirect`) or a 502 (the provider's discovery document could not be read) both say
+     * the handler exists, and a button that leads to a readable error beats no button.
+     * A network failure answers false: on SaaS, where the answer is false anyway, a dead
+     * API address must not draw a login that cannot work.
+     */
+    oidcAvailable(): Promise<boolean>;
+    /**
+     * This installation's licence (docs/onprem-delivery.md §6.5). Readable by any
+     * signed-in user: the footer it feeds is on every page for everybody.
+     *
+     * On SaaS it answers `onPrem: false` rather than 404, so the caller has one shape to
+     * read and the surfaces draw nothing on the flag.
+     */
+    license(): Promise<Ok<"getLicense">>;
+    /**
+     * The names of this deployment (app domain, docs address). Callable without auth.
+     *
+     * This exists so the dashboard does not hard-code a domain into the screen
+     * (docs/environments.md §3.2) — hard-coded, the dev screen tells people a
+     * production address, and because that address opens, nobody ever says it is
+     * wrong.
+     */
+    siteConfig(): Promise<Ok<"getSiteConfig">>;
     me(): Promise<Ok<"getMe">>;
     listOrgs(): Promise<Ok<"listOrgs">>;
+    /** Changes the display name only (admin). The slug is the name that becomes an address, so it is not on this surface. */
+    /**
+     * `requireTotp` is left out when it is not given, on purpose: the server reads
+     * an absent field as "leave it alone". Sending `false` by default would mean a
+     * rename silently switched the org's second-factor requirement off.
+     */
+    updateOrg(org: string, name: string, requireTotp?: boolean): Promise<Ok<"updateOrg">>;
+    /**
+     * Deletes the organization (admin). **This cannot be undone.**
+     *
+     * `confirm` has to be the organization slug exactly — the confirmation lives on
+     * the server because three places call this surface (the screen, the CLI, and
+     * scripts). If a live project, domain, repository, or DNS zone is left, it is a
+     * 409 `org_not_empty` and `details.holdings` says what is left — **projects
+     * already deleted are not counted.**
+     *
+     * The `purgeAfter` in the answer is when the rows actually disappear. By the
+     * moment it returns the organization is already gone from every surface; what
+     * remains is retention until that time.
+     */
+    deleteOrg(org: string, confirm: string): Promise<Ok<"deleteOrg">>;
     createOrg(slug: string, name: string): Promise<Ok<"createOrg">>;
     /**
-     * org 의 최근 알림 (docs/limits.md §3.4).
+     * The organization's recent notifications (docs/limits.md §3.4).
      *
-     * `sentAt` 이 없는 행은 아직 큐에 있거나 받을 이메일이 없는 것이다 — 후자에게
-     * 이 목록이 유일한 통로라, 화면은 두 상태를 같게 그린다.
+     * A row with no `sentAt` is either still queued or has no email address to
+     * reach — and for the second, this list is the only channel, so the screen
+     * draws both states the same way.
      */
     listNotifications(org: string, limit?: number): Promise<Ok<"listNotifications">>;
+    /**
+     * The plan and billing state (docs/billing.md). If `enabled` is false, this
+     * deployment has no billing — the screen shows only a contact address.
+     */
+    getBilling(org: string): Promise<Ok<"getBilling">>;
+    /**
+     * A Pro checkout session. Send the browser to the `url` that comes back. Even
+     * once payment finishes, the thing that changes the plan is the webhook, so
+     * read `getBilling` again after the browser returns.
+     */
+    createBillingCheckout(org: string, returnTo: string): Promise<Ok<"createBillingCheckout">>;
+    /** A one-time `url` for the customer portal (payment method, receipts, cancellation). */
+    createBillingPortal(org: string, returnTo: string): Promise<Ok<"createBillingPortal">>;
+    /** The customer session token for the payment-method embed (1 hour). An org with no payment history gets a 404. */
+    createBillingSession(org: string): Promise<Ok<"createBillingSession">>;
+    /** Schedules cancellation at the end of the period (`cancel: true`), or undoes it. There is no immediate revocation. */
+    cancelBilling(org: string, body: {
+        cancel: boolean;
+        reason?: string;
+        comment?: string;
+    }): Promise<Ok<"cancelBilling">>;
     listProjects(org: string): Promise<Ok<"listProjects">>;
     createProject(org: string, name: string): Promise<Ok<"createProject">>;
     getProject(org: string, name: string): Promise<Ok<"getProject">>;
+    /**
+     * Renames the project (admin). **The default address moves with it and there is
+     * no alias** — which is why the response carries the new address. Unlike the
+     * org slug, this name can change because it is the inner label of the org
+     * wildcard certificate.
+     */
+    updateProject(org: string, name: string, next: string): Promise<Ok<"updateProject">>;
+    /**
+     * Starts tearing the project down (admin). **This cannot be undone and leaves
+     * no recovery generation.** `confirm` has to be the project name exactly.
+     */
+    deleteProject(org: string, name: string, confirm: string): Promise<Ok<"deleteProject">>;
+    /**
+     * Disables a project (admin): it stops serving and taking new backups, and
+     * keeps everything it has. A project disabled for a year is deleted for good.
+     */
+    disableProject(org: string, name: string): Promise<Ok<"disableProject">>;
+    /** Enables a disabled project (admin). 409 `project_limit` when there is no room for it. */
+    enableProject(org: string, name: string): Promise<Ok<"enableProject">>;
+    /** Watches the teardown operation to its end even after the project is gone. */
+    getOrgOperation(org: string, opId: string): Promise<Ok<"getOrgOperation">>;
+    /** Everything the project's first screen takes in one call. Usage calls `getUsage` alongside it. */
+    getProjectOverview(org: string, name: string): Promise<Ok<"getProjectOverview">>;
     listDeployments(org: string, name: string): Promise<Ok<"listDeployments">>;
-    /** 본문이 곧 번들이다. 다이제스트 하나가 코드와 자산 전부를 덮는다. */
-    deploy(org: string, name: string, bundle: Uint8Array): Promise<Ok<"createDeployment">>;
-    /** 멱등이다. 두 번 불러도 비밀번호는 굴지 않고 같은 접속 정보가 온다. */
+    /**
+     * One deployment, with `migrations` when the control plane applied its
+     * `migrations/` — which today means a preview deployed with `db=branch`
+     * (docs/studio.md §6.6 step 2).
+     *
+     * A preview's deployment is read under **the parent project's name**, the name
+     * the caller deployed through: the preview is a project of its own, but the
+     * caller never learns its name.
+     */
+    getDeployment(org: string, name: string, deploymentId: string): Promise<Ok<"getDeployment">>;
+    /** Completed-front HTTP outcomes only; native crash-free health is unknown. */
+    getReleaseHealth(org: string, name: string): Promise<Ok<"getReleaseHealth">>;
+    /** Historical first transition per issue; never substitutes a latest occurrence. */
+    listReleaseIssues(org: string, name: string, version: number, opts: {
+        kind: "new" | "regressed";
+        windowStart: string;
+        windowEnd: string;
+        cursor?: string;
+    }): Promise<Ok<"listReleaseIssues">>;
+    /** Runlot Errors: the issue stream (docs/customer-error-tracking.md). */
+    listErrorIssues(org: string, name: string, opts?: {
+        status?: "unresolved" | "resolved" | "archived" | "all";
+        query?: string;
+        cursor?: string;
+        limit?: number;
+    }): Promise<Ok<"listErrorIssues">>;
+    getErrorIssue(org: string, name: string, issueId: string): Promise<Ok<"getErrorIssue">>;
+    updateErrorIssue(org: string, name: string, issueId: string, update: ErrorIssueUpdate): Promise<Ok<"updateErrorIssue">>;
+    /** Source context, suspects and owners for the selected stored occurrence, or latest when omitted. */
+    getErrorInsights(org: string, name: string, issueId: string, opts?: {
+        eventId?: string;
+    }): Promise<Ok<"getErrorInsights">>;
+    listErrorEvents(org: string, name: string, issueId: string, opts?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<Ok<"listErrorEvents">>;
+    getErrorEvent(org: string, name: string, issueId: string, eventId: string): Promise<Ok<"getErrorEvent">>;
+    /**
+     * Other events of the project joined to this one by front's request ID or a
+     * browser-minted trace ID (§12). Correlation only: issues are never merged.
+     */
+    getRelatedErrorEvents(org: string, name: string, issueId: string, eventId: string): Promise<Ok<"getRelatedErrorEvents">>;
+    /** An issue's hourly history from the ClickHouse store; `available: false` where there is none. */
+    getErrorHistory(org: string, name: string, issueId: string, days?: number): Promise<Ok<"getErrorHistory">>;
+    /** Assign an issue to an org member, or clear it with null. */
+    assignErrorIssue(org: string, name: string, issueId: string, userId: string | null): Promise<Ok<"assignErrorIssue">>;
+    listErrorComments(org: string, name: string, issueId: string): Promise<Ok<"listErrorComments">>;
+    /** Plain text, at most 4000 characters; the author is the signed-in user. */
+    addErrorComment(org: string, name: string, issueId: string, body: string): Promise<Ok<"addErrorComment">>;
+    /** Merge up to ten issues of the same origin into `targetIssueId`. */
+    mergeErrorIssues(org: string, name: string, targetIssueId: string, sourceIssueIds: string[]): Promise<Ok<"mergeErrorIssues">>;
+    /** Take a merged source back out of the issue it was merged into. */
+    unmergeErrorIssue(org: string, name: string, issueId: string): Promise<Ok<"unmergeErrorIssue">>;
+    /** Shared stack hints: frame overlap, never a merge or a causal claim. */
+    similarErrorIssues(org: string, name: string, issueId: string): Promise<Ok<"similarErrorIssues">>;
+    getErrorFingerprintRules(org: string, name: string): Promise<Ok<"getErrorFingerprintRules">>;
+    putErrorFingerprintRules(org: string, name: string, rules: ErrorFingerprintRule[]): Promise<Ok<"putErrorFingerprintRules">>;
+    getErrorAlerts(org: string, name: string): Promise<Ok<"getErrorAlerts">>;
+    putErrorAlertRule(org: string, name: string, id: string, rule: components["schemas"]["ErrorAlertRule"]): Promise<Ok<"putErrorAlertRule">>;
+    deleteErrorAlertRule(org: string, name: string, id: string): Promise<void>;
+    putErrorAlertDestination(org: string, name: string, id: string, input: components["schemas"]["ErrorAlertDestinationInput"]): Promise<Ok<"putErrorAlertDestination">>;
+    deleteErrorAlertDestination(org: string, name: string, id: string): Promise<void>;
+    getErrorAlertMail(org: string, name: string): Promise<Ok<"getErrorAlertMail">>;
+    putErrorAlertMail(org: string, name: string, preference: components["schemas"]["ErrorAlertMailPreference"]): Promise<Ok<"putErrorAlertMail">>;
+    listErrorAlertDeliveries(org: string, name: string): Promise<Ok<"listErrorAlertDeliveries">>;
+    listMonitors(org: string, name: string): Promise<Ok<"listMonitors">>;
+    exportMonitors(org: string, name: string): Promise<Ok<"exportMonitors">>;
+    getMonitor(org: string, name: string, id: string): Promise<Ok<"getMonitor">>;
+    putMonitor(org: string, name: string, id: string, monitor: components["schemas"]["Monitor"]): Promise<Ok<"putMonitor">>;
+    deleteMonitor(org: string, name: string, id: string): Promise<void>;
+    getMonitorHistory(org: string, name: string, id: string, limit?: number): Promise<Ok<"getMonitorHistory">>;
+    testMonitor(org: string, name: string, id: string): Promise<Ok<"testMonitor">>;
+    listDowntimes(org: string, name: string): Promise<Ok<"listDowntimes">>;
+    putDowntime(org: string, name: string, id: string, downtime: components["schemas"]["Downtime"]): Promise<Ok<"putDowntime">>;
+    deleteDowntime(org: string, name: string, id: string): Promise<void>;
+    listSLOs(org: string, name: string): Promise<Ok<"listSLOs">>;
+    getSLO(org: string, name: string, id: string): Promise<Ok<"getSLO">>;
+    putSLO(org: string, name: string, id: string, slo: components["schemas"]["SLO"]): Promise<Ok<"putSLO">>;
+    deleteSLO(org: string, name: string, id: string): Promise<void>;
+    /**
+     * Observability access and governance (customer-observability.md §12, §16, §17.15):
+     * the caller's grants, per-project role overrides, the audit trail, the data page,
+     * caps, export destinations and rehydration.
+     */
+    getObservabilityPermissions(org: string, name: string): Promise<Ok<"getObservabilityPermissions">>;
+    listObservabilityRoles(org: string, name: string): Promise<Ok<"listObservabilityRoles">>;
+    putObservabilityRole(org: string, name: string, userId: string, grants: ObservabilityPermission[]): Promise<Ok<"putObservabilityRole">>;
+    deleteObservabilityRole(org: string, name: string, userId: string): Promise<void>;
+    listObservabilityAudit(org: string, name: string, opts?: {
+        limit?: number;
+        before?: string;
+    }): Promise<Ok<"listObservabilityAudit">>;
+    getObservabilityData(org: string, name: string): Promise<Ok<"getObservabilityData">>;
+    getObservabilityCaps(org: string, name: string): Promise<Ok<"getObservabilityCaps">>;
+    /** Named meters only: a number, -1 (no cap, Pro) or null (the plan's included amount). */
+    putObservabilityCaps(org: string, name: string, caps: Schemas["ObservabilityCapsUpdate"]): Promise<Ok<"putObservabilityCaps">>;
+    listObservabilityExports(org: string, name: string): Promise<Ok<"listObservabilityExports">>;
+    getObservabilityExport(org: string, name: string, exportId: string): Promise<Ok<"getObservabilityExport">>;
+    createObservabilityExport(org: string, name: string, input: Schemas["ObservabilityExportCreate"]): Promise<Ok<"createObservabilityExport">>;
+    updateObservabilityExport(org: string, name: string, exportId: string, input: Schemas["ObservabilityExportUpdate"]): Promise<Ok<"updateObservabilityExport">>;
+    deleteObservabilityExport(org: string, name: string, exportId: string): Promise<void>;
+    listObservabilityRehydrations(org: string, name: string): Promise<Ok<"listObservabilityRehydrations">>;
+    getObservabilityRehydration(org: string, name: string, jobId: string): Promise<Ok<"getObservabilityRehydration">>;
+    /** Loads an archived range back for seven days; the answer is the queued job. */
+    createObservabilityRehydration(org: string, name: string, input: {
+        exportId: string;
+        from: string;
+        to: string;
+    }): Promise<Ok<"createObservabilityRehydration">>;
+    /** `runlot bug-report` (customer-observability.md §14): the CP snapshots what the references name. */
+    createBugReport(org: string, input: Schemas["BugReportCreate"]): Promise<Ok<"createBugReport">>;
+    listBugReports(org: string): Promise<Ok<"listBugReports">>;
+    getBugReport(org: string, reportId: string, opts?: {
+        snapshot?: boolean;
+    }): Promise<Ok<"getBugReport">>;
+    deleteBugReport(org: string, reportId: string): Promise<void>;
+    /** Synthetic HTTP checks of the project's own addresses (customer-observability.md §17.11). */
+    listUptimeChecks(org: string, name: string): Promise<Ok<"listUptimeChecks">>;
+    putUptimeCheck(org: string, name: string, id: string, input: components["schemas"]["UptimeCheckInput"]): Promise<Ok<"putUptimeCheck">>;
+    deleteUptimeCheck(org: string, name: string, id: string): Promise<void>;
+    listUptimeRuns(org: string, name: string, id: string, limit?: number): Promise<Ok<"listUptimeRuns">>;
+    /** Dashboards (customer-observability.md §17.7). A built-in's id is `builtin:<key>`. */
+    listDashboards(org: string, name: string): Promise<Ok<"listDashboards">>;
+    createDashboard(org: string, name: string, input: Schemas["DashboardInput"]): Promise<Ok<"createDashboard">>;
+    getDashboard(org: string, name: string, id: string): Promise<Ok<"getDashboard">>;
+    putDashboard(org: string, name: string, id: string, input: Schemas["DashboardInput"]): Promise<Ok<"putDashboard">>;
+    deleteDashboard(org: string, name: string, id: string): Promise<void>;
+    /** The `.runlot/dashboards/<key>.json` form of a dashboard. */
+    exportDashboard(org: string, name: string, id: string): Promise<Ok<"exportDashboard">>;
+    /** Make (or rotate) the public link; the token is shown once. */
+    shareDashboard(org: string, name: string, id: string, isPublic?: boolean): Promise<Ok<"shareDashboard">>;
+    unshareDashboard(org: string, name: string, id: string): Promise<void>;
+    getDashboardWidgetData(org: string, name: string, id: string, widgetId: string, req?: Schemas["WidgetDataRequest"]): Promise<Ok<"getDashboardWidgetData">>;
+    getDashboardSettings(org: string, name: string): Promise<Ok<"getDashboardSettings">>;
+    putDashboardSettings(org: string, name: string, settings: Schemas["DashboardSettings"]): Promise<Ok<"putDashboardSettings">>;
+    /** Deploy and OOM markers for every time series. */
+    getObservabilityMarkers(org: string, name: string, range?: {
+        from?: string;
+        to?: string;
+    }): Promise<Ok<"getObservabilityMarkers">>;
+    /** Watchdog insights (§17.10). Free: deploy regressions only. */
+    listInsights(org: string, name: string, opts?: {
+        state?: "open" | "resolved" | "all";
+        limit?: number;
+    }): Promise<Ok<"listInsights">>;
+    resolveInsight(org: string, name: string, id: string): Promise<void>;
+    /** Synthetic checks (§17.11): the uptime checks, including multi-step API checks. */
+    listSynthetics(org: string, name: string): Promise<Ok<"listSynthetics">>;
+    putSynthetic(org: string, name: string, id: string, input: Schemas["UptimeCheckInput"]): Promise<Ok<"putSynthetic">>;
+    deleteSynthetic(org: string, name: string, id: string): Promise<void>;
+    listSyntheticRuns(org: string, name: string, id: string, limit?: number): Promise<Ok<"listSyntheticRuns">>;
+    /** A public dashboard link. Needs no credential. */
+    getSharedDashboard(token: string): Promise<Ok<"getSharedDashboard">>;
+    getSharedDashboardWidgetData(token: string, widgetId: string, req?: Schemas["WidgetDataRequest"]): Promise<Ok<"getSharedDashboardWidgetData">>;
+    private obsApmPath;
+    getObsMetricsOverview(org: string, name: string, opts?: ObsRangeQuery & ObsRedQuery & {
+        groupBy?: "version";
+    }): Promise<Ok<"getObsMetricsOverview">>;
+    getObsMetricsMemory(org: string, name: string, opts?: ObsRangeQuery): Promise<Ok<"getObsMetricsMemory">>;
+    getObsMetricsInfrastructure(org: string, name: string, opts?: ObsRangeQuery): Promise<Ok<"getObsMetricsInfrastructure">>;
+    getObsMetricsCustom(org: string, name: string, opts: ObsRangeQuery & {
+        name: string;
+        agg?: string;
+        tags?: string;
+        groupBy?: string;
+    }): Promise<Ok<"getObsMetricsCustom">>;
+    getObsMetricsCustomNames(org: string, name: string): Promise<Ok<"getObsMetricsCustomNames">>;
+    listObsRoutes(org: string, name: string): Promise<Ok<"listObsRoutes">>;
+    putObsRoute(org: string, name: string, input: components["schemas"]["ObsRouteStateInput"]): Promise<Ok<"putObsRoute">>;
+    getObsAPMRoutes(org: string, name: string, opts?: ObsRangeQuery & ObsRedQuery): Promise<Ok<"getObsAPMRoutes">>;
+    getObsAPMBreakdown(org: string, name: string, route: string, opts?: ObsRangeQuery & {
+        version?: number;
+    }): Promise<Ok<"getObsAPMBreakdown">>;
+    getObsAPMServiceMap(org: string, name: string, opts?: ObsRangeQuery & {
+        version?: number;
+    }): Promise<Ok<"getObsAPMServiceMap">>;
+    getObsAPMCompare(org: string, name: string, a: number, b: number, opts?: ObsRangeQuery): Promise<Ok<"getObsAPMCompare">>;
+    listObsAPMTraces(org: string, name: string, opts?: {
+        from?: string;
+        to?: string;
+        before?: string;
+        route?: string;
+        status?: string;
+        minDuration?: number;
+        hasError?: boolean;
+        version?: number;
+    }): Promise<Ok<"listObsAPMTraces">>;
+    getObsAPMTrace(org: string, name: string, traceId: string): Promise<Ok<"getObsAPMTrace">>;
+    listObsTraceFilters(org: string, name: string): Promise<Ok<"listObsTraceFilters">>;
+    createObsTraceFilter(org: string, name: string, input: components["schemas"]["ObsTraceFilterInput"]): Promise<Ok<"createObsTraceFilter">>;
+    updateObsTraceFilter(org: string, name: string, id: string, input: components["schemas"]["ObsTraceFilterInput"]): Promise<Ok<"updateObsTraceFilter">>;
+    deleteObsTraceFilter(org: string, name: string, id: string): Promise<void>;
+    listObsDBQueries(org: string, name: string, opts?: {
+        from?: string;
+        to?: string;
+    }): Promise<Ok<"listObsDBQueries">>;
+    getObsDBQuery(org: string, name: string, fingerprint: string, opts?: {
+        from?: string;
+        to?: string;
+    }): Promise<Ok<"getObsDBQuery">>;
+    getObsDBHealth(org: string, name: string): Promise<Ok<"getObsDBHealth">>;
+    /** The continuous profiler's switch (customer-observability.md §17.13). */
+    getObsProfilerSettings(org: string, name: string): Promise<ObsProfilerSettings>;
+    /** On, off, or null for the default. Applies from the next deployment or restart. Admin. */
+    putObsProfilerSettings(org: string, name: string, enabled: boolean | null): Promise<ObsProfilerSettings>;
+    /** The logs/traces sampling override; a null field is the manifest's. */
+    getObsSampling(org: string, name: string): Promise<ObsSampling>;
+    /** Replaces the override (null = the manifest's). Admin. */
+    putObsSampling(org: string, name: string, body: ObsSampling): Promise<ObsSampling>;
+    listObsProfiles(org: string, name: string, q?: ObsProfileQuery): Promise<ObsProfileList>;
+    /** The windows within a minute of `ts` — the profile of a slow trace's minute. */
+    nearObsProfiles(org: string, name: string, ts: string): Promise<ObsProfileList>;
+    getObsFlamegraph(org: string, name: string, q?: Omit<ObsProfileQuery, "limit">): Promise<ObsFlamegraph>;
+    getObsProfileTop(org: string, name: string, q?: ObsProfileQuery): Promise<ObsProfileTop>;
+    /** Self-time share per function, version a against version b. */
+    compareObsProfiles(org: string, name: string, a: number, b: number, q?: Pick<ObsProfileQuery, "from" | "to">): Promise<ObsProfileCompare>;
+    /** RUM: page views, sessions and p75 vitals over time (Pro). */
+    getObsRUMOverview(org: string, name: string, q?: ObsRUMQuery): Promise<ObsRUMOverview>;
+    /** RUM by page template, with vitals, long tasks and resource/fetch timings (Pro). */
+    listObsRUMPages(org: string, name: string, q?: ObsRUMQuery & {
+        sort?: "views" | "lcp" | "inp" | "cls";
+    }): Promise<ObsRUMPages>;
+    /** RUM by device class (Pro). */
+    listObsRUMDevices(org: string, name: string, q?: ObsRUMQuery): Promise<ObsRUMDevices>;
+    /** RUM page views, newest (or slowest LCP) first (Pro). */
+    listObsRUMViews(org: string, name: string, q?: ObsRUMQuery & {
+        session?: string;
+        sort?: "recent" | "slowest";
+        limit?: number;
+    }): Promise<ObsRUMViewList>;
+    /** One page view and the server requests it caused (Pro). */
+    getObsRUMView(org: string, name: string, viewId: string): Promise<ObsRUMView>;
+    /** Starts one heap snapshot (Pro, admin; pauses the app while taken). Poll the list. */
+    createObsHeapSnapshot(org: string, name: string): Promise<ObsHeapSnapshot>;
+    listObsHeapSnapshots(org: string, name: string): Promise<ObsHeapSnapshotList>;
+    /** The download URL of a ready snapshot (a `.heapsnapshot` file). */
+    obsHeapSnapshotURL(org: string, name: string, snapshotId: string): string;
+    /** A ready snapshot's text (Chrome DevTools heap snapshot JSON). */
+    downloadObsHeapSnapshot(org: string, name: string, snapshotId: string): Promise<string>;
+    getErrorOwnership(org: string, name: string): Promise<Ok<"getErrorOwnership">>;
+    createErrorOwnershipPin(org: string, name: string, input: Schemas["ErrorOwnershipPinInput"]): Promise<Ok<"createErrorOwnershipPin">>;
+    revokeErrorOwnershipPin(org: string, name: string, deploymentId: string, selector: string): Promise<void>;
+    getErrorCapturePolicy(org: string, name: string): Promise<Ok<"getErrorCapturePolicy">>;
+    putErrorCapturePolicy(org: string, name: string, policy: ErrorCapturePolicy, acknowledgePII?: boolean): Promise<Ok<"putErrorCapturePolicy">>;
+    private obsPath;
+    getObservabilityCapabilities(org: string, name: string): Promise<Ok<"getObservabilityCapabilities">>;
+    /** Runs a query; `{ available: false }` where there is no event store. */
+    queryObservability(org: string, name: string, query: ObsQuery): Promise<Ok<"queryObservability">>;
+    listObservabilityKeys(org: string, name: string, opts?: {
+        since?: string;
+        until?: string;
+        view?: "events" | "invocations" | "spans";
+    }): Promise<Ok<"listObservabilityKeys">>;
+    listObservabilityValues(org: string, name: string, key: string, opts?: {
+        since?: string;
+        until?: string;
+        view?: "events" | "invocations" | "spans";
+    }): Promise<Ok<"listObservabilityValues">>;
+    listObservabilityPatterns(org: string, name: string, opts?: {
+        since?: string;
+        until?: string;
+        level?: string;
+    }): Promise<Ok<"listObservabilityPatterns">>;
+    getObservabilityRequest(org: string, name: string, requestId: string): Promise<Ok<"getObservabilityRequest">>;
+    listSavedQueries(org: string, name: string): Promise<Ok<"listSavedQueries">>;
+    getSavedQuery(org: string, name: string, queryId: string): Promise<Ok<"getSavedQuery">>;
+    createSavedQuery(org: string, name: string, input: SavedQueryInput): Promise<Ok<"createSavedQuery">>;
+    updateSavedQuery(org: string, name: string, queryId: string, input: SavedQueryInput): Promise<Ok<"updateSavedQuery">>;
+    deleteSavedQuery(org: string, name: string, queryId: string): Promise<void>;
+    starSavedQuery(org: string, name: string, queryId: string): Promise<Ok<"starSavedQuery">>;
+    unstarSavedQuery(org: string, name: string, queryId: string): Promise<Ok<"unstarSavedQuery">>;
+    getObservabilityPipeline(org: string, name: string): Promise<Ok<"getObservabilityPipeline">>;
+    putObservabilityPipeline(org: string, name: string, processors: ObsProcessor[]): Promise<Ok<"putObservabilityPipeline">>;
+    getObservabilityScanner(org: string, name: string): Promise<Ok<"getObservabilityScanner">>;
+    putObservabilityScanner(org: string, name: string, scanner: ObsScannerConfig): Promise<Ok<"putObservabilityScanner">>;
+    /** Runs a scanner (the project's, or `scanner`) over a sample; nothing is stored. */
+    testObservabilityScanner(org: string, name: string, text: string, scanner?: ObsScannerConfig): Promise<Ok<"testObservabilityScanner">>;
+    /** The whole ingest configuration, shaped as `.runlot/logs.json`. */
+    exportObservabilityLogsConfig(org: string, name: string): Promise<Ok<"exportObservabilityLogsConfig">>;
+    listObservabilityLogMetrics(org: string, name: string): Promise<Ok<"listObservabilityLogMetrics">>;
+    putObservabilityLogMetric(org: string, name: string, metric: string, def: ObsLogMetric): Promise<Ok<"putObservabilityLogMetric">>;
+    deleteObservabilityLogMetric(org: string, name: string, metric: string): Promise<void>;
+    getErrorEventPII(org: string, name: string, issueId: string, eventId: string): Promise<Ok<"getErrorEvent">>;
+    getErrorSettings(org: string, name: string): Promise<Ok<"getErrorSettings">>;
+    putErrorSettings(org: string, name: string, 
+    /** Omitted writable fields preserve their values; ownership assignment defaults off. */
+    settings: Schemas["ErrorSettingsUpdate"]): Promise<Ok<"putErrorSettings">>;
+    /**
+     * One AI diagnosis of an issue, billed to the org's AI credit. There is no
+     * prompt to pass: the control plane builds it from the issue's stored event.
+     * The same `idempotencyKey` again returns the stored answer without a second
+     * charge, so a caller retrying after a timeout must reuse its key.
+     */
+    diagnoseErrorIssue(org: string, name: string, issueId: string, body: {
+        model: string;
+        idempotencyKey: string;
+    }): Promise<Ok<"diagnoseErrorIssue">>;
+    listErrorDiagnoses(org: string, name: string, issueId: string): Promise<Ok<"listErrorDiagnoses">>;
+    private fixPath;
+    /**
+     * Ask a model to propose a fix for an issue. Billed to the org's AI credit and
+     * writes nothing: the repository, base commit and files are chosen by the control
+     * plane. Reuse `idempotencyKey` on a retry so it is not charged twice.
+     */
+    proposeErrorFix(org: string, name: string, issueId: string, body: {
+        model: string;
+        idempotencyKey: string;
+    }): Promise<Ok<"proposeErrorFix">>;
+    listErrorFixProposals(org: string, name: string, issueId: string): Promise<Ok<"listErrorFixProposals">>;
+    getErrorFixProposal(org: string, name: string, issueId: string, proposalId: string): Promise<Ok<"getErrorFixProposal">>;
+    /**
+     * Write a ready proposal as one commit on its own `runlot/autofix/` branch. It
+     * builds, deploys and merges nothing. `proposalSha` must be the proposal's exactly.
+     */
+    applyErrorFix(org: string, name: string, issueId: string, proposalId: string, proposalSha: string): Promise<Ok<"applyErrorFix">>;
+    lookupErrorFixProposal(org: string, name: string, issueId: string, key: string): Promise<ErrorFixProposal>;
+    lookupErrorFixPreview(org: string, name: string, issueId: string, proposalId: string, key: string): Promise<ErrorFixPreview>;
+    lookupErrorFixVerification(org: string, name: string, issueId: string, proposalId: string, jobId: string, key: string): Promise<ErrorFixPreviewVerification>;
+    approveErrorFixPreview(org: string, name: string, issueId: string, proposalId: string, body: ErrorFixPreviewApproval): Promise<Ok<"approveErrorFixPreview">>;
+    getErrorFixPreview(org: string, name: string, issueId: string, proposalId: string, jobId: string): Promise<Ok<"getErrorFixPreview">>;
+    approveErrorFixPreviewVerification(org: string, name: string, issueId: string, proposalId: string, jobId: string, body: ErrorFixPreviewVerificationApproval): Promise<Ok<"approveErrorFixPreviewVerification">>;
+    /** Erase captured issue data, after explicit review. Admin; unmerge first. */
+    deleteErrorIssue(org: string, name: string, issueId: string): Promise<Ok<"deleteErrorIssue">>;
+    /** Erase an exact application user ID; anonymous aggregates remain. Admin. */
+    eraseErrorUser(org: string, name: string, userId: string): Promise<Ok<"eraseErrorUser">>;
+    /** Untrusted browser histograms and technical-fuse counters, not billed usage. Viewer. */
+    getBrowserTelemetry(org: string, name: string): Promise<Ok<"getBrowserTelemetry">>;
+    /** Unverified feedback whose exact browser error anchor belongs to this issue. Never includes email. */
+    listBrowserFeedback(org: string, name: string, issueId: string): Promise<Ok<"listBrowserFeedback">>;
+    /** Explicit sensitive read. Admin + errors:pii; optional unverified email only while feedback-email retention is on. */
+    listBrowserFeedbackWithPII(org: string, name: string, issueId: string): Promise<Ok<"listBrowserFeedback">>;
+    /** The masked structural replay switch, cap and this month's count. Viewer. */
+    getErrorReplaySettings(org: string, name: string): Promise<Ok<"getErrorReplaySettings">>;
+    /**
+     * Both fields are required: `monthlyCap` null is the plan's amount, `0` stops collection,
+     * `-1` removes the cap (Pro). Admin.
+     */
+    putErrorReplaySettings(org: string, name: string, settings: {
+        enabled: boolean;
+        monthlyCap: number | null;
+    }): Promise<Ok<"putErrorReplaySettings">>;
+    /** An issue's complete masked structural replays. Admin, until a granular PII scope exists. */
+    listErrorReplays(org: string, name: string, issueId: string): Promise<Ok<"listErrorReplays">>;
+    /** One replay and its re-validated batches, for the sandboxed player. Admin. */
+    getErrorReplay(org: string, name: string, issueId: string, replayId: string): Promise<Ok<"getErrorReplay">>;
+    /**
+     * Scheduled runs: what the live deployment declares, when each fires next, and
+     * the recent history (docs/cron.md §8). `limit` bounds the history rows only —
+     * the schedules and the per-schedule last run are never paged.
+     */
+    getProjectCron(org: string, name: string, limit?: number): Promise<Ok<"getProjectCron">>;
+    /**
+     * Queues: what the live deployment declares, how deep each one is, and the
+     * recent batch history (docs/queues.md §6). The depth is read from the
+     * project's own database; `depthError` on the answer says when it could not be.
+     */
+    getProjectQueues(org: string, name: string, limit?: number): Promise<Ok<"getProjectQueues">>;
+    /**
+     * Durable Objects: how many this project has placed, against the two caps
+     * (docs/durable-objects.md).
+     *
+     * **It answers how much, never which.** There is no actor id in the response
+     * and none is coming — those name individual objects, and a list of them would
+     * be an object enumeration wearing a quota's name. `nodes` is keyed by node id
+     * because `nodeLimit` is a separate bound that can refuse a placement while
+     * the project-wide cap still has room.
+     */
+    getProjectDurableObjects(org: string, name: string): Promise<Ok<"getProjectDurableObjects">>;
+    private queuePath;
+    listQueueRuns(org: string, name: string, queue: string, limit?: number): Promise<Ok<"listQueueRuns">>;
+    /** The head of the queue without leasing it — looking cannot delay a delivery. */
+    peekQueue(org: string, name: string, queue: string, limit?: number): Promise<Ok<"peekQueue">>;
+    /** Irreversible. The confirmation is the caller's — the server holds none. */
+    purgeQueue(org: string, name: string, queue: string): Promise<Ok<"purgeQueue">>;
+    /**
+     * Moves a dead-letter queue's messages back. `to` is required only when the
+     * dead-letter queue belongs to more than one consumer, or to none.
+     */
+    redriveQueue(org: string, name: string, queue: string, to?: string): Promise<Ok<"redriveQueue">>;
+    /**
+     * The vector store: every namespace with its count and width, and the plan's
+     * bounds (docs/vectors.md §4). Read from the project's own database;
+     * `readError` on the answer says when it could not be.
+     */
+    getProjectVectors(org: string, name: string): Promise<Ok<"getProjectVectors">>;
+    /** Irreversible. The confirmation is the caller's — the server holds none. */
+    deleteVectorNamespace(org: string, name: string, namespace: string): Promise<Ok<"deleteVectorNamespace">>;
+    /** The body is the bundle. One digest covers all of the code and the assets. */
+    /**
+     * Uploads the bundle. `headers` carries the provenance headers
+     * (`X-Runlot-Git-*`, openapi createDeployment) — the body is the bundle
+     * itself, so the metadata can only travel in headers.
+     */
+    deploy(org: string, name: string, bundle: Uint8Array, headers?: Record<string, string>): Promise<Ok<"createDeployment">>;
+    /**
+     * The same upload, aimed at a preview (docs/preview.md). **It does not move
+     * production's live pointer** — that is the whole difference, and it is why
+     * this is a named method rather than an optional argument on `deploy`: a
+     * caller that forgets the argument deploys to production.
+     *
+     * `db` picks what `env.db` points at (`branch` by default, `shared` at
+     * production's own database, `none` for no database), and `from` pours the
+     * branch from a named generation instead of the newest one.
+     */
+    deployPreview(org: string, name: string, bundle: Uint8Array, opts: {
+        preview: string;
+        db?: string | undefined;
+        from?: string | undefined;
+    }, headers?: Record<string, string>): Promise<DeployedPreview>;
+    /**
+     * Opens an incremental upload (docs/incremental-deploy-upload.md §1.1). `files` is
+     * the bundle's entry list in tar order; the answer names the hashes to upload.
+     * An older CP answers 404 here — the caller falls back to `deploy`.
+     */
+    createDeploymentUpload(org: string, name: string, files: DeploymentUploadEntry[], preview?: PreviewTarget): Promise<DeploymentUpload>;
+    /** One batch: a gzip tar whose entries are named by their content's sha256 (§1.2). */
+    uploadDeploymentBlobs(org: string, name: string, uploadId: string, batch: Uint8Array): Promise<{
+        received: string[];
+        missing: string[];
+    }>;
+    /**
+     * Assembles and deploys the session (§1.3). The answer is `createDeployment`'s
+     * (with `preview` for a preview session). Idempotent per session, so a retry
+     * after an edge timeout returns the same deployment.
+     */
+    commitDeploymentUpload(org: string, name: string, uploadId: string, headers?: Record<string, string>): Promise<DeployedPreview>;
+    /** The parent's live previews (viewer). A deleted preview is not listed. */
+    listPreviews(org: string, name: string): Promise<Ok<"listPreviews">>;
+    /**
+     * Deletes a preview and its branch (member).
+     *
+     * No confirmation string, unlike `deleteProject`: a branch is a copy taken at a
+     * moment and nothing in it is the only copy of anything.
+     */
+    deletePreview(org: string, name: string, preview: string): Promise<void>;
+    /**
+     * Makes the preview's artifact the parent's live deployment (member).
+     *
+     * **The code, never the data** (docs/preview.md §7). The branch is not merged
+     * and production's database is not replaced. The preview stays alive.
+     */
+    promotePreview(org: string, name: string, preview: string): Promise<Ok<"promotePreview">>;
+    /**
+     * The project's share link — `<label>.share.<app-domain>`, the one address
+     * Studio hands to somebody who is not a developer (docs/studio.md §6.9).
+     *
+     * 404 when the project has never been shared: a link is minted by
+     * `putShareLink`, never as a side effect of reading.
+     */
+    getShareLink(org: string, name: string): Promise<Ok<"getShareLink">>;
+    /**
+     * Points the share link at a preview, minting the label if there is none.
+     *
+     * Idempotent: the label is kept across shares, so somebody holding the link
+     * keeps working. `rotate` mints a new label and retires the old name in the
+     * same request ("링크 재발급"), so the project never has two live links.
+     */
+    putShareLink(org: string, name: string, opts?: {
+        preview?: string;
+        rotate?: boolean;
+    }): Promise<Ok<"putShareLink">>;
+    /** Stops the link answering and forgets the label. The preview keeps running. */
+    deleteShareLink(org: string, name: string): Promise<void>;
+    /** Idempotent. Called twice, the password is not rolled and the same connection details come back. */
     createDatabase(org: string, name: string): Promise<Ok<"createDatabase">>;
     getDatabase(org: string, name: string): Promise<Ok<"getDatabase">>;
     /**
-     * 접속 자격까지. `getDatabase` 와 라우트가 갈린 것은 역할 때문이다 —
-     * viewer 는 여부를 알아도 되지만 비밀번호는 아니다 (proto/openapi.yaml).
+     * The connection credentials as well. The route is split from `getDatabase`
+     * because of roles — a viewer may know whether there is a database, but not
+     * the password (proto/openapi.yaml).
      */
     getDatabaseConnect(org: string, name: string): Promise<Ok<"getDatabaseConnect">>;
-    /** 접속 끝점만 — 자격 없음. viewer 도 받는다. `runlot port-forward` 가 쓴다. */
+    /** The endpoint only — no credentials. A viewer gets it too. Used by `runlot port-forward`. */
     getDatabaseEndpoint(org: string, name: string): Promise<Ok<"getDatabaseEndpoint">>;
-    /** 단기 기계 자격 발급. 비밀번호는 이 응답에만 실린다. */
+    /** Issues a short-lived machine credential. The password is carried in this response and nowhere else. */
     createDatabaseToken(org: string, name: string, ttlSeconds?: number): Promise<Ok<"createDatabaseToken">>;
     listDatabaseTokens(org: string, name: string): Promise<Ok<"listDatabaseTokens">>;
     deleteDatabaseToken(org: string, name: string, user: string): Promise<void>;
     /**
-     * 진단 이미지를 하나 만든다.
+     * Makes one diagnostic image.
      *
-     * **멱등이 아니다** — 부를 때마다 이미지가 하나 생긴다. 그리고 느리다:
-     * 응답은 덤프가 끝난 뒤에 오고, 그동안 그 프로젝트의 액터는 붙잡혀 있다
-     * (proto/openapi.yaml).
+     * **Not idempotent** — every call makes another image. And it is slow: the
+     * response comes after the dump finishes, and that project's actor is held
+     * for the whole of it (proto/openapi.yaml).
      */
     exportDatabase(org: string, name: string): Promise<Ok<"exportDatabase">>;
     /**
-     * 복원이 고를 수 있는 세대 전부. 최신 순이고, `lastCheckedAt` 은 무변경
-     * 스킵의 하트비트다 — 세대가 늘지 않는 것과 백업이 죽은 것을 가른다.
+     * Every generation a restore can choose, newest first. `lastCheckedAt` is the
+     * heartbeat of the no-change skip — it is what tells "no new generations"
+     * apart from "the backup is dead".
      */
     listGenerations(org: string, name: string): Promise<Ok<"listGenerations">>;
     /**
-     * 세대로 되돌린다. **그 사이의 쓰기는 사라진다.**
+     * Runs one statement in the project's database (the dashboard console).
      *
-     * 202 로 끝난다 — 돌아오는 것은 연산 id 이고, 진행은
-     * `getDatabaseOperation` 으로 본다. `latest` 는 서버가 풀지 않는다:
-     * 목록에서 고른 `(epoch, seq)` 를 그대로 싣는다 (proto/openapi.yaml).
+     * `readOnly` is **omitted, not sent as false**, when the caller wants the safe
+     * mode: the server treats an absent field as read-only, so leaving it out is the
+     * one spelling that cannot be misread. Sending `false` is the explicit ask for
+     * write mode, and only then does the server run outside a transaction.
+     *
+     * SQL failures arrive as an `ApiError` whose body carries `details.sqlstate` —
+     * PostgreSQL's own code, which is what the error panel shows.
+     */
+    executeSQL(org: string, name: string, sql: string, opts?: {
+        readOnly?: boolean;
+        params?: unknown[];
+    }): Promise<Ok<"executeSQL">>;
+    /**
+     * Rolls back to a generation. **Writes made since then are lost.**
+     *
+     * It ends at 202 — what comes back is an operation id, and progress is read
+     * through `getDatabaseOperation`. The server does not resolve `latest`: the
+     * `(epoch, seq)` chosen from the list is carried as-is (proto/openapi.yaml).
      */
     restoreDatabase(org: string, name: string, epoch: number, seq: number): Promise<Ok<"restoreDatabase">>;
     /**
-     * 데이터베이스를 없앤다. `confirm` 은 프로젝트 이름과 **정확히** 같아야
-     * 하고, 다르면 서버가 400 `confirm_mismatch` 로 거절한다.
+     * Rolls back to a restore point **inside** a backup (pg-feather docs/37):
+     * `txnId` is that commit, `at` is the last commit at or before that time. One
+     * backup carries the commits in between in order, so the place you can roll
+     * back to is not tied to a backup boundary. Everything else is as in
+     * restoreDatabase — 202, an operation id, and one safety backup before the
+     * rollback.
+     */
+    restoreDatabaseTo(org: string, name: string, target: {
+        txnId: number;
+    } | {
+        at: string;
+    }): Promise<Ok<"restoreDatabase">>;
+    /**
+     * Removes the database. `confirm` has to match the project name **exactly**;
+     * if it does not, the server refuses with 400 `confirm_mismatch`.
      */
     deleteDatabase(org: string, name: string, confirm: string): Promise<Ok<"deleteDatabase">>;
-    /** 연산 하나의 진행. 연산 id 는 자격이 아니라 프로젝트 경로 아래에 있다. */
+    /** The progress of one operation. The operation id is not a credential; it lives under the project path. */
     getDatabaseOperation(org: string, name: string, opId: string): Promise<Ok<"getDatabaseOperation">>;
-    /** 되돌릴 수 없는 phase 앞의 연산을 중단한다. */
+    /** Aborts an operation that has not yet reached a phase it cannot come back from. */
     abortDatabaseOperation(org: string, name: string, opId: string): Promise<Ok<"abortDatabaseOperation">>;
     /**
-     * 로그 라이브 테일. **JSON 이 아니라 스트림**이라 `request` 를 안 지난다 —
-     * 돌려주는 것은 줄 단위 `LogEvent` 의 async iterable 이고, `signal` 을 abort
-     * 하면 연결이 끊긴다. 오류 응답(4xx/5xx)은 다른 메서드와 같은 `ApiError` 다.
+     * A live tail of the logs. It is **a stream, not JSON**, so it does not go
+     * through `request` — what comes back is an async iterable of line-by-line
+     * `LogEvent`, and aborting `signal` closes the connection. An error response
+     * (4xx/5xx) is the same `ApiError` as in every other method.
      */
     tailLogs(org: string, name: string, opts?: {
         tail?: number;
         follow?: boolean;
         signal?: AbortSignal;
-    }): AsyncGenerator<LogEvent, void, undefined>;
+    } & LogTailFilter): AsyncGenerator<LogEvent, void, undefined>;
+    /**
+     * The live tail as `LogRecord`s — the stored event's shape (`--format json`).
+     * Pings and the end event still arrive as `LogEvent`s.
+     */
+    tailLogRecords(org: string, name: string, opts?: {
+        tail?: number;
+        follow?: boolean;
+        signal?: AbortSignal;
+    } & LogTailFilter): AsyncGenerator<LogRecord | LogEvent, void, undefined>;
+    private tailStream;
+    /**
+     * The stored lane (0062). It is a plain JSON page, not a stream: the history
+     * does not reach a node, so it answers for a project that is cold, parked, or
+     * has moved since the lines were written — every one of which is a 409 on
+     * `tailLogs`.
+     *
+     * `q` is a plain substring, matched case-insensitively. It is not a regular
+     * expression — `%` and `_` match themselves.
+     *
+     * Paging is keyset: pass the `cursor` from a page back to get the next, older
+     * one. A page with no `cursor` is the end of what is kept.
+     */
+    getLogHistory(org: string, name: string, opts?: {
+        since?: string | undefined;
+        until?: string | undefined;
+        q?: string | undefined;
+        stream?: "stdout" | "stderr" | "runlot" | undefined;
+        limit?: number | undefined;
+        cursor?: string | undefined;
+    }): Promise<LogHistoryPage>;
     listSecrets(org: string, name: string): Promise<Ok<"listSecrets">>;
-    /** 값은 이 호출로만 나간다. 어떤 응답에도 값은 없다. */
+    /** The value travels in this call only. It is in no response at all. */
     setSecret(org: string, name: string, secret: string, value: string): Promise<Ok<"setSecret">>;
     deleteSecret(org: string, name: string, secret: string): Promise<void>;
     getUsage(org: string, name: string, hours?: number): Promise<Ok<"getUsage">>;
-    /** 부여 여부·접두·쿼터·사용량. `usedBytes` 는 노드 보고 주기만큼 늦다. */
+    /** Grant, prefix, quota, usage. `usedBytes` lags by the node's reporting interval. */
     getStorage(org: string, name: string): Promise<Ok<"getStorage">>;
     /**
-     * 스토리지를 부여한다. 멱등이라 두 번 눌러도 접두는 그대로다. 접두·쿼터를
-     * 인자로 받지 않는 것이 요점이다 — 접두는 격리의 경계이고 쿼터는 요금제가
-     * 정한다 (proto/openapi.yaml).
+     * Grants storage. It is idempotent, so pressing twice leaves the prefix as it
+     * was. Taking neither the prefix nor the quota as an argument is the point —
+     * the prefix is the isolation boundary and the quota is set by the plan
+     * (proto/openapi.yaml).
      */
     grantStorage(org: string, name: string): Promise<Ok<"grantStorage">>;
-    /** 부여를 뗀다. **객체는 지워지지 않는다** (docs/storage.md §7). */
+    /** Removes the grant. **The objects are not deleted** (docs/storage.md §7). */
     revokeStorage(org: string, name: string): Promise<void>;
     /**
-     * 부여 여부·설정·프로바이더·호스트. **가입자는 안 온다** — 그 표는 프로젝트
-     * DB 안이고 (docs/auth.md §6) 워커의 `env.auth` 만 본다.
+     * The key prefixes this project serves unsigned (docs/storage.md §4.7).
      *
-     * `providers` 에는 client id 만 있다. 클라이언트 시크릿은 봉인돼 어느
-     * 응답에도 안 나온다.
+     * A prefix is stored normalized — `assets` becomes `assets/`, and `/` becomes
+     * the empty string, which means every key. The value that comes back is the
+     * value that governs, so a screen must render the response rather than what
+     * the user typed.
      */
-    getAuth(org: string, name: string): Promise<Ok<"getAuth">>;
+    listStoragePublic(org: string, name: string): Promise<Ok<"listStoragePublic">>;
+    /** Publishes a prefix. Idempotent. All three verbs answer with the whole list. */
+    addStoragePublic(org: string, name: string, prefix: string): Promise<Ok<"addStoragePublic">>;
     /**
-     * 인증을 켠다 (member). 멱등이다.
+     * Unpublishes a prefix. Idempotent.
      *
-     * **데이터베이스가 없으면 409 `database_required`** 다 — 가입자 표가
-     * 프로젝트 DB 안이라 부여만 세우면 워커가 뜨는 순간 표가 없다. 부르는 쪽은
-     * 그 코드를 잡아 `runlot pg create` 를 안내한다.
+     * **The world keeps reading for up to a minute.** The object front caches the
+     * list, so this call is not a revocation that takes effect at the instant it
+     * returns — a screen that says "no longer public" the moment this resolves is
+     * telling a small lie.
      */
-    grantAuth(org: string, name: string): Promise<Ok<"grantAuth">>;
+    removeStoragePublic(org: string, name: string, prefix: string): Promise<Ok<"removeStoragePublic">>;
     /**
-     * 설정을 바꾼다 (member). **부분 갱신이다** — 준 칸만 바뀐다. 스위치 하나에
-     * 전체를 실어 보내면 두 사람이 같은 카드를 만질 때 나중 저장이 앞 저장을
-     * 덮는다. 부여가 없으면 404 `not_granted`.
+     * One page of objects grouped by `/` (`runlot storage ls`). `prefixes` are the
+     * folders one level down; feed `cursor` back unchanged, its absence is the end.
      */
-    updateAuthSettings(org: string, name: string, settings: AuthSettingsInput): Promise<Ok<"updateAuthSettings">>;
+    listStorageObjects(org: string, name: string, opts?: {
+        prefix?: string;
+        cursor?: string;
+        limit?: number;
+    }): Promise<Ok<"listStorageObjects">>;
     /**
-     * 인증을 해제한다 (admin). **가입자는 안 지워진다** — `runlot_auth` 의 표는
-     * 프로젝트 DB 에 남고, 다시 켜면 같은 사람들이 그대로 로그인한다.
+     * A five-minute signed GET for one object (`runlot storage download`). The key's
+     * `/` segments stay in the path; each segment is encoded on its own.
+     */
+    signStorageObject(org: string, name: string, key: string): Promise<Ok<"signStorageObject">>;
+    /** Grant, address, sender, limits, recent counts. The address comes back as a preview even without a grant. */
+    getEmail(org: string, name: string): Promise<Ok<"getEmail">>;
+    /** Turns it on. **Idempotent** — we choose the address. The deploy reads `"email": true` and calls this. */
+    grantEmail(org: string, name: string): Promise<Ok<"grantEmail">>;
+    /** Turns it off. Mail arriving at that address now gets a 550. */
+    revokeEmail(org: string, name: string): Promise<void>;
+    /** The project's own sending domains, each with the records to publish. */
+    listEmailDomains(org: string, name: string): Promise<Ok<"listEmailDomains">>;
+    /**
+     * Creates the provider identity and answers with the records to publish.
+     * `publish` writes them into the zone when we host one covering the domain.
+     */
+    addEmailDomain(org: string, name: string, domain: string, publish?: boolean): Promise<Ok<"addEmailDomain">>;
+    /** Re-checks now. The background loop does the same once a minute while pending. */
+    verifyEmailDomain(org: string, name: string, domain: string): Promise<Ok<"verifyEmailDomain">>;
+    /** Deletes the identity and the row. Sending from it is refused from the next convergence. */
+    removeEmailDomain(org: string, name: string, domain: string): Promise<void>;
+    /**
+     * The model catalogue. **Being logged in is enough to see it** — what you can
+     * buy is not an organization's secret, and this list is the price table.
+     *
+     * Prices are integer **micro-cents** per million tokens (1 µ¢ = 1e-8 USD).
+     * Not letting the server pick the decimal place is the point — a small call
+     * rounded to cents becomes 0.
+     */
+    listAIModels(): Promise<Ok<"listAIModels">>;
+    /** Grant, limits, the org balance, 24 h usage. The limits come back as a preview even without a grant. */
+    getAI(org: string, name: string): Promise<Ok<"getAI">>;
+    /** Turns it on. **Idempotent.** The deploy reads `"ai": true` and calls this. */
+    grantAI(org: string, name: string): Promise<Ok<"grantAI">>;
+    /**
+     * Lends the org's own Claude/Codex subscriptions to this project's
+     * `anthropic/*` and `openai/*` calls (docs/studio-byos-ai.md §3.1).
+     *
+     * **Omitting a field leaves it as it was**, so turning lending on does not
+     * clear a fallback that was already set. Admin only: the subscription that
+     * carries the vendor-terms risk belongs to a person, not to the org.
+     */
+    patchAI(org: string, name: string, body: {
+        byos?: boolean;
+        byosCreditFallback?: boolean;
+    }): Promise<Ok<"patchAI">>;
+    /** Turns it off. **The ledger and the balance are untouched** — the balance belongs to the org and the grant belongs to the project. */
+    revokeAI(org: string, name: string): Promise<void>;
+    /** The org's credit balance and its automatic top-up settings. The balance is in micro-cents and can be negative. */
+    getAICredit(org: string): Promise<Ok<"getAICredit">>;
+    /**
+     * One page of this project's AI calls, newest first (docs/ai-observability.md §6.1).
+     * `before` is the previous page's opaque `nextBefore`.
+     */
+    listAICalls(org: string, name: string, opts?: {
+        from?: string;
+        to?: string;
+        model?: string;
+        op?: "run" | "embed" | "judge";
+        lane?: "credit" | "byos" | "none";
+        byos?: "served" | "fellBack" | "refused" | "attempted";
+        status?: "ok" | "error";
+        sessionId?: string;
+        userId?: string;
+        requestId?: string;
+        tag?: string;
+        before?: string;
+        limit?: number;
+    }): Promise<Ok<"listAICalls">>;
+    /** One AI call; the input and output ride only for a reader with observability:pii. */
+    getAICall(org: string, name: string, callId: string): Promise<Ok<"getAICall">>;
+    /** AI calls over time, by model, and the reasons lending did not serve (§6.3). */
+    getAISummary(org: string, name: string, opts?: {
+        from?: string;
+        to?: string;
+    }): Promise<Ok<"getAISummary">>;
+    /** AI calls grouped by the app's `metadata.sessionId` (§6.4). */
+    listAISessions(org: string, name: string, opts?: {
+        from?: string;
+        to?: string;
+        before?: string;
+        limit?: number;
+    }): Promise<Ok<"listAISessions">>;
+    /** The org members' desktops that can lend to this project right now (§6.5). */
+    getAILenders(org: string, name: string): Promise<Ok<"getAILenders">>;
+    /** Whether this project records prompts and answers (§5). */
+    getAICapture(org: string, name: string): Promise<Ok<"getAICapture">>;
+    /** Turns prompt capture on or off. observability:admin; audited. */
+    setAICapture(org: string, name: string, captureBodies: boolean): Promise<Ok<"setAICapture">>;
+    /** One page of the org ledger. The cursor is `ledger_id` — cutting on time splits the same millisecond. */
+    listAILedger(org: string, opts?: {
+        limit?: number;
+        before?: number;
+        kind?: "call" | "topup" | "adjust";
+        since?: string;
+    }): Promise<Ok<"listAILedger">>;
+    /**
+     * The credit top-up checkout. **A browser coming back is not evidence** — the
+     * one thing that raises the balance is the `order.paid` webhook, and the
+     * screen polls the balance after the success event.
+     */
+    createAICreditCheckout(org: string, microCents: number, returnTo: string): Promise<Ok<"createAICreditCheckout">>;
+    /**
+     * Turns automatic top-up on or off. **Turning it on is explicit consent**
+     * (docs/ai.md §3.5) — the screen shows the charging terms verbatim and calls
+     * this only after the box is checked.
+     */
+    setAIAutoTopup(org: string, body: {
+        enabled: boolean;
+        belowMicroCents?: number;
+        microCents?: number;
+    }): Promise<Ok<"setAIAutoTopup"> | void>;
+    /** One page of the mail log (docs/email.md §6.1). Newest first, cursor-paged. */
+    listMailLog(org: string, name: string, opts?: {
+        direction?: "in" | "out";
+        cursor?: string;
+        limit?: number;
+    }): Promise<Ok<"listMailLog">>;
+    /** The metadata of one message. */
+    getMailLog(org: string, name: string, mailId: string): Promise<Ok<"getMailLog">>;
+    /** The URL of the raw message — the screen uses it as a download link (.eml). */
+    mailLogRawURL(org: string, name: string, mailId: string): string;
+    /** The raw text. What the detail view draws the headers and body from. */
+    getMailLogRaw(org: string, name: string, mailId: string): Promise<string>;
+    /**
+     * Grant, settings, providers, hosts. **The signed-up users do not come** —
+     * that table is inside the project DB (docs/auth.md §6) and only the worker's
+     * `env.auth` sees it.
+     *
+     * `providers` carries the client id only. The client secret is sealed and
+     * appears in no response.
+     */
+    getAuth(org: string, name: string): Promise<AuthStatus>;
+    /**
+     * Turns auth on (member). Idempotent.
+     *
+     * **With no database it is 409 `database_required`** — the user table lives
+     * inside the project DB, so standing up the grant alone leaves no table the
+     * moment the worker starts. The caller catches that code and points at the
+     * `"database": true` declaration — the deploy never sees this code, because
+     * its ordering rules it out.
+     */
+    grantAuth(org: string, name: string): Promise<AuthStatus>;
+    /**
+     * The app's end users, newest first (`runlot auth users`). Read-only, and read
+     * from the project's own database — a parked or unreachable one answers 502/504.
+     * Feed `cursor` back unchanged; its absence is the end.
+     */
+    listAppUsers(org: string, name: string, opts?: {
+        search?: string;
+        cursor?: string;
+        limit?: number;
+    }): Promise<Ok<"listAppUsers">>;
+    /**
+     * One `env.ai.run` on the development lane: catalog models, the free plan's caps,
+     * the org's credit, recorded as `lane = dev`. One JSON answer, no streaming.
+     */
+    devAIRun(org: string, name: string, body: DevAIRunRequest): Promise<Ok<"devAIRun">>;
+    /**
+     * Changes the settings (member). **A partial update** — only the fields given
+     * change. Sending the whole thing on one switch means that when two people
+     * touch the same card, the later save overwrites the earlier one. With no
+     * grant it is 404 `not_granted`.
+     */
+    updateAuthSettings(org: string, name: string, settings: AuthSettingsInput): Promise<AuthStatus>;
+    /**
+     * Turns auth off (admin). **The signed-up users are not deleted** — the
+     * `runlot_auth` tables stay in the project DB, and turning it back on lets the
+     * same people log in unchanged.
      */
     revokeAuth(org: string, name: string): Promise<void>;
     /**
-     * 소셜 프로바이더를 등록하거나 교체한다 (admin). 같은 PUT 이라 멱등이다.
+     * Registers or replaces a social provider (admin). It is the same PUT, so it
+     * is idempotent.
      *
-     * **`clientSecret` 은 다시 볼 수 없다.** 콜백 URL 은 호스트마다
-     * `https://<host>/__runlot/auth/callback/<provider>` 이고, 호스트 목록은
-     * 응답의 `hosts` 에 있다.
+     * **`clientSecret` cannot be read back.** The callback URL is
+     * `https://<host>/__runlot/auth/callback/<provider>` for each host, and the
+     * list of hosts is in the response's `hosts`.
+     *
+     * `issuer` is the base URL of your own GitHub Enterprise Server installation,
+     * and only `github` takes one. **This PUT is the whole row** — the same reason
+     * `clientSecret` has to be sent every time — so an empty string clears it and
+     * puts that provider back on github.com. The key is left out entirely when the
+     * argument is omitted, so a caller that does not know about issuers sends the
+     * body it always sent.
+     */
+    setAuthProvider(org: string, name: string, provider: AuthProvider, clientId: string, clientSecret: string, issuer?: string): Promise<AuthStatus>;
+    /**
+     * Turns on the Runlot provider (admin): "Continue with Runlot", with email,
+     * Google and GitHub at Runlot behind it and nothing to register. 409
+     * `runlot_unavailable` when this deployment has no sign-in broker.
+     */
+    setRunlotAuthProvider(org: string, name: string): Promise<AuthStatus>;
+    /**
+     * Registers or replaces a generic OIDC provider under a project-chosen id
+     * (admin). The CP reads `<issuer>/.well-known/openid-configuration` when
+     * saving; a failure is 400 `oidc_discovery_failed` quoting the provider.
+     */
+    setOidcAuthProvider(org: string, name: string, id: string, body: {
+        issuer: string;
+        clientId: string;
+        clientSecret: string;
+        displayName?: string;
+        iconUrl?: string;
+        scopes?: string;
+    }): Promise<AuthStatus>;
+    /**
+     * The statements that create the `runlot_auth` schema (member). 404 when
+     * login is not turned on for the project.
+     */
+    getAuthSchema(org: string, name: string): Promise<AuthSchema>;
+    /** The project's sign-in branding with defaults filled (docs/custom-sign-in.md §12.3). */
+    getAuthBranding(org: string, name: string): Promise<AuthBranding>;
+    /** The GET answer whole: the filled brand plus the methods the chooser would draw now. */
+    getAuthBrandingAnswer(org: string, name: string): Promise<AuthBrandingAnswer>;
+    /**
+     * Replaces the whole branding object (member). Validated server-side; a bad
+     * field is 400 `invalid_branding` with `fields: [{path, message}]`.
+     */
+    putAuthBranding(org: string, name: string, branding: Partial<AuthBranding>): Promise<AuthBranding>;
+    /**
+     * The URL of the rendered chooser with (draft) branding (§12.4). A page, not
+     * JSON: the dashboard puts it in an iframe and the CLI opens it in a browser.
+     * `draft` travels as base64url JSON.
      */
-    setAuthProvider(org: string, name: string, provider: AuthProvider, clientId: string, clientSecret: string): Promise<Ok<"setAuthProvider">>;
+    authBrandingPreviewUrl(org: string, name: string, opts?: AuthPreviewOpts): string;
+    /** Sign-in funnel counters for the last `days` days (§9.4). No per-person data. */
+    getAuthFunnel(org: string, name: string, days?: number): Promise<AuthFunnel>;
     /**
-     * 프로바이더를 뗀다 (admin). 그 프로바이더로만 가입한 사람은 로그인할 길을
-     * 잃지만 사용자 행은 남는다 — 다시 등록하면 같은 계정으로 돌아온다.
+     * Removes a provider (admin). Someone who signed up only through that provider
+     * loses their way in, but the user row stays — register it again and they come
+     * back to the same account.
      */
     deleteAuthProvider(org: string, name: string, provider: AuthProvider): Promise<void>;
     /**
-     * 이 배포에 누가 닿을 수 있는가. **값은 없다** — 비밀번호도 우회 시크릿도
-     * 해시로만 살고, 여기 오는 것은 `hasPassword`·`hasBypass` 라는 사실이다.
+     * Who can reach this deployment. **No values** — both the password and the
+     * bypass secret live only as hashes, and what comes back here is the fact that
+     * there is one: `hasPassword` and `hasBypass`.
      *
-     * 정책을 한 번도 안 정한 프로젝트는 `mode: "public"` 에 `updatedAt` 이
-     * 없다. 화면이 그 둘을 가르는 이유는 §7 — 빈 상태 대신 상태 문장이다.
+     * A project that has never set a policy is `mode: "public"` with no
+     * `updatedAt`. The screen tells those two apart for the reason in §7 — a
+     * sentence about the state instead of an empty state.
      */
     getAccess(org: string, name: string): Promise<Ok<"getAccess">>;
     /**
-     * 정책을 바꾼다 (admin). `password` 를 안 보내면 **있던 비밀번호가 남는다** —
-     * 모드만 바꾸는 저장이 비밀번호를 지우면 되돌아왔을 때 다시 정해야 한다.
+     * Changes the policy (admin). Without a `password`, **the existing password
+     * stays** — if a save that only changes the mode wiped the password, coming
+     * back to that mode would mean setting it again.
      */
     setAccess(org: string, name: string, mode: AccessMode, password?: string): Promise<Ok<"setAccess">>;
     /**
-     * 자동화 우회 시크릿을 만든다 (admin). **값은 이 답에만 있다** — 화면은
-     * 받은 즉시 한 번 보여주고 다시 못 가져온다. 다시 부르면 옛 값이 죽는다.
+     * Makes a bypass secret for automation (admin). **The value is in this answer
+     * and nowhere else** — the screen shows it once on arrival and can never fetch
+     * it again. Calling again kills the old value.
      */
     newAccessBypass(org: string, name: string): Promise<Ok<"newAccessBypass">>;
-    /** 우회를 뗀다 (admin). 없는 우회를 떼는 것도 성공이다. */
+    /** Removes the bypass (admin). Removing one that does not exist also succeeds. */
     revokeAccessBypass(org: string, name: string): Promise<void>;
     /**
-     * 보호된 배포로 돌아가는 1 회용 주소를 받는다 (docs/access.md §3.4-3).
+     * Gets a one-time address back into a protected deployment (docs/access.md §3.4-3).
      *
-     * 프로젝트 경로 아래가 **아니다**: 부르는 화면이 아는 것은 호스트네임뿐이고
-     * (원 요청이 그리로 갔다), org·프로젝트 이름은 서버가 그것에서 유도한다.
-     * 받은 `redirect` 로 `location.replace` 하는 것이 호출부의 일이다.
+     * It is **not** under the project path: all the calling screen knows is the
+     * hostname (the original request went there), and the server derives the org
+     * and project names from it. Doing `location.replace` with the `redirect` that
+     * comes back is the caller's job.
      */
     authorizeAccess(to: string, next?: string): Promise<Ok<"authorizeAccess">>;
     listMembers(org: string): Promise<Ok<"listMembers">>;
-    /** 초대가 아니다 — 사용자는 이미 한 번 로그인해 있어야 한다 (404 `user_not_found`). */
+    /** This is not an invite — the user must already have logged in once (404 `user_not_found`). */
     addMember(org: string, provider: "dev" | "github", subject: string, role: Role): Promise<Ok<"addMember">>;
     setMemberRole(org: string, userId: string, role: Role): Promise<Ok<"setMemberRole">>;
+    /**
+     * Removing someone else is admin; **removing yourself is leaving**, which
+     * anyone can do (docs/members.md). The last admin can do neither
+     * (409 `last_admin`).
+     */
     removeMember(org: string, userId: string): Promise<void>;
-    /** 기본 호스트네임과 커스텀 도메인이 함께 온다 (viewer). */
+    /** Pending and expired invites (admin). Accepted and revoked ones are history, so they do not come. */
+    listInvites(org: string): Promise<Ok<"listInvites">>;
+    /**
+     * Invites by email (admin). **Calling again with the same address is a
+     * resend** — the same row is updated rather than a new one created, and the
+     * server gives 200 instead of 201.
+     */
+    createInvite(org: string, email: string, role: Role): Promise<Ok<"createInvite">>;
+    /** Revokes an invite (admin). Mail that has not gone out yet does not go out. */
+    revokeInvite(org: string, inviteId: string): Promise<void>;
+    /**
+     * A preview of the invite. **No session needed** — whoever got the link has
+     * not logged in yet, and they need to know what they are accepting before
+     * they do.
+     */
+    getInvite(token: string): Promise<Ok<"getInvite">>;
+    /** Accepts (login required). If they are already a member the role does not change. */
+    acceptInvite(token: string): Promise<Ok<"acceptInvite">>;
+    /** The default hostname and the custom domains come together (viewer). */
     listHostnames(org: string, name: string): Promise<Ok<"listHostnames">>;
     /**
-     * 커스텀 도메인을 건다 (member).
+     * Attaches a custom domain (member).
      *
-     * 멱등이다 — 같은 이름을 다시 보내면 있던 행이 그대로 온다. 응답의 `verify`
-     * 가 고객이 넣어야 하는 CNAME·TXT 다.
+     * Idempotent — sending the same name again returns the existing row
+     * unchanged. The response's `verify` is the CNAME and TXT the customer has to
+     * add.
      */
-    addHostname(org: string, name: string, hostname: string): Promise<Ok<"addHostname">>;
-    /** 배경 검증과 같은 판정을 즉시 부른다 (member). */
+    addHostname(org: string, name: string, hostname: string, role?: "app" | "login"): Promise<Ok<"addHostname">>;
+    /** Runs the same check the background verifier makes, right now (member). */
     verifyHostname(org: string, name: string, host: string): Promise<Ok<"verifyHostname">>;
-    /** 커스텀 도메인을 뗀다 (member). 기본 호스트네임은 400 이다. */
+    /** Detaches a custom domain (member). The default hostname gives a 400. */
     deleteHostname(org: string, name: string, host: string): Promise<void>;
-    /** 이 조직의 존 목록. `rrsets` 는 없다 — 단건 조회에만 실려요. */
+    /** The organization's zones. No `rrsets` — those ride only on a single-zone lookup. */
     listZones(org: string): Promise<Ok<"listZones">>;
-    /** 멱등이에요. 이미 있는 존은 그대로 돌아와요. */
+    /** Idempotent. A zone that already exists comes back unchanged. */
     createZone(org: string, name: string): Promise<Ok<"createZone">>;
     getZone(org: string, zone: string): Promise<Ok<"getZone">>;
     deleteZone(org: string, zone: string): Promise<void>;
     /**
-     * rrset 하나를 **통째로** 바꿔요. `records` 가 그 (이름, 타입) 의 새 전부라,
-     * 값 하나를 더하려면 지금 값을 함께 보내야 해요.
+     * Replaces one rrset **whole**. `records` is the complete new set for that
+     * (name, type), so adding a single value means sending the current ones with
+     * it.
      */
     putRRset(org: string, zone: string, name: string, type: RRsetType, ttl: number, records: string[]): Promise<Ok<"putRRset">>;
     deleteRRset(org: string, zone: string, name: string, type: RRsetType): Promise<void>;
     setZoneDNSSEC(org: string, zone: string, enabled: boolean): Promise<Ok<"setZoneDNSSEC">>;
     setZoneDS(org: string, zone: string, ds: string[]): Promise<Ok<"setZoneDS">>;
-    /** DNS 표면의 공통 접두. */
+    /** The shared prefix of the DNS surface. */
     private dnsPath;
-    /** `@` 도 `*` 도 이름으로 와요. 네 군데에 같은 문자열을 적지 않아요. */
+    /** Both `@` and `*` arrive as a name. Keeps the same string out of four places. */
     private rrsetPath;
     /**
-     * 이름을 찾아본다 (member 이상).
+     * Looks a name up (member or above).
      *
-     * `priceCents` 는 첫 등록 1 년, `renewalCents` 는 갱신 1 년이다. 둘이
-     * 나뉘어 있는 이유는 첫해 할인이 흔해서다 — 하나로 접으면 "1 달러에 사서
-     * 다음 해 15 달러" 를 화면이 말할 수 없다.
+     * `priceCents` is the first year of registration; `renewalCents` is one year
+     * of renewal. They are separate because a first-year discount is common —
+     * folded into one, the screen cannot say "buy it for $1, then $15 next year".
      */
     checkDomains(org: string, names: string[]): Promise<Ok<"checkDomains">>;
     /**
-     * 도메인을 산다 (admin — 돈을 써요).
+     * Buys a domain (admin — this spends money).
      *
-     * **ICANN 검증 메일이 `contact.email` 로 가요.** 화면은 사기 전에 그
-     * 사실을 알려야 해요 (docs/domains.md §5.5).
+     * **Payment comes first** (docs/domains.md §5.8). With a saved payment method
+     * the answer is the registered domain; otherwise a `DomainCharge` whose
+     * `checkoutUrl` is where to pay — follow it with `getDomainCharge`. Paying also
+     * agrees to the automatic yearly renewal charge.
      *
-     * 같은 요청을 다시 보내는 것이 안전해요 — 끝난 도메인이면 그대로 오고,
-     * 중간에 멈춘 구매면 그 자리에서 이어 가요.
+     * **The ICANN verification mail goes to `contact.email`.** The screen has to
+     * say so before the purchase (docs/domains.md §5.5).
      */
     purchaseDomain(org: string, body: {
         name: string;
         years?: number;
         contact: DomainContact;
         projectId?: string;
-    }): Promise<Ok<"purchaseDomain">>;
-    /** 이미 가진 도메인을 가져와요 (admin). 등록기관을 부르지 않고 존만 만들어요. */
+        checkout?: boolean;
+        returnTo?: string;
+    }): Promise<Domain | DomainCharge>;
+    /** One domain payment — how a `DomainCharge` from purchase or renewal is followed. */
+    getDomainCharge(org: string, chargeId: string): Promise<Ok<"getDomainCharge">>;
+    /** Domain payments, newest first. */
+    listDomainCharges(org: string): Promise<Ok<"listDomainCharges">>;
+    /** Imports a domain you already own (admin). Creates the zone only; the registrar is not called. */
     importDomain(org: string, name: string): Promise<Ok<"importDomain">>;
     listDomains(org: string): Promise<Ok<"listDomains">>;
     getDomain(org: string, name: string): Promise<Ok<"getDomain">>;
-    renewDomain(org: string, name: string, years: number): Promise<Ok<"renewDomain">>;
+    /** Renews now, paid the same way as a purchase. */
+    renewDomain(org: string, name: string, years: number, pay?: {
+        checkout?: boolean;
+        returnTo?: string;
+    }): Promise<Domain | DomainCharge>;
     /**
-     * 자동 갱신 **의사**만 바꿔요.
-     *
-     * 등록기관 쪽 자동 갱신은 그대로 켜져 있어요 — 도메인은 하루 늦으면 잃는
-     * 자산이라 우리가 먼저 갱신하고 뒤에 청구해요. 화면은 이 사실을 함께
-     * 말해야 해요.
+     * Turns automatic renewal on or off. On: one year is charged 30 days before
+     * expiry. Off: nothing is charged and the domain lapses at expiry.
      */
     setDomainAutoRenew(org: string, name: string, enabled: boolean): Promise<Ok<"setDomainAutoRenew">>;
     setDomainLock(org: string, name: string, locked: boolean): Promise<Ok<"setDomainLock">>;
-    /** 이전 코드예요. 감사에 발급 사실이 남고 **코드는 남지 않아요**. */
+    /** The transfer auth code. The audit records that one was issued and **not the code itself**. */
     domainAuthCode(org: string, name: string): Promise<Ok<"getDomainAuthCode">>;
-    /** 지금 등록기관에서 다시 읽어요 (member). */
+    /** Re-reads from the registrar right now (member). */
     syncDomain(org: string, name: string): Promise<Ok<"syncDomain">>;
-    /** 도메인 표면의 공통 접두. 열 군데에 같은 문자열을 적지 않아요. */
+    /** The shared prefix of the domain surface. Keeps the same string out of ten places. */
     private domainsPath;
     private domainPath;
-    /** 프로젝트 표면의 공통 접두다. */
+    /** The shared prefix of the project surface. */
     private projectPath;
-    /** 데이터베이스 표면의 공통 접두다. 다섯 군데에 같은 문자열을 적지 않는다. */
+    /** The shared prefix of the database surface. Keeps the same string out of five places. */
     private dbPath;
+    listRepos(org: string, project: string): Promise<Ok<"listRepos">>;
+    createRepo(org: string, project: string, body: {
+        name: string;
+        visibility?: RepoVisibility | undefined;
+        defaultBranch?: string | undefined;
+    }): Promise<Ok<"createRepo">>;
+    getRepo(org: string, project: string, name: string): Promise<Ok<"getRepo">>;
+    updateRepo(org: string, project: string, name: string, body: {
+        name?: string | undefined;
+        visibility?: RepoVisibility | undefined;
+        defaultBranch?: string | undefined;
+    }): Promise<void>;
+    deleteRepo(org: string, project: string, name: string): Promise<void>;
+    /** The ref history. The lead for recovering a commit lost to a force-push is here. */
+    listRefUpdates(org: string, project: string, name: string): Promise<Ok<"listRefUpdates">>;
+    getDeployHook(org: string, project: string, name: string): Promise<Ok<"getDeployHook">>;
+    setDeployHook(org: string, project: string, name: string, body: {
+        enabled?: boolean | undefined;
+        branch?: string | undefined;
+        rootDir?: string | undefined;
+    }): Promise<Ok<"setDeployHook">>;
+    deleteDeployHook(org: string, project: string, name: string): Promise<void>;
+    /** Build a commit without pushing. Omit `commitSha` for the hooked branch's tip. */
+    deployRepoNow(org: string, project: string, name: string, commitSha?: string): Promise<Ok<"deployRepoNow">>;
+    listBuilds(org: string, project: string, limit?: number): Promise<Ok<"listBuilds">>;
+    getBuild(org: string, project: string, buildId: string): Promise<Ok<"getBuild">>;
+    /**
+     * A build's output. It comes back as **text**, not JSON — see the endpoint's
+     * description. `json()` would try to parse it and fail on the first line.
+     */
+    getBuildLog(org: string, project: string, buildId: string): Promise<string>;
+    cancelBuild(org: string, project: string, buildId: string): Promise<void>;
+    listSSHKeys(): Promise<Ok<"listSSHKeys">>;
+    addSSHKey(publicKey: string, name?: string): Promise<Ok<"addSSHKey">>;
+    deleteSSHKey(keyId: string): Promise<void>;
+    listAccessTokens(): Promise<Ok<"listAccessTokens">>;
+    /** The plaintext is carried in this response **once** and never again. */
+    createAccessToken(body: {
+        name: string;
+        /** 0032's single-valued field. `scopes` is the one to send. */
+        scope?: TokenScope | undefined;
+        scopes?: readonly ApiScope[] | undefined;
+        /** Restrict the token to one org, and optionally to one project inside it. */
+        org?: string | undefined;
+        project?: string | undefined;
+        ttlHours?: number | undefined;
+        /** Days until expiry. The server defaults to 90 and refuses more than 365. */
+        expiresInDays?: number | undefined;
+        noExpiry?: boolean | undefined;
+    }): Promise<Ok<"createAccessToken">>;
+    revokeAccessToken(tokenId: string): Promise<void>;
+    getRepoRefs(org: string, project: string, name: string): Promise<Ok<"getRepoRefs">>;
+    getRepoTree(org: string, project: string, name: string, ref?: string, path?: string): Promise<Ok<"getRepoTree">>;
+    getRepoBlob(org: string, project: string, name: string, ref?: string, path?: string): Promise<Ok<"getRepoBlob">>;
+    getRepoCommits(org: string, project: string, name: string, ref?: string, limit?: number): Promise<Ok<"getRepoCommits">>;
+    /** The shared prefix of the repository surface. It sits under the project (§19). */
+    private repoPath;
     rollback(org: string, name: string, version: number): Promise<Ok<"rollback">>;
 }
+/** A metric read's range (customer-observability.md §8). */
+export type ObsRangeQuery = {
+    from?: string;
+    to?: string;
+    step?: string;
+};
+/** RED filters shared by the overview and the APM routes. */
+export type ObsRedQuery = {
+    version?: number;
+    handler?: string;
+    route?: string;
+    synthetic?: "exclude" | "include" | "only";
+};
+export type ObsMetricsOverview = components["schemas"]["ObsMetricsOverview"];
+export type ObsAPMRoutes = components["schemas"]["ObsAPMRoutes"];
+export type ObsTrace = components["schemas"]["ObsTrace"];
+export type ObsTraceFilter = components["schemas"]["ObsTraceFilter"];
+export type ReleaseIssuePage = components["schemas"]["ReleaseIssuePage"];
+export type ReleaseIssueTransition = components["schemas"]["ReleaseIssueTransition"];
+export type ReleaseHealthSummary = components["schemas"]["ReleaseHealthSummary"];
+export type ReleaseHealthRelease = components["schemas"]["ReleaseHealthRelease"];
 //# sourceMappingURL=index.d.ts.map