@sparkvault/sdk-mobile 7.1.10 → 7.1.12

package/src/http.ts

@@ -10,7 +10,7 @@ import {
 import { isTransientHttpStatus } from './app-sdk/transient.js';
 import { createDedupMutex } from './mutex.js';
 import { queryString, type ApiPath, type QueryParams } from './request-path.js';
-import type { ApiErrorBody, ApiMeta, ApiResponse, RateLimitInfo } from './types.js';
+import type { ApiErrorBody, ApiMeta, ApiResponse } from './types.js';
 
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 
@@ -21,7 +21,6 @@ export interface RequestOptions {
   query?: QueryParams;
   skipAuth?: boolean;
   vat?: string;
-  timeoutMs?: number;
 }
 
 export type AuthEvent = 'logout' | 'token_refreshed';
@@ -72,24 +71,11 @@ export class MobileHttpClient {
   private readonly authListeners = new Set<AuthEventListener>();
   private readonly refreshMutex = createDedupMutex<RefreshOutcome>();
   private lastMeta: ApiMeta | null = null;
-  private rateLimitInfo: RateLimitInfo | null = null;
 
   constructor(config: ResolvedMobileConfig) {
     this.config = config;
   }
 
-  get baseUrl(): string {
-    return this.config.apiBaseUrl;
-  }
-
-  get meta(): ApiMeta | null {
-    return this.lastMeta;
-  }
-
-  get rateLimit(): RateLimitInfo | null {
-    return this.rateLimitInfo;
-  }
-
   onAuthEvent(listener: AuthEventListener): () => void {
     this.authListeners.add(listener);
     return () => this.authListeners.delete(listener);
@@ -133,32 +119,6 @@ export class MobileHttpClient {
     return headers;
   }
 
-  private parseRateLimitHeaders(headers: Headers): void {
-    const limit = headers.get('X-RateLimit-Limit');
-    const remaining = headers.get('X-RateLimit-Remaining');
-    const reset = headers.get('X-RateLimit-Reset');
-
-    if (!limit || !remaining || !reset) return;
-
-    const parsedLimit = parseInt(limit, 10);
-    const parsedRemaining = parseInt(remaining, 10);
-    const parsedReset = parseInt(reset, 10);
-
-    if (
-      Number.isFinite(parsedLimit) &&
-      Number.isFinite(parsedRemaining) &&
-      Number.isFinite(parsedReset)
-    ) {
-      this.rateLimitInfo = {
-        limit: parsedLimit,
-        remaining: parsedRemaining,
-        reset: parsedReset,
-      };
-    } else {
-      this.config.logger.warn('Malformed rate limit headers', { limit, remaining, reset });
-    }
-  }
-
   /** The SDK error for a request the fetch adapter rejected (no HTTP response). */
   private transportError(err: unknown): SparkVaultMobileError {
     if (err instanceof SparkVaultMobileError) {
@@ -181,12 +141,6 @@ export class MobileHttpClient {
     return new SparkVaultMobileError(err instanceof Error ? err.message : 'Unknown request error');
   }
 
-  /**
-   * Single mapping for non-OK responses: 402s become typed gate errors
-   * (PlanRequiredError / QuotaExceededError) so the subscribe / add-on UX keys
-   * off one set of types; everything else becomes a SparkVaultMobileError
-   * carrying the server code, status, details, and meta.
-   */
   /** An error response's JSON body, or an empty one when it has none. */
   private async readErrorBody(response: Response): Promise<ApiErrorBody> {
     try {
@@ -209,6 +163,12 @@ export class MobileHttpClient {
     }
   }
 
+  /**
+   * Single mapping for non-OK responses: 402s become typed gate errors
+   * (PlanRequiredError / QuotaExceededError) so the subscribe / add-on UX keys
+   * off one set of types; everything else becomes a SparkVaultMobileError
+   * carrying the server code, status, details, and meta.
+   */
   private httpError(status: number, errorBody: ApiErrorBody): SparkVaultMobileError {
     if (errorBody.meta) {
       this.lastMeta = errorBody.meta;
@@ -358,7 +318,7 @@ export class MobileHttpClient {
 
   async request<T>(method: HttpMethod, path: ApiPath, options: RequestOptions = {}): Promise<ApiResponse<T>> {
     const url = this.makeUrl(path, options.query);
-    const timeoutMs = options.timeoutMs ?? this.config.timeoutMs;
+    const timeoutMs = this.config.timeoutMs;
     const body = method === 'GET' ? undefined : this.serializeBody(options.body);
     let headers = await this.getHeaders({ ...options, body: options.body });
 
@@ -368,7 +328,6 @@ export class MobileHttpClient {
     } catch (err) {
       throw this.transportError(err);
     }
-    this.parseRateLimitHeaders(response.headers);
 
     if (response.status === 401 && !options.skipAuth) {
       await this.throwIfVatRefused(response);
@@ -379,7 +338,6 @@ export class MobileHttpClient {
       } catch (err) {
         throw this.transportError(err);
       }
-      this.parseRateLimitHeaders(response.headers);
     }
 
     if (response.status === 204) {

package/src/index.ts

@@ -133,7 +133,6 @@ export {
   vatRefusalReason,
   QuotaExceededError,
   SparkVaultAuthenticationError,
-  SparkVaultAuthorizationError,
   SparkVaultMobileError,
   SparkVaultNetworkError,
   SparkVaultTimeoutError,

package/src/ingots.test-d.ts

@@ -6,13 +6,16 @@
  * and every assertion would pass. `tsc --noEmit` (`pnpm typecheck`) is the gate
  * instead. It is deliberately NOT a `*.test.ts`, which tsconfig excludes.
  *
- * Mirrored server source: apps/api/src/ingots/sharing.js (`formatSharingConfig`,
- * the one shape GET and PUT /vaults/:id/ingots/:ingot_id/sharing answer). A
- * field the server never sends reads as undefined wherever an app trusts it:
- * a link section keyed on it never renders.
+ * Mirrored server sources: apps/api/src/ingots/sharing.js (`formatSharingConfig`,
+ * the one shape GET and PUT /vaults/:id/ingots/:ingot_id/sharing answer),
+ * apps/api/src/repositories/IngotRepository.js (`toPublicFormat`, the one
+ * projection every ingot answer uses) and apps/api/src/lib/pagination.js
+ * (`buildPaginatedResponse`: one page, `{ ingots, count, has_more,
+ * next_cursor? }`). A field the server never sends reads as undefined wherever
+ * an app trusts it: a link section keyed on it never renders.
  */
 
-import type { IngotSharingConfig } from './types.js';
+import type { Ingot, IngotSharingConfig, ListIngotsResponse } from './types.js';
 
 /** Fails to compile unless `T` resolves to exactly `true`. */
 type Assert<T extends true> = T;
@@ -43,4 +46,24 @@ export type IngotsWireContract = [
   Assert<Equals<IngotSharingConfig['public_url'], string | null>>,
   Assert<Equals<IngotSharingConfig['link_code'], string | null>>,
   Assert<Equals<IngotSharingConfig['visibility'], 'invite_only' | 'authenticated' | 'public' | null>>,
+  // A page reports its own length and whether more follow; it carries no total.
+  Assert<Equals<keyof ListIngotsResponse, 'ingots' | 'count' | 'has_more' | 'next_cursor'>>,
+  // Fields toPublicFormat projects, and none it keeps to the row (storage
+  // location, last access, the abandoned-upload expiry).
+  Assert<
+    Equals<
+      keyof Ingot,
+      | 'ingot_id'
+      | 'name'
+      | 'content_type'
+      | 'size_bytes'
+      | 'status'
+      | 'folder_id'
+      | 'managed_by'
+      | 'created_at'
+      | 'access_count'
+      | 'content_hmac'
+      | 'content_version'
+    >
+  >,
 ];

package/src/ingots.ts

@@ -121,8 +121,12 @@ export interface UploadFromUriOptions extends UploadOptions {
   debug?: DebugLogger;
 }
 
-/** A replace addresses its ingot by id: no name is placed, so the create-only hooks do not apply. */
-export interface ReplaceFromUriOptions extends Omit<UploadFromUriOptions, 'name' | 'onNameConflict' | 'onIngotCreated'> {
+/**
+ * A replace addresses its ingot by id: no name is placed and the ingot stays
+ * in its folder, so the create-only hooks and the folder target do not apply.
+ */
+export interface ReplaceFromUriOptions
+  extends Omit<UploadFromUriOptions, 'name' | 'folder' | 'folderId' | 'onNameConflict' | 'onIngotCreated'> {
   ingotId: string;
   /**
    * A new name for the ingot, stored in the same request as the content.
@@ -195,11 +199,6 @@ export interface DownloadToFileResult {
   sizeBytes: number;
 }
 
-export interface AddInviteOptions {
-  /** Invite lifetime in seconds. Omit to inherit the link's existing expiry. */
-  expiresInSeconds?: number;
-}
-
 export interface CreateUploadOptions {
   vaultId: string;
   vat: string;
@@ -411,7 +410,6 @@ export class MobileIngotsClient {
       ingot_id: init.ingotId,
       name,
       size_bytes: init.sizeBytes ?? options.fileSize,
-      storage_location: 's3',
       // A server that does not report it minted the row (the upsert is the
       // only other outcome, and it always says so).
       created,
@@ -464,7 +462,6 @@ export class MobileIngotsClient {
       ingot_id: options.ingotId,
       name: options.name,
       size_bytes: options.fileSize,
-      storage_location: 's3',
       created: false,
       status: ingot.status,
       ...publicationOf(ingot),
@@ -600,7 +597,6 @@ export class MobileIngotsClient {
       ingot_id: response.data.ingot_id,
       name,
       size_bytes: fileSize,
-      storage_location: 's3',
       // A replace never mints an ingot: the row is the caller's existing one.
       created: false,
       status: ingot.status,
@@ -868,18 +864,12 @@ export class MobileIngotsClient {
     return response.data;
   }
 
-  async addInvite(
-    vaultId: string,
-    ingotId: string,
-    vat: string,
-    identity: string,
-    options: AddInviteOptions = {}
-  ): Promise<IngotInvite> {
+  async addInvite(vaultId: string, ingotId: string, vat: string, identity: string): Promise<IngotInvite> {
     validateVaultId(vaultId);
     validateIngotId(ingotId);
     const response = await this.http.post<IngotInvite>(
       apiPath`/vaults/${vaultId}/ingots/${ingotId}/sharing/invite`,
-      { identity, expires_in_seconds: options.expiresInSeconds },
+      { identity },
       { vat }
     );
     return response.data;
@@ -925,19 +915,7 @@ export class MobileIngotsClient {
     validateVaultId(vaultId);
     validateIngotId(ingotId);
     const ingot = await this.get(vaultId, ingotId, vat);
-    return {
-      total_downloads: ingot.access_count ?? 0,
-      last_accessed_at: ingot.last_accessed_at ?? ingot.accessed_at,
-    };
-  }
-
-  async purgeAccessLogs(vaultId: string, ingotId: string, vat: string): Promise<void> {
-    validateVaultId(vaultId);
-    validateIngotId(ingotId);
-    void vat;
-    throw new SparkVaultValidationError(
-      'Ingot audit logs are read-only. Configure vault access-log retention to expire old entries.'
-    );
+    return { total_downloads: ingot.access_count ?? 0 };
   }
 
   /**

package/src/products/identity.ts

@@ -20,9 +20,8 @@ import type {
   PasskeyRegisterChallenge,
   PasskeySession,
   PasskeyStatus,
-  RequestPinRequest,
-  RequestPinResponse,
   SendOtpRequest,
+  SendOtpResponse,
   SparkVaultUser,
   SubmitSecondFactorRequest,
   VerifyOtpRequest,
@@ -127,10 +126,6 @@ export class MobileIdentityClient {
     }
   }
 
-  isConfigPreloaded(): boolean {
-    return this.configCache !== null;
-  }
-
   async getJwks(options: { forceRefresh?: boolean } = {}): Promise<IdentityJwks> {
     const now = Date.now();
     const expired = now - this.jwksCachedAt > JWKS_CACHE_TTL_MS;
@@ -247,31 +242,14 @@ export class MobileIdentityClient {
     return key;
   }
 
-  async sendOtp(request: SendOtpRequest): Promise<RequestPinResponse> {
+  async sendOtp(request: SendOtpRequest): Promise<SendOtpResponse> {
     const identity = this.normalizeIdentity(request.identity, request.identityType);
-    const result = await this.postIdentity<{
-      kindling: string;
-      expires_at?: number;
-      retry_after?: number;
-    }>(apiPath`/otp/send`, {
+    const result = await this.postIdentity<SendOtpResponse>(apiPath`/otp/send`, {
       recipient: identity,
       method: request.method,
     });
 
-    return {
-      kindling: result.kindling,
-      expires_at: result.expires_at ?? Math.floor(Date.now() / 1000) + 900,
-      retry_after: result.retry_after,
-      is_signup: false,
-    };
-  }
-
-  async requestPin(request: RequestPinRequest): Promise<RequestPinResponse> {
-    return this.sendOtp({
-      identity: request.email,
-      identityType: 'email',
-      method: 'email',
-    });
+    return { kindling: result.kindling, expires_at: result.expires_at };
   }
 
   async verifyOtp(request: VerifyOtpRequest): Promise<IdentityVerifyResult> {
@@ -371,7 +349,12 @@ export class MobileIdentityClient {
     }
   }
 
-  async getPasskeyAuthOptions(_identity?: string, _identityType?: IdentityType): Promise<PasskeyAuthChallenge> {
+  /**
+   * Start a discoverable passkey ceremony: the request names no identity, so
+   * the authenticator offers every passkey it holds for the Identity relying
+   * party, and the one chosen names its person (its user handle is the SVID).
+   */
+  async getPasskeyAuthOptions(): Promise<PasskeyAuthChallenge> {
     return this.postIdentity<PasskeyAuthChallenge>(apiPath`/passkey/verify`, {});
   }
 
@@ -507,9 +490,7 @@ export class MobileIdentityClient {
         recipient: this.normalizeIdentity(request.recipient, inferIdentityType(request.recipient)),
       });
     } catch (err) {
-      const apiError = err as SparkVaultMobileError & {
-        data?: { kindling?: string; expires_at?: number };
-      };
+      const apiError = err as SparkVaultMobileError;
       const message = apiError.message || 'Verification failed';
       const code = apiError.statusCode ?? apiError.code;
 
@@ -599,15 +580,10 @@ export class MobileIdentityClient {
     return (data.data ?? data) as T;
   }
 
-  private async postIdentity<T>(
-    path: ApiPath,
-    body: Record<string, unknown>,
-    options: { bearerToken?: string } = {}
-  ): Promise<T> {
-    const headers = this.identityHeaders(options.bearerToken);
+  private async postIdentity<T>(path: ApiPath, body: Record<string, unknown>): Promise<T> {
     const response = await this.config.fetch(identityUrl(this.config, path), {
       method: 'POST',
-      headers,
+      headers: this.identityHeaders(),
       body: JSON.stringify(body),
       timeoutMs: this.config.timeoutMs,
     });
@@ -615,30 +591,24 @@ export class MobileIdentityClient {
     if (!response.ok) {
       const errorBody = await response.json().catch(() => ({} as ApiErrorBody));
       const message = errorBody.error?.message ?? errorBody.message ?? 'Identity verification failed';
-      const error = new SparkVaultMobileError(message, {
+      throw new SparkVaultMobileError(message, {
         code: errorBody.error?.code ?? response.status,
         statusCode: response.status,
         details: errorBody.error?.details,
         meta: errorBody.meta,
       });
-      (error as SparkVaultMobileError & { data?: unknown }).data = errorBody.data ?? errorBody;
-      throw error;
     }
 
     const data = await response.json();
     return (data.data ?? data) as T;
   }
 
-  private identityHeaders(bearerToken?: string): Record<string, string> {
-    const headers: Record<string, string> = {
+  private identityHeaders(): Record<string, string> {
+    return {
       'Content-Type': 'application/json',
       Accept: 'application/json',
       'User-Agent': this.config.userAgent,
     };
-    if (bearerToken) {
-      headers.Authorization = `Bearer ${bearerToken}`;
-    }
-    return headers;
   }
 
   private identityLookupBody(identity: string, identityType?: IdentityType): Record<string, string> {

package/src/sparks.ts

@@ -3,10 +3,10 @@ import type { ShareSparkResponse, SparkShareStatus, UnshareSparkResponse } from
 import { apiPath } from './request-path.js';
 import { validateResourceId } from './validation.js';
 
+/** A Spark as GET /sparks lists it: never its payload, which only `get` reads. */
 export interface Spark {
   spark_id: string;
   status: string;
-  payload?: string;
   content_type?: string;
 }
 
@@ -31,9 +31,12 @@ export interface SparkResponse {
 export interface CreateSparkOptions {
   payload: string;
   contentType?: string;
+  /**
+   * Time-to-live: a whole number of minutes from 1 to 1440 (24h). Defaults to
+   * 1440 server-side. A fraction is refused with a 400 `VALIDATION_ERROR`.
+   */
   ttlMinutes?: number;
   kindling?: string;
-  name?: string;
 }
 
 export interface CreateSparkResponse {
@@ -75,7 +78,6 @@ export class MobileSparksClient {
       content_type: options.contentType,
       ttl_minutes: options.ttlMinutes,
       kindling: options.kindling,
-      name: options.name,
     });
     return response.data;
   }

package/src/tus.ts

@@ -37,7 +37,6 @@ import type {
 } from './types.js';
 
 export interface ParsedForgeUrl {
-  baseUrl: string;
   tusEndpoint: string;
   istk: string;
 }
@@ -169,11 +168,7 @@ export function parseForgeUrl(
       reason: read.reason,
     });
   }
-  return {
-    baseUrl: read.origin,
-    tusEndpoint: read.endpoint,
-    istk: read.istk,
-  };
+  return { tusEndpoint: read.endpoint, istk: read.istk };
 }
 
 /**

package/src/types.ts

@@ -48,16 +48,9 @@ export interface ApiErrorBody {
     details?: Record<string, unknown>;
   };
   message?: string;
-  data?: unknown;
   meta?: ApiMeta;
 }
 
-export interface RateLimitInfo {
-  limit: number;
-  remaining: number;
-  reset: number;
-}
-
 /** Account-scoped role. Owners and admins manage the organization and team. */
 export type OrgRole = 'owner' | 'admin' | 'user';
 
@@ -282,7 +275,6 @@ export interface IdentityBranding {
   companyName: string | null;
   logoLight: string | null;
   logoDark: string | null;
-  backdrop_blur?: boolean;
   themeMode?: 'light' | 'dark';
 }
 
@@ -380,52 +372,37 @@ export interface VerifyOtpRequest {
   recipient: string;
 }
 
-export interface RequestPinRequest {
-  email: string;
-  organization_name?: string;
-}
-
-export interface RequestPinResponse {
+/** A code sent: the kindling its verify names, and when the code expires (Unix seconds). */
+export interface SendOtpResponse {
   kindling: string;
   expires_at: number;
-  retry_after?: number;
-  is_signup: boolean;
 }
 
 export interface PinVerifyLoginResponse {
   access_token: string;
   refresh_token: string;
-  token_type: 'Bearer';
-  expires_in: number;
   user: SparkVaultUser;
 }
 
+/**
+ * A verified identity with no SparkVault user yet: `signup_token` (an
+ * identity-only access token) authorizes `account.completeSignup`.
+ */
 export interface PinVerifySignupPendingResponse {
   verified: true;
   needs_signup_info: true;
   signup_token: string;
-  expires_at: number;
 }
 
 /**
- * Variant of the Core exchange result indicating the account has 2FA enabled:
- * the caller must collect a second factor via
- * `products.identity.submitSecondFactor({ ticket, code })` and re-exchange the
- * resulting Identity token via `account.exchangeIdentityToken`.
+ * The Core exchange of a verified Identity token. A second factor is collected
+ * at the Identity Product before its token exists (`products.identity.verifyOtp`
+ * throws for it, and `submitSecondFactor` finishes it), so the exchange is a
+ * login or a pending signup, never a second-factor challenge.
  */
-export interface PinVerifySecondFactorPendingResponse {
-  verified: false;
-  second_factor_required: true;
-  /** Opaque pending-login handle to submit the second factor against. */
-  ticket: string;
-  /** Methods the user may use, e.g. ['authenticator','recovery_code']. */
-  methods: string[];
-}
-
 export type PinVerifyResponse =
   | PinVerifyLoginResponse
-  | PinVerifySignupPendingResponse
-  | PinVerifySecondFactorPendingResponse;
+  | PinVerifySignupPendingResponse;
 
 export interface SubmitSecondFactorRequest {
   /** Pending-login ticket from a second_factor_required response. */
@@ -442,8 +419,6 @@ export interface CompleteSignupRequest {
 export interface CompleteSignupResponse {
   access_token: string;
   refresh_token: string;
-  token_type?: 'Bearer';
-  expires_in?: number;
   user: SparkVaultUser;
   account: SparkVaultAccount;
 }
@@ -454,10 +429,14 @@ export interface PasskeyAuthOptions {
   challenge: string;
   timeout: number;
   rpId: string;
+  /**
+   * The person's credentials when the ceremony is scoped to an identifier:
+   * ids only, since a transport list would hand an unauthenticated probe a
+   * device fingerprint.
+   */
   allowCredentials?: Array<{
     id: string;
     type: 'public-key';
-    transports?: string[];
   }>;
   userVerification: 'required' | 'preferred' | 'discouraged';
 }
@@ -523,15 +502,15 @@ export interface PasskeyCredential {
 
 export interface PasskeyStatus {
   has_passkey: boolean;
-  registered_at?: number;
-  last_used_at?: number;
 }
 
+/**
+ * POST /auth/identity/verify: a session for the verified identity's member, or,
+ * with `user` and `account` null, an identity-only token for a signup.
+ */
 export interface IdentitySessionResponse {
   access_token: string;
   refresh_token: string;
-  token_type?: 'Bearer';
-  expires_in?: number;
   user: SparkVaultUser | null;
   account: SparkVaultAccount | null;
 }
@@ -549,18 +528,16 @@ export interface Vault {
   unseal_count?: number;
 }
 
+/** A vault is created with its name alone; a description is set with `update`. */
 export interface CreateVaultRequest {
   name: string;
-  description?: string;
 }
 
 export interface CreateVaultResponse {
   vault_id: string;
   name: string;
-  description?: string;
   vmk: string;
   vmk_warning: string;
-  status: 'sealed';
   created_at: number;
 }
 
@@ -700,7 +677,6 @@ export interface Ingot {
   name: string;
   content_type: string;
   size_bytes: number;
-  storage_location: 'dynamodb' | 's3';
   /** `uploading` until Forge activates the upload, then `active`. */
   status?: 'uploading' | 'active';
   folder_id?: string | null;
@@ -712,10 +688,7 @@ export interface Ingot {
    */
   managed_by?: string | null;
   created_at: number;
-  accessed_at?: number;
-  last_accessed_at?: number;
   access_count?: number;
-  expires_at?: number;
   /**
    * Client-computed, vault-keyed HMAC of the plaintext (43-char base64url),
    * or null when the uploader did not supply one. Used for upload dedup and
@@ -736,9 +709,14 @@ export interface HashCheckResponse {
   found: HashCheckMatch[];
 }
 
+/**
+ * One page of GET /vaults/:id/ingots or /ingots/search. `count` is this
+ * page's length: the server reports no total.
+ */
 export interface ListIngotsResponse {
   ingots: Ingot[];
-  total: number;
+  count: number;
+  has_more: boolean;
   next_cursor?: string;
 }
 
@@ -762,7 +740,6 @@ export interface UploadResult {
    */
   name: string;
   size_bytes: number;
-  storage_location: 's3';
   /**
    * Whether this upload minted the ingot (true) or went into an existing row
    * (false): the one holding the name, as the create's name-conflict policy
@@ -842,8 +819,6 @@ export interface IngotAccessLog {
 
 export interface IngotAccessStats {
   total_downloads: number;
-  unique_visitors?: number;
-  last_accessed_at?: number;
 }
 
 /** A folder as every folder route answers it (Core's FolderRepository.toPublicFormat). */
@@ -886,16 +861,13 @@ export interface TokenStorageAdapter {
   clearTokens(): Promise<void>;
   getUser?<T = SparkVaultUser>(): Promise<T | null>;
   setUser?<T = SparkVaultUser>(user: T): Promise<void>;
-  getAccount?<T = SparkVaultAccount>(): Promise<T | null>;
   setAccount?<T = SparkVaultAccount>(account: T): Promise<void>;
-  clearAll?(): Promise<void>;
 }
 
 export type FetchLike = (
   url: string,
   options?: RequestInit & {
     timeoutMs?: number;
-    responseType?: XMLHttpRequestResponseType;
   }
 ) => Promise<Response>;
 
@@ -1106,7 +1078,6 @@ export interface MobileFileDownloader {
 
 export interface DebugLogger {
   log(message: string): void;
-  warn(message: string): void;
   error(message: string): void;
   success(message: string): void;
 }