@spacefast/common 0.0.24 → 0.2.1

package/dist/contracts/teams.js

@@ -1,23 +1,30 @@
 import { z } from "zod";
 import { CursorPaginationSchema, cursorListQuerySchema } from "./common.js";
 import { planCodeSchema, planLimitValueSchema } from "./features.js";
+import { systemPresentationSchema } from "./space-config.js";
+import { ManifestStatusSchema } from "./tenants.js";
 export const TEAM_ROLE_VALUES = ["owner", "admin", "member"];
 export const teamMemberRole = z.enum(TEAM_ROLE_VALUES);
 /**
- * Better Auth stores the member role as free text, so every surface that reads
- * it back has to land on the same canonical value. Unknown roles carry no
- * privilege, so they read as the least-privileged one.
+ * Better Auth stores the member role as free text. Unknown roles carry no
+ * privilege, so they read as `member`.
  */
 export function normalizeTeamMemberRole(role) {
     const parsed = teamMemberRole.safeParse(role ?? "member");
     return parsed.success ? parsed.data : "member";
 }
+// An invitation is its own resource under `/v1/team-invitations`, so the team
+// it belongs to travels in the body (create) or the query (list) instead of a
+// path segment.
 export const teamInvitationCreateSchema = z.object({
+    teamId: z.string().trim().min(1).describe("The team to invite this person to."),
     email: z.string().trim().email().toLowerCase(),
     role: teamMemberRole.default("member"),
 });
 export const teamMemberListQuerySchema = cursorListQuerySchema;
