@viso-lol/sdk 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 viso.lol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,115 @@
-# Temporary Holding Version
+# @viso-lol/sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The official TypeScript SDK for the [viso.lol](https://viso.lol) API: face detection, comparison and collections, plus image storage and CDN delivery.
+
+- Zero runtime dependencies. Works anywhere `fetch` exists: Node.js 20+, Bun, Deno, Cloudflare Workers.
+- Typed requests, responses and error codes.
+- Automatic retries with backoff for rate limits and transient failures.
+- Auto-pagination with `for await`.
+
+```bash
+npm install @viso-lol/sdk
+```
+
+## Quickstart
+
+Create an API key in the dashboard and keep it on your server.
+
+```ts
+import { Viso } from "@viso-lol/sdk";
+
+const viso = new Viso({ apiKey: process.env.VISO_API_KEY });
+
+// Images
+const bucket = await viso.images.buckets.create({ name: "Avatars", visibility: "public" });
+const file = await viso.images.upload({
+  bucketId: bucket.id,
+  path: "users/ada.png",
+  body: await readFile("ada.png"),
+});
+console.log(file.url); // https://cdn.viso.lol/bkt_.../users/ada.png
+
+// Face (enable Face for the project in the dashboard first)
+const { faces } = await viso.face.detect({ image: { fileId: file.id }, attributes: "all" });
+```
+
+`apiKey` defaults to the `VISO_API_KEY` environment variable and `baseUrl` to `VISO_BASE_URL` or `https://api.viso.lol/v1`.
+
+## Images from browsers
+
+Never send an API key to a browser. Create a single-use upload URL on your server and upload to it from the client:
+
+```ts
+// Server
+const { uploadUrl } = await viso.images.createUploadUrl({
+  bucketId,
+  path: `avatars/${userId}.png`,
+  maxSize: 5 * 1024 * 1024,
+  expiresIn: 600,
+});
+
+// Browser
+import { uploadToSignedUrl } from "@viso-lol/sdk";
+
+const file = await uploadToSignedUrl(uploadUrl, input.files[0], {
+  onProgress: ({ loaded, total }) => console.log(loaded, total),
+});
+```
+
+The `Viso` client refuses to run in browsers (it would expose your key) unless you pass `dangerouslyAllowBrowser: true` for a local experiment.
+
+## Face images
+
+Every Face method takes images as bytes (`Blob`, `File`, `ArrayBuffer`, `Uint8Array`, Node `Buffer`), as base64 (`{ base64 }`, data URLs work too) or as a file stored with Images (`{ fileId }`). Bytes are sent as multipart, without base64 overhead.
+
+```ts
+const result = await viso.face.compare({
+  source: { fileId: "file_..." },
+  target: await blob.arrayBuffer(),
+  similarityThreshold: 90,
+});
+
+const collection = await viso.face.collections.create({ name: "Members" });
+await viso.face.collections.faces.index(collection.id, { image: photo, externalId: "user_42" });
+const { matches } = await viso.face.collections.search(collection.id, { image: selfie });
+```
+
+## Pagination
+
+List methods resolve to the first page and are also async iterables over every item:
+
+```ts
+const page = await viso.images.files.list({ bucketId, prefix: "users/", delimiter: "/" });
+console.log(page.folders, page.nextCursor);
+
+for await (const file of viso.images.files.list({ bucketId })) {
+  console.log(file.path);
+}
+```
+
+## Errors and retries
+
+API errors throw `VisoError` with a stable `code`, the HTTP `status`, the `requestId` (include it when you contact support) and optional `details`. Network failures and timeouts throw `VisoConnectionError`.
+
+```ts
+import { VisoError } from "@viso-lol/sdk";
+
+try {
+  await viso.images.upload({ bucketId, path: "a.png", body });
+} catch (error) {
+  if (error instanceof VisoError && error.code === "images.file_exists") {
+    // ...
+  }
+}
+```
+
+The client retries up to `maxRetries` times (default 2) with exponential backoff and jitter, honoring `Retry-After`:
+
+- `429` and `503` for any method (the request was not processed);
+- other `5xx` responses and network errors only for `GET`, `PUT` and `DELETE`.
+
+Quota errors (`403 quota.exceeded`) are never retried. Uploads from streams are not retried because a stream can be read once. Every method accepts a final `{ signal, timeoutMs, maxRetries }` argument.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,521 @@
+/**
+ * Public API shapes. They are written out by hand so the published declarations have no
+ * dependencies; `types.check.ts` fails the build when they drift from the API's schemas.
+ */
+/** Stable error codes returned by the API (see https://viso.lol/docs). */
+type ErrorCode = "request.invalid" | "request.malformed" | "request.body_too_large" | "request.unsupported_media_type" | "request.not_found" | "auth.missing_api_key" | "auth.invalid_api_key" | "auth.api_key_revoked" | "auth.api_key_expired" | "auth.insufficient_scope" | "auth.unauthenticated" | "auth.forbidden" | "rate_limit.exceeded" | "quota.exceeded" | "plan.limit_reached" | "resource.not_found" | "resource.conflict" | "images.file_too_large" | "images.unsupported_type" | "images.file_exists" | "images.invalid_path" | "images.length_required" | "images.upload_token_invalid" | "images.upload_token_expired" | "images.upload_token_used" | "face.not_enabled" | "face.image_too_large" | "face.unsupported_format" | "face.image_too_small" | "face.invalid_image" | "face.no_face_detected" | "face.provider_unavailable" | "face.provider_capacity" | "waitlist.verification_failed" | "internal";
+interface Page<T> {
+  object: "list";
+  data: T[];
+  /** Pass as `cursor` to get the next page; `null` on the last page. */
+  nextCursor: string | null;
+}
+interface PageParams {
+  /** Items per page, 1–100. */
+  limit?: number | undefined;
+  cursor?: string | undefined;
+}
+interface Deleted {
+  id: string;
+  deleted: true;
+}
+type ImageMimeType = "image/jpeg" | "image/png" | "image/webp" | "image/gif" | "image/avif" | "image/svg+xml";
+type BucketVisibility = "public" | "private";
+interface Bucket {
+  object: "bucket";
+  id: string;
+  projectId: string;
+  name: string;
+  slug: string;
+  /** `public` files are served by anyone with the URL; `private` files need a signed URL. */
+  visibility: BucketVisibility;
+  allowedMimeTypes: ImageMimeType[];
+  /** Largest accepted file, in bytes. */
+  maxFileSize: number;
+  /** CDN and browser cache lifetime, in seconds. */
+  cacheMaxAge: number;
+  createdAt: string;
+  updatedAt: string;
+}
+interface ImageFile {
+  object: "file";
+  id: string;
+  bucketId: string;
+  path: string;
+  /** Public CDN URL, or `null` in private buckets (use a signed URL). */
+  url: string | null;
+  originalName: string | null;
+  /** Detected from the file's content. */
+  mimeType: ImageMimeType;
+  size: number;
+  width: number | null;
+  height: number | null;
+  etag: string;
+  sha256: string;
+  createdAt: string;
+}
+interface FileList extends Page<ImageFile> {
+  /** Sub-folders of `prefix` when `delimiter` is `/`. */
+  folders: {
+    prefix: string;
+  }[];
+}
+interface CreateBucketParams {
+  name: string;
+  slug?: string | undefined;
+  visibility?: BucketVisibility | undefined;
+  allowedMimeTypes?: ImageMimeType[] | undefined;
+  maxFileSize?: number | undefined;
+  cacheMaxAge?: number | undefined;
+}
+type UpdateBucketParams = Partial<CreateBucketParams>;
+interface ListFilesParams extends PageParams {
+  bucketId: string;
+  /** Only paths starting with this. */
+  prefix?: string | undefined;
+  /** Group deeper paths into `folders` instead of listing them. */
+  delimiter?: "/" | undefined;
+}
+/** Raw bytes accepted by uploads. Streams are sent as they are read and are never retried. */
+type UploadBody = Blob | ArrayBuffer | ArrayBufferView | ReadableStream<Uint8Array> | string;
+interface UploadParams {
+  bucketId: string;
+  /** Where to store the file inside the bucket, for example `avatars/ada.png`. */
+  path: string;
+  body: UploadBody;
+  /** Ignored by the API (types are detected from content) but sent for completeness. */
+  contentType?: string | undefined;
+  /** Original file name, kept for downloads. */
+  name?: string | undefined;
+  /** Replace an existing file at `path` instead of failing with `images.file_exists`. */
+  overwrite?: boolean | undefined;
+}
+interface CreateUploadUrlParams {
+  bucketId: string;
+  path: string;
+  maxSize?: number | undefined;
+  allowedMimeTypes?: ImageMimeType[] | undefined;
+  /** Seconds until the URL expires, 60–3600 (default 900). */
+  expiresIn?: number | undefined;
+  overwrite?: boolean | undefined;
+}
+interface UploadUrl {
+  object: "upload_url";
+  uploadUrl: string;
+  method: "PUT";
+  expiresAt: string;
+  constraints: {
+    path: string;
+    maxSize: number;
+    allowedMimeTypes: ImageMimeType[];
+    overwrite: boolean;
+  };
+}
+interface SignedUrlParams {
+  /** Seconds until the URL expires, 60–86400 (default 3600). */
+  expiresIn?: number | undefined;
+  /** Serve with `Content-Disposition: attachment`. */
+  download?: boolean | undefined;
+}
+interface SignedUrl {
+  object: "signed_url";
+  url: string;
+  expiresAt: string;
+}
+interface DeleteFilesParams {
+  bucketId: string;
+  /** Up to 100 file IDs. */
+  ids: string[];
+}
+interface DeleteFilesResult {
+  deleted: string[];
+  notFound: string[];
+}
+/**
+ * A JPEG or PNG of up to 5 MB and at least 80×80 pixels: raw bytes, base64 (a `data:` URL
+ * works too), or the ID of a file stored with Images in the same project.
+ */
+type ImageSource = Blob | ArrayBuffer | ArrayBufferView | {
+  base64: string;
+} | {
+  fileId: string;
+};
+type FaceAttribute = "ageRange" | "beard" | "emotions" | "eyeDirection" | "eyeglasses" | "eyesOpen" | "faceOccluded" | "gender" | "mouthOpen" | "mustache" | "smile" | "sunglasses";
+type Emotion = "happy" | "sad" | "angry" | "confused" | "disgusted" | "surprised" | "calm" | "fear" | "unknown";
+type QualityFilter = "none" | "auto" | "low" | "medium" | "high";
+/** Position and size as ratios of the image width and height (0–1). */
+interface BoundingBox {
+  left: number;
+  top: number;
+  width: number;
+  height: number;
+}
+interface FaceFlag {
+  value: boolean;
+  /** 0–100. */
+  confidence: number;
+}
+interface FaceDetail {
+  boundingBox: BoundingBox;
+  /** Confidence that this is a face, 0–100. */
+  confidence: number;
+  landmarks: {
+    type: string;
+    x: number;
+    y: number;
+  }[];
+  pose: {
+    roll: number;
+    yaw: number;
+    pitch: number;
+  };
+  quality: {
+    brightness: number;
+    sharpness: number;
+  };
+  ageRange?: {
+    low: number;
+    high: number;
+  };
+  gender?: {
+    value: "male" | "female";
+    confidence: number;
+  };
+  smile?: FaceFlag;
+  eyeglasses?: FaceFlag;
+  sunglasses?: FaceFlag;
+  beard?: FaceFlag;
+  mustache?: FaceFlag;
+  eyesOpen?: FaceFlag;
+  mouthOpen?: FaceFlag;
+  faceOccluded?: FaceFlag;
+  emotions?: {
+    type: Emotion;
+    confidence: number;
+  }[];
+  eyeDirection?: {
+    yaw: number;
+    pitch: number;
+    confidence: number;
+  };
+}
+interface DetectParams {
+  image: ImageSource;
+  /** `default` (box, landmarks, pose, quality), `all`, or the attributes you need. */
+  attributes?: "default" | "all" | FaceAttribute[] | undefined;
+}
+interface FaceDetection {
+  object: "face_detection";
+  faces: FaceDetail[];
+  image: {
+    width: number | null;
+    height: number | null;
+    format: "jpeg" | "png";
+  };
+}
+interface CompareParams {
+  /** The image with the face to look for (its largest face is used). */
+  source: ImageSource;
+  /** The image to look in. */
+  target: ImageSource;
+  /** Minimum similarity for a match, 0–100 (default 80). */
+  similarityThreshold?: number | undefined;
+}
+interface ComparedFace {
+  boundingBox: BoundingBox;
+  confidence: number;
+}
+interface FaceComparison {
+  object: "face_comparison";
+  sourceFace: ComparedFace;
+  matches: {
+    similarity: number;
+    face: FaceDetail;
+  }[];
+  unmatched: FaceDetail[];
+}
+type FaceCollectionStatus = "creating" | "active" | "deleting";
+interface FaceCollection {
+  object: "face_collection";
+  id: string;
+  projectId: string;
+  name: string;
+  slug: string;
+  status: FaceCollectionStatus;
+  faceCount: number;
+  faceModelVersion: string | null;
+  createdAt: string;
+}
+interface CreateCollectionParams {
+  name: string;
+  slug?: string | undefined;
+}
+interface Face {
+  object: "face";
+  id: string;
+  collectionId: string;
+  externalId: string | null;
+  /** The Images file the face was indexed from, if any. */
+  sourceFileId: string | null;
+  boundingBox: BoundingBox;
+  confidence: number;
+  createdAt: string;
+}
+interface IndexFacesParams {
+  image: ImageSource;
+  /** Your identifier for the person or image, for example a user ID. */
+  externalId?: string | undefined;
+  /** Index at most this many faces, largest first (1–100, default 1). */
+  maxFaces?: number | undefined;
+  qualityFilter?: QualityFilter | undefined;
+}
+interface FaceIndexResult {
+  object: "face_index_result";
+  indexed: Face[];
+  unindexed: {
+    boundingBox: BoundingBox;
+    reasons: string[];
+  }[];
+}
+interface ListFacesParams extends PageParams {
+  externalId?: string | undefined;
+}
+interface SearchFacesParams {
+  /** Return at most this many matches (1–100, default 10). */
+  maxFaces?: number | undefined;
+  /** Minimum similarity, 0–100 (default 80). */
+  threshold?: number | undefined;
+}
+interface SearchByImageParams extends SearchFacesParams {
+  image: ImageSource;
+}
+interface FaceSearchResult {
+  object: "face_search_result";
+  /** The face that was searched for, when searching by image. */
+  searchedFace: ComparedFace | null;
+  matches: {
+    similarity: number;
+    face: Face;
+  }[];
+}
+interface Quota {
+  used: number;
+  limit: number;
+}
+interface Usage {
+  object: "usage";
+  /** Current monthly period (UTC), for example `2026-10`. */
+  period: string;
+  /** Shared by every project of the team. */
+  team: {
+    storageBytes: Quota;
+    faceOperations: Quota;
+    storedFaces: Quota;
+  };
+  project: {
+    id: string;
+    /** Requests in the last 24 hours (estimated); `null` while analytics are unavailable. */
+    requests24h: number | null;
+  };
+  rateLimit: {
+    limit: number;
+    windowSeconds: number;
+  };
+}
+/**
+ * The first page of a list, which is also an async iterable over every item of every
+ * page: `await viso.face.collections.list()` or `for await (const c of ...list())`.
+ */
+type ListPromise<Item, P extends Page<Item> = Page<Item>> = Promise<P> & AsyncIterable<Item>;
+declare class FacesResource {
+  #private;
+  constructor(client: Viso);
+  /** Detects faces in the image and stores them in the collection, largest first. */
+  index(collectionId: string, params: IndexFacesParams, options?: RequestOptions): Promise<FaceIndexResult>;
+  /** Faces of a collection, oldest first. Iterate with `for await` to read every page. */
+  list(collectionId: string, params?: ListFacesParams, options?: RequestOptions): ListPromise<Face>;
+  delete(collectionId: string, faceId: string, options?: RequestOptions): Promise<Deleted>;
+  /** Searches the collection for faces similar to a stored face. */
+  search(collectionId: string, faceId: string, params?: SearchFacesParams, options?: RequestOptions): Promise<FaceSearchResult>;
+}
+declare class CollectionsResource {
+  #private;
+  readonly faces: FacesResource;
+  constructor(client: Viso);
+  create(params: CreateCollectionParams, options?: RequestOptions): Promise<FaceCollection>;
+  list(options?: RequestOptions): ListPromise<FaceCollection>;
+  get(collectionId: string, options?: RequestOptions): Promise<FaceCollection>;
+  /** Deletion is accepted at once and finishes in the background. */
+  delete(collectionId: string, options?: RequestOptions): Promise<Deleted>;
+  /** Searches the collection for the largest face in the image. */
+  search(collectionId: string, params: SearchByImageParams, options?: RequestOptions): Promise<FaceSearchResult>;
+}
+declare class FaceResource {
+  #private;
+  readonly collections: CollectionsResource;
+  constructor(client: Viso);
+  /** Finds faces with their box, landmarks, pose and quality, plus requested attributes. */
+  detect(params: DetectParams, options?: RequestOptions): Promise<FaceDetection>;
+  /** Compares the largest face in `source` with every face in `target`. */
+  compare(params: CompareParams, options?: RequestOptions): Promise<FaceComparison>;
+}
+declare class BucketsResource {
+  #private;
+  constructor(client: Viso);
+  create(params: CreateBucketParams, options?: RequestOptions): Promise<Bucket>;
+  list(options?: RequestOptions): ListPromise<Bucket>;
+  get(bucketId: string, options?: RequestOptions): Promise<Bucket>;
+  /** Changing visibility or cache lifetime purges the bucket's cached files. */
+  update(bucketId: string, params: UpdateBucketParams, options?: RequestOptions): Promise<Bucket>;
+  /** Deletes the bucket and every file in it; stored bytes are removed in the background. */
+  delete(bucketId: string, options?: RequestOptions): Promise<Deleted>;
+}
+declare class FilesResource {
+  #private;
+  constructor(client: Viso);
+  /**
+   * Files ordered by path. The promise resolves to the first page (with `folders` when
+   * `delimiter` is `/`); `for await` iterates the files of every page.
+   */
+  list(params: ListFilesParams, options?: RequestOptions): ListPromise<ImageFile, FileList>;
+  get(fileId: string, options?: RequestOptions): Promise<ImageFile>;
+  delete(fileId: string, options?: RequestOptions): Promise<Deleted>;
+  /** Deletes up to 100 files of a bucket at once. */
+  deleteMany(params: DeleteFilesParams, options?: RequestOptions): Promise<DeleteFilesResult>;
+  /** A time-limited CDN URL, required for files in private buckets. */
+  createSignedUrl(fileId: string, params?: SignedUrlParams, options?: RequestOptions): Promise<SignedUrl>;
+}
+declare class ImagesResource {
+  #private;
+  readonly buckets: BucketsResource;
+  readonly files: FilesResource;
+  constructor(client: Viso);
+  /**
+   * Uploads a file from your server. Bytes are sent as the raw request body; streams are
+   * forwarded as they are read. The file type is detected from its content.
+   */
+  upload(params: UploadParams, options?: RequestOptions): Promise<ImageFile>;
+  /**
+   * A single-use URL a browser can `PUT` one image to without an API key. Create it on
+   * your server and pass `uploadUrl` to `uploadToSignedUrl` in the browser.
+   */
+  createUploadUrl(params: CreateUploadUrlParams, options?: RequestOptions): Promise<UploadUrl>;
+}
+declare class UsageResource {
+  #private;
+  constructor(client: Viso);
+  /** The team's quotas, the project's recent requests and the per-key rate limit. */
+  get(options?: RequestOptions): Promise<Usage>;
+}
+export declare const VERSION = "0.1.0";
+export declare const DEFAULT_BASE_URL = "https://api.viso.lol/v1";
+/** The subset of `fetch` the SDK calls; `globalThis.fetch` and most wrappers fit. */
+type Fetch = (input: URL | string, init: RequestInit) => Promise<Response>;
+interface VisoOptions {
+  /** A project API key (`viso_sk_...`). Defaults to the `VISO_API_KEY` environment variable. */
+  apiKey?: string | undefined;
+  /** Defaults to `VISO_BASE_URL` or `https://api.viso.lol/v1`. */
+  baseUrl?: string | undefined;
+  /** Retries for rate limits, provider throttling and transient failures. Default 2. */
+  maxRetries?: number | undefined;
+  /** Per-attempt timeout in milliseconds. Default 60 000. */
+  timeoutMs?: number | undefined;
+  /** A custom `fetch`, for example to add tracing. */
+  fetch?: Fetch | undefined;
+  /**
+   * Secret keys must stay on servers: anyone who can read your page can read the key. Set
+   * this only for local experiments. Browsers upload with `uploadToSignedUrl` instead.
+   */
+  dangerouslyAllowBrowser?: boolean | undefined;
+}
+/** Options accepted by every method as its last argument. */
+interface RequestOptions {
+  signal?: AbortSignal | undefined;
+  timeoutMs?: number | undefined;
+  maxRetries?: number | undefined;
+}
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+type QueryValue = string | number | boolean | undefined;
+interface ApiRequest {
+  method: HttpMethod;
+  path: string;
+  query?: Record<string, QueryValue> | undefined;
+  json?: unknown;
+  form?: FormData | undefined;
+  body?: BodyInit | undefined;
+  contentType?: string | undefined;
+  options?: RequestOptions | undefined;
+}
+/**
+ * The viso.lol API client.
+ *
+ * ```ts
+ * const viso = new Viso({ apiKey: process.env.VISO_API_KEY });
+ * const { faces } = await viso.face.detect({ image: await file.arrayBuffer() });
+ * ```
+ */
+export declare class Viso {
+  #private;
+  readonly face: FaceResource;
+  readonly images: ImagesResource;
+  readonly usage: UsageResource;
+  readonly baseUrl: string;
+  readonly maxRetries: number;
+  readonly timeoutMs: number;
+  constructor(options?: VisoOptions);
+  /** Sends a request, retrying when it is safe, and returns the parsed JSON body. */
+  request<T>(request: ApiRequest): Promise<T>;
+}
+interface VisoErrorInit {
+  code: ErrorCode | (string & {});
+  status: number;
+  message: string;
+  requestId: string | null;
+  details?: Record<string, unknown> | undefined;
+  headers?: Headers | undefined;
+}
+/** An error response from the API: `{ error: { code, message, details?, requestId } }`. */
+export declare class VisoError extends Error {
+  /** Stable machine-readable code, for example `images.file_exists`. */
+  readonly code: ErrorCode | (string & {});
+  /** HTTP status. */
+  readonly status: number;
+  /** Include it when reporting a problem. */
+  readonly requestId: string | null;
+  readonly details: Record<string, unknown> | undefined;
+  readonly headers: Headers;
+  constructor(init: VisoErrorInit);
+}
+/** The request never got a response: network failure or timeout. */
+export declare class VisoConnectionError extends Error {
+  /** True when the SDK gave up after `timeoutMs`. */
+  readonly timeout: boolean;
+  constructor(message: string, options?: {
+    cause?: unknown;
+    timeout?: boolean;
+  });
+}
+interface UploadProgress {
+  loaded: number;
+  /** `null` when the size is unknown. */
+  total: number | null;
+}
+interface UploadToSignedUrlOptions {
+  /** Called as bytes are sent (browsers only: needs `XMLHttpRequest`). */
+  onProgress?: ((progress: UploadProgress) => void) | undefined;
+  signal?: AbortSignal | undefined;
+  /** Original file name, kept for downloads. Defaults to the `File` name. */
+  name?: string | undefined;
+  /** A custom `fetch`, used where `XMLHttpRequest` is not available. */
+  fetch?: Fetch | undefined;
+}
+type SignedUploadBody = Blob | ArrayBuffer | ArrayBufferView;
+/**
+ * Uploads one file to a signed upload URL created on your server with
+ * `viso.images.createUploadUrl()`. Safe in browsers: the URL is the credential and it
+ * works once. Uploads are not retried automatically; a rejected upload (wrong type, too
+ * large) leaves the URL usable for another attempt.
+ */
+export declare function uploadToSignedUrl(uploadUrl: string, body: SignedUploadBody, options?: UploadToSignedUrlOptions): Promise<ImageFile>;
+export type { BoundingBox, Bucket, BucketVisibility, BucketsResource, CollectionsResource, CompareParams, ComparedFace, CreateBucketParams, CreateCollectionParams, CreateUploadUrlParams, DeleteFilesParams, DeleteFilesResult, Deleted, DetectParams, Emotion, ErrorCode, Face, FaceAttribute, FaceCollection, FaceCollectionStatus, FaceComparison, FaceDetail, FaceDetection, FaceFlag, FaceIndexResult, FaceResource, FaceSearchResult, FacesResource, Fetch, FileList, FilesResource, ImageFile, ImageMimeType, ImageSource, ImagesResource, IndexFacesParams, ListFacesParams, ListFilesParams, ListPromise, Page, PageParams, QualityFilter, Quota, RequestOptions, SearchByImageParams, SearchFacesParams, SignedUploadBody, SignedUrl, SignedUrlParams, UpdateBucketParams, UploadBody, UploadParams, UploadProgress, UploadToSignedUrlOptions, UploadUrl, Usage, UsageResource, VisoOptions };
+//# sourceMappingURL=index.d.ts.map