@calmlens/sdk 0.16.2 → 0.17.1

package/esm/testing.d.ts

@@ -1,17 +1,125 @@
-import { $ as SearchAssetsOptions, A as DeleteAssetContentOptions, B as Lens, C as CdnAssetUrlOptions, D as CreateAssetSignedUrlOptions, G as ModerateTextOptions, H as ListAssetChildrenOptions, K as MoveAssetOptions, M as EnsureLensOptions, N as EnsureLensesOptions, O as CreateFolderOptions, P as FolderIdOptions, Q as RetryAssetOptions, R as IterateAssetChildrenOptions, S as CalmLensServerClientOptions, Tt as Folder, U as ListAssetsOptions, W as ListEventsOptions, Z as RetrieveAssetOptions, _ as AssetSearchResponse, _t as TypedEvent, a as AssetChildrenPage, at as UpdateFolderOptions, et as SignUploadTokenOptions, ht as Event, it as UpdateAssetOptions, j as DeleteAssetOptions, jt as AssetBinaryPayloadInput, mt as PostAssetSignedUrlResponse, n as WebhookEventPayload, ot as UploadAssetPartOptions, p as AssetPage, pt as GetEventsResponse, q as MoveFolderOptions, r as Asset, rt as SubmitAssetOptions, tt as SignedUploadToken, ut as WaitForAssetDecisionOptions, w as CdnServeOptions, wt as PermissionGrant, z as IterateAssetsOptions } from "./WebhookPayload-CJoIkGBD.js";
-import { t as ClassificationTestSignal } from "./TestTriggers-CRKtulyp-vrzEq2wm.js";
-//#region src/contract/MediaTestTriggers.d.ts
-//#region packages/shared/src/MediaTestTriggers.d.ts
-export declare const MEDIA_TEST_SIGNALS: readonly ["sexual", "violence", "self-harm", "harassment", "hate", "criminal-activity", "violence.graphic"];
+import { Ft as TypedEvent, Ht as PermissionGrant, T as CalmLensServerClientOptions, Ut as Folder, Yt as AssetBinaryPayloadInput, _t as SignedUploadToken, f as AssetModeration, gt as SignUploadTokenOptions, n as Asset, w as CalmLensAppClientOptions } from "./CalmLensTypes-9Vt16pc7.js";
+import { t as CalmLensAppClient } from "./CalmLensAppClient-CV_K26Ce.js";
+import { l as ApiErrorCode, n as WebhookEventPayload } from "./WebhookPayload-2aL31v0J.js";
+import { t as CalmLensServerClient } from "./CalmLensServerClient-JtP687a3.js";
+import { t as ClassificationTestSignal } from "./TestTriggers-By07LR31-CmK0yTyR.js";
+import "zod";
+/**
+ * Signs a single-use upload token with `apiKey`, locally. `CalmLensServerClient` and
+ * `MockCalmLensServerClient` share it so both check options the same way. `@calmlens/sdk/testing`
+ * exports it as `signUploadToken`, whose fixed `now` (milliseconds since the epoch) and `nonce`
+ * give the same token every time, for comparing with known tokens in tests.
+ */
+declare const signUploadTokenWithApiKey: (apiKey: string, options: SignUploadTokenOptions, { now, nonce }?: {
+  now?: number;
+  nonce?: string;
+}) => Promise<SignedUploadToken>;
+export declare const MEDIA_TEST_SIGNALS: readonly ["sexual", "violence", "self-harm", "harassment", "hate", "criminal-activity", "personal-information", "profanity", "violence.graphic"];
 /** Read this aloud, or render it as large, high-contrast text in a video frame. */
-export declare function generateMediaTestCode(signal: ClassificationTestSignal, testInputKey: string): string;
-//#endregion
-//#endregion
-//#region src/testing/MockApiKey.d.ts
+export declare function generateMediaTestCode(signal: ClassificationTestSignal, testInputKey: string): Promise<string>;
 export declare const MOCK_API_KEY_PREFIX = "sk_test_";
 export declare const createMockApiKey: (grants?: PermissionGrant[]) => string;
