@workwae/sdk 0.1.0-alpha.1 → 0.1.0-alpha.3

package/contract/contacts/routes.d.ts

@@ -15,6 +15,8 @@ export declare const contactFolders: {
         readonly missing_scope: "The API key lacks the scope the operation needs.";
         readonly role_forbidden: "The member's role does not allow the operation.";
         readonly account_token_forbidden: "An account token called an operation account tokens cannot call.";
+        readonly account_scope_forbidden: "A credential limited to specific accounts called an operation that reaches beyond them.";
+        readonly mcp_only_key: "An MCP-only key (minted for an end user's MCP client) was used outside the MCP server.";
         readonly rate_limited: "The tenant used up its plan's request rate; Retry-After says when the window ends.";
         readonly too_many_requests: "The credential has too many requests in flight at once; retry after Retry-After.";
         readonly overloaded: "The API is shedding load; retry after Retry-After.";
@@ -87,6 +89,8 @@ export declare const contacts: {
         readonly missing_scope: "The API key lacks the scope the operation needs.";
         readonly role_forbidden: "The member's role does not allow the operation.";
         readonly account_token_forbidden: "An account token called an operation account tokens cannot call.";
+        readonly account_scope_forbidden: "A credential limited to specific accounts called an operation that reaches beyond them.";
+        readonly mcp_only_key: "An MCP-only key (minted for an end user's MCP client) was used outside the MCP server.";
         readonly rate_limited: "The tenant used up its plan's request rate; Retry-After says when the window ends.";
         readonly too_many_requests: "The credential has too many requests in flight at once; retry after Retry-After.";
         readonly overloaded: "The API is shedding load; retry after Retry-After.";
@@ -159,6 +163,8 @@ export declare const contacts: {
         readonly missing_scope: "The API key lacks the scope the operation needs.";
         readonly role_forbidden: "The member's role does not allow the operation.";
         readonly account_token_forbidden: "An account token called an operation account tokens cannot call.";
+        readonly account_scope_forbidden: "A credential limited to specific accounts called an operation that reaches beyond them.";
+        readonly mcp_only_key: "An MCP-only key (minted for an end user's MCP client) was used outside the MCP server.";
         readonly rate_limited: "The tenant used up its plan's request rate; Retry-After says when the window ends.";
         readonly too_many_requests: "The credential has too many requests in flight at once; retry after Retry-After.";
         readonly overloaded: "The API is shedding load; retry after Retry-After.";
@@ -195,6 +201,8 @@ export declare const contacts: {
         readonly missing_scope: "The API key lacks the scope the operation needs.";
         readonly role_forbidden: "The member's role does not allow the operation.";
         readonly account_token_forbidden: "An account token called an operation account tokens cannot call.";
+        readonly account_scope_forbidden: "A credential limited to specific accounts called an operation that reaches beyond them.";
+        readonly mcp_only_key: "An MCP-only key (minted for an end user's MCP client) was used outside the MCP server.";
         readonly rate_limited: "The tenant used up its plan's request rate; Retry-After says when the window ends.";
         readonly too_many_requests: "The credential has too many requests in flight at once; retry after Retry-After.";
         readonly overloaded: "The API is shedding load; retry after Retry-After.";
@@ -334,6 +342,8 @@ export declare const contacts: {
         readonly missing_scope: "The API key lacks the scope the operation needs.";
         readonly role_forbidden: "The member's role does not allow the operation.";
         readonly account_token_forbidden: "An account token called an operation account tokens cannot call.";
+        readonly account_scope_forbidden: "A credential limited to specific accounts called an operation that reaches beyond them.";
+        readonly mcp_only_key: "An MCP-only key (minted for an end user's MCP client) was used outside the MCP server.";
         readonly rate_limited: "The tenant used up its plan's request rate; Retry-After says when the window ends.";
         readonly too_many_requests: "The credential has too many requests in flight at once; retry after Retry-After.";
         readonly overloaded: "The API is shedding load; retry after Retry-After.";
@@ -481,6 +491,8 @@ export declare const contacts: {
         readonly missing_scope: "The API key lacks the scope the operation needs.";
         readonly role_forbidden: "The member's role does not allow the operation.";
         readonly account_token_forbidden: "An account token called an operation account tokens cannot call.";
+        readonly account_scope_forbidden: "A credential limited to specific accounts called an operation that reaches beyond them.";
+        readonly mcp_only_key: "An MCP-only key (minted for an end user's MCP client) was used outside the MCP server.";
         readonly rate_limited: "The tenant used up its plan's request rate; Retry-After says when the window ends.";
         readonly too_many_requests: "The credential has too many requests in flight at once; retry after Retry-After.";
         readonly overloaded: "The API is shedding load; retry after Retry-After.";
@@ -565,6 +577,8 @@ export declare const contacts: {
         readonly missing_scope: "The API key lacks the scope the operation needs.";
         readonly role_forbidden: "The member's role does not allow the operation.";
         readonly account_token_forbidden: "An account token called an operation account tokens cannot call.";
+        readonly account_scope_forbidden: "A credential limited to specific accounts called an operation that reaches beyond them.";
+        readonly mcp_only_key: "An MCP-only key (minted for an end user's MCP client) was used outside the MCP server.";
         readonly rate_limited: "The tenant used up its plan's request rate; Retry-After says when the window ends.";
         readonly too_many_requests: "The credential has too many requests in flight at once; retry after Retry-After.";
         readonly overloaded: "The API is shedding load; retry after Retry-After.";

package/contract/custom-domain.d.ts

@@ -0,0 +1,12 @@
+import * as z from "zod";
+export declare const customDomainHostname: (example: string) => z.ZodString;
+export declare const CUSTOM_DOMAIN_STATUSES: readonly [
+    "pending",
+    "active",
+    "failed"
+];
+export declare const customDomainRecord: () => z.ZodObject<{
+    type: z.ZodString;
+    name: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strip>;

package/contract/email-validation/models.d.ts

@@ -0,0 +1,119 @@
+import * as z from "zod";
+export declare const Reachability: z.ZodEnum<{
+    unknown: "unknown";
+    safe: "safe";
+    risky: "risky";
+    invalid: "invalid";
+}>;
+export type Reachability = z.infer<typeof Reachability>;
+export declare const CreateEmailValidation: z.ZodObject<{
+    addresses: z.ZodArray<z.ZodEmail>;
+    suppressInvalid: z.ZodDefault<z.ZodBoolean>;
+    refresh: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type CreateEmailValidation = z.infer<typeof CreateEmailValidation>;
+export declare const EmailValidationResult: z.ZodObject<{
+    address: z.ZodString;
+    reachability: z.ZodEnum<{
+        unknown: "unknown";
+        safe: "safe";
+        risky: "risky";
+        invalid: "invalid";
+    }>;
+    validSyntax: z.ZodBoolean;
+    domainAcceptsMail: z.ZodNullable<z.ZodBoolean>;
+    deliverable: z.ZodNullable<z.ZodBoolean>;
+    disabled: z.ZodNullable<z.ZodBoolean>;
+    fullInbox: z.ZodNullable<z.ZodBoolean>;
+    catchAll: z.ZodNullable<z.ZodBoolean>;
+    disposable: z.ZodNullable<z.ZodBoolean>;
+    roleAccount: z.ZodNullable<z.ZodBoolean>;
+    suppressed: z.ZodBoolean;
+    cached: z.ZodBoolean;
+    checkedAt: z.ZodPreprocess<z.ZodDate, Date>;
+}, z.core.$strip>;
+export type EmailValidationResult = z.infer<typeof EmailValidationResult>;
+export declare const EmailValidation: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        reachability: z.ZodEnum<{
+            unknown: "unknown";
+            safe: "safe";
+            risky: "risky";
+            invalid: "invalid";
+        }>;
+        validSyntax: z.ZodBoolean;
+        domainAcceptsMail: z.ZodNullable<z.ZodBoolean>;
+        deliverable: z.ZodNullable<z.ZodBoolean>;
+        disabled: z.ZodNullable<z.ZodBoolean>;
+        fullInbox: z.ZodNullable<z.ZodBoolean>;
+        catchAll: z.ZodNullable<z.ZodBoolean>;
+        disposable: z.ZodNullable<z.ZodBoolean>;
+        roleAccount: z.ZodNullable<z.ZodBoolean>;
+        suppressed: z.ZodBoolean;
+        cached: z.ZodBoolean;
+        checkedAt: z.ZodPreprocess<z.ZodDate, Date>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type EmailValidation = z.infer<typeof EmailValidation>;
+export declare const EmailValidationRecord: z.ZodObject<{
+    address: z.ZodString;
+    reachability: z.ZodEnum<{
+        unknown: "unknown";
+        safe: "safe";
+        risky: "risky";
+        invalid: "invalid";
+    }>;
+    validSyntax: z.ZodBoolean;
+    domainAcceptsMail: z.ZodNullable<z.ZodBoolean>;
+    deliverable: z.ZodNullable<z.ZodBoolean>;
+    disabled: z.ZodNullable<z.ZodBoolean>;
+    fullInbox: z.ZodNullable<z.ZodBoolean>;
+    catchAll: z.ZodNullable<z.ZodBoolean>;
+    disposable: z.ZodNullable<z.ZodBoolean>;
+    roleAccount: z.ZodNullable<z.ZodBoolean>;
+    suppressed: z.ZodBoolean;
+    cached: z.ZodBoolean;
+    checkedAt: z.ZodPreprocess<z.ZodDate, Date>;
+    id: z.ZodUUID;
+    createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+}, z.core.$strip>;
+export type EmailValidationRecord = z.infer<typeof EmailValidationRecord>;
+export declare const EmailValidationRecordPage: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        reachability: z.ZodEnum<{
+            unknown: "unknown";
+            safe: "safe";
+            risky: "risky";
+            invalid: "invalid";
+        }>;
+        validSyntax: z.ZodBoolean;
+        domainAcceptsMail: z.ZodNullable<z.ZodBoolean>;
+        deliverable: z.ZodNullable<z.ZodBoolean>;
+        disabled: z.ZodNullable<z.ZodBoolean>;
+        fullInbox: z.ZodNullable<z.ZodBoolean>;
+        catchAll: z.ZodNullable<z.ZodBoolean>;
+        disposable: z.ZodNullable<z.ZodBoolean>;
+        roleAccount: z.ZodNullable<z.ZodBoolean>;
+        suppressed: z.ZodBoolean;
+        cached: z.ZodBoolean;
+        checkedAt: z.ZodPreprocess<z.ZodDate, Date>;
+        id: z.ZodUUID;
+        createdAt: z.ZodPreprocess<z.ZodDate, Date>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type EmailValidationRecordPage = z.infer<typeof EmailValidationRecordPage>;
+export declare const ListEmailValidationsQuery: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodString>;
+    reachability: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        safe: "safe";
+        risky: "risky";
+        invalid: "invalid";
+    }>>;
+}, z.core.$strip>;
+export type ListEmailValidationsQuery = z.infer<typeof ListEmailValidationsQuery>;

package/contract/email-validation/routes.d.ts

@@ -0,0 +1,106 @@
+export declare const emailValidations: {
+    create: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        addresses: import("zod").ZodArray<import("zod").ZodEmail>;
+        suppressInvalid: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        refresh: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        results: import("zod").ZodArray<import("zod").ZodObject<{
+            address: import("zod").ZodString;
+            reachability: import("zod").ZodEnum<{
+                unknown: "unknown";
+                safe: "safe";
+                risky: "risky";
+                invalid: "invalid";
+            }>;
+            validSyntax: import("zod").ZodBoolean;
+            domainAcceptsMail: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            deliverable: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            disabled: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            fullInbox: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            catchAll: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            disposable: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            roleAccount: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            suppressed: import("zod").ZodBoolean;
+            cached: import("zod").ZodBoolean;
+            checkedAt: import("zod").ZodPreprocess<import("zod").ZodDate, Date>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, import("../errors.js").DeclaredErrors<{
+        readonly invalid_input: "The request does not match the operation's input schema (a malformed body included); data.issues names each problem.";
+        readonly unauthenticated: "No usable credential: none was sent, or it is malformed, unknown, revoked or an expired account token.";
+        readonly api_key_expired: "The API key is past its expiry (or the grace of the rotation that replaced it).";
+        readonly missing_scope: "The API key lacks the scope the operation needs.";
+        readonly role_forbidden: "The member's role does not allow the operation.";
+        readonly account_token_forbidden: "An account token called an operation account tokens cannot call.";
+        readonly account_scope_forbidden: "A credential limited to specific accounts called an operation that reaches beyond them.";
+        readonly mcp_only_key: "An MCP-only key (minted for an end user's MCP client) was used outside the MCP server.";
+        readonly rate_limited: "The tenant used up its plan's request rate; Retry-After says when the window ends.";
+        readonly too_many_requests: "The credential has too many requests in flight at once; retry after Retry-After.";
+        readonly overloaded: "The API is shedding load; retry after Retry-After.";
+        readonly payload_too_large: "The request body is larger than the API accepts.";
+        readonly internal_error: "An unexpected failure on our side.";
+        readonly invalid_idempotency_key: "POST only: the Idempotency-Key header is not 1 to 255 printable ASCII characters.";
+        readonly idempotency_key_reused: "POST only: the Idempotency-Key was used in the last 24 hours with another method, path or body.";
+        readonly idempotency_key_in_progress: "POST only: the request first sent with this Idempotency-Key has not been answered yet.";
+    }>>, import("../errors.js").DeclaredErrors<{
+        readonly email_validation_disabled: "Email validation is unavailable.";
+        readonly email_validation_unavailable: "The validation service fails or does not answer in time; no address is suppressed.";
+        readonly email_validation_suspended: "The validation service refuses Workwae's requests for now; try again later.";
+        readonly plan_limit_validations: "The addresses to check again exceed what the plan allows today (UTC); nothing was checked.";
+        readonly plan_required: "The workspace has no plan and is not its owner's Free workspace (the Free plan covers one workspace per owner): choose a plan under Billing.";
+        readonly validation_credits_exhausted: "The tenant has fewer email validation credits than the addresses to check again; data.balance and data.needed say how many; nothing was checked.";
+    }>>, Record<never, never>>;
+    list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        limit: import("zod").ZodDefault<import("zod").ZodCoercedNumber<unknown>>;
+        cursor: import("zod").ZodOptional<import("zod").ZodString>;
+        address: import("zod").ZodOptional<import("zod").ZodString>;
+        reachability: import("zod").ZodOptional<import("zod").ZodEnum<{
+            unknown: "unknown";
+            safe: "safe";
+            risky: "risky";
+            invalid: "invalid";
+        }>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        items: import("zod").ZodArray<import("zod").ZodObject<{
+            address: import("zod").ZodString;
+            reachability: import("zod").ZodEnum<{
+                unknown: "unknown";
+                safe: "safe";
+                risky: "risky";
+                invalid: "invalid";
+            }>;
+            validSyntax: import("zod").ZodBoolean;
+            domainAcceptsMail: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            deliverable: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            disabled: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            fullInbox: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            catchAll: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            disposable: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            roleAccount: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            suppressed: import("zod").ZodBoolean;
+            cached: import("zod").ZodBoolean;
+            checkedAt: import("zod").ZodPreprocess<import("zod").ZodDate, Date>;
+            id: import("zod").ZodUUID;
+            createdAt: import("zod").ZodPreprocess<import("zod").ZodDate, Date>;
+        }, import("zod/v4/core").$strip>>;
+        nextCursor: import("zod").ZodNullable<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, import("../errors.js").DeclaredErrors<{
+        readonly invalid_input: "The request does not match the operation's input schema (a malformed body included); data.issues names each problem.";
+        readonly unauthenticated: "No usable credential: none was sent, or it is malformed, unknown, revoked or an expired account token.";
+        readonly api_key_expired: "The API key is past its expiry (or the grace of the rotation that replaced it).";
+        readonly missing_scope: "The API key lacks the scope the operation needs.";
+        readonly role_forbidden: "The member's role does not allow the operation.";
+        readonly account_token_forbidden: "An account token called an operation account tokens cannot call.";
+        readonly account_scope_forbidden: "A credential limited to specific accounts called an operation that reaches beyond them.";
+        readonly mcp_only_key: "An MCP-only key (minted for an end user's MCP client) was used outside the MCP server.";
+        readonly rate_limited: "The tenant used up its plan's request rate; Retry-After says when the window ends.";
+        readonly too_many_requests: "The credential has too many requests in flight at once; retry after Retry-After.";
+        readonly overloaded: "The API is shedding load; retry after Retry-After.";
+        readonly payload_too_large: "The request body is larger than the API accepts.";
+        readonly internal_error: "An unexpected failure on our side.";
+        readonly invalid_idempotency_key: "POST only: the Idempotency-Key header is not 1 to 255 printable ASCII characters.";
+        readonly idempotency_key_reused: "POST only: the Idempotency-Key was used in the last 24 hours with another method, path or body.";
+        readonly idempotency_key_in_progress: "POST only: the request first sent with this Idempotency-Key has not been answered yet.";
+    }>>, import("../errors.js").DeclaredErrors<{
+        readonly invalid_cursor: "The cursor is not one this list issued.";
+    }>>, Record<never, never>>;
+};

package/contract/errors.d.ts

@@ -1,5 +1,4 @@
 import { type ErrorReason, type ReasonDataSchema, type ReasonStatus, type ReasonTable } from "./reasons.js";
-/** A declared error: its reason's status and data schema, with the condition as its message. */
 export type DeclaredError<R extends ErrorReason> = {
     status: ReasonStatus<R>;
     message: string;
@@ -9,22 +8,14 @@ export type DeclaredError<R extends ErrorReason> = {
 export type DeclaredErrors<C> = {
     [R in keyof C & ErrorReason]: DeclaredError<R>;
 };
-/**
- * The oRPC error map for `conditions` (reason -> when it is answered, one sentence), each with its
- * reason's status and data schema from `table`. errors() below and the console's wrap it; they
- * are declared functions with named return types so declarations reference the table by name
- * instead of inlining it into every route.
- */
 export declare function errorMap(table: ReasonTable, conditions: Record<string, string | undefined>): Record<string, {
     status: number;
     message: string;
     data?: unknown;
 }>;
-/** The error map of a /v1 route; console routes use console/reasons.ts's, which knows theirs. */
 export declare function errors<const C extends {
     [R in ErrorReason]?: string;
 }>(conditions: C): DeclaredErrors<C>;
-/** What any route can answer with, whoever calls it and whatever it does. */
 export declare const GLOBAL_ERRORS: DeclaredErrors<{
     readonly invalid_input: "The request does not match the operation's input schema (a malformed body included); data.issues names each problem.";
     readonly unauthenticated: "No usable credential: none was sent, or it is malformed, unknown, revoked or an expired account token.";
@@ -32,6 +23,8 @@ export declare const GLOBAL_ERRORS: DeclaredErrors<{
     readonly missing_scope: "The API key lacks the scope the operation needs.";
     readonly role_forbidden: "The member's role does not allow the operation.";
     readonly account_token_forbidden: "An account token called an operation account tokens cannot call.";
+    readonly account_scope_forbidden: "A credential limited to specific accounts called an operation that reaches beyond them.";
+    readonly mcp_only_key: "An MCP-only key (minted for an end user's MCP client) was used outside the MCP server.";
     readonly rate_limited: "The tenant used up its plan's request rate; Retry-After says when the window ends.";
     readonly too_many_requests: "The credential has too many requests in flight at once; retry after Retry-After.";
     readonly overloaded: "The API is shedding load; retry after Retry-After.";
@@ -41,7 +34,6 @@ export declare const GLOBAL_ERRORS: DeclaredErrors<{
     readonly idempotency_key_reused: "POST only: the Idempotency-Key was used in the last 24 hours with another method, path or body.";
     readonly idempotency_key_in_progress: "POST only: the request first sent with this Idempotency-Key has not been answered yet.";
 }>;
-/** The builder every route starts from: oc with GLOBAL_ERRORS declared. */
 export declare const base: import("@orpc/contract").ContractBuilder<import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").MergedErrorMap<Record<never, never>, DeclaredErrors<{
     readonly invalid_input: "The request does not match the operation's input schema (a malformed body included); data.issues names each problem.";
     readonly unauthenticated: "No usable credential: none was sent, or it is malformed, unknown, revoked or an expired account token.";
@@ -49,6 +41,8 @@ export declare const base: import("@orpc/contract").ContractBuilder<import("@orp
     readonly missing_scope: "The API key lacks the scope the operation needs.";
     readonly role_forbidden: "The member's role does not allow the operation.";
     readonly account_token_forbidden: "An account token called an operation account tokens cannot call.";
+    readonly account_scope_forbidden: "A credential limited to specific accounts called an operation that reaches beyond them.";
+    readonly mcp_only_key: "An MCP-only key (minted for an end user's MCP client) was used outside the MCP server.";
     readonly rate_limited: "The tenant used up its plan's request rate; Retry-After says when the window ends.";
     readonly too_many_requests: "The credential has too many requests in flight at once; retry after Retry-After.";
     readonly overloaded: "The API is shedding load; retry after Retry-After.";
@@ -59,46 +53,60 @@ export declare const base: import("@orpc/contract").ContractBuilder<import("@orp
     readonly idempotency_key_in_progress: "POST only: the request first sent with this Idempotency-Key has not been answered yet.";
 }>>, Record<never, never>>;
 export declare const SESSION_ONLY: DeclaredErrors<{
-    readonly session_required: "The caller is not a board session (only board sessions may call this).";
+    readonly session_required: "The caller is not a console session (only console sessions may call this).";
 }>;
 export declare const OWNER_ONLY: DeclaredErrors<{
-    readonly session_required: "The caller is not a board session (only board sessions may call this).";
+    readonly session_required: "The caller is not a console session (only console sessions may call this).";
     readonly owner_required: "The caller does not own the organization.";
 }>;
 export declare const PLATFORM_ONLY: DeclaredErrors<{
-    readonly session_required: "The caller is not a board session (only board sessions may call this).";
+    readonly session_required: "The caller is not a console session (only console sessions may call this).";
     readonly platform_admin_required: "The caller is not a platform administrator.";
     readonly email_verification_required: "The platform administrator has not verified their email address yet.";
 }>;
-/** The account a path names: missing, deleted, or another account than an account token's. */
 export declare const ACCOUNT_NOT_FOUND: DeclaredErrors<{
     readonly account_not_found: "The account does not exist, or the caller is an account token for another account.";
 }>;
-/** The account states that keep a route from reaching the provider; `account` names the account
- * and may narrow when, e.g. "With source=provider, the account". */
+export declare const MAIL_ACCOUNT: {
+    mail_disabled: {
+        status: 409;
+        message: string;
+    };
+    account_not_found: {
+        status: 404;
+        message: string;
+    };
+    plan_module_unavailable: {
+        status: 403;
+        message: string;
+    };
+};
 export declare function accountState(account?: string): DeclaredErrors<{
     readonly account_paused: `${string} is paused.`;
     readonly account_disabled: `${string} is disabled.`;
     readonly account_reauth_required: `${string} must be reconnected: its stored grant or login no longer works.`;
     readonly account_misconfigured: `${string}'s stored grant cannot be used until an administrator fixes what it relies on (the tenant's OAuth app or organization connection is refused, missing or unreadable).`;
 }>;
-/** What any provider call answers when it fails. A route the provider can refuse adds
- * `provider_forbidden` with its own condition, and one reading an item `provider_not_found`. */
 export declare const PROVIDER_FAILURES: DeclaredErrors<{
     readonly provider_throttled: "The provider asked us to slow down (with Retry-After when it named a wait).";
     readonly provider_unavailable: "The provider could not be reached (with Retry-After when it named a wait).";
 }>;
-/** What asking for stored bodies through `field` refuses. */
 export declare function bodyStorage(field: string): DeclaredErrors<{
     readonly storage_unavailable: `${string} is cache or full and no object store is configured.`;
     readonly plan_limit_storage: `${string} is cache or full and the tenant's plan does not include body storage.`;
 }>;
-/** A route of a module the tenant's plan may lack, e.g. planModule("calendar"). */
 export declare function planModule(module: string): DeclaredErrors<{
     readonly plan_module_unavailable: `The tenant's plan does not include ${string}.`;
 }>;
+export declare const PLAN_REQUIRED_CONDITION = "The workspace has no plan and is not its owner's Free workspace (the Free plan covers one workspace per owner): choose a plan under Billing.";
+export declare const PLAN_REQUIRED: DeclaredErrors<{
+    readonly plan_required: "The workspace has no plan and is not its owner's Free workspace (the Free plan covers one workspace per owner): choose a plan under Billing.";
+}>;
+export declare function spendCapCondition(what: string): string;
 export declare const PLAN_LIMIT_ACCOUNTS: DeclaredErrors<{
     readonly plan_limit_accounts: "The tenant already has as many accounts as its plan allows.";
+    readonly plan_required: "The workspace has no plan and is not its owner's Free workspace (the Free plan covers one workspace per owner): choose a plan under Billing.";
+    readonly spend_cap_reached: string;
 }>;
 export declare const BILLING_PAST_DUE: DeclaredErrors<{
     readonly billing_past_due: "The tenant's payment is past due beyond the grace period (sends already queued or scheduled still go out).";