@calmlens/sdk 0.12.0 → 0.14.0

package/README.md

@@ -38,8 +38,8 @@ const client = new CalmLensServerClient({
 // Text (comments, captions, bios): waits for the decision
 const comment = await client.text.moderate({ text: "Great photo!", externalId: "comment-42" });
 
-if (comment.status === "approved") {
-  // publish it; if comment.report?.flagged is true, also queue it for review
+if (comment.moderation.status === "approved") {
+  // publish it; if comment.moderation.action is "alert", also queue it for review
 } else {
   // "rejected": don't publish it
 }
@@ -50,16 +50,19 @@ const image = await client.assets.create({
   content: { data: file, type: "image/jpeg" },
   externalId: "post-7",
 });
-console.log(image.status); // "pending"
+console.log(image.processing.status, image.moderation.status); // "processing" "pending"
 ```
 
-| `status` | `report.flagged` | Meaning |
-| --- | --- | --- |
-| `approved` | `false` | Safe to show. |
-| `approved` | `true` | Show it, but your policy asked to be alerted. |
-| `rejected` | `true` | Your policy hid or purged it. Don't show it. |
-| `pending` | — | Still being classified. |
-| `error` | — | Processing failed. |
+| `processing.status` | `moderation.status` | `moderation.action` | Meaning |
+| --- | --- | --- | --- |
+| `done` | `approved` | `null` | Safe to show. |
+| `done` | `approved` | `alert` | Show it, but your policy asked to be alerted. |
+| `done` | `rejected` | `hide` or `purge` | Your policy hid or purged it. Don't show it. |
+| `uploading` or `processing` | `pending` | `null` | Still being received or classified. |
+| `failed` | `pending` | `null` | Processing failed; see `assets.retry`. |
+
+A reviewer's decision (`moderation.reviewerAction`) takes precedence over the automated one in
+`moderation.status`; `moderation.action` keeps what your policy did.
 
 See [How CalmLens works](https://calmlens.com/docs/how-it-works) and [Testing your integration](https://calmlens.com/docs/guides/testing) for test inputs that trigger rejections safely.
 
@@ -146,16 +149,18 @@ Both resolve to the stored `Asset`, a plain object with camelCase keys exactly a
 ```typescript
 const asset = await client.text.moderate({ text: "Great photo!", externalId: "comment-42" });
 asset.id;            // string
-asset.status;        // "approved" | "rejected" | "error"; "pending" for audio and video, which always run in the background
-asset.type;          // "plaintext-document" for text
-asset.report?.flagged;                       // boolean
-asset.report?.score;                         // number, the overall score
-asset.report?.categories.harassment.status;  // "evaluated" | "partial" | "not-evaluated"
-asset.moderationAction;                      // the policy action applied, if any
-asset.createdAt;     // milliseconds since the Unix epoch
+asset.processing.status;  // "uploading" | "processing" | "done" | "failed"; audio and video keep processing in the background
+asset.moderation.status;  // "pending" | "approved" | "rejected"
+asset.moderation.action;  // "alert" | "hide" | "purge", what your policy did with flagged content; null when nothing was flagged
+asset.moderation.report?.score;                         // number, the overall score
+asset.moderation.report?.categories.harassment.status;  // "evaluated" | "partial" | "not-evaluated"
+asset.content.status;     // "temporary" | "stored" | "removed"
+asset.content.removalReason; // "policy" | "retention" | "requested" | "parent-removed" | "disposed" | null
+asset.type;               // "plaintext-document" for text
+asset.createdAt;          // milliseconds since the Unix epoch
 ```
 
-Always present: `id`, `projectId`, `name`, `type`, `status`, `createdAt` and `updatedAt`. Every other field may be `null` or missing: `report` is absent when processing failed (`status: "error"`) or has not finished, `moderationAction` when no policy action applied, `externalId`, `description`, `metadata`, `folderId`, `visibility` and `processingOptions` when you did not set them, and `sizeInBytes`, `fileFormat`, `imageData`, `documentData`, `previewImage` and `extractedText` when they do not apply to the content. Inside a report, a category's `score` and `likelihood` exist only when its `status` is `evaluated` or `partial` (see [Moderation Reports](#moderation-reports)).
+Always present: `id`, `projectId`, `name`, `type`, `createdAt`, `updatedAt`, `processing`, `moderation` and `content` (with their `status` fields). Other fields may be `null`: `moderation.report` until classification finishes (and when processing failed), `moderation.action` when nothing was flagged, the `moderation.reviewer*` fields until a reviewer decides, `externalId`, `description`, `metadata`, `folderId`, `visibility` and `processingOptions` when you did not set them, and `content.format`, `content.sizeInBytes`, `content.image`, `content.previewImage` and `content.extractedText` when they do not apply to the content. Content is `temporary` until processing finishes and then `removed` (reason `retention`) unless you set `processingOptions.keepContentAfterProcessing`. Inside a report, a category's `score` and `likelihood` exist only when its `status` is `evaluated` or `partial` (see [Moderation Reports](#moderation-reports)).
 
 ##### assets.retrieve(options)
 
@@ -168,8 +173,8 @@ async assets.retrieve(options: { assetId: string }): Promise<Asset>
 **Example:**
 ```typescript
 const asset = await client.assets.retrieve({ assetId: "asset-uuid-here" });
-console.log(asset.status);
-console.log(asset.report); // Classification results
+console.log(asset.moderation.status);
+console.log(asset.moderation.report); // Classification results
 ```
 
 ##### ensureLens(options)
@@ -197,7 +202,7 @@ const image = await client.cdn.serve({
 });
 ```
 
-For several lenses, use `ensureLenses()` to perform all ensures in one request. Each lens keeps the same independent versioning rules.
+For several lenses, use `ensureLenses()` to ensure them together: new definitions go in one request, or in consecutive requests of up to 100 each, in order. Each lens keeps the same independent versioning rules.
 
 ```typescript
 const [normal, uhd] = await client.ensureLenses({ lenses: [normalLens, uhdLens] });
@@ -233,14 +238,14 @@ const result = await client.assets.list({
 
 console.log(`Found ${result.total} assets`);
 result.items.forEach(asset => {
-  console.log(`${asset.name}: ${asset.status}`);
+  console.log(`${asset.name}: ${asset.moderation.status}`);
 });
 ```
 
 To read every matching asset, iterate instead of paging by hand. Pages are fetched as you go; assets created or deleted meanwhile can shift pages, so one may be skipped or repeated.
 
 ```typescript
-for await (const asset of client.assets.iterate({ filter: "status==rejected", pageSize: 100 })) {
+for await (const asset of client.assets.iterate({ filter: "moderation.status==rejected", pageSize: 100 })) {
   console.log(asset.id);
 }
 ```
@@ -294,13 +299,26 @@ await client.assets.move({
 
 ##### assets.retry(options)
 
-Process an asset that failed (status `error`) again. It returns to `pending` and is moderated like a
-new upload, so handle the result the same way (webhook or polling). Its content must still be stored:
+Process an asset whose processing failed (`processing.status` `failed`) again. It returns to
+`processing` and is moderated like a new upload, so handle the result the same way (webhook or polling). Its content must still be stored:
 otherwise this throws `asset/content-unavailable`, and you need to upload it again.
 
 ```typescript
 const asset = await client.assets.retry({ assetId: "asset-uuid" });
-// asset.status === "pending"
+// asset.processing.status === "processing"
+```
+
+##### assets.waitForDecision(options)
+
+Wait for an asset's moderation decision and get the decided asset: it returns once `moderation.status`
+is `approved` or `rejected`, or `processing.status` is `failed`. The SDK checks the asset every few seconds and rejects with `sdk/timeout` if there's no decision within
+`timeoutMs` (default 60000). Pass `signal` to stop waiting early (`sdk/cancelled`). Use it after
+`assets.create`, or with an asset ID you stored earlier. Webhooks report decisions without polling.
+
+```typescript
+const queued = await client.assets.create({ name: "photo.jpg", content: { blob, type: "image/jpeg" } });
+const decided = await client.assets.waitForDecision({ assetId: queued.id, timeoutMs: 30_000 });
+if (decided.moderation.status === "rejected") hidePhoto(decided.id);
 ```
 
 ##### folders.list()
@@ -448,7 +466,7 @@ const analyzed = await client.assets.moderate({
     isFinal: true
   }
 });
-console.log(analyzed.status);
+console.log(analyzed.moderation.status);
 ```
 
 #### Static Methods
@@ -486,7 +504,7 @@ const client = new CalmLensAppClient({
 });
 
 const asset = await client.assets.moderate({ name: file.name, content: { data: file, type: file.type } });
-// asset.status is present when the preset shows decisions to uploaders
+// asset.status (the moderation status) is present when the preset shows decisions to uploaders
 ```
 
 **Options:** `uploadPresetId` (required), `token` (a string, or a function that returns one or a promise of one), plus `baseUrl`, `fetch`, `uploadFetch`, `timeoutMs`, `uploadTimeoutMs`, `maxRetries`, `maxResponseBytes` and `signal` as for `CalmLensServerClient`. Passing `apiKey` throws `sdk/invalid-config`.
@@ -520,12 +538,11 @@ Assets can be of the following types:
 
 ## Asset Status
 
-Assets progress through these statuses:
-- `uploading` - Multipart upload is accepting more parts
-- `pending` - Asset is being processed
-- `approved` - Processing completed and delivery is allowed; an `alert` action can still leave `report.flagged` set to `true`
-- `rejected` - A hide, purge, child-asset, or manual rejection decision was applied
-- `error` - Processing failed
+An asset's state is split in three:
+
+- `processing.status`: `uploading` (a multipart upload is accepting more parts), `processing`, then `done` or `failed`
+- `moderation.status`: `pending` until moderation finishes, then `approved` or `rejected`. A reviewer's decision (`moderation.reviewerAction`) takes precedence over the automated one. `moderation.action` is what your policy did with flagged content (`alert`, `hide` or `purge`), or `null` when nothing was flagged; an `alert` leaves the asset `approved`.
+- `content.status`: `temporary` (kept only until processing finishes), `stored` or `removed`, with `content.removalReason` `policy` (purged), `retention` (`keepContentAfterProcessing` off), `requested`, `parent-removed` or `disposed`
 
 ## Moderation Reports
 
@@ -610,7 +627,7 @@ The API keeps a response for 24 hours. Reusing a key for a different request fai
 
 ## Forward compatibility
 
-The SDK does not validate responses against its types, so fields and values added to the API later reach your code unchanged. `AssetStatus`, `AssetType` and `AssetVisibility` include `string` for that reason: handle values you don't know (for example, treat an unknown status as "not ready"). Event types and fact keys are typed for the ones this version knows; keep a default branch when you switch on them.
+The SDK does not validate responses against its types, so fields and values added to the API later reach your code unchanged. `AssetProcessingStatus`, `AssetModerationStatus`, `AssetModerationAction`, `AssetReviewerAction`, `AssetContentStatus`, `AssetContentRemovalReason`, `AssetType` and `AssetVisibility` include `string` for that reason: handle values you don't know (for example, treat an unknown status as "not ready"). Event types and fact keys are typed for the ones this version knows; keep a default branch when you switch on them.
 
 ## Testing
 
@@ -629,7 +646,7 @@ const client = new MockCalmLensServerClient({
 
 `MockCalmLensServerClient` accepts the same options as `CalmLensServerClient` (`apiKey`, `projectId`, `baseUrl`, `cdnBaseUrl`, `timeoutMs`, ...) and validates them the same way, plus `mockOptions`. `cdn.getAssetUrl` uses `cdnBaseUrl` (default `mock://calmlens/v1`).
 
-It behaves like the API where tests depend on it: errors carry the API's code, HTTP `status`, a `requestId` and `headers`; `assets.list` applies `ordering`, `folderId` and simple `filter` expressions (comparisons joined by `;` and `,`; anything else throws `sdk/invalid-argument` rather than returning wrong results); `assets.search` matches names, IDs, external IDs, descriptions and tags; multipart parts must arrive in order and the queue mode chosen at the start applies to the final part; a reused `idempotencyKey` replays the first result; and `cdn.serve` returns CDN-like responses with JSON error bodies. `client.enqueueEvent({ type, ... })` adds an event that `events.list` and `events.pages` then return.
+It behaves like the API where tests depend on it: errors carry the API's code, HTTP `status`, a `requestId` and `headers`; `assets.list` applies `ordering`, `folderId` and simple `filter` expressions (comparisons joined by `;` and `,`; anything else throws `sdk/invalid-argument` rather than returning wrong results); `assets.search` matches names, IDs, external IDs, descriptions and tags; multipart parts must arrive in order and the queue mode chosen at the start applies to the final part; `mockOptions.queuedOutcome` (default `pending`) and `mockOptions.analyzedOutcome` (default `approved`) set where queued and waited-for uploads end up (`pending`, `approved`, `rejected` or `failed`); content is removed with reason `retention` once processing is done unless `keepContentAfterProcessing` is set, and `assets.deleteContent` removes it with reason `requested`; a reused `idempotencyKey` replays the first result; and `cdn.serve` returns CDN-like responses with JSON error bodies. `client.enqueueEvent({ type, ... })` adds an event that `events.list` and `events.pages` then return.
 
 Every call is recorded in `client.calls` as `{ operation, options }`, where `operation` is the method path (`"text.moderate"`, `"assets.retrieve"`, `"events.list"`, ...) and `options` is the object you passed. `client.callsTo(operation)` filters them. To test failure handling, `client.failNextRequest()` makes the next call throw the same `CalmLensError` the real client throws when the network fails (`sdk/transport-error`); pass `"timeout"` for `sdk/timeout`, or any `Error` to throw it as is, and `{ operation }` to fail only that method. Each queued failure is used once.
 
@@ -648,7 +665,7 @@ To test a webhook handler, build a signed delivery the way CalmLens sends it:
 ```typescript
 import { createWebhookHeaders, toWebhookEventPayload } from "@calmlens/sdk/testing";
 
-const event = client.enqueueEvent({ type: "asset.classified", assetId: asset.id });
+const event = client.enqueueEvent({ type: "asset.approved", assetId: asset.id });
 const body = JSON.stringify(toWebhookEventPayload(event));
 const headers = await createWebhookHeaders({ secret, body, deliveryId: "delivery-1" });
 const response = await app.request("/api/webhooks/calmlens", { method: "POST", body, headers });

package/cjs/CalmLensConnection-Bth5fJyp.js

@@ -0,0 +1,234 @@
+const require_CalmLensVersion = require("./CalmLensVersion-Bs0DreBV.js");
+const require_CalmLensUtils = require("./CalmLensUtils-DNdmYeX6.js");
+//#region src/client/CalmLensConnection.ts
+const DEFAULT_TIMEOUT_MS = 12e4;
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_MAX_RESPONSE_BYTES = 33554432;
+/**
+* Bytes as a fetch body. They're sent as they are rather than in a Blob: React Native can't
+* build a Blob from bytes, and every fetch accepts a Uint8Array.
+*/
+const toBodyBytes = (value) => value.buffer instanceof ArrayBuffer ? value : Uint8Array.from(value);
+const toRawUploadBody = (payload) => {
+	const data = require_CalmLensUtils.assetToData(payload);
+	if (data instanceof Response) {
+		if (!data.body) throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message: "Response upload data must have a body" });
+		return data.body;
+	}
+	if (data instanceof ArrayBuffer || data instanceof Blob) return data;
+	if ("getReader" in data) return data;
+	return toBodyBytes(data);
+};
+const setOptionalQueryValue = (params, key, value) => {
+	if (value !== void 0 && value !== null) params.set(key, typeof value === "string" ? value : JSON.stringify(value));
+};
+const assertValidUploadMimeType = (mimeType) => {
+	if (require_CalmLensUtils.isRejectedUploadMimeType(mimeType)) throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.API_ERROR_CODES.INVALID_UPLOAD_MIME_TYPE, {
+		message: require_CalmLensUtils.getRejectedUploadMimeTypeError(mimeType),
+		details: { mimeType }
+	});
+};
+const isImageMimeType = (mimeType) => mimeType.toLowerCase().startsWith("image/");
+const invalidPayload = (message) => new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.API_ERROR_CODES.INVALID_UPLOAD_PAYLOAD, { message });
+/** Checks upload options before anything is sent. */
+const prepareSubmitAssetOptions = (options) => {
+	if (!options || typeof options !== "object") throw require_CalmLensVersion.invalidArgument("Asset options are required");
+	if (!("content" in options) && !("url" in options) && !("part" in options)) throw invalidPayload("Either file content, URL, or multipart part is required");
+	if (!options.name) throw invalidPayload("Asset name is required");
+	if (!("part" in options) && "isFinal" in options) throw invalidPayload("isFinal is only valid for multipart uploads");
+	if ("part" in options && options.part.partNumber && options.part.partNumber > 1) throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.API_ERROR_CODES.USE_UPLOAD_PART, { message: "Use uploadPart for multipart upload parts after the first part" });
+	if ("content" in options) {
+		assertValidUploadMimeType(options.content.type);
+		if (!("plainText" in options.content)) {
+			const validation = require_CalmLensUtils.validateAssetPayload(options.content);
+			if (!validation.ok) throw invalidPayload(validation.error);
+		}
+	}
+	if ("part" in options) {
+		assertValidUploadMimeType(options.part.type);
+		const partSizeInBytes = options.part.sizeInBytes ?? require_CalmLensUtils.getAssetPayloadByteLength(options.part);
+		if (isImageMimeType(options.part.type) && partSizeInBytes !== void 0) {
+			if (partSizeInBytes > require_CalmLensUtils.MAX_IMAGE_UPLOAD_BYTES) throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.API_ERROR_CODES.MULTIPART_IMAGE_TOO_LARGE, { message: "Multipart image uploads cannot exceed 20MB." });
+			if (options.part.isFinal && partSizeInBytes < require_CalmLensUtils.MIN_MULTIPART_IMAGE_UPLOAD_BYTES) throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.API_ERROR_CODES.MULTIPART_IMAGE_TOO_SMALL, { message: "Multipart image uploads must total at least 10MB." });
+		}
+		const validation = require_CalmLensUtils.validateAssetPayload(options.part, {
+			multipart: true,
+			isFinal: options.part.isFinal
+		});
+		if (!validation.ok) throw invalidPayload(validation.error);
+	}
+	return options;
+};
+const newIdempotencyKey = () => require_CalmLensUtils.randomUuid();
+/** Text content is small, so it keeps the API deadline; binary files may be arbitrarily large. */
+const isTextPayload = (payload) => "plainText" in payload;
+const hasStringStatus = (value) => !!value && typeof value === "object" && typeof value.status === "string";
+const isAsset = (data) => !!data && typeof data === "object" && typeof data.id === "string" && !!data.id && hasStringStatus(data.processing) && hasStringStatus(data.moderation);
+const isUploadedAsset = (data) => !!data && typeof data === "object" && typeof data.id === "string" && !!data.id;
+const expectUploadedAsset = (data) => {
+	if (!isUploadedAsset(data)) throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.SDK_ERROR_CODES.INVALID_RESPONSE, {
+		message: "Expected an uploaded asset response",
+		status: 200
+	});
+	return data;
+};
+const expectAsset = (data) => {
+	if (!isAsset(data)) throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.SDK_ERROR_CODES.INVALID_RESPONSE, {
+		message: "Expected an asset response",
+		status: 200
+	});
+	return data;
+};
+/** Fills in the default API base URL and drops trailing slashes. */
+const resolveConnectionOptions = (options) => ({
+	...options,
+	baseUrl: (options.baseUrl ?? `https://api.calmlens.com/v1`).replace(/\/+$/, "")
+});
+/** One client's transport, base URL and deadlines, and the requests both clients make. */
+var CalmLensConnection = class {
+	constructor(options, apiKey) {
+		this.options = options;
+		const resolveFetch = () => {
+			const fetchImpl = this.options.fetch ?? globalThis.fetch;
+			if (typeof fetchImpl !== "function") throw new require_CalmLensVersion.CalmLensError(require_CalmLensVersion.SDK_ERROR_CODES.NO_FETCH, { message: "No fetch implementation is available; pass one as the fetch option" });
+			return fetchImpl;
+		};
+		this.transport = new require_CalmLensUtils.CalmLensTransport({
+			apiKey,
+			fetch: ((input, init) => resolveFetch()(input, init)),
+			signal: options.signal,
+			maxRetries: options.maxRetries ?? DEFAULT_MAX_RETRIES,
+			maxResponseBytes: options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES
+		});
+	}
+	get timeoutMs() {
+		return this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	}
+	url(path, query) {
+		const search = query ? require_CalmLensUtils.stringifyQuery(query) : "";
+		return `${this.options.baseUrl}${path}${search ? `?${search}` : ""}`;
+	}
+	/** A JSON request whose deadline covers reading the response. */
+	json(method, path, { query, body, headers, idempotencyKey } = {}) {
+		return this.transport.json({
+			method,
+			url: this.url(path, query),
+			headers: body === void 0 ? headers : {
+				...headers,
+				"Content-Type": "application/json"
+			},
+			body: body === void 0 ? void 0 : JSON.stringify(body),
+			idempotencyKey,
+			timeoutMs: this.timeoutMs,
+			deadline: "body"
+		});
+	}
+	upload(url, payload, headers, idempotencyKey) {
+		return this.transport.json({
+			method: "POST",
+			url,
+			headers,
+			body: toRawUploadBody(payload),
+			idempotencyKey,
+			timeoutMs: isTextPayload(payload) ? this.timeoutMs : this.options.uploadTimeoutMs,
+			deadline: "body",
+			fetch: this.options.uploadFetch
+		});
+	}
+	/**
+	* Uploads file content or a first multipart part to `uploadsPath` (`.../assets`), as raw
+	* bytes with the options in the query.
+	*/
+	submitRawUpload(uploadsPath, options, queue, authHeaders = {}) {
+		const query = new URLSearchParams();
+		query.set("name", options.name);
+		query.set("queue", String(queue));
+		setOptionalQueryValue(query, "description", options.description);
+		setOptionalQueryValue(query, "processingOptions", options.processingOptions);
+		setOptionalQueryValue(query, "visibility", options.visibility);
+		setOptionalQueryValue(query, "metadata", options.metadata);
+		setOptionalQueryValue(query, "externalId", options.externalId);
+		setOptionalQueryValue(query, "externalUrl", options.externalUrl);
+		setOptionalQueryValue(query, "folderId", options.folderId);
+		setOptionalQueryValue(query, "uploadPresetId", options.uploadPresetId);
+		const isMultipart = "part" in options;
+		const payload = isMultipart ? options.part : options.content;
+		query.set("contentType", payload.type);
+		setOptionalQueryValue(query, "sizeInBytes", payload.sizeInBytes ?? require_CalmLensUtils.getAssetPayloadByteLength(payload));
+		if (isMultipart) {
+			const part = payload;
+			const multipartOptions = options;
+			query.set("partNumber", String(part.partNumber ?? 1));
+			query.set("isFinal", String(part.isFinal ?? false));
+			setOptionalQueryValue(query, "sizeInBytes", part.sizeInBytes ?? multipartOptions.sizeInBytes);
+			setOptionalQueryValue(query, "totalSizeInBytes", multipartOptions.totalSizeInBytes);
+		}
+		return this.upload(this.url(`${uploadsPath}?${query}`), payload, {
+			...authHeaders,
+			"Content-Type": payload.type,
+			"X-CalmLens-Upload": isMultipart ? "part" : "content"
+		}, options.idempotencyKey ?? newIdempotencyKey());
+	}
+	/** Uploads the next part of a multipart upload to `partPath` (`.../assets/{id}/part`). */
+	uploadPart(partPath, { part, queue, idempotencyKey }, authHeaders = {}) {
+		if (!part) throw require_CalmLensVersion.invalidArgument("Part options are required");
+		const validation = require_CalmLensUtils.validateAssetPayload(part, {
+			multipart: true,
+			isFinal: part.isFinal
+		});
+		if (!validation.ok) throw invalidPayload(validation.error);
+		const query = new URLSearchParams({
+			partNumber: String(part.partNumber),
+			isFinal: String(part.isFinal ?? false)
+		});
+		if (queue !== void 0) query.set("queue", String(queue));
+		setOptionalQueryValue(query, "sizeInBytes", part.sizeInBytes ?? require_CalmLensUtils.getAssetPayloadByteLength(part));
+		return this.upload(this.url(`${partPath}?${query}`), part, {
+			...authHeaders,
+			"X-CalmLens-Upload": "part"
+		}, idempotencyKey ?? newIdempotencyKey());
+	}
+};
+//#endregion
+Object.defineProperty(exports, "CalmLensConnection", {
+	enumerable: true,
+	get: function() {
+		return CalmLensConnection;
+	}
+});
+Object.defineProperty(exports, "expectAsset", {
+	enumerable: true,
+	get: function() {
+		return expectAsset;
+	}
+});
+Object.defineProperty(exports, "expectUploadedAsset", {
+	enumerable: true,
+	get: function() {
+		return expectUploadedAsset;
+	}
+});
+Object.defineProperty(exports, "invalidPayload", {
+	enumerable: true,
+	get: function() {
+		return invalidPayload;
+	}
+});
+Object.defineProperty(exports, "newIdempotencyKey", {
+	enumerable: true,
+	get: function() {
+		return newIdempotencyKey;
+	}
+});
+Object.defineProperty(exports, "prepareSubmitAssetOptions", {
+	enumerable: true,
+	get: function() {
+		return prepareSubmitAssetOptions;
+	}
+});
+Object.defineProperty(exports, "resolveConnectionOptions", {
+	enumerable: true,
+	get: function() {
+		return resolveConnectionOptions;
+	}
+});