-//#endregion
-//#region src/testing/MockStorage.d.ts
+/**
+ * The prefix of every kind of object customers can see, so an ID says what it identifies:
+ * `proj_8fK2mQx7Lp4NvB3tRz9Y` is a project. Rows that never leave the backend (usage meters, upload
+ * token uses, retained variants, terms acceptances, notices) keep their own internal IDs.
+ */
+declare const ID_PREFIXES: {
+  readonly organisation: "org";
+  readonly project: "proj";
+  readonly asset: "asset";
+  readonly folder: "fldr";
+  readonly lens: "lens";
+  readonly apiKey: "key";
+  readonly uploadPreset: "preset";
+  readonly connector: "conn";
+  readonly connectorDelivery: "dlv";
+  readonly hashList: "hl";
+  readonly hashListEntry: "hle";
+  readonly policy: "pol";
+  readonly event: "evt";
+  readonly user: "user";
+  readonly member: "mem";
+  readonly invitation: "inv";
+  readonly supportTicket: "tkt";
+  readonly supportTicketMessage: "msg";
+  readonly humanReview: "rev";
+  readonly appeal: "apl";
+  readonly complianceCase: "case";
+  readonly safetyHold: "hold";
+  readonly creditPurchase: "cp";
+  readonly oauthClient: "oac";
+  readonly waitlistEntry: "wl";
+};
+type IdKind = keyof typeof ID_PREFIXES;
+type IdPrefix = (typeof ID_PREFIXES)[IdKind];
+/** The parent categories, in the API's order. */
+declare const MOCK_CATEGORIES: readonly ["sexual", "violence", "self-harm", "harassment", "hate", "criminal-activity", "personal-information", "profanity"];
+/**
+ * Where the mock's moderation leaves an upload: `pending` (still processing), `failed`
+ * (processing failed, retryable), or a decision with that moderation status (`purged` also
+ * removes the content).
+ */
+type MockAssetOutcome = "pending" | "failed" | "allowed" | "limited" | "age-restricted" | "blocked" | "purged";
+type Category = (typeof MOCK_CATEGORIES)[number];
+/**
+ * A moderation decision for `mockOptions.moderate` or `completeProcessing`, built with
+ * `mockDecision(status)`: flag the categories it found, with their scores and qualifiers, and
+ * mark the categories it couldn't assess. Each call checks its names and scores and throws
+ * `sdk/invalid-argument` for one CalmLens doesn't have.
+ */
+export declare class MockDecision {
+  #private;
+  readonly status: MockAssetOutcome;
+  constructor(status: MockAssetOutcome);
+  /**
+   * Records findings in `category` with its `score` (0 to 1) and, optionally, scores for its
+   * qualifiers, such as `{ "violence-threat": 0.9 }`. The policy acts on a category at 0.5 and
+   * above, so `flaggedCategories` lists it there unless the status is `allowed`.
+   */
+  flag(category: Category, score: number, qualifiers?: Record<string, number>): this;
+  /** Marks `category` as not assessed (`not-evaluated` for reason `not-supported`). */
+  notEvaluated(category: Category): this;
+  /**
+   * The report a decided asset gets, as the API sends it: every category (unflagged ones
+   * evaluated with score 0), policy-adjusted results and the automated action and
+   * `flaggedCategories`. `undefined` for `pending` and `failed`.
+   */
+  report(): Omit<AssetModeration, "status" | "manualReviews"> | undefined;
+}
+/** Starts a moderation decision with this status; see `MockDecision`. */
+export declare const mockDecision: (status: MockAssetOutcome) => MockDecision;
+/** Why the mock is moderating an asset, for `mockOptions.moderate`. */
+type MockModerationTrigger =
+/** An upload completed: `assets.create`, `assets.classify`, `text.classify` or a final part. */
+"upload" |
+/** `assets.retry` queued a failed asset again. */
+"retry" |
+/** `assets.explain` with `rerun: true` queued the asset again. */
+"rerun" |
+/** `completeProcessing(assetId)` finished processing without a decision of its own. */
+"complete";
+/** What `mockOptions.moderate` receives for each asset the mock moderates. */
+interface MockModerationInput {
+  /** The asset as stored, still processing. */
+  asset: Asset;
+  /** The uploaded bytes (`null` without stored content, such as a website), and the text of a plain-text upload. */
+  content: {
+    bytes: Uint8Array | null;
+    text: string | null;
+  };
+  trigger: MockModerationTrigger;
+  /**
+   * `true` when the API would queue the work rather than answer with the decision: queued
+   * uploads, retries, reruns and `completeProcessing`.
+   */
+  queued: boolean;
+}
+/**
+ * Decides an asset the mock moderates: a status or a `mockDecision(...)`, or a promise of one.
+ * Without it, queued uploads, retries and reruns stay `pending` and everything else is `allowed`.
+ */
+type MockModerate = (input: MockModerationInput) => MockAssetOutcome | MockDecision | Promise<MockAssetOutcome | MockDecision>;
 interface MockStoredContent {
   assetId: string;
   parts: Map<number, Uint8Array>;
@@ -68,208 +176,196 @@ export declare class InMemoryMockDatabaseStorage implements MockDatabaseStorage
   listFolders(projectId: string): Promise<Folder[]>;
   deleteFolder(folderId: string): Promise<void>;
 }
