@observertc/observer-js 1.0.0-beta.15 → 1.0.0-beta.16

package/README.md

@@ -497,9 +497,15 @@ Key members:
 - `getOrCreateObservedCall<T>(settings): ObservedCall<T> | undefined`
 - `update(): void` — force an aggregation/`observer-updated` tick
 - `addObserverDetector(name, config?): this` — build a cross-call detector onto `observer.detectors`
-- `addCallDetector(name, config?): this` / `removeCallDetector(name): this` — register a call-scoped
-  detector for every call created **from now on**
+- `addCallDetector(name, config?): this` — register a call-scoped detector for every call created
+  from now on
+- `removeCallDetector(name, { includeOpenCalls? }): number` — stop building it, and (by default) drop
+  it from calls already open. Returns how many live instances were removed
+- `removeObserverDetector(name): number` — remove an observer-scoped detector. For one specific
+  instance use `observer.detectors.remove(detector)`
 - `addValidator(name, config?): this` — start a one-shot structural check
+- `cancelValidator(name | validator, reason?): number` — stop a running check; it finishes
+  `inconclusive` with the reason and emits `validation-ready`
 - `close(): void`
 - `readonly detectors: Detectors` — observer-scoped registry. **Starts empty**; nothing is implicit
 - `readonly callDetectorConfigs: Map<name, config>` — what `addCallDetector` recorded
@@ -532,6 +538,8 @@ Key members:
 - `getObservedClient<T>(clientId)`, `createObservedClient<T>(settings)`, `getOrCreateObservedClient<T>(settings)` (all `… | undefined`)
 - `addIssue(issue: ObserverIssue): void` — raise a **call-level** issue → emits `call-issue`
 - `addDetector(name, config?): this` — build a call-scoped detector onto this call only