-export const teamInvitationListQuerySchema = cursorListQuerySchema;
+export const teamInvitationListQuerySchema = cursorListQuerySchema.extend({
+    teamId: z.string().trim().min(1).describe("The team whose invitations to list."),
+});
 export const teamListQuerySchema = cursorListQuerySchema;
 export const teamSpaceListQuerySchema = cursorListQuerySchema;
 export const TeamMemberUserSchema = z.object({
@@ -26,10 +33,9 @@ export const TeamMemberUserSchema = z.object({
     email: z.string().email().describe("The member's email address."),
     image: z.string().nullable().describe("Avatar URL, or null when the user has none."),
 });
-// The one membership shape: every surface that shows or edits a team member
-// (dashboard, superadmin, CLI, MCP) types from this. Better Auth's
-// organization plugin owns the underlying rows, but its plugin-inferred types
-// never cross an app boundary.
+// The one membership shape every surface types from. Better Auth's organization
+// plugin owns the underlying rows; its inferred types never cross an app
+// boundary.
 export const TeamMemberSchema = z.object({
     id: z.string().describe("The membership id, stable for the life of the membership."),
     teamId: z.string().describe("The team this membership belongs to."),
@@ -41,16 +47,40 @@ export const TeamMemberSchema = z.object({
 export const teamMemberRoleUpdateSchema = z.object({
     role: teamMemberRole.describe("The role to grant this member."),
 });
+/**
+ * The one invitation status vocabulary, shared by the collection and the by-id
+ * read. Better Auth's organization plugin owns the stored column and writes
+ * `pending | accepted | rejected | canceled`; `expired` is derived, because a
+ * still-pending invitation past `expiresAt` can never be accepted and no writer
+ * ever rewrites the row.
+ */
+export const teamInvitationStatus = z.enum([
+    "pending",
+    "accepted",
+    "rejected",
+    "canceled",
+    "expired",
+]);
+/**
+ * The stored column is free text over a closed domain. An unrecognized value is
+ * not something a recipient may act on, so it fails closed to `canceled` —
+ * never `pending` (which would offer a dead link) and never `accepted` (which
+ * would claim a membership nobody holds).
+ */
+export function normalizeTeamInvitationStatus(status) {
+    const parsed = teamInvitationStatus.safeParse(status);
+    return parsed.success ? parsed.data : "canceled";
+}
 export const TeamInvitationSchema = z.object({
     id: z.string(),
     teamId: z.string(),
     email: z.string().email(),
     role: teamMemberRole,
-    status: z.string(),
+    status: teamInvitationStatus,
     expiresAt: z.string().datetime(),
     createdAt: z.string().datetime(),
 });
-// Team (internal-docs/platform.md "Team"): Better Auth team in the main
+// Team (the platform spec "Team"): Better Auth team in the main
 // tenant, carrying the resolved plan and default data location.
 export const teamPlanCode = planCodeSchema;
 export const TeamSummarySchema = z.object({
@@ -73,6 +103,14 @@ export const TeamDetailSchema = TeamSummarySchema.extend({
         .string()
         .nullable()
         .describe("Stripe customer id linked to this team; null until billing is initialized."),
+    systemSpaceId: z
+        .string()
+        .nullable()
+        .describe("The space that supplies this team's page, theme, and presentation defaults."),
+    manifestStatus: ManifestStatusSchema.describe("The status of the restricted manifest from the team's system space."),
+    presentation: systemPresentationSchema
+        .nullable()
+        .describe("The presentation from the team's system space, or null when no value is active."),
 });
 export const teamListResponseSchema = z.object({
     data: z.array(TeamSummarySchema),
@@ -89,14 +127,14 @@ export const teamJoinResponseSchema = z.object({
         role: z.literal("member"),
     }),
 });
-// Accepting an invitation is by its id (the opaque token carried in the accept
-// email link and returned by the invitations list/preview endpoints).
-export const teamInvitationAcceptSchema = z.object({
+// Every by-id invitation door — read, accept, resend, revoke — is addressed by
+// the opaque token carried in the invite link.
+export const teamInvitationParamsSchema = z.object({
     invitationId: z
         .string()
         .trim()
         .min(1)
-        .describe("The invitation id to accept (the token from the invite link)."),
+        .describe("The invitation id (the token from the invite link)."),
 });
 export const teamInvitationAcceptResponseSchema = z.object({
     data: z.object({
@@ -112,8 +150,7 @@ export const teamInvitationListResponseSchema = z.object({
 });
 // Team activity is served by `GET /v1/teams/{teamId}/activity`, a facade over
 // the one activity store using the ActivityEvent contract (contracts/activity.ts).
-// `defaultDataLocation` is the spec Team field: "auto" lets placement decide,
-// any other value must be an available placement region id.
+// Any value other than "auto" must be an available placement region id.
 export const teamDataLocationSchema = z
     .string()
     .trim()
@@ -123,22 +160,21 @@ export const teamDataLocationSchema = z
 export const teamSettingsUpdateSchema = z.object({
     defaultDataLocation: teamDataLocationSchema,
 });
-const wpCloudCapabilityOptionSchema = z.object({
+const infraCapabilityOptionSchema = z.object({
     id: z.string(),
     label: z.string(),
 });
-// Served by `GET /v1/teams/{teamId}/settings` (and echoed by the PATCH):
-// the default data location plus the placement options it may take.
+// Served by `GET /v1/teams/{teamId}/settings`, and echoed by the PATCH.
 export const teamSettingsResponseSchema = z.object({
     teamId: z.string().describe("The team id the settings belong to."),
     defaultDataLocation: teamDataLocationSchema,
     regionOptions: z
-        .array(wpCloudCapabilityOptionSchema)
+        .array(infraCapabilityOptionSchema)
         .describe("Placement regions currently available for new spaces."),
-    wpCloudCapabilities: z
+    infraCapabilities: z
         .object({
-        datacenters: z.array(wpCloudCapabilityOptionSchema),
-        phpVersions: z.array(wpCloudCapabilityOptionSchema),
+        datacenters: z.array(infraCapabilityOptionSchema),
+        phpVersion: z.literal("8.5"),
     })
         .describe("Live capabilities for the team's infra provider account."),
 });
@@ -153,7 +189,7 @@ export const teamUsageResponseSchema = z.object({
         members: z.number().int().describe("Team members."),
         storageBytes: z
             .number()
-            .describe("Disk actually occupied across the team's spaces, as measured by the serving infrastructure. Nothing is deduplicated: a file present in two spaces sits on two disks and counts twice."),
+            .describe("Disk occupied across the team's spaces, as measured by the serving infrastructure. Nothing is deduplicated: a file present in two spaces sits on two disks and counts twice."),
         storageQuotaBytes: z
             .union([z.number(), z.literal("unlimited")])
             .describe('Plan storage quota; "unlimited" when unbounded.'),
@@ -161,7 +197,7 @@ export const teamUsageResponseSchema = z.object({
         storageCalculatedAt: z
             .string()
             .nullable()
-            .describe("How far back the weakest measurement behind this total reaches. Null when the team's storage has not been measured yet. This is a lagging meter — expect it to trail the present by about an hour."),
+            .describe("How far back the weakest measurement behind this total reaches. Null when the team's storage has not been measured yet. The meter lags the present by about an hour."),
         buildsDeploysThisMonth: z
             .number()
             .int()
@@ -180,17 +216,21 @@ export const teamUsageResponseSchema = z.object({
         title: z.string().describe("Space display title."),
         storageBytes: z
             .number()
-            .describe("Disk this space occupies, as measured by the infrastructure serving it. Zero for a space that has not been measured yet."),
+            .describe("Disk this space occupies, as measured by the infrastructure serving it. Zero until the space has been measured."),
     }))
         .describe("Per-space storage breakdown for spaces the caller can read."),
 });
-// Served by `GET /v1/teams/invitations/{invitationId}/preview`: the unauthenticated
-// invite landing view (email is masked, never the full address).
-export const teamInvitationPreviewSchema = z.object({
+// Served by `GET /v1/team-invitations/{invitationId}`: the unauthenticated
+// invite landing view. Same field names and same status vocabulary as the
+// collection item; the address is masked and the team name is carried so the
+// page can render before sign-in.
+export const teamInvitationDetailSchema = z.object({
     id: z.string().describe("Invitation id."),
     teamName: z.string().describe("Inviting team's display name."),
-    invitedEmail: z.string().describe("Masked invited email address."),
-    status: z.enum(["pending", "expired", "closed"]).describe("Whether the invite can be accepted."),
+    email: z
+        .string()
+        .describe("The invited address, masked (`ja****@example.com`); never the full address."),
+    status: teamInvitationStatus.describe("Current state of the invitation. Only `pending` can be accepted."),
     expiresAt: z.string().describe("Instant when the invitation expires."),
 });
 export const teamCreateSchema = z.object({
@@ -219,6 +259,25 @@ export const teamUpdateSchema = z
     logo: z.string().trim().max(2048).nullable().optional(),
     metadata: z.string().nullable().optional(),
     defaultDataLocation: teamDataLocationSchema.optional(),
+    systemSpaceId: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Set the team's system space. Use null to clear the current system space."),
+    baseSystemSpaceId: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("The current system-space id that the caller expects. The update fails if this value is stale."),
+})
+    .superRefine((value, ctx) => {
+    if (value.baseSystemSpaceId !== undefined && value.systemSpaceId === undefined) {
+        ctx.addIssue({
+            code: "custom",
+            message: "baseSystemSpaceId requires systemSpaceId.",
+            path: ["baseSystemSpaceId"],
+        });
+    }
 })
     .refine((value) => Object.keys(value).length > 0, {
     message: "At least one team field is required.",

package/dist/contracts/tenants.d.ts

@@ -0,0 +1,135 @@
+import { z } from "zod";
+/**
+ * One manifest key's materialization status, as it surfaces on the tenant
+ * self-view. This is a projection, not the stored blob: the reconcile records a
+ * `declared` snapshot per item, but that (and any ownership proof inside it) is
+ * NEVER serialized to a partner surface — the self-view carries only where each
+ * key landed, not what was declared.
+ */
+export declare const ManifestStatusItemSchema: z.ZodObject<{
+    key: z.ZodString;
+    state: z.ZodEnum<{
+        active: "active";
+        failed: "failed";
+        pending: "pending";
+    }>;
+    detail: z.ZodOptional<z.ZodString>;
+    since: z.ZodString;
+    audience: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ManifestStatusItem = z.infer<typeof ManifestStatusItemSchema>;
+/**
+ * The materialization status of the tenant's system-space manifest: one item per
+ * declared key, plus the live version they were all converged from. Empty items
+ * with a null `sourceVersionId` means nothing is materialized (no designated
+ * system space, no live version, or an empty manifest).
+ */
+export declare const ManifestStatusSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        state: z.ZodEnum<{
+            active: "active";
+            failed: "failed";
+            pending: "pending";
+        }>;
+        detail: z.ZodOptional<z.ZodString>;
+        since: z.ZodString;
+        audience: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    sourceVersionId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ManifestStatus = z.infer<typeof ManifestStatusSchema>;
+/**
+ * A tenant's view of itself.
+ *
+ * Deliberately a self-view and not a tenant directory: a credential is rooted
+ * at exactly one tenant, so the only tenant it can read is its own. There is no
+ * list, and asking for another tenant's id is a refusal rather than an empty
+ * result.
+ *
+ * `provisioning.mode` is derived, not stored: a tenant whose sites run under
+ * its own provider client is `byo`, everything else is `managed`. That means
+ * the answer follows the actual account wiring instead of a flag someone has to
+ * remember to flip.
+ */
+export declare const TenantSelfSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        internal: "internal";
+        main: "main";
+        partner: "partner";
+    }>;
+    mode: z.ZodEnum<{
+        live: "live";
+        test: "test";
+    }>;
+    status: z.ZodEnum<{
+        active: "active";
+        past_due: "past_due";
+        suspended: "suspended";
+        deleted: "deleted";
+    }>;
+    name: z.ZodString;
+    defaultRegion: z.ZodNullable<z.ZodString>;
+    provisioning: z.ZodObject<{
+        mode: z.ZodEnum<{
+            managed: "managed";
+            byo: "byo";
+        }>;
+        providerClientId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    systemSpaceId: z.ZodNullable<z.ZodString>;
+    manifestStatus: z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            state: z.ZodEnum<{
+                active: "active";
+                failed: "failed";
+                pending: "pending";
+            }>;
+            detail: z.ZodOptional<z.ZodString>;
+            since: z.ZodString;
+            audience: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        sourceVersionId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    presentation: z.ZodNullable<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        logo: z.ZodOptional<z.ZodString>;
+        supportUrl: z.ZodOptional<z.ZodString>;
+        claimOrigin: z.ZodOptional<z.ZodString>;
+        accessHandoffOrigin: z.ZodOptional<z.ZodString>;
+        problemDocsBaseUrl: z.ZodOptional<z.ZodString>;
+        contacts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type TenantSelf = z.infer<typeof TenantSelfSchema>;
+/**
+ * Compare-and-swap on the system space, house style: send the value you believe
+ * is current as `baseSystemSpaceId` and the write is rejected with a conflict
+ * if it has moved under you. Omit it to write unconditionally. This mirrors
+ * `baseSettingsDigest` on spaces — the CAS token rides in the body, not in an
+ * `If-Match` header.
+ */
+export declare const tenantPatchSchema: z.ZodObject<{
+    systemSpaceId: z.ZodNullable<z.ZodString>;
+    baseSystemSpaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type TenantPatch = z.infer<typeof tenantPatchSchema>;
+export declare const TenantParamsSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Promote the linked test tenant's system-space configuration onto this (live)
+ * tenant. An explicit export/copy, never a mode flip: the test tenant's
+ * system-space manifest (minus its token issuers, which each mode declares
+ * distinctly) is carried onto the live tenant's designated system space and
+ * reconciled with fresh ids and fresh verification. Test data stays test.
+ *
+ * No parameters today; the body is reserved for future promotion options
+ * (a subset of keys to promote, a dry-run, a CAS token).
+ */
+export declare const tenantPromoteSchema: z.ZodObject<{}, z.core.$strip>;
+export type TenantPromote = z.infer<typeof tenantPromoteSchema>;

package/dist/contracts/tenants.js

@@ -0,0 +1,120 @@
+import { z } from "zod";
+import { tenantKind, tenantMode, tenantStatus } from "./enums.js";
+import { systemPresentationSchema } from "./space-config.js";
+/**
+ * One manifest key's materialization status, as it surfaces on the tenant
+ * self-view. This is a projection, not the stored blob: the reconcile records a
+ * `declared` snapshot per item, but that (and any ownership proof inside it) is
+ * NEVER serialized to a partner surface — the self-view carries only where each
+ * key landed, not what was declared.
+ */
+export const ManifestStatusItemSchema = z.object({
+    key: z.string().describe("The manifest key this item materializes."),
+    state: z
+        .enum(["pending", "active", "failed"])
+        .describe("Where the last reconcile landed this key."),
+    detail: z
+        .string()
+        .optional()
+        .describe("Human-readable reason, present when the state warrants one (typically `failed`)."),
+    since: z
+        .string()
+        .datetime()
+        .describe("When this key last CHANGED state — stable across no-op re-runs, so it reads as `<state> since …`."),
+    audience: z
+        .string()
+        .optional()
+        .describe("`tokenIssuers` only: the server-minted opaque audience for the issuer this key materialized. Not a secret — it rides in every partner token's `aud` claim and is verified server-side — and the partner needs it to sign the activation proof and to mint tokens, so it is served here rather than handed over out of band."),
+});
+/**
+ * The materialization status of the tenant's system-space manifest: one item per
+ * declared key, plus the live version they were all converged from. Empty items
+ * with a null `sourceVersionId` means nothing is materialized (no designated
+ * system space, no live version, or an empty manifest).
+ */
+export const ManifestStatusSchema = z.object({
+    items: z.array(ManifestStatusItemSchema).describe("Per-key materialization status."),
+    sourceVersionId: z
+        .string()
+        .nullable()
+        .describe("The system space's live version every item was converged from, or null when nothing is materialized."),
+});
+/**
+ * A tenant's view of itself.
+ *
+ * Deliberately a self-view and not a tenant directory: a credential is rooted
+ * at exactly one tenant, so the only tenant it can read is its own. There is no
+ * list, and asking for another tenant's id is a refusal rather than an empty
+ * result.
+ *
+ * `provisioning.mode` is derived, not stored: a tenant whose sites run under
+ * its own provider client is `byo`, everything else is `managed`. That means
+ * the answer follows the actual account wiring instead of a flag someone has to
+ * remember to flip.
+ */
+export const TenantSelfSchema = z.object({
+    id: z.string().describe("Tenant id."),
+    kind: tenantKind.describe("Tenant class."),
+    mode: tenantMode.describe("`test` for a linked test tenant (a sandbox twin), `live` otherwise. Distinct from `provisioning.mode`."),
+    status: tenantStatus.describe("Whether the tenant is active, past due, suspended, or deleted."),
+    name: z.string().describe("Human-readable tenant name."),
+    defaultRegion: z
+        .string()
+        .nullable()
+        .describe("Region new spaces are placed in unless one is requested; null means auto."),
+    provisioning: z
+        .object({
+        mode: z
+            .enum(["managed", "byo"])
+            .describe("`byo` when the tenant's sites run under its own provider client, `managed` when they run under ours."),
+        providerClientId: z
+            .string()
+            .nullable()
+            .describe("The tenant's own provider client (`pvc_`), when it has one."),
+    })
+        .describe("How this tenant's infrastructure is accounted for."),
+    systemSpaceId: z
+        .string()
+        .nullable()
+        .describe("Space designated as this tenant's own system surface (its dashboard, portal, or control page). Must be a space this tenant owns."),
+    manifestStatus: ManifestStatusSchema.describe("Materialization status of the system-space manifest, reconciled from that space's live version."),
+    presentation: systemPresentationSchema
+        .nullable()
+        .describe("The partner-facing branding and links currently materialized from the system-space manifest, or null when none is materialized."),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+});
+/**
+ * Compare-and-swap on the system space, house style: send the value you believe
+ * is current as `baseSystemSpaceId` and the write is rejected with a conflict
+ * if it has moved under you. Omit it to write unconditionally. This mirrors
+ * `baseSettingsDigest` on spaces — the CAS token rides in the body, not in an
+ * `If-Match` header.
+ */
+export const tenantPatchSchema = z.object({
+    systemSpaceId: z
+        .string()
+        .nullable()
+        .describe("Space to designate as the tenant's system surface, or null to clear it."),
+    baseSystemSpaceId: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("The systemSpaceId the caller believes is current. When supplied and stale, the write is rejected instead of applied."),
+});
+export const TenantParamsSchema = z.object({
+    tenantId: z.string().min(1).describe("Tenant id. Must be the credential's own tenant."),
+});
+/**
+ * Promote the linked test tenant's system-space configuration onto this (live)
+ * tenant. An explicit export/copy, never a mode flip: the test tenant's
+ * system-space manifest (minus its token issuers, which each mode declares
+ * distinctly) is carried onto the live tenant's designated system space and
+ * reconciled with fresh ids and fresh verification. Test data stays test.
+ *
+ * No parameters today; the body is reserved for future promotion options
+ * (a subset of keys to promote, a dry-run, a CAS token).
+ */
+export const tenantPromoteSchema = z
+    .object({})
+    .describe("Promotion request. No parameters yet; reserved for future options.");

package/dist/contracts/test-triggers.d.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import type { TenantMode } from "./enums.js";
+export declare const testTriggerValues: readonly ["build_failure", "domain_verification_pending", "domain_verification_failed", "tls_failure", "rate_limit", "webhook_retry", "principal_suspension", "usage_correction"];
+export declare const testTrigger: z.ZodEnum<{
+    rate_limit: "rate_limit";
+    build_failure: "build_failure";
+    domain_verification_pending: "domain_verification_pending";
+    domain_verification_failed: "domain_verification_failed";
+    tls_failure: "tls_failure";
+    webhook_retry: "webhook_retry";
+    principal_suspension: "principal_suspension";
+    usage_correction: "usage_correction";
+}>;
+export type TestTrigger = z.infer<typeof testTrigger>;
+/**
+ * Every trigger, in one record: the reserved token, the input that carries it,
+ * and what a test tenant gets instead of success.
+ *
+ * `carrier` and `effect` are contract text, not commentary — the partner API
+ * document renders its trigger table straight from them, so a renamed token or
+ * a new trigger cannot leave the published contract describing something else.
+ *
+ * No token is a substring of another, so a plain `includes` scan is unambiguous.
+ * Keep them lowercase — the detector lowercases the input, and every carrier (a
+ * DNS label, a slug, a principal id) is compared case-insensitively.
+ */
+export declare const TEST_TRIGGER_META: {
+    readonly build_failure: {
+        readonly sentinel: "sf-sim-build-fail";
+        readonly carrier: "space slug";
+        readonly effect: "the space's next build fails";
+    };
+    readonly domain_verification_pending: {
+        readonly sentinel: "sf-sim-domain-pending";
+        readonly carrier: "custom domain name";
+        readonly effect: "domain verification stays pending";
+    };
+    readonly domain_verification_failed: {
+        readonly sentinel: "sf-sim-domain-fail";
+        readonly carrier: "custom domain name";
+        readonly effect: "domain verification fails";
+    };
+    readonly tls_failure: {
+        readonly sentinel: "sf-sim-tls-fail";
+        readonly carrier: "custom domain name";
+        readonly effect: "certificate issuance fails";
+    };
+    readonly rate_limit: {
+        readonly sentinel: "sf-sim-rate-limit";
+        readonly carrier: "space slug (on create)";
+        readonly effect: "the create returns 429 `rate_limited`";
+    };
+    readonly webhook_retry: {
+        readonly sentinel: "sf-sim-webhook-retry";
+        readonly carrier: "webhook URL";
+        readonly effect: "delivery fails and enters the retry schedule";
+    };
+    readonly principal_suspension: {
+        readonly sentinel: "sf-sim-suspend";
+        readonly carrier: "external principal id";
+        readonly effect: "the principal is suspended";
+    };
+    readonly usage_correction: {
+        readonly sentinel: "sf-sim-usage-correction";
+        readonly carrier: "space slug";
+        readonly effect: "the next settled usage sample appends a linked correction";
+    };
+};
+export declare function detectTestTrigger(input: string | null | undefined): TestTrigger | null;
+export declare function resolveTestTrigger(mode: TenantMode | string | null | undefined, input: string | null | undefined): TestTrigger | null;