-//#endregion
-//#region src/testing/MockCalmLensServerClient.d.ts
-interface MockCalmLensServerClientOptions extends CalmLensServerClientOptions {
-  mockOptions?: {
-    databaseStorage?: MockDatabaseStorage;
-    imageStorage?: MockImageStorage;
-    createId?: () => string;
-    now?: () => number;
-    /** Outcome of `assets.create` (and queued multipart uploads). Defaults to `pending`. */
-    queuedOutcome?: MockAssetOutcome;
-    /** Outcome of `assets.moderate` and `text.moderate`. Defaults to `approved`. */
-    analyzedOutcome?: MockAssetOutcome;
-    signedUrlBaseUrl?: string;
-  };
-}
+/** A reviewer's decision for `decide`: the moderation status it gives the asset. */
+type MockReviewDecision = "allowed" | "limited" | "age-restricted" | "blocked" | "purged";
 /**
- * Where a mock upload ends up: `pending` (still processing), `approved` or `rejected` (processing
- * done with that decision), or `failed` (processing failed, retryable).
+ * A client method, named like its path on the client. A request is recorded under the first
+ * method that sends it; `callsTo` and `failNextRequest` also match the others (see
+ * `MockCalmLensCall`).
  */
-type MockAssetOutcome = "pending" | "approved" | "rejected" | "failed";
-/** The options each `MockCalmLensServerClient` method was given, by operation name. */
-interface MockCalmLensOperationOptions {
-  "assets.list": ListAssetsOptions;
-  "assets.search": SearchAssetsOptions;
-  "assets.retrieve": RetrieveAssetOptions;
-  "assets.update": UpdateAssetOptions;
-  "assets.listChildren": ListAssetChildrenOptions;
-  "assets.create": SubmitAssetOptions;
-  "assets.moderate": SubmitAssetOptions;
-  "assets.uploadPart": UploadAssetPartOptions;
-  "assets.createSignedUrl": CreateAssetSignedUrlOptions;
-  "assets.move": MoveAssetOptions;
-  "assets.retry": RetryAssetOptions;
-  "assets.waitForDecision": WaitForAssetDecisionOptions;
-  "assets.deleteContent": DeleteAssetContentOptions;
-  "assets.delete": DeleteAssetOptions;
-  "text.moderate": ModerateTextOptions;
-  "cdn.serve": CdnServeOptions;
-  "events.list": ListEventsOptions;
-  "folders.list": undefined;
-  "folders.retrieve": FolderIdOptions;
-  "folders.create": CreateFolderOptions;
-  "folders.update": UpdateFolderOptions;
-  "folders.delete": FolderIdOptions;
-  "folders.move": MoveFolderOptions;
-  ensureLens: EnsureLensOptions;
-  ensureLenses: EnsureLensesOptions;
-  "uploadTokens.sign": SignUploadTokenOptions;
-}
-/** A `MockCalmLensServerClient` method, named like its path on the client. */
-type MockCalmLensOperation = keyof MockCalmLensOperationOptions;
+type MockCalmLensOperation = "assets.list" | "assets.iterate" | "assets.search" | "assets.retrieve" | "assets.waitForDecision" | "assets.update" | "assets.listChildren" | "assets.iterateChildren" | "assets.create" | "assets.classify" | "assets.uploadPart" | "assets.createSignedUrl" | "assets.move" | "assets.retry" | "assets.explain" | "assets.decide" | "assets.deleteContent" | "assets.delete" | "assets.batch" | "text.classify" | "cdn.serve" | "events.list" | "events.pages" | "folders.list" | "folders.retrieve" | "folders.create" | "folders.update" | "folders.delete" | "folders.move" | "hashLists.list" | "hashLists.retrieve" | "hashLists.create" | "hashLists.update" | "hashLists.delete" | "hashLists.listEntries" | "hashLists.addEntry" | "hashLists.removeEntry" | "ensureLens" | "ensureLenses";
 /**
- * One recorded call: the method and the options object it was given, exactly as passed. Narrow
- * on `operation` (or use `callsTo`) to get its options type.
+ * One request a mock client sent, as the in-memory API received it. `operation` is the client
+ * method that sends it; requests several methods send are recorded under the first: `text.classify`
+ * as `assets.classify`, `ensureLens` as `ensureLenses`, `assets.waitForDecision` polls as
+ * `assets.retrieve`, `assets.iterate` pages as `assets.list`, and so on. `callsTo` matches all of
+ * them. Methods that send nothing, such as `uploadTokens.sign` or a cached `ensureLens`, are not
+ * recorded.
  */
