@layers/amba 1.1.0 → 4.0.3

package/README.md

@@ -38,7 +38,7 @@ After restarting your MCP client, paste:
 
 …to scaffold a full Expo app with Amba as the only backend. The skill
 fetches the canonical prompt from
-<https://docs.amba.dev/docs/prompts/expo-build> at invocation time and
+<https://docs.amba.dev/prompts/expo-build> at invocation time and
 falls back to an inlined snapshot when offline. Use `--no-skills` to
 skip the skill install.
 

package/dist/api-client.d.ts

@@ -20,6 +20,7 @@ export interface ProjectSummary {
     platform: string;
     environment?: string;
     bundle_id?: string | null;
+    google_oauth_client_id?: string | null;
     status?: string;
     created_at?: string;
 }
@@ -27,6 +28,12 @@ export declare function listProjects(): Promise<ApiListResponse<ProjectSummary>>
 export declare function createProject(input: {
     name: string;
     bundle_id?: string;
+    /**
+     * Google OAuth 2.0 client id. Doubles as the audience the server
+     * expects on Google Sign In id tokens — set this if your app uses
+     * Sign in with Google. Public identifier, not a secret.
+     */
+    google_oauth_client_id?: string;
     platform?: string;
     /**
      * Project environment. `'development'` flags the row as the developer's
@@ -40,6 +47,25 @@ export declare function createProject(input: {
     platform: string;
     environment?: string;
 }>>;
+/**
+ * PATCH /admin/projects/:projectId — update mutable fields. Server
+ * silently ignores unknown keys; we filter to the documented allow-list
+ * before sending so a typo at the CLI doesn't pass the wire silently.
+ */
+export declare function updateProject(projectId: string, patch: {
+    name?: string;
+    bundle_id?: string | null;
+    google_oauth_client_id?: string | null;
+    platform?: string;
+    environment?: string;
+}): Promise<ApiResponse<{
+    id: string;
+    name: string;
+    bundle_id: string | null;
+    google_oauth_client_id: string | null;
+    platform: string;
+    environment: string;
+}>>;
 export declare function getProject(projectId: string): Promise<ApiResponse<{
     id: string;
     name: string;
@@ -53,15 +79,16 @@ export declare function deleteProject(projectId: string): Promise<ApiResponse<{
     deleted: boolean;
 }>>;
 export declare function reprovisionProject(projectId: string): Promise<ApiResponse<{
-    workflowId?: string;
+    projectId: string;
+    job_id?: string;
     status?: string;
-    message?: string;
+    collapsed?: boolean;
 }>>;
 export declare function getProvisioningStatus(projectId: string): Promise<ApiResponse<{
     projectId: string;
     status: string;
-    workflowId?: string | null;
-    errorMessage?: string | null;
+    provisioned_at: string | null;
+    region: string | null;
 }>>;
 export declare function createApiKey(projectId: string, keyType: 'client' | 'server', environment: 'development' | 'production'): Promise<ApiResponse<{
     id: string;
@@ -321,11 +348,14 @@ export declare function scheduleFunction(projectId: string, input: {
     schedule_id: string;
 }>>;
 export interface FunctionLogEvent {
-    /** Logpush row — see `r2-log-reader.ts:LogpushTraceEvent`. Field-shape stable. */
+    /** Sanitized log row — see `r2-log-reader.ts:SanitizedLogEvent`. Field-shape stable. */
     Event?: {
         Timestamp?: string;
     };
-    ScriptName?: string;
+    /** The function's name (parsed server-side from the internal script name). */
+    function_name?: string;
+    /** The deploy version this event came from. */
+    version?: number;
     Outcome?: string;
     Logs?: Array<{
         Level?: string;
@@ -390,8 +420,8 @@ export declare function listSecretSyncStatus(projectId: string): Promise<ApiList
 export interface SetSecretResultRow {
     /** Secret name as set by the customer. */
     name: string;
-    /** Function name the secret binds to. */
-    function: string;
+    /** Function the secret binds to, or `null` for a project-wide secret. */
+    function: string | null;
     /** Secret store version number (1, 2, 3, ...). */
     version: number;
     /** Backend version resource path — exposed for ops debugging. */
@@ -405,12 +435,16 @@ export declare function setSecretViaApi(projectId: string, input: {
     name: string;
     /** Plaintext secret value. <=64KiB. */
     value: string;
-    /** Function name the secret binds to. v1 has no project-wide secrets. */
-    function: string;
+    /**
+     * Function the secret binds to. OMIT for a PROJECT-WIDE secret
+     * (applied to every function in the project, including ones deployed
+     * later).
+     */
+    function?: string;
 }): Promise<ApiResponse<SetSecretResultRow>>;
 export interface ListSecretsRow {
-    /** Function name the secret binds to. */
-    function: string;
+    /** Function the secret binds to, or `null` for a project-wide secret. */
+    function: string | null;
     /** Secret name. */
     name: string;
     /** Latest secret-store version number. */
@@ -420,12 +454,14 @@ export interface ListSecretsRow {
     last_error: string | null;
     updated_at: string;
 }
-export declare function listSecretsViaApi(projectId: string): Promise<ApiListResponse<ListSecretsRow>>;
-export declare function deleteSecretViaApi(projectId: string, name: string, options: {
-    function: string;
+export declare function listSecretsViaApi(projectId: string, options?: {
+    function?: string;
+}): Promise<ApiListResponse<ListSecretsRow>>;
+export declare function deleteSecretViaApi(projectId: string, name: string, options?: {
+    function?: string;
 }): Promise<ApiResponse<{
     name: string;
-    function: string;
+    function: string | null;
     deleted: true;
 }>>;
 /** Closed set of column types the server accepts. */
@@ -521,8 +557,8 @@ export declare function dropCollection(projectId: string, name: string, confirm:
 export type AiProviderName = 'anthropic' | 'openai';
 export interface AiProviderRow {
     name: AiProviderName;
-    /** Canonical secret name in the secret store. NULL only mid-rotation. */
-    api_key_secret_name: string | null;
+    /** Whether an API key is currently configured for this provider. */
+    configured: boolean;
     /** Preview cue printed to the CLI on register; NOT a real partial key. */
     api_key_preview?: string;
     created_at?: string;
@@ -552,9 +588,23 @@ export interface SiteDomainRow {
     hostname: string;
     provider_hostname_id: string | null;
     cert_status: 'pending_validation' | 'pending_issuance' | 'pending_deployment' | 'active' | 'error';
+    ownership_status: 'pending' | 'active' | 'error';
     created_at: string;
     updated_at: string;
 }
+/** A DNS record the customer must publish to validate / prove ownership. */
+export interface DomainValidationRecord {
+    txt_name?: string;
+    txt_value?: string;
+    http_url?: string;
+    http_body?: string;
+}
+/** Hostname-ownership token returned as a DNS TXT record. */
+export interface DomainOwnershipVerification {
+    type?: string;
+    name?: string;
+    value?: string;
+}
 export declare function createSite(projectId: string, input: {
     name: string;
 }): Promise<ApiResponse<SiteRow>>;
@@ -595,7 +645,16 @@ export declare function addSiteDomainViaApi(projectId: string, siteName: string,
     hostname: string;
     provider_hostname_id: string;
     cert_status: SiteDomainRow["cert_status"];
+    ownership_status: SiteDomainRow["ownership_status"];
     dns_target: string;
+    is_apex: boolean;
+    dns_note: string | null;
+    ssl_validation: DomainValidationRecord[];
+    ownership_verification: DomainOwnershipVerification | null;
+    ownership_verification_http: {
+        http_url?: string;
+        http_body?: string;
+    } | null;
     created_at: string;
 }>>;
 /**
@@ -627,6 +686,51 @@ export declare function deleteSiteViaApi(projectId: string, siteName: string, op
     deleted: true;
     cascade: DeleteCascadeSummary;
 }>>;
+/** A candidate domain from a search. */
+export interface DomainSuggestion {
+    domain: string;
+    available: boolean;
+    price_usd: number | null;
+    currency: string;
+    premium: boolean;
+}
+/** Authoritative availability + price for a specific domain. */
+export interface DomainAvailability extends DomainSuggestion {
+    supported: boolean;
+}
+/** Purchase response — either a quote (executed=false) or a result. */
+export interface DomainPurchaseResult {
+    domain: string;
+    site: string;
+    executed: boolean;
+    available?: boolean;
+    price_usd?: number | null;
+    currency?: string;
+    premium?: boolean;
+    confirmation_required?: boolean;
+    gated?: boolean;
+    live?: boolean;
+    registered?: boolean;
+    provisioned?: boolean;
+    cert_status?: string;
+    ownership_status?: string;
+    dns_autoconfigured?: boolean;
+    url?: string;
+    public_url?: string;
+    message?: string;
+}
+export declare function searchDomainsViaApi(projectId: string, query: string, limit?: number): Promise<ApiListResponse<DomainSuggestion>>;
+export declare function checkDomainsViaApi(projectId: string, domains: string[]): Promise<ApiListResponse<DomainAvailability>>;
+export declare function purchaseDomainViaApi(projectId: string, body: {
+    domain: string;
+    site: string;
+    accept_price_usd?: number;
+    confirm?: boolean;
+    auto_renew?: boolean;
+    privacy?: boolean;
+    years?: number;
+}): Promise<ApiResponse<DomainPurchaseResult>>;
+export declare function listPurchasedDomainsViaApi(projectId: string): Promise<ApiListResponse<Record<string, unknown>>>;
 /**
  * Delete a function entirely. Cascade: removes the deployed script
  * (backend 404 treated as success), then marks every historical

package/dist/auth.d.ts

@@ -37,6 +37,14 @@ export declare function clearCredentials(): Promise<void>;
  * `null` clears any prior override.
  */
 export declare function setBearerOverride(token: string | null): void;
+/**
+ * Read the current bearer override without consuming it. Returns
+ * `null` when no override is set. Used by commands that need to know
+ * "did the operator supply a PAT for this invocation?" — e.g. `init`
+ * branches on whether to bypass stored-creds and use the supplied
+ * token verbatim.
+ */
+export declare function getBearerOverride(): string | null;
 /** Test-only: reset the override between cases. */
 export declare function __resetTokenOverride(): void;
 /**

package/dist/bundle.d.ts

@@ -1,24 +1,38 @@
 /**
  * Customer-function bundling for `amba functions deploy`.
  *
- * Uses esbuild (the Workers ecosystem bundler-of-record). The shared
- * runtime stdlib is marked `external` so customer bundles don't
- * re-include megabytes of `@anthropic-ai/sdk`, `postgres`, `zod`, etc.;
- * these resolve at dispatch time via platform-level bindings.
+ * Uses esbuild. Customer code is bundled into a single self-contained
+ * ES module — the upstream runtime resolves nothing at dispatch time
+ * except built-in JavaScript globals.
  *
  * Two checks gate the bundle before upload:
  *   1. Pre-upload size check against `BUNDLE_MAX_SIZE_BYTES` (8 MB
  *      default — the platform's 10 MB compressed cap minus 2 MB
  *      headroom) with a clear error pointing at the externalization
  *      config.
- *   2. Bundle-shape report — the CLI prints what's externalized vs
- *      bundled at deploy time so size issues are debuggable.
+ *   2. Bundle-shape report — the CLI prints what's bundled vs
+ *      externalized at deploy time so size issues are debuggable.
+ *
+ * History note (2026-05-27): the prior version of this file pinned
+ * `@layers/amba-functions` + `@layers/amba-api-middleware` as
+ * "platform-level bindings" externals. Neither is — they were
+ * server-side packages, and `@layers/amba-functions` was unpublished
+ * in the 4.0.2 cutover (a deprecated wrapper that never matched the
+ * actual runtime). Any function importing one of them was rejected
+ * upstream as "no such module." The default externals list is now
+ * empty; customer code is expected to be self-contained.
  */
 import { type BuildOptions } from 'esbuild';
 /**
- * Modules customer code MUST externalize. The runtime exposes these as
- * platform-level bindings; bundling them per-script wastes hundreds of
- * KB to MBs and quickly hits the script-size cap.
+ * Modules the bundler treats as `external` by default. The Amba
+ * function runtime exposes zero npm packages — there is no "platform
+ * stdlib" for customer functions to import. Keep this list empty.
+ *
+ * The `extraExternals` field on `BundleOptions` is a programmatic
+ * escape hatch (used by tests + future CLI wiring). It's intentionally
+ * not exposed as a `amba functions deploy` flag today — externalizing
+ * a module that isn't actually provided at runtime is exactly the
+ * footgun this list-defaults-to-empty change closes.
  */
 export declare const RUNTIME_STDLIB_EXTERNALS: readonly string[];
 /**

package/dist/commands/billing.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `amba billing *` subcommands — CLI access to the per-project billing
+ * surface that ships behind `/v1/admin/projects/:id/billing/*`.
+ *
+ *   amba billing status                    — tier, headroom on each
+ *                                            metered axis, next-bill date,
+ *                                            human_action_required.
+ *
+ *   amba billing upgrade --tier <t>        — print the Stripe Checkout
+ *                                            URL for tier ∈ {pro, scale}
+ *     [--interval month|year]               at the chosen interval. CLI
+ *                                            deliberately does NOT auto-
+ *                                            open a browser: agents pipe
+ *                                            the URL into a confirmation
+ *                                            step, humans copy-paste.
+ *
+ *   amba billing portal                    — print the Customer Portal
+ *                                            URL for card / cancel / etc.
+ *
+ *   amba billing set-ceiling <usd|off>     — cap (or remove) the monthly
+ *                                            spend ceiling.
+ *
+ * Project is resolved via `loadProjectConfig` (AMBA_PROJECT_ID env, then
+ * .env / .env.local in the cwd) — same pattern as `amba secrets *`.
+ */
+export declare function billingStatusCommand(): Promise<void>;
+export declare function billingUpgradeCommand(input: {
+    tier: 'pro' | 'scale';
+    interval?: 'month' | 'year';
+}): Promise<void>;
+export declare function billingPortalCommand(): Promise<void>;
+export declare function billingSetCeilingCommand(input: {
+    ceiling: number | null;
+}): Promise<void>;

package/dist/commands/claim.d.ts

@@ -0,0 +1,41 @@
+/**
+ * `amba claim <email>` — bind a sandbox account to a real email address
+ * via a one-click magic link.
+ *
+ * Sandbox accounts are minted with an auto-generated address
+ * (`sandbox-<epoch>-<nonce>@layers.com`) and remain capped at 100 MAU /
+ * 10 MB DB until the developer claims a real email. This command POSTs
+ * the target email to `/v1/auth/developer/claim` under the developer's
+ * stored PAT; the backend emails a single-use magic link that — when
+ * clicked — updates the developer row and flips the project tier from
+ * `sandbox` to `verified_free` (1,000 MAU, 500 MB DB).
+ *
+ * Wire shape:
+ *
+ *   POST {AMBA_API_URL}/v1/auth/developer/claim
+ *   Authorization: Bearer {pat}
+ *   Content-Type: application/json
+ *   Body: { "email": "<target-email>" }
+ *
+ * Success: HTTP 200 `{ "ok": true }`
+ * Errors:  HTTP 400 INVALID_INPUT
+ *          HTTP 409 EMAIL_TAKEN     — that address already owns another account
+ *          HTTP 409 ALREADY_CLAIMED — this account is already verified
+ *          HTTP 429                  — rate-limited
+ *          HTTP 5xx                  — surface verbatim with code + message
+ *
+ * UX contract: a single ✓ line + a hint that the link expires in 15
+ * minutes. No copy-paste tokens, no follow-up commands. The click in
+ * the email is the whole flow.
+ */
+export interface ClaimCommandOptions {
+    /** Override the API root for tests + ops. Defaults to env or `https://api.amba.dev`. */
+    apiUrl?: string;
+    /** Inject a fetch implementation — test seam. */
+    fetchImpl?: typeof fetch;
+    /** Inject the developer PAT directly — test seam. Bypasses ~/.amba lookup. */
+    pat?: string;
+    /** Override `~/` resolution for credential lookup — test seam. */
+    homeDir?: string;
+}
+export declare function claimCommand(email: string, options?: ClaimCommandOptions): Promise<void>;

package/dist/commands/domains.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `amba domains ...` commands — buy a domain through Amba.
+ *
+ *   amba domains search <query>         find available domains + prices
+ *   amba domains check <domain...>      authoritative availability + price
+ *   amba domains buy <domain> --site s  buy + connect to a site
+ *   amba domains list                   domains this project has purchased
+ *
+ * Search + check are free. `buy` surfaces the cost and requires explicit
+ * confirmation (interactive y/N, or `--yes`) before it submits a purchase —
+ * and the API itself only executes a real, paid registration when the
+ * platform has live purchasing enabled. A registered domain is auto-
+ * connected to the chosen site with no DNS setup by the customer.
+ */
+export declare function domainsSearchCommand(query: string, options?: {
+    limit?: number;
+}): Promise<void>;
+export declare function domainsCheckCommand(domains: string[]): Promise<void>;
+export interface DomainsBuyOptions {
+    site: string;
+    yes?: boolean;
+    noPrivacy?: boolean;
+    noAutoRenew?: boolean;
+    years?: number;
+}
+export declare function domainsBuyCommand(domain: string, options: DomainsBuyOptions): Promise<void>;
+export declare function domainsListCommand(): Promise<void>;

package/dist/commands/functions-logs.d.ts

@@ -9,8 +9,8 @@
  * Output formatting:
  *   - `--json`: NDJSON to stdout (one event per line) so `| jq` works.
  *   - default: human-readable lines:
- *       2026-05-08T12:34:56.789Z scan-letter-v3 [info] "scanning"
- *       2026-05-08T12:34:57.012Z scan-letter-v3 [exception] TypeError: …
+ *       2026-05-08T12:34:56.789Z scan-letter@v3 [info] "scanning"
+ *       2026-05-08T12:34:57.012Z scan-letter@v3 [exception] TypeError: …
  *
  * Server-side scoping is enforced — the API filters by ScriptName
  * prefix so a developer can never read another tenant's logs.

package/dist/commands/functions.d.ts

@@ -55,11 +55,12 @@ export interface DevOptions {
  * — externalization rules, size cap, and source-map handling are
  * identical so dev → prod parity is automatic.
  *
- * Handler shape: `export default async function (req: Request): Promise<Response>`.
+ * Handler shape: `export default { async fetch(req, env, ctx) { ... } }`.
  * `.env.local` values in the customer's working directory are passed
- * through to the child process so the handler can read them via
- * `process.env.MY_KEY`. Existing values in the parent's env take
- * priority (so `MY_KEY=x amba functions dev …` wins).
+ * through to the child process and bridged into the `env` parameter so
+ * the handler reads them the same way as in production (`env.MY_KEY`).
+ * Existing values in the parent's env take priority (so
+ * `MY_KEY=x amba functions dev …` wins).
  */
 export declare function functionsDevCommand(entryPoint: string, options?: DevOptions): Promise<void>;
 /**

package/dist/commands/init.d.ts

@@ -40,42 +40,42 @@ export declare function runSandboxInit(cwd: string, options: {
     sandboxEmail?: string;
     noMcpConfig?: boolean;
     /**
-     * Skip the project-local `/amba-build` Claude Code skill install.
-     * Default is to install (the skill is what makes the agentic
-     * "/amba-build <design>" invocation work). Set true in CI or
-     * during tests that don't want stray files written into the
-     * caller's CWD.
+     * Skip the project-local skill install. Default is to install. Set
+     * true in CI or during tests that don't want stray files written.
      */
     noSkills?: boolean;
     json?: boolean;
     /**
      * Override `~/` resolution. The CLI itself never passes this — it's
      * the seam tests use to avoid touching the developer's actual home
-     * directory. (vi.spyOn can't intercept `os.homedir` under ESM, so
-     * dependency injection is the cleanest substitute.)
+     * directory.
      */
     homeDir?: string;
 }): Promise<SandboxResult>;
 /**
  * Build the plaintext (no ANSI) success-output block printed at the
- * end of `amba init --sandbox`. Pure function — exported only for the
- * vitest cases that assert on per-line content. The CLI wraps each
- * line with picocolors in `printSandboxNextSteps` below.
+ * end of `amba init --sandbox`. Pure function — exported for the
+ * vitest cases that assert on per-line content. The CLI wraps the
+ * output with picocolors in `printSandboxNextSteps` below.
  *
- * Structure (in order):
- *   1. Per-artifact checklist (`✓ ...` lines)
- *   2. SDK install + configure hint
- *   3. "Done." + per-client restart bullets — ONLY for clients we
- *      actually wrote configs to. Never instruct the user to "restart
- *      Cursor" if we only touched `~/.claude.json`. When no config
- *      was written (manual-paste path), falls back to a generic
- *      "quit + reopen" line.
- *   4. Tail-line resume hint + sandbox limits + verify URL.
+ * Design: silent-until-done. The install (provision account, mint
+ * keys, write .env.local, write MCP config, install skill) is COMPLETE
+ * the moment this output lands. The MCP config has been persisted —
+ * it activates on the next launch of the developer's coding agent. We
+ * do NOT instruct the developer to restart anything; we just state
+ * what's wired and what's next.
  *
- * We intentionally do NOT print any "kill -HUP / SIGHUP" advanced
- * workaround. Telling the agent to surface a clean "restart your MCP
- * client" instruction to the human is the whole optimization — adding
- * an experimental fallback just dilutes the signal and risks the
- * agent surfacing the workaround instead.
+ * Shape (~6 lines, Vercel/Stripe aesthetic):
+ *   ✓ Amba ready
+ *     project: <id>
+ *     keys → .env.local
+ *     mcp → <paths> (active next agent launch)
+ *     skill → <skill paths> (when installed)
+ *
+ *     next: npm install <sdk-pkg>
+ *           Amba.configure({ projectId, clientKey }) at app startup
+ *
+ * The fallback for "no MCP client config detected" is a one-line
+ * note + a paste-ready snippet — still no restart copy.
  */
 export declare function buildSandboxNextStepsLines(r: SandboxResult): string[];

package/dist/commands/projects.d.ts

@@ -3,8 +3,16 @@ export declare function projectsCreateCommand(input: {
     name: string;
     env?: string;
     bundleId?: string;
+    googleOauthClientId?: string;
     platform?: string;
 }): Promise<void>;
+export declare function projectsUpdateCommand(projectId: string, input: {
+    name?: string;
+    bundleId?: string;
+    googleOauthClientId?: string;
+    platform?: string;
+    environment?: string;
+}): Promise<void>;
 export declare function projectsShowCommand(projectId: string): Promise<void>;
 export declare function projectsDeleteCommand(projectId: string, opts?: {
     yes?: boolean;

package/dist/commands/secrets.d.ts

@@ -1,13 +1,25 @@
 /**
- * `amba secrets ...` — write per-function secrets through the platform
- * API. The CLI sends `{name, value, function}` to the admin endpoint;
- * the server stores the value, validates reserved binding names, and
- * propagates it to the deployed Worker's binding. Sync is eventual —
- * `amba secrets list` shows progress.
+ * `amba secrets ...` — write secrets through the platform API. The CLI
+ * sends `{name, value, function?}` to the admin endpoint; the server
+ * stores the value, validates reserved binding names, and propagates it to
+ * the deployed Worker binding(s). Sync is eventual — `amba secrets list`
+ * shows progress.
+ *
+ * Two scopes:
+ *   - `--function <name>` → the secret binds to that one function.
+ *   - no `--function`     → a PROJECT-WIDE secret, visible to every
+ *     function in the project (and to any function deployed later). Set it
+ *     once instead of repeating the same value per function.
+ *
+ * Secrets may be set BEFORE the function is deployed. The sync drains once
+ * a deployment lands (and `amba functions deploy` re-syncs at the end).
  */
 export interface SecretsSetOptions {
-    /** Function name the secret binds to. Required — there are no project-wide secrets. */
-    function: string;
+    /**
+     * Function the secret binds to. Omit for a PROJECT-WIDE secret (applied
+     * to every function in the project, including ones deployed later).
+     */
+    function?: string;
     /**
      * Environment selector. Currently informational: both `dev` and `prod`
      * write to the same secret namespace per project. Workarounds:
@@ -23,7 +35,15 @@ export interface SecretsSetOptions {
     fromStdin?: boolean;
 }
 export declare function secretsSetCommand(name: string, value: string | undefined, options: SecretsSetOptions): Promise<void>;
-export declare function secretsListCommand(): Promise<void>;
+export interface SecretsListOptions {
+    /**
+     * Filter to secrets for a single function. Without this, all secrets
+     * across all functions in the project are listed — noisy when a
+     * project has 10+ functions.
+     */
+    function?: string;
+}
+export declare function secretsListCommand(options?: SecretsListOptions): Promise<void>;
 export declare function secretsUnsetCommand(name: string, options: {
-    function: string;
+    function?: string;
 }): Promise<void>;