+- `removeDetector(name): number` — remove it from this call, `close()`ing it. For one specific
+  instance use `call.detectors.remove(detector)`
 - `readonly detectors: Detectors` — server-side detector registry (empty by default; see [Detectors](#detectors-server-side-extension-point))
 - `readonly activeIssuesRegistry: ActiveIssuesRegistry` — this call's open client issues, propagating into the observer's
 - `readonly unconsumedOutboundTracks: Set<ObservedOutboundTrack>` — maintained by the resolver
@@ -959,12 +967,63 @@ observer.addObserverDetector('turn-server-outage-detector', { minClientsAtPeak:
 observer.addCallDetector('call-concurrent-issue-detector', {
   issueTypes: [ 'congestion', 'ice-disconnected' ],
 });
-observer.removeCallDetector('unconsumed-track-detector');   // undo, for future calls
-
 // one specific call
 observedCall.addDetector('issue-fan-out-detector', { issueTypes: [ 'freezed-video-track' ] });
 ```
 
+Every `add*` is **chainable** — it returns the owning entity:
+
+```ts
+observer
+  .addObserverDetector('turn-server-health-detector')
+  .addObserverDetector('turn-server-outage-detector', { minClientsAtPeak: 10 })
+  .addValidator('remote-track-resolver');
+```
+
+#### Removing them
+
+By **name**, on the entity — which removes *every* instance under that name:
+
+```ts
+observer.removeObserverDetector('turn-server-outage-detector');   // → 1
+observer.removeCallDetector('call-concurrent-issue-detector');    // stops it everywhere
+observedCall.removeDetector('issue-fan-out-detector');            // this call only
+```
+
+By **instance**, through the registry — which is where instances live, since `add*` returns the
+entity rather than the detector:
+
+```ts
+observer
+  .addObserverDetector('client-population-issue-detector', { issueTypes: [ 'cpulimitation' ], groupBy: 'browser' })
+  .addObserverDetector('client-population-issue-detector', { issueTypes: [ 'cpulimitation' ], groupBy: 'operationSystem' });
+
+const [ byBrowser, byOs ] = observer.detectors.getAll('client-population-issue-detector');
+
+observer.detectors.remove(byOs);   // keeps the browser axis running
+```
+
+`Detectors` is a small collection: `instances` (a copy, in registration order), `listOfNames`,
+`size`, `get(name)`, `getAll(name)`, `has(name)`, `add(detector)`, `remove(detector)`,
+`removeByName(name)`, `clear()`, and it is iterable — `for (const detector of call.detectors)`.
+`instances` being a copy is deliberate: removing while iterating the live array would skip entries,
+and "drop the ones that look like X" is the most natural thing to want to write.
+
+Two things worth knowing:
+
+- **By name removes every instance under it**, not the first. A name can legitimately be registered
+  more than once — `ClientPopulationIssueDetector` is meant to be added once per `groupBy` axis — and
+  "remove whichever is first in the array" is not something a caller can predict from a name. Go via
+  `detectors.getAll(name)` + `detectors.remove(instance)` when you mean one of them.
+- **`removeCallDetector` affects calls already open, by default.** Otherwise whether a detector runs
+  would depend on when a call happened to join, which is not a state anyone can reason about. Pass
+  `{ includeOpenCalls: false }` to change only what future calls are built with.
+
+Every removal path calls the detector's `close()`, so it unsubscribes from the issue registry and
+drops any timers or bus listeners. A detector removed without closing would keep being fed matching
+issues for the life of the call — invisible, unbounded, and it would still look healthy if you
+inspected it.
+
 Detectors are named by their kebab-case `NAME`, and the name types the config — an unknown name or a
 key that belongs to a different detector will not compile. Each detector owns its defaults in its own
 constructor, beside the doc explaining what each threshold means; there is no central table to keep
@@ -1093,6 +1152,23 @@ onDeploy(() => observer.addValidator('simulcast-receivers'));   // check again
 finishing. There is no revalidation timer: a deploy, not elapsed time, is what makes a structural
 verdict stale, so re-checking means starting another.
 
+**Cancelling.** A check that has not decided can be stopped, by name or by instance:
+
+```ts
+observer.cancelValidator('simulcast-receivers', 'sfu redeployed');
+
+// or one specific instance — `observer.validators` holds what is running
+for (const validator of observer.validators) observer.cancelValidator(validator, 'shutting down');
+```
+
+Cancelling is **not** silent discarding. The validator finishes `inconclusive` with your reason,
+emits `validation-ready` like any other completion, and removes itself. That matters twice over:
+anything waiting on the verdict would otherwise wait forever, and *"we stopped asking"* is a
+materially different outcome from *"we asked and learned nothing"* — which is exactly what an
+`inconclusive` carrying a reason records. Pass a real reason; the default tells the reader nothing
+they could not already infer. `observer.close()` cancels whatever is still running with
+`'observer closed'`.
+
 | Validator | `addValidator` name | Question | Also raises |
 |-----------|---------------------|----------|-------------|
 | `SimulcastReceiverValidator` 🔗 | `simulcast-receivers` | Does the SFU pick layers per receiver, or drag the publisher down to the worst one? | `WORST_RECEIVER_CONTAGION` |

package/dist/index.d.mts

@@ -2468,8 +2468,13 @@ interface Validator<S extends Record<string, unknown> = Record<string, unknown>>
     onDone: (report: ValidationReport<S>) => void;
     /** Gather evidence; decide if there is now enough. Called on every `observer.update()`. */
     update(): void;
-    /** Give up without a verdict. Finishes with `inconclusive`, so a caller waiting on it is freed. */
-    cancel: () => void;
+    /**
+     * Give up without a verdict. Finishes with `inconclusive`, so a caller waiting on it is freed.
+     *
+     * `reason` is carried into the report. Worth passing something specific — "cancelled" tells the
+     * reader nothing, whereas "sfu redeployed" explains why a check that was running has no verdict.
+     */
+    cancel: (reason?: string) => void;
 }
 /**
  * The part of a validator the observer needs in order to drive it.
@@ -4412,11 +4417,48 @@ type AvailableDetectorsConfigs = AvailableObserverScopeDetectorsConfigs | Availa
 declare class Detectors {
     private _detectors;
     constructor(...detectors: Detector[]);
+    /**
+     * Every registered detector, in registration order.
+     *
+     * This is **the** way to get hold of an instance: `addDetector` / `addObserverDetector` are
+     * chainable and return the owning entity, so the registry is where instances live. Read it to
+     * inspect a detector's state, or to pick one out and {@link remove} it.
+     *
+     * A copy, not the live array — a caller iterating this while removing would otherwise skip
+     * entries, and that is exactly what "remove the ones that look like X" does.
+     */
+    get instances(): Detector[];
+    /** Iterate the registry directly: `for (const detector of call.detectors)`. */
+    [Symbol.iterator](): IterableIterator<Detector>;
+    /** The names in registration order. Duplicates are meaningful — see {@link getAll}. */
     get listOfNames(): string[];
     get size(): number;
     add(detector: Detector): void;
+    /** The first detector registered under `name`. See {@link getAll} when several can share one. */
     get(name: string): Detector | undefined;
-    remove(detector: Detector): void;
+    /**
+     * Every detector registered under `name`.
+     *
+     * More than one is legitimate: `ClientPopulationIssueDetector` is meant to be added once per
+     * `groupBy` axis, and two instances of it share a name.
+     */
+    getAll(name: string): Detector[];
+    has(name: string): boolean;
+    /** Remove one specific instance. Returns `false` if it was not registered here. */
+    remove(detector: Detector): boolean;
+    /**
+     * Remove **every** detector registered under `name`, returning how many were removed.
+     *
+     * All of them rather than the first, because a name can legitimately be registered more than once
+     * (see {@link getAll}) and "remove the `client-population-issue-detector`" cannot sensibly mean
+     * "remove whichever axis happens to be first in the array". Removing all of them is the only
+     * behaviour that leaves the registry in a state the caller can predict from the name alone.
+     *
+     * Each removed detector gets `close()`, so trackers unsubscribe from the issue registry, bus
+     * listeners drop, and timers clear — a detector removed without closing keeps being fed issues
+     * forever.
+     */
+    removeByName(name: string): number;
     update(): void;
     clear(): void;
     private _close;
@@ -4565,7 +4607,32 @@ declare class ObservedCall<AppData extends Record<string, unknown> = Record<stri
     constructor(settings: ObservedCallSettings<AppData>, observer: Observer, activeIssuesRegistry: ActiveIssuesRegistry);
     get numberOfClients(): number;
     get score(): number | undefined;
+    /**
+     * Build a call-scoped detector onto this call. Chainable.
+     *
+     * To get a handle on what was built — to inspect it, or to remove that exact instance later — read
+     * it back off the registry: `call.detectors.getAll(name)`, or `call.detectors.instances`.
+     */
     addDetector<K extends keyof AvailableCallScopeDetectorsConfigs>(name: K, config?: Partial<AvailableCallScopeDetectorsConfigs[K]>): this;
+    /**
+     * Remove a detector from **this call** by name, returning how many were removed.
+     *
+     * **Every** instance under the name goes — a name can legitimately be registered more than once.
+     * When you want one of them specifically, go through the registry, which deals in instances:
+     *
+     * ```ts
+     * const [ first ] = call.detectors.getAll('issue-fan-out-detector');
+     *
+     * call.detectors.remove(first);
+     * ```
+     *
+     * Either route `close()`s the detector, so it unsubscribes from `activeIssuesRegistry` — without
+     * that the registry keeps feeding a detector nobody is running any more, and its tracked set grows
+     * for the life of the call.
+     *
+     * To stop building it on *future* calls too, use `observer.removeCallDetector(name)`.
+     */
+    removeDetector(name: keyof AvailableCallScopeDetectorsConfigs): number;
     /**
      * Raise a call-level (server-side) finding; surfaced on the Observer bus as `call-issue`.
      *
@@ -5113,6 +5180,12 @@ declare class Observer<AppData extends Record<string, unknown> = Record<string,
     constructor(config?: Partial<ObserverConfig<AppData>>);
     get numberOfCalls(): number;
     get appData(): AppData | undefined;
+    /**
+     * Build a cross-call detector onto `observer.detectors`. Chainable.
+     *
+     * To get a handle on what was built — to inspect it, or to remove that exact instance later — read
+     * it back off the registry: `observer.detectors.getAll(name)`, or `observer.detectors.instances`.
+     */
     addObserverDetector<K extends keyof AvailableObserverScopeDetectorsConfigs>(name: K, config?: Partial<AvailableObserverScopeDetectorsConfigs[K]>): this;
     /**
      * Enable a call-scoped detector for calls created **from now on**.
@@ -5121,8 +5194,36 @@ declare class Observer<AppData extends Record<string, unknown> = Record<string,
      * built with. To add one to an existing call, use `observedCall.addDetector(...)` directly.
      */
     addCallDetector<K extends keyof AvailableCallScopeDetectorsConfigs>(name: K, config?: Partial<AvailableCallScopeDetectorsConfigs[K]>): this;
-    /** Stop building `name` on calls created from now on. Calls already open are untouched. */
-    removeCallDetector(name: keyof AvailableCallScopeDetectorsConfigs): this;
+    /**
+     * Remove an observer-scoped detector by name, returning how many were removed.
+     *
+     * **Every** instance registered under the name goes, since a name can legitimately be registered
+     * more than once (`ClientPopulationIssueDetector` is meant to be added once per `groupBy` axis).
+     * When you want one of them specifically, go through the registry, which deals in instances:
+     *
+     * ```ts
+     * const [ byBrowser, byOs ] = observer.detectors.getAll('client-population-issue-detector');
+     *
+     * observer.detectors.remove(byOs);   // keeps the browser axis running
+     * ```
+     *
+     * Either route `close()`s the detector, so it unsubscribes from the issue registry and drops any
+     * timers or bus listeners it held.
+     */
+    removeObserverDetector(name: keyof AvailableObserverScopeDetectorsConfigs): number;
+    /**
+     * Stop building `name` on calls created from now on.
+     *
+     * By default this also removes it from the calls **already open**, so that "remove this detector"
+     * means the same thing whether you say it before or after a call started — the alternative leaves
+     * a fleet where the detector is live on some calls and not others, decided by join time. Pass
+     * `{ includeOpenCalls: false }` to change only what future calls are built with.
+     *
+     * Returns the number of live detector instances removed (`0` when only the config changed).
+     */
+    removeCallDetector(name: keyof AvailableCallScopeDetectorsConfigs, { includeOpenCalls }?: {
+        includeOpenCalls?: boolean;
+    }): number;
     /**
      * Start a structural check. It runs on each `observer.update()` until it can decide, reports once
      * on `validation-ready`, and removes itself.
@@ -5136,6 +5237,25 @@ declare class Observer<AppData extends Record<string, unknown> = Record<string,
      * elapsed time is what makes a structural verdict stale.
      */
     addValidator<K extends keyof AvailableValidatorConfigs>(name: K, config?: Partial<AvailableValidatorConfigs[K]>): this;
+    /**
+     * Stop a running validation, by name or by instance. Returns how many were cancelled.
+     *
+     * Cancelling is **not** silent discarding. The validator finishes with `inconclusive` and the given
+     * `reason`, emits `validation-ready` like any other completion, and removes itself. That matters
+     * because anything waiting on the verdict — a deploy gate, a dashboard, a promise — would otherwise
+     * wait forever, and because "we stopped asking" is a materially different outcome from "we asked
+     * and learned nothing", which is exactly what `inconclusive` with a reason records.
+     *
+     * ```ts
+     * observer.cancelValidator('simulcast-receivers', 'sfu redeployed');
+     *
+     * // or one specific instance — `observer.validators` holds what is running
+     * for (const validator of observer.validators) observer.cancelValidator(validator, 'shutting down');
+     * ```
+     *
+     * Pass a real reason. The default tells the reader nothing they could not already infer.
+     */
+    cancelValidator(target: keyof AvailableValidatorConfigs | RunningValidator, reason?: string): number;
     getObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(callId: string): ObservedCall<T> | undefined;
     createObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(settings: ObservedCallSettings<T>): ObservedCall<T> | undefined;
     getOrCreateObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(settings: ObservedCallSettings<T>): ObservedCall<T> | undefined;

package/dist/index.d.ts

@@ -2468,8 +2468,13 @@ interface Validator<S extends Record<string, unknown> = Record<string, unknown>>
     onDone: (report: ValidationReport<S>) => void;
     /** Gather evidence; decide if there is now enough. Called on every `observer.update()`. */
     update(): void;
-    /** Give up without a verdict. Finishes with `inconclusive`, so a caller waiting on it is freed. */
-    cancel: () => void;
+    /**
+     * Give up without a verdict. Finishes with `inconclusive`, so a caller waiting on it is freed.
+     *
+     * `reason` is carried into the report. Worth passing something specific — "cancelled" tells the
+     * reader nothing, whereas "sfu redeployed" explains why a check that was running has no verdict.
+     */
+    cancel: (reason?: string) => void;
 }
 /**
  * The part of a validator the observer needs in order to drive it.
@@ -4412,11 +4417,48 @@ type AvailableDetectorsConfigs = AvailableObserverScopeDetectorsConfigs | Availa
 declare class Detectors {
     private _detectors;
     constructor(...detectors: Detector[]);
+    /**
+     * Every registered detector, in registration order.
+     *
+     * This is **the** way to get hold of an instance: `addDetector` / `addObserverDetector` are
+     * chainable and return the owning entity, so the registry is where instances live. Read it to
+     * inspect a detector's state, or to pick one out and {@link remove} it.
+     *
+     * A copy, not the live array — a caller iterating this while removing would otherwise skip
+     * entries, and that is exactly what "remove the ones that look like X" does.
+     */
+    get instances(): Detector[];
+    /** Iterate the registry directly: `for (const detector of call.detectors)`. */
+    [Symbol.iterator](): IterableIterator<Detector>;
+    /** The names in registration order. Duplicates are meaningful — see {@link getAll}. */
     get listOfNames(): string[];
     get size(): number;
     add(detector: Detector): void;
+    /** The first detector registered under `name`. See {@link getAll} when several can share one. */
     get(name: string): Detector | undefined;
-    remove(detector: Detector): void;
+    /**
+     * Every detector registered under `name`.
+     *
+     * More than one is legitimate: `ClientPopulationIssueDetector` is meant to be added once per
+     * `groupBy` axis, and two instances of it share a name.
+     */
+    getAll(name: string): Detector[];
+    has(name: string): boolean;
+    /** Remove one specific instance. Returns `false` if it was not registered here. */
+    remove(detector: Detector): boolean;
+    /**
+     * Remove **every** detector registered under `name`, returning how many were removed.
+     *
+     * All of them rather than the first, because a name can legitimately be registered more than once
+     * (see {@link getAll}) and "remove the `client-population-issue-detector`" cannot sensibly mean
+     * "remove whichever axis happens to be first in the array". Removing all of them is the only
+     * behaviour that leaves the registry in a state the caller can predict from the name alone.
+     *
+     * Each removed detector gets `close()`, so trackers unsubscribe from the issue registry, bus
+     * listeners drop, and timers clear — a detector removed without closing keeps being fed issues
+     * forever.
+     */
+    removeByName(name: string): number;
     update(): void;
     clear(): void;
     private _close;
@@ -4565,7 +4607,32 @@ declare class ObservedCall<AppData extends Record<string, unknown> = Record<stri
     constructor(settings: ObservedCallSettings<AppData>, observer: Observer, activeIssuesRegistry: ActiveIssuesRegistry);
     get numberOfClients(): number;
     get score(): number | undefined;
+    /**
+     * Build a call-scoped detector onto this call. Chainable.
+     *
+     * To get a handle on what was built — to inspect it, or to remove that exact instance later — read
+     * it back off the registry: `call.detectors.getAll(name)`, or `call.detectors.instances`.
+     */
     addDetector<K extends keyof AvailableCallScopeDetectorsConfigs>(name: K, config?: Partial<AvailableCallScopeDetectorsConfigs[K]>): this;
+    /**
+     * Remove a detector from **this call** by name, returning how many were removed.
+     *
+     * **Every** instance under the name goes — a name can legitimately be registered more than once.
+     * When you want one of them specifically, go through the registry, which deals in instances:
+     *
+     * ```ts
+     * const [ first ] = call.detectors.getAll('issue-fan-out-detector');
+     *
+     * call.detectors.remove(first);
+     * ```
+     *
+     * Either route `close()`s the detector, so it unsubscribes from `activeIssuesRegistry` — without
+     * that the registry keeps feeding a detector nobody is running any more, and its tracked set grows
+     * for the life of the call.
+     *
+     * To stop building it on *future* calls too, use `observer.removeCallDetector(name)`.
+     */
+    removeDetector(name: keyof AvailableCallScopeDetectorsConfigs): number;
     /**
      * Raise a call-level (server-side) finding; surfaced on the Observer bus as `call-issue`.
      *
@@ -5113,6 +5180,12 @@ declare class Observer<AppData extends Record<string, unknown> = Record<string,
     constructor(config?: Partial<ObserverConfig<AppData>>);
     get numberOfCalls(): number;
     get appData(): AppData | undefined;
+    /**
+     * Build a cross-call detector onto `observer.detectors`. Chainable.
+     *
+     * To get a handle on what was built — to inspect it, or to remove that exact instance later — read
+     * it back off the registry: `observer.detectors.getAll(name)`, or `observer.detectors.instances`.
+     */
     addObserverDetector<K extends keyof AvailableObserverScopeDetectorsConfigs>(name: K, config?: Partial<AvailableObserverScopeDetectorsConfigs[K]>): this;
     /**
      * Enable a call-scoped detector for calls created **from now on**.
@@ -5121,8 +5194,36 @@ declare class Observer<AppData extends Record<string, unknown> = Record<string,
      * built with. To add one to an existing call, use `observedCall.addDetector(...)` directly.
      */
     addCallDetector<K extends keyof AvailableCallScopeDetectorsConfigs>(name: K, config?: Partial<AvailableCallScopeDetectorsConfigs[K]>): this;
-    /** Stop building `name` on calls created from now on. Calls already open are untouched. */
-    removeCallDetector(name: keyof AvailableCallScopeDetectorsConfigs): this;
+    /**
+     * Remove an observer-scoped detector by name, returning how many were removed.
+     *
+     * **Every** instance registered under the name goes, since a name can legitimately be registered
+     * more than once (`ClientPopulationIssueDetector` is meant to be added once per `groupBy` axis).
+     * When you want one of them specifically, go through the registry, which deals in instances:
+     *
+     * ```ts
+     * const [ byBrowser, byOs ] = observer.detectors.getAll('client-population-issue-detector');
+     *
+     * observer.detectors.remove(byOs);   // keeps the browser axis running
+     * ```
+     *
+     * Either route `close()`s the detector, so it unsubscribes from the issue registry and drops any
+     * timers or bus listeners it held.
+     */
+    removeObserverDetector(name: keyof AvailableObserverScopeDetectorsConfigs): number;
+    /**
+     * Stop building `name` on calls created from now on.
+     *
+     * By default this also removes it from the calls **already open**, so that "remove this detector"
+     * means the same thing whether you say it before or after a call started — the alternative leaves
+     * a fleet where the detector is live on some calls and not others, decided by join time. Pass
+     * `{ includeOpenCalls: false }` to change only what future calls are built with.
+     *
+     * Returns the number of live detector instances removed (`0` when only the config changed).
+     */
+    removeCallDetector(name: keyof AvailableCallScopeDetectorsConfigs, { includeOpenCalls }?: {
+        includeOpenCalls?: boolean;
+    }): number;
     /**
      * Start a structural check. It runs on each `observer.update()` until it can decide, reports once
      * on `validation-ready`, and removes itself.
@@ -5136,6 +5237,25 @@ declare class Observer<AppData extends Record<string, unknown> = Record<string,
      * elapsed time is what makes a structural verdict stale.
      */
     addValidator<K extends keyof AvailableValidatorConfigs>(name: K, config?: Partial<AvailableValidatorConfigs[K]>): this;
+    /**
+     * Stop a running validation, by name or by instance. Returns how many were cancelled.
+     *
+     * Cancelling is **not** silent discarding. The validator finishes with `inconclusive` and the given
+     * `reason`, emits `validation-ready` like any other completion, and removes itself. That matters
+     * because anything waiting on the verdict — a deploy gate, a dashboard, a promise — would otherwise
+     * wait forever, and because "we stopped asking" is a materially different outcome from "we asked
+     * and learned nothing", which is exactly what `inconclusive` with a reason records.
+     *
+     * ```ts
+     * observer.cancelValidator('simulcast-receivers', 'sfu redeployed');
+     *
+     * // or one specific instance — `observer.validators` holds what is running
+     * for (const validator of observer.validators) observer.cancelValidator(validator, 'shutting down');
+     * ```
+     *
+     * Pass a real reason. The default tells the reader nothing they could not already infer.
+     */
+    cancelValidator(target: keyof AvailableValidatorConfigs | RunningValidator, reason?: string): number;
     getObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(callId: string): ObservedCall<T> | undefined;
     createObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(settings: ObservedCallSettings<T>): ObservedCall<T> | undefined;
     getOrCreateObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(settings: ObservedCallSettings<T>): ObservedCall<T> | undefined;