-type MockCalmLensCall<TOperation extends MockCalmLensOperation = MockCalmLensOperation> = { [Operation in TOperation]: {
-  operation: Operation;
-  options: MockCalmLensOperationOptions[Operation];
-}; }[TOperation];
+interface MockCalmLensCall {
+  operation: MockCalmLensOperation;
+  method: string;
+  /** The request URL. */
+  url: string;
+  /** The path after the API (or CDN) base URL, with each segment decoded, such as `/assets/a1`. */
+  path: string;
+  /** Query parameters as sent, such as `{ "ordering[0][field]": "createdAt" }`. */
+  query: Record<string, string>;
+  /** Request headers, with lowercase names. */
+  headers: Record<string, string>;
+  /** The JSON body, the text of a `text/*` upload, the bytes of another upload, or `undefined`. */
+  body: unknown;
+  /** The HTTP status the mock answered with, or `undefined` when the request failed without one. */
+  status: number | undefined;
+}
 /**
- * What a simulated request failure throws: `"transport-error"` and `"timeout"` throw the same
- * `CalmLensError` the real client throws for a network failure (`sdk/transport-error`) or a
- * deadline (`sdk/timeout`); any `Error` is thrown as given.
+ * What a simulated request failure does: `"transport-error"` and `"timeout"` fail the request
+ * like a network failure (`sdk/transport-error`) or a deadline (`sdk/timeout`); an API error
+ * code, such as `"upload/limit-exceeded"`, answers with that API error and its HTTP status; a
+ * `CalmLensError` is thrown as is and any other `Error` as the cause of `sdk/transport-error`,
+ * like an exception from `fetch`.
  */
-type MockRequestFailure = "transport-error" | "timeout" | Error;
+type MockRequestFailure = "transport-error" | "timeout" | ApiErrorCode | Error;
+/** Options for a simulated API error: its `details` and the `Retry-After` it answers with. */
+interface MockFailureOptions {
+  operation?: MockCalmLensOperation;
+  /** The error's `details`, for an API error code. */
+  details?: Record<string, unknown>;
+  /** Seconds for the `Retry-After` header, for an API error code. */
+  retryAfter?: number;
+}
 /** An event to add to the mock feed; omitted fields get defaults. */
 type MockEventInput = Partial<Omit<TypedEvent, "type">> & {
   type: TypedEvent["type"];
 };
+/** The upload preset settings a `MockCalmLensAppClient` applies, as the API would. */
+interface MockUploadPreset {
+  /** Refuse uploads without a token, like **Users your server approves**. Defaults to `false`. */
+  requireToken?: boolean;
+  /** Accepted content types, such as `["image/*"]`. Defaults to any type. */
+  allowedContentTypes?: string[];
+  maxFileSizeInBytes?: number;
+  /** Return `status` to the uploader. Defaults to `true`. */
+  showDecisions?: boolean;
+  /** Defaults to `public`. */
+  visibility?: "public" | "private";
+  /** Defaults to `true`, so the CDN can serve the upload. */
+  keepContentAfterProcessing?: boolean;
+  folderId?: string | null;
+}
+interface MockCalmLensServerClientOptions extends CalmLensServerClientOptions {
+  mockOptions?: {
+    databaseStorage?: MockDatabaseStorage;
+    imageStorage?: MockImageStorage;
+    /**
+     * Returns a new ID for an object of the kind `prefix` names (`asset`, `fldr`, `hl`, `hle`,
+     * `lens`, `evt` or `rev`). The default is like the API's: the prefix, `_` and 20 random
+     * base62 characters, such as `asset_5Gm2Rk8XqT3wLp9VbN4c`.
+     */
+    createId?: (prefix: IdPrefix) => string;
+    /**
+     * The clock, in epoch milliseconds. The default is the system clock, moved on by at least a
+     * millisecond per reading, so assets created in a row have increasing `createdAt` values and
+     * orderings by `createdAt` don't depend on IDs.
+     */
+    now?: () => number;
+    /**
+     * Decides each asset the mock moderates, from the stored asset, its content (bytes, and the
+     * text of a plain-text upload) and why it is moderated (`upload`, `retry`, `rerun` or
+     * `complete`). Return a status or a `mockDecision(...)`, whose report fills the asset's
+     * categories and policy. Without it, queued uploads, retries and reruns stay `pending` until
+     * `completeProcessing`, and everything else is `allowed`.
+     */
+    moderate?: MockModerate;
+    signedUrlBaseUrl?: string;
+  };
+}
 /**
- * An in-memory stand-in for `CalmLensServerClient` with the same methods, validation and error
- * codes. API errors carry the HTTP status, a `requestId` and response headers like the real
- * client's, so error handling can be tested without a network.
+ * The real `CalmLensServerClient`, answered by an in-memory CalmLens API and CDN instead of the
+ * network: every method runs the real client's code, and the in-memory API answers its requests
+ * with the API's statuses, bodies, error bodies and headers. Mock helpers decide assets, add
+ * events, change the API key's grants, fail requests and list the requests sent.
  */
-export declare class MockCalmLensServerClient {
+export declare class MockCalmLensServerClient extends CalmLensServerClient {
+  #private;
   readonly databaseStorage: MockDatabaseStorage;
   readonly imageStorage: MockImageStorage;
-  private readonly createId;
-  private readonly now;
-  private readonly queuedOutcome;
-  private readonly analyzedOutcome;
-  private readonly apiKeyGrants;
-  private readonly signedUrlBaseUrl;
-  private readonly cdnBaseUrl;
-  private readonly projectId;
-  private readonly apiKey;
-  private readonly lenses;
-  private readonly eventFeed;
-  /** The queue mode each open multipart upload was started with, as the API saves it. */
-  private readonly uploadQueues;
-  private readonly idempotentResults;
-  private requestCount;
-  private readonly pendingFailures;
-  /** Every call made through this client, oldest first. */
-  readonly calls: MockCalmLensCall[];
-  /** Accepts the same options as `CalmLensServerClient` (validated the same way), plus `mockOptions`. */
+  /**
+   * Accepts the same options as `CalmLensServerClient` (validated the same way), plus
+   * `mockOptions`. `maxRetries` defaults to 0, so a failed request fails once; retry backoff and
+   * `assets.waitForDecision` take no real time.
+   */
   constructor(options: MockCalmLensServerClientOptions);
   /**
-   * Makes the next call (or the next call to `operation`) throw `failure` instead of running,
-   * as if the request never completed. Queue several to fail several calls in a row.
+   * Every request sent to the mock's API and CDN, oldest first, by this client and the
+   * `MockCalmLensAppClient`s that use it, each with the client method that sent it.
    */
-  failNextRequest(failure?: MockRequestFailure, { operation }?: {
-    operation?: MockCalmLensOperation;
-  }): void;
-  /** Calls recorded for one operation, oldest first. */
-  callsTo<TOperation extends MockCalmLensOperation>(operation: TOperation): MockCalmLensCall<TOperation>[];
+  get calls(): MockCalmLensCall[];
+  /**
+   * Requests `operation` sends, oldest first. A request several methods send matches each of
+   * them: `callsTo("text.classify")` also lists `assets.classify` text uploads, and
+   * `callsTo("assets.waitForDecision")` the `assets.retrieve` requests it polls with.
+   */
+  callsTo(operation: MockCalmLensOperation): MockCalmLensCall[];
+  /** Forgets the requests recorded so far, so `calls` lists only later ones. */
+  clearCalls(): void;
+  /**
+   * Makes the next request (or the next one `operation` sends) fail instead of reaching the
+   * in-memory API. Each queued failure fails one request, so a retry takes the next queued
+   * failure or reaches the API. An API error code answers with that error and its HTTP status,
+   * with `details` and a `Retry-After` of `retryAfter` seconds when given.
+   */
+  failNextRequest(failure?: MockRequestFailure, options?: MockFailureOptions): void;
+  /**
+   * Changes the grants of the mock's API key, as editing the key in the portal would: later
+   * requests, such as `cdn.serve`, use them. The key itself stays the same, so idempotency keys
+   * it used still replay.
+   */
+  setApiKeyGrants(grants: PermissionGrant[]): void;
   /**
    * Adds an event to the feed `events.list` reads, as if CalmLens had recorded it. Returns the
    * stored event; pass it to `toWebhookEventPayload` to build a matching webhook body.
    */
-  enqueueEvent(input: MockEventInput): TypedEvent;
-  /** An API error as the real client throws it: status, default message and request ID. */
-  private apiError;
-  private assertValidUploadMimeType;
-  private invalidPayload;
-  private findOwnAsset;
-  private begin;
-  private jsonResponse;
-  get cdn(): {
-    getAssetUrl: ({ assetIdentifier, ...options }: CdnAssetUrlOptions) => string;
-    /**
-     * Serves stored content like the CDN: `200` with `Content-Type`, `Content-Length`,
-     * `ETag` and `X-Request-Id`, or a JSON error body with `404`/`403`. Never throws for
-     * HTTP errors, like the real client.
-     */
-    serve: (serveOptions: CdnServeOptions) => Promise<Response>;
-  };
-  get events(): {
-    /**
-     * Reads the mock feed like the API: without `after`, no events and a cursor for "now";
-     * with `after`, up to `limit` events added since, oldest first. Add events with
-     * `enqueueEvent`.
-     */
-    list: (options?: ListEventsOptions) => Promise<GetEventsResponse>;
-    pages: (options?: ListEventsOptions) => AsyncGenerator<GetEventsResponse, void, undefined>;
-  };
-  private listEvents;
-  private iterateEventPages;
-  private iteratePages;
-  get text(): {
-    moderate: (options: ModerateTextOptions) => Promise<Asset>;
-  };
-  get assets(): {
+  enqueueEvent(input: MockEventInput): Promise<TypedEvent>;
+  /**
+   * Applies a reviewer's decision to a stored asset, as the portal or API would: the moderation
+   * status changes (`purged` also removes the content, with reason `requested` and an
+   * `asset.content-removed` event), the review joins `manualReviews`, and an `asset.<decision>`
+   * event with a `decided-by: reviewer` fact joins the events feed. Rejects with
+   * `asset/not-found` for an unknown asset. It sends no request.
+   */
+  decide(assetId: string, decision: MockReviewDecision): Promise<Asset>;
+  /**
+   * Finishes processing a pending asset as the moderation pipeline would: with `decision`, or
+   * else what `mockOptions.moderate` returns for the `complete` trigger (`allowed` by default).
+   * The asset gets the decision's report, and `asset.classified` and the automated
+   * `asset.<status>` (or `asset.failed`) join the events feed. No review is recorded, so the
+   * asset can still be moderated again. Rejects with `asset/not-found` for an unknown asset and
+   * `sdk/invalid-argument` for one that isn't processing. It sends no request.
+   */
+  completeProcessing(assetId: string, decision?: MockAssetOutcome | MockDecision): Promise<Asset>;
+}
+interface MockCalmLensAppClientOptions extends CalmLensAppClientOptions {
+  mockOptions?: {
     /**
-     * Matches `query` (case-insensitively) against each asset's name, ID, external ID,
-     * description and tags, best match first. Mock scores are 1 for an exact match and 0.5
-     * otherwise; `mode` is accepted but there is no semantic search.
+     * The mock project the uploads go into. Pass the `MockCalmLensServerClient` your server code
+     * uses to see the uploads there and serve them from its CDN. Without one, the client creates
+     * its own, available as `server`.
      */
-    search: (options: SearchAssetsOptions) => Promise<AssetSearchResponse>;
-    /** Lists assets with the real client's paging, `ordering`, `folderId` and `filter`. */
-    list: (options?: ListAssetsOptions) => Promise<AssetPage>;
-    iterate: (options?: IterateAssetsOptions) => AsyncGenerator<Asset, void, undefined>;
-    retrieve: (options: RetrieveAssetOptions) => Promise<Asset>;
-    listChildren: (childrenOptions?: ListAssetChildrenOptions) => Promise<AssetChildrenPage>;
-    iterateChildren: (options: IterateAssetChildrenOptions) => AsyncGenerator<Asset, void, undefined>;
-    update: (options: UpdateAssetOptions) => Promise<Asset>;
-    create: (options: SubmitAssetOptions) => Promise<Asset>;
-    moderate: (options: SubmitAssetOptions) => Promise<Asset>;
-    /** Continues a multipart upload: parts must arrive in order while it is `uploading`. */
-    uploadPart: (options: UploadAssetPartOptions) => Promise<Asset>;
-    createSignedUrl: (signedUrlOptions: CreateAssetSignedUrlOptions) => Promise<PostAssetSignedUrlResponse>;
-    move: (options: MoveAssetOptions) => Promise<Asset>;
-    retry: (options: RetryAssetOptions) => Promise<Asset>;
-    /** Waits like the real client, checking the mock's storage for a decision. */
-    waitForDecision: (options: WaitForAssetDecisionOptions) => Promise<Asset>;
-    deleteContent: (options: DeleteAssetContentOptions) => Promise<Asset>;
-    delete: (options: DeleteAssetOptions) => Promise<void>;
+    server?: MockCalmLensServerClient;
+    preset?: MockUploadPreset;
+    /** The server's `mockOptions.moderate` when the client creates its own server. */
+    moderate?: MockModerate;
   };
-  /** Signs real upload tokens with the mock's API key, like the real client, without a request. */
-  get uploadTokens(): {
-    sign: (options: SignUploadTokenOptions) => Promise<SignedUploadToken>;
-  };
-  get folders(): {
-    list: () => Promise<Folder[]>;
-    retrieve: (options: FolderIdOptions) => Promise<Folder>;
-    create: (options: CreateFolderOptions) => Promise<Folder>;
-    update: (options: UpdateFolderOptions) => Promise<Folder>;
-    delete: (options: FolderIdOptions) => Promise<void>;
-    move: (options: MoveFolderOptions) => Promise<Folder>;
-  };
-  ensureLens(options: EnsureLensOptions): Promise<Lens>;
-  private ensureLensDefinition;
-  ensureLenses(options: EnsureLensesOptions): Promise<Lens[]>;
-  /** Replays the first result for a reused idempotency key, like the API. */
-  private withIdempotency;
-  private moderateAsset;
-  private createAsset;
-  /**
-   * Moves an asset to `outcome` like the pipeline would: a decision finishes processing, and
-   * finished processing removes content kept only temporarily (`keepContentAfterProcessing` off).
-   */
-  private applyOutcome;
-  private resolveFolder;
-  private findOwnFolder;
-  private assertUniqueFolderName;
-  private getContentFormat;
-  private getSizeInBytes;
 }
-//#endregion
-//#region src/testing/MockWebhooks.d.ts
-/** The JSON body of a webhook delivery for a stored event (or an event from `events.list`). */
-export declare const toWebhookEventPayload: (event: Event) => WebhookEventPayload;
+/**
+ * The real `CalmLensAppClient`, answered by the in-memory API of a `MockCalmLensServerClient`.
+ * The API applies `mockOptions.preset` to this client's uploads like CalmLens applies an upload
+ * preset: its token, content type and size rules with the API's error codes, and its visibility,
+ * folder, content retention and decision display. The client can check and continue only the
+ * uploads it made.
+ */
+export declare class MockCalmLensAppClient extends CalmLensAppClient {
+  #private;
+  /** The mock project the uploads are stored in. */
+  readonly server: MockCalmLensServerClient;
+  constructor(options: MockCalmLensAppClientOptions);
+}
+/**
+ * The JSON body of a webhook delivery for an event, such as one from `events.list`: the event in
+ * the same shape `events.list` returns it. Fields that are not part of that shape are left out.
+ */
+export declare const toWebhookEventPayload: (event: TypedEvent) => WebhookEventPayload;
 /** `v1=<hex HMAC-SHA256 of "<timestamp>.<body>">`, the `x-calmlens-signature` header value. */
 export declare const createWebhookSignatureHeader: (secret: string, timestamp: number | string, body: string) => Promise<string>;
 /** Headers for one signed delivery of `body`, as CalmLens sends them. */
@@ -279,5 +375,4 @@ export declare const createWebhookHeaders: (options: {
   deliveryId: string;
   timestampSeconds?: number;
 }) => Promise<Record<string, string>>;
-//#endregion
-export type { MockCalmLensCall, MockCalmLensOperation, MockCalmLensOperationOptions, MockCalmLensServerClientOptions, MockDatabaseStorage, MockEventInput, MockImageStorage, MockRequestFailure, MockStoredContent };
+export { type MockAssetOutcome, type MockCalmLensAppClientOptions, type MockCalmLensCall, type MockCalmLensOperation, type MockCalmLensServerClientOptions, type MockDatabaseStorage, type MockEventInput, type MockFailureOptions, type MockImageStorage, type MockModerate, type MockModerationInput, type MockModerationTrigger, type MockRequestFailure, type MockReviewDecision, type MockStoredContent, type MockUploadPreset, signUploadTokenWithApiKey as signUploadToken };