@tearleads/client-sdk 0.0.0-stage → 0.1.13

package/internal/api-client/ApiClient.js

@@ -0,0 +1,844 @@
+import { sign } from "../crypto/index.js";
+import { bindBlobAttachmentOperation, blobWireHeaderKeys, cancelStripeSubscriptionOperation, challengeOperation, claimNativeOrganizationSubscriptionOperation, completeMultipartBlobStageOperation, createContainerOperation, createContainerWithMetadataDocumentOperation, createDocumentOperation, createOrganizationGroupOperation, createOrganizationOperation, createStripeCheckoutOperation, createStripeCheckoutSessionOperation, createStripePortalOperation, deleteContainerOperation, deleteOrganizationGroupOperation, destroySessionOperation, detachBlobAttachmentOperation, documentSyncOperation, getContainerKekLogOperation, getContainerReplacementAuthorizationsOperation, getContainerWriterProjectionOperation, getDocumentPurgeProofOperation, getDocumentWriterProjectionOperation, getHealthOperation, getMultipartBlobStageOperation, getOrganizationBillingHistoryOperation, getOrganizationBillingManagementUrlOperation, getOrganizationBillingOperation, getOrganizationDataUsageOperation, getOrganizationNativePurchaseEligibilityOperation, getOrganizationPolicyHistoryOperation, getOrganizationReadModelOperation, getRootIdentityOperation, getRootOrganizationDataUsageOperation, getRootOrganizationOperation, getStripeCheckoutOptionsOperation, initiateMultipartBlobStageOperation, linkDocumentOperation, listContainerDocumentsOperation, listContainerParentLanesOperation, listDocumentAttachmentsOperation, listOrganizationGroupMembersOperation, listRootDataUsageReportOperation, listRootIdentitiesOperation, listRootIdentityOrganizationsOperation, listRootOrganizationIdentitiesOperation, listRootOrganizationsOperation, listSessionsOperation, logoutOperation, moveContainerOperation, purgeDocumentOperation, reciteContainerOperation, registerOperation, rekeyContainerOperation, revokeContainerOperation, shareContainerOperation, startOrganizationTrialOperation, unlinkDocumentOperation, updateOrganizationProfileOperation, updateOrganizationRosterEntryOperation, uploadMultipartBlobPartBytesOperation, userIdentityOperation, verifyOperation, webSocketTicketOperation, } from "../validators/operation/index.js";
+import { BoundedCache } from "./ApiCache.js";
+import { ApiRequestRuntime } from "./apiRequestRuntime.js";
+import { createOperationTransport, } from "./operationTransportFactory.js";
+import { PrincipalPolicyRequests } from "./principalPolicyRequests.js";
+import { ProjectionHistoryTransport } from "./projectionHistoryTransport.js";
+import { bindPrototypeMethods, cachedRequest, dedupedRequest, evictWriterProjectionIfSyncChanged, listContainerDocumentsRequestKey, listContainerParentLanesRequestKey, } from "./requestInternals.js";
+import { destroySession as authDestroySession, listSessions as authListSessions, logout as authLogout, userIdentity as authUserIdentity, } from "./routes/auth/session.js";
+import { bindBlobAttachment as blobAttachmentBind, detachBlobAttachment as blobAttachmentDetach, } from "./routes/blobs/attachments.js";
+import { getBlobBytes, } from "./routes/blobs/get.js";
+import { completeMultipartBlobStage as multipartComplete, getMultipartBlobStage as multipartGet, initiateMultipartBlobStage as multipartInitiate, } from "./routes/blobs/multipart.js";
+import { containerCreate, containerCreateWithMetadataDocument, containerDelete, containerMove, containerRecite, containerRekey, containerRevoke, containerShare, } from "./routes/containers/mutations.js";
+import { containerDocuments, containerKekLog, containerParentLanes, } from "./routes/containers/reads.js";
+import { listDocumentAttachments as documentAttachmentsList } from "./routes/documents/attachments.js";
+import { DocumentAttributionRequests } from "./routes/documents/attributionRequests.js";
+import { documentCreate, documentLink, documentPurge, documentPurgeProof, documentUnlink, } from "./routes/documents/mutations.js";
+import { organizationBilling } from "./routes/organizations/billing.js";
+import { createOrganizationGroup as groupCreate } from "./routes/organizations/createGroup.js";
+import { getOrganizationDataUsage as organizationDataUsage } from "./routes/organizations/dataUsage.js";
+import { deleteOrganizationGroup as groupDelete } from "./routes/organizations/deleteGroup.js";
+import { listOrganizationGroupMembers as groupMembers } from "./routes/organizations/groupMembers.js";
+import { updateOrganizationProfile as profileUpdate } from "./routes/organizations/profile.js";
+import { updateOrganizationRosterEntry as rosterUpdate } from "./routes/organizations/roster.js";
+import { organizationStripeCheckout } from "./routes/organizations/stripeCheckout.js";
+import { containerWriterProjection, documentWriterProjection, } from "./routes/writerProjections.js";
+import { CitingProjectionCache, evictWriterProjectionsCiting, } from "./writerProjectionCitations.js";
+import { primeWriterProjectionSlot } from "./writerProjectionPrime.js";
+/** The rotations that may carry descendant rekeys, each with its operation. */
+const CONTAINER_ROTATIONS = {
+    move: { operation: moveContainerOperation, route: containerMove },
+    rekey: { operation: rekeyContainerOperation, route: containerRekey },
+    revoke: { operation: revokeContainerOperation, route: containerRevoke },
+};
+export class ApiClient {
+    requestRuntime;
+    projectionHistory = new ProjectionHistoryTransport();
+    containerDocumentListRequestsByKey = new Map();
+    containerParentLaneRequestsByKey = new Map();
+    containerWriterProjectionRequestsByContainerId = new CitingProjectionCache();
+    documentWriterProjectionRequestsByDocumentId = new CitingProjectionCache();
+    containerWriterProjectionResultsInFlightByContainerId = new Map();
+    documentWriterProjectionResultsInFlightByDocumentId = new Map();
+    documentAttachmentListRequestsByDocumentId = new BoundedCache();
+    documentAttributionRequests;
+    userIdentityRequestsByUserId = new BoundedCache();
+    principalPolicyRequestsByKey = new BoundedCache();
+    principalPolicyRequests;
+    transport;
+    request;
+    requestResult;
+    constructor(baseUrl) {
+        bindPrototypeMethods(this, ApiClient.prototype);
+        this.requestRuntime = new ApiRequestRuntime(baseUrl);
+        this.principalPolicyRequests = new PrincipalPolicyRequests(this.requestRuntime, this.principalPolicyRequestsByKey, this.clearWriterProjectionCaches);
+        this.request = this.projectionHistory.wrapRequest(this.requestRuntime.request);
+        this.requestResult = this.projectionHistory.wrapRequestResult(this.requestRuntime.requestResult);
+        this.transport = createOperationTransport(this.requestRuntime.responseRequest);
+        this.documentAttributionRequests = new DocumentAttributionRequests(this.transport);
+    }
+    clearAuthScopedCaches() {
+        this.projectionHistory.clear();
+        this.containerDocumentListRequestsByKey.clear();
+        this.containerParentLaneRequestsByKey.clear();
+        this.documentAttachmentListRequestsByDocumentId.clear();
+        this.documentAttributionRequests.clear();
+        this.containerWriterProjectionRequestsByContainerId.clear();
+        this.documentWriterProjectionRequestsByDocumentId.clear();
+        this.containerWriterProjectionResultsInFlightByContainerId.clear();
+        this.documentWriterProjectionResultsInFlightByDocumentId.clear();
+        this.userIdentityRequestsByUserId.clear();
+        this.principalPolicyRequestsByKey.clear();
+    }
+    invalidateDocumentAttribution(documentId) {
+        this.documentAttributionRequests.invalidate(documentId);
+    }
+    clearWriterProjectionCaches() {
+        this.documentAttachmentListRequestsByDocumentId.clear();
+        this.containerWriterProjectionRequestsByContainerId.clear();
+        this.documentWriterProjectionRequestsByDocumentId.clear();
+        this.containerWriterProjectionResultsInFlightByContainerId.clear();
+        this.documentWriterProjectionResultsInFlightByDocumentId.clear();
+    }
+    /** After a peer changed these containers' manifests; see the helper. */
+    evictWriterProjectionsCiting(containerIds) {
+        evictWriterProjectionsCiting(new Set(containerIds), {
+            attachmentLists: this.documentAttachmentListRequestsByDocumentId,
+            containers: {
+                cache: this.containerWriterProjectionRequestsByContainerId,
+                inFlight: this.containerWriterProjectionResultsInFlightByContainerId,
+            },
+            documents: {
+                cache: this.documentWriterProjectionRequestsByDocumentId,
+                inFlight: this.documentWriterProjectionResultsInFlightByDocumentId,
+            },
+        });
+    }
+    evictUserIdentity(userId) {
+        this.userIdentityRequestsByUserId.delete(userId);
+    }
+    /**
+     * Evict a document's projection and attachment envelopes together: link/unlink
+     * changes both. A stale attachment list would regenerate an already committed
+     * destination wrap during a move. Unrelated documents keep their caches.
+     */
+    evictDocumentWriterProjection(documentId) {
+        this.documentAttachmentListRequestsByDocumentId.delete(documentId);
+        this.documentWriterProjectionRequestsByDocumentId.delete(documentId);
+        this.documentWriterProjectionResultsInFlightByDocumentId.delete(documentId);
+    }
+    /**
+     * Container counterpart of {@link evictDocumentWriterProjection}: evict a
+     * single container's cached writer projection. A stale-projection create
+     * retry only implicates the container it is creating under, so it evicts just
+     * that entry rather than clearing the whole projection cache.
+     */
+    evictContainerWriterProjection(containerId) {
+        this.containerWriterProjectionRequestsByContainerId.delete(containerId);
+        this.containerWriterProjectionResultsInFlightByContainerId.delete(containerId);
+    }
+    updateCachedDocumentAttachmentList(documentId, update) {
+        const cached = this.documentAttachmentListRequestsByDocumentId.get(documentId);
+        if (!cached) {
+            return;
+        }
+        let next;
+        next = cached
+            .then((attachments) => {
+            if (!attachments) {
+                if (this.documentAttachmentListRequestsByDocumentId.get(documentId) ===
+                    next) {
+                    this.documentAttachmentListRequestsByDocumentId.delete(documentId);
+                }
+                return attachments;
+            }
+            return update(attachments);
+        })
+            .catch(() => {
+            // The underlying list fetch failed. Drop this derived cache entry so the
+            // next read refetches, and resolve to null (the cache's miss semantics)
+            // rather than rethrowing: nothing awaits this derived promise directly,
+            // so a rethrow would surface as an unhandled rejection. Callers already
+            // awaiting the original request still observe its rejection.
+            if (this.documentAttachmentListRequestsByDocumentId.get(documentId) ===
+                next) {
+                this.documentAttachmentListRequestsByDocumentId.delete(documentId);
+            }
+            return null;
+        });
+        this.documentAttachmentListRequestsByDocumentId.set(documentId, next);
+    }
+    cacheBlobAttachmentBindResponse(response) {
+        const { documentId, writeHeaderHash: _writeHeaderHash, ...binding } = response;
+        this.updateCachedDocumentAttachmentList(documentId, (attachments) => [
+            ...attachments.filter((cachedBinding) => cachedBinding.slotId !== response.slotId),
+            binding,
+        ]);
+    }
+    cacheBlobAttachmentDetachResponse(response) {
+        this.updateCachedDocumentAttachmentList(response.documentId, (attachments) => attachments.filter((binding) => binding.bindingId !== response.bindingId));
+    }
+    setOnError(handler) {
+        this.requestRuntime.setOnError(handler);
+    }
+    setOnNetworkError(handler) {
+        this.requestRuntime.setOnNetworkError(handler);
+    }
+    setOnNetworkSuccess(handler) {
+        this.requestRuntime.setOnNetworkSuccess(handler);
+    }
+    setOnApiVersion(handler) {
+        this.requestRuntime.setOnApiVersion(handler);
+    }
+    setOnSessionExpired(handler) {
+        this.requestRuntime.setOnSessionExpired(handler);
+    }
+    setOnPaymentRequired(handler) {
+        this.requestRuntime.setOnPaymentRequired(handler);
+    }
+    setAuthToken(token) {
+        if (this.requestRuntime.setAuthToken(token)) {
+            this.clearAuthScopedCaches();
+        }
+    }
+    getAuthToken() {
+        return this.requestRuntime.getAuthToken();
+    }
+    getRequestFailure(input) {
+        return this.requestRuntime.getRequestFailure(input);
+    }
+    async requestWebSocketTicket() {
+        const response = await this.transport.request(webSocketTicketOperation, {
+            params: {},
+        });
+        return response?.ticket ?? null;
+    }
+    getHealth() {
+        return this.transport.request(getHealthOperation, { params: {} });
+    }
+    registerUser(userId, organizationId, rootContainerId, signingPublicKey, encapsulationPublicKey, initialAdminGroup, initialMemberGroup, initialOrganizationPolicy, initialRootContainer, initialRootMetadataDocument, initialRosterProfileContainer, initialRosterProfileDocument, initialOrganizationMetadataContainer, initialOrganizationProfileDocument, initialSystemContainers) {
+        return this.transport.request(registerOperation, {
+            body: {
+                userId,
+                organizationId,
+                rootContainerId,
+                signingPublicKey: Array.from(signingPublicKey),
+                encapsulationPublicKey: Array.from(encapsulationPublicKey),
+                initialAdminGroup,
+                initialMemberGroup,
+                initialOrganizationPolicy,
+                initialRootContainer,
+                initialRootMetadataDocument,
+                initialRosterProfileContainer,
+                initialRosterProfileDocument,
+                initialOrganizationMetadataContainer,
+                initialOrganizationProfileDocument,
+                initialSystemContainers,
+            },
+            params: {},
+        });
+    }
+    createOrganization(request) {
+        return this.transport.request(createOrganizationOperation, {
+            body: request,
+            params: {},
+        });
+    }
+    async authenticate(fingerprint, secretKey) {
+        const challenge = await this.transport.request(challengeOperation, { body: { fingerprint }, params: {} }, { retryOnSessionExpired: false });
+        if (!challenge)
+            return null;
+        return this.authenticateWithChallenge(fingerprint, secretKey, challenge.challenge);
+    }
+    async authenticateWithChallenge(fingerprint, secretKey, challengeHex) {
+        const signed = sign(this.requestRuntime.authChallengeBytes(challengeHex, fingerprint), secretKey);
+        const response = await this.transport.request(verifyOperation, {
+            body: { fingerprint, signature: Array.from(signed) },
+            params: {},
+        }, { retryOnSessionExpired: false });
+        return response?.authenticated ? response : null;
+    }
+    getUserIdentity(userId) {
+        return cachedRequest(this.userIdentityRequestsByUserId, userId, () => this.request(authUserIdentity.path(userId), authUserIdentity.isResponse, authUserIdentity.method, undefined, undefined, userIdentityOperation));
+    }
+    getUserIdentityRequestFailure(userId) {
+        return this.getRequestFailure({
+            method: authUserIdentity.method,
+            path: authUserIdentity.path(userId),
+        });
+    }
+    listSessions() {
+        return this.request(authListSessions.path, authListSessions.isResponse, authListSessions.method, undefined, undefined, listSessionsOperation);
+    }
+    destroySession(sessionId) {
+        return this.request(authDestroySession.path(sessionId), authDestroySession.isResponse, authDestroySession.method, undefined, undefined, destroySessionOperation);
+    }
+    logout() {
+        return this.request(authLogout.path, authLogout.isResponse, authLogout.method, undefined, { retryOnSessionExpired: false }, logoutOperation);
+    }
+    getPrincipalPolicyPages(principalType, principalId, options = {}) {
+        return this.principalPolicyRequests.pages(principalType, principalId, options);
+    }
+    getCurrentPrincipalPolicy(principalType, principalId, options = {}) {
+        return this.principalPolicyRequests.get(principalType, principalId, options);
+    }
+    putPrincipalPolicy(principalType, principalId, input, options = {}) {
+        return this.principalPolicyRequests.put(principalType, principalId, input, options);
+    }
+    commitOrganizationGroupPolicy(organizationId, groupId, input) {
+        return this.commitOrganizationGroupPolicyResult(organizationId, groupId, input).then((result) => (result.ok ? result.data : null));
+    }
+    /**
+     * Status-bearing group policy commit. A rematerialized rotation the server
+     * refuses for stranding a granted path names the descendant rekeys the batch
+     * must carry, which the plain method collapses to null.
+     */
+    async commitOrganizationGroupPolicyResult(organizationId, groupId, input, options = {}) {
+        return this.principalPolicyRequests.commitResult(organizationId, groupId, input, options);
+    }
+    getOrganizationPolicyHistoryResult(organizationId, stateHash, options = {}) {
+        return this.transport.requestResult(getOrganizationPolicyHistoryOperation, { params: { organizationId }, query: { stateHash } }, options);
+    }
+    getOrganizationReadModelResult(organizationId, cursor, options = {}) {
+        return this.transport.requestResult(getOrganizationReadModelOperation, {
+            params: { organizationId },
+            query: { cursor },
+        }, options);
+    }
+    getRootOrganizationDataUsageResult(organizationId, options = {}) {
+        return this.transport.requestResult(getRootOrganizationDataUsageOperation, { params: { organizationId } }, options);
+    }
+    listRootDataUsageReportResult(query = {}, options = {}) {
+        return this.transport.requestResult(listRootDataUsageReportOperation, { params: {}, query }, options);
+    }
+    listRootOrganizationsResult(query = {}, options = {}) {
+        return this.transport.requestResult(listRootOrganizationsOperation, { params: {}, query }, options);
+    }
+    getRootOrganizationResult(organizationId, options = {}) {
+        return this.transport.requestResult(getRootOrganizationOperation, { params: { organizationId } }, options);
+    }
+    listRootOrganizationIdentitiesResult(organizationId, query = {}, options = {}) {
+        return this.transport.requestResult(listRootOrganizationIdentitiesOperation, { params: { organizationId }, query }, options);
+    }
+    listRootIdentitiesResult(query = {}, options = {}) {
+        return this.transport.requestResult(listRootIdentitiesOperation, { params: {}, query }, options);
+    }
+    getRootIdentityResult(userId, options = {}) {
+        return this.transport.requestResult(getRootIdentityOperation, { params: { userId } }, options);
+    }
+    listRootIdentityOrganizationsResult(userId, options = {}) {
+        return this.transport.requestResult(listRootIdentityOrganizationsOperation, { params: { userId } }, options);
+    }
+    getOrganizationDataUsageResult(organizationId, options = {}) {
+        return this.requestResult(organizationDataUsage.path(organizationId), organizationDataUsage.isResponse, organizationDataUsage.method, undefined, options, getOrganizationDataUsageOperation);
+    }
+    getOrganizationBilling(organizationId) {
+        return this.request(organizationBilling.get.path(organizationId), organizationBilling.get.isResponse, organizationBilling.get.method, undefined, undefined, getOrganizationBillingOperation);
+    }
+    getOrganizationBillingHistory(organizationId) {
+        return this.request(organizationBilling.history.path(organizationId), organizationBilling.history.isResponse, organizationBilling.history.method, undefined, undefined, getOrganizationBillingHistoryOperation);
+    }
+    getOrganizationBillingManagementUrl(organizationId) {
+        return this.request(organizationBilling.managementUrl.path(organizationId), organizationBilling.managementUrl.isResponse, organizationBilling.managementUrl.method, undefined, undefined, getOrganizationBillingManagementUrlOperation);
+    }
+    getOrganizationNativePurchaseEligibility(organizationId, store) {
+        return this.request(organizationBilling.nativeEligibility.path(organizationId, store), organizationBilling.nativeEligibility.isResponse, organizationBilling.nativeEligibility.method, undefined, undefined, getOrganizationNativePurchaseEligibilityOperation);
+    }
+    claimNativeOrganizationSubscription(organizationId, store) {
+        return this.requestResult(organizationBilling.nativeClaim.path(organizationId, store), organizationBilling.nativeClaim.isResponse, organizationBilling.nativeClaim.method, undefined, { reportErrors: false }, claimNativeOrganizationSubscriptionOperation);
+    }
+    /** Empty options means unconfigured; 403/409 remain errors. */
+    getStripeCheckoutOptions(organizationId, options = {}) {
+        return this.requestResult(organizationStripeCheckout.options.path(organizationId), organizationStripeCheckout.options.isResponse, organizationStripeCheckout.options.method, undefined, options, getStripeCheckoutOptionsOperation);
+    }
+    /** Starts or resumes inline checkout; an existing subscription returns 409. */
+    createStripeCheckout(organizationId) {
+        return this.request(organizationStripeCheckout.checkout.path(organizationId), organizationStripeCheckout.checkout.isResponse, organizationStripeCheckout.checkout.method, undefined, undefined, createStripeCheckoutOperation);
+    }
+    /** Opens hosted checkout; a null URL means unavailable or ineligible. */
+    createStripeCheckoutSession(organizationId, returnUrl) {
+        return this.request(organizationStripeCheckout.checkoutSession.path(organizationId), organizationStripeCheckout.checkoutSession.isResponse, organizationStripeCheckout.checkoutSession.method, JSON.stringify(organizationStripeCheckout.checkoutSession.body(returnUrl)), undefined, createStripeCheckoutSessionOperation);
+    }
+    /** Opens Stripe's subscription-management portal for the organization. */
+    createStripePortal(organizationId, returnUrl) {
+        return this.request(organizationStripeCheckout.portal.path(organizationId), organizationStripeCheckout.portal.isResponse, organizationStripeCheckout.portal.method, JSON.stringify(organizationStripeCheckout.portal.body(returnUrl)), undefined, createStripePortalOperation);
+    }
+    /** Schedules period-end cancellation; any non-2xx resolves null. */
+    cancelStripeSubscription(organizationId) {
+        return this.request(organizationStripeCheckout.cancel.path(organizationId), organizationStripeCheckout.cancel.isResponse, organizationStripeCheckout.cancel.method, undefined, undefined, cancelStripeSubscriptionOperation);
+    }
+    startOrganizationTrial(organizationId) {
+        return this.request(organizationBilling.startTrial.path(organizationId), organizationBilling.startTrial.isResponse, organizationBilling.startTrial.method, undefined, undefined, startOrganizationTrialOperation);
+    }
+    updateOrganizationRosterEntry(organizationId, userId, input) {
+        return this.request(rosterUpdate.path(organizationId, userId), rosterUpdate.isResponse, rosterUpdate.method, JSON.stringify(input), { expectedPaymentRequiredOrganizationId: organizationId }, updateOrganizationRosterEntryOperation);
+    }
+    updateOrganizationProfile(organizationId, input) {
+        return this.request(profileUpdate.path(organizationId), profileUpdate.isResponse, profileUpdate.method, JSON.stringify(input), { expectedPaymentRequiredOrganizationId: organizationId }, updateOrganizationProfileOperation);
+    }
+    createOrganizationGroup(organizationId, input) {
+        const groupRequestKey = JSON.stringify(["group", input.groupId]);
+        const organizationRequestKey = JSON.stringify([
+            "organization",
+            organizationId,
+        ]);
+        this.principalPolicyRequestsByKey.delete(groupRequestKey);
+        this.principalPolicyRequestsByKey.delete(organizationRequestKey);
+        return this.request(groupCreate.path(organizationId), groupCreate.isResponse, groupCreate.method, JSON.stringify(input), { expectedPaymentRequiredOrganizationId: organizationId }, createOrganizationGroupOperation).finally(() => {
+            this.principalPolicyRequestsByKey.delete(groupRequestKey);
+            this.principalPolicyRequestsByKey.delete(organizationRequestKey);
+            this.clearWriterProjectionCaches();
+        });
+    }
+    deleteOrganizationGroup(organizationId, groupId, input) {
+        const groupRequestKey = JSON.stringify(["group", groupId]);
+        const organizationRequestKey = JSON.stringify([
+            "organization",
+            organizationId,
+        ]);
+        this.principalPolicyRequestsByKey.delete(groupRequestKey);
+        this.principalPolicyRequestsByKey.delete(organizationRequestKey);
+        return this.request(groupDelete.path(organizationId, groupId), groupDelete.isResponse, groupDelete.method, JSON.stringify(input), { expectedPaymentRequiredOrganizationId: organizationId }, deleteOrganizationGroupOperation).finally(() => {
+            this.principalPolicyRequestsByKey.delete(groupRequestKey);
+            this.principalPolicyRequestsByKey.delete(organizationRequestKey);
+            this.clearWriterProjectionCaches();
+        });
+    }
+    listOrganizationGroupMembers(organizationId, groupId) {
+        return this.request(groupMembers.path(organizationId, groupId), groupMembers.isResponse, groupMembers.method, undefined, undefined, listOrganizationGroupMembersOperation);
+    }
+    createDocument(input, options = {}) {
+        return this.request(documentCreate.path, documentCreate.isResponse, documentCreate.method, JSON.stringify(input), options, createDocumentOperation);
+    }
+    createDocumentResult(input, options = {}) {
+        return this.requestResult(documentCreate.path, documentCreate.isResponse, documentCreate.method, JSON.stringify(input), options, createDocumentOperation);
+    }
+    getContainerWriterProjection(containerId) {
+        return cachedRequest(this.containerWriterProjectionRequestsByContainerId, containerId, () => this.request(containerWriterProjection.path(containerId), containerWriterProjection.isResponseFor(containerId), containerWriterProjection.method, undefined, undefined, getContainerWriterProjectionOperation));
+    }
+    getContainerReplacementAuthorizationsResult(containerId, replacesOrganizationId) {
+        return this.transport.requestResult(getContainerReplacementAuthorizationsOperation, { params: { containerId, replacesOrganizationId } }, { reportErrors: false });
+    }
+    /**
+     * The append-only rotation log for one container — the rebuild/repair
+     * read path. Never cached: it is fetched exactly when the served keyring
+     * failed verification and the ground truth is needed. A historical keyring
+     * is O(its epoch) bytes, so at most one ships per request, named by
+     * `keyringForEpoch`.
+     */
+    getContainerKekLog(containerId, options = {}) {
+        return this.request(containerKekLog.path(containerId, options), containerKekLog.isResponse, containerKekLog.method, undefined, undefined, getContainerKekLogOperation);
+    }
+    getContainerWriterProjectionResult(containerId, options = {}) {
+        return this.writerProjectionResult(this.containerWriterProjectionRequestsByContainerId, this.containerWriterProjectionResultsInFlightByContainerId, containerId, containerWriterProjection.path(containerId), containerWriterProjection.isResponseFor(containerId), options, getContainerWriterProjectionOperation);
+    }
+    // Shared by the writer-projection result variants: coalesce concurrent
+    // result callers onto one in-flight fetch, reuse a cached success, fetch a
+    // result otherwise, and reconcile the cache without ever clobbering an entry
+    // that changed while the fetch was in flight.
+    writerProjectionResult(cache, inFlightResults, cacheKey, path, validator, options, failureOperation) {
+        // Request-affecting options make the response caller-specific: run the
+        // request directly with the caller's options, join no shared fetch, and
+        // never publish the outcome to the shared caches. Only reporting-only
+        // callers below participate in coalescing and cache warming.
+        if (options.headers !== undefined ||
+            options.retryOnSessionExpired !== undefined) {
+            return this.requestResult(path, validator, "GET", undefined, options, failureOperation);
+        }
+        // A concurrent burst shares one fetch — failure included — so it cannot
+        // repeat the HTTP request or the 402 billing signal. The entry lives only
+        // while the fetch is in flight: failures are shared, never cached, so a
+        // later retry refetches. An in-flight fetch is joinable only while the
+        // value slot and per-key invalidation stamp it started against are
+        // unchanged: a prime, a completed plain GET, or an eviction of THIS id
+        // that lands mid-flight makes the older fetch unadoptable, so a later
+        // caller reads the current cache state (or fetches fresh) instead of
+        // joining a fetch that predates it — while invalidations of other ids
+        // leave the coalescing intact. Eviction and priming also delete the
+        // entry outright; the identity guard keeps a late settle from deleting a
+        // successor's entry.
+        //
+        // The shared fetch itself is always silent; each caller applies its OWN
+        // reporting policy to the shared outcome below. Coalescing therefore
+        // never lets one caller's reportErrors suppress (or force) another's,
+        // and caller options never reach the request — the fetch takes none.
+        const slot = cache.get(cacheKey);
+        const invalidationStamp = cache.invalidationStamp(cacheKey);
+        const inFlight = inFlightResults.get(cacheKey);
+        let shared;
+        if (inFlight &&
+            inFlight.slot === slot &&
+            inFlight.invalidationStamp === invalidationStamp) {
+            shared = inFlight.resultPromise;
+        }
+        else {
+            const entry = {
+                invalidationStamp,
+                resultPromise: this.fetchWriterProjectionResult(cache, cacheKey, path, validator, failureOperation).finally(() => {
+                    if (inFlightResults.get(cacheKey) === entry) {
+                        inFlightResults.delete(cacheKey);
+                    }
+                }),
+                slot,
+            };
+            inFlightResults.set(cacheKey, entry);
+            shared = entry.resultPromise;
+        }
+        if (options.reportErrors === false) {
+            return shared;
+        }
+        return shared.then((result) => {
+            if (!result.ok) {
+                result.report();
+            }
+            return result;
+        });
+    }
+    // The fetch half of writerProjectionResult. Cache reconciliation guards
+    // against both mid-flight slot replacement (identity comparison) and
+    // mid-flight eviction of an empty slot (the per-key invalidation stamp),
+    // so a projection an eviction (e.g. after a revoke) meant to drop is never
+    // re-cached.
+    async fetchWriterProjectionResult(cache, cacheKey, path, validator, failureOperation) {
+        let cached = cache.get(cacheKey);
+        while (cached) {
+            try {
+                const data = await cached;
+                if (data) {
+                    return { data, ok: true };
+                }
+            }
+            catch {
+                // A rejected shared entry is reconciled by its own settle handler;
+                // fall through either way.
+            }
+            // The awaited entry settled empty. Re-read the slot before fetching: a
+            // newer entry installed while we awaited must be reused, not fetched
+            // over — the set below would otherwise clobber it.
+            const current = cache.get(cacheKey);
+            if (current === cached) {
+                break;
+            }
+            cached = current;
+        }
+        // The plain value cache never sees this fetch while it is in flight: a
+        // published always-silent entry would hand a concurrent PLAIN caller a
+        // null without its normal error reporting. Plain callers keep their own
+        // fetch-and-report behavior instead, and only a success is published.
+        // Always silent here: reporting is per-caller in writerProjectionResult,
+        // and taking no caller options is what guarantees nothing
+        // request-affecting can be smuggled into the shared fetch.
+        const invalidationStamp = cache.invalidationStamp(cacheKey);
+        const result = await this.requestResult(path, validator, "GET", undefined, {
+            reportErrors: false,
+        }, failureOperation);
+        if (result.ok) {
+            // Publish the success unless the slot changed or this id was
+            // invalidated mid-flight. The stamp check is what makes an eviction of
+            // THIS id visible even when the slot was empty before and after the
+            // flight — the case the identity comparison alone cannot see — and it
+            // never caches a projection an eviction meant to drop.
+            if (cache.get(cacheKey) === cached &&
+                cache.invalidationStamp(cacheKey) === invalidationStamp) {
+                cache.set(cacheKey, Promise.resolve(result.data));
+            }
+        }
+        else if (cached && cache.get(cacheKey) === cached) {
+            // The adopted entry settled empty and the fetch confirmed there is
+            // nothing to serve: drop it so a later read refetches.
+            cache.delete(cacheKey);
+        }
+        return result;
+    }
+    createContainer(input, options = {}) {
+        return this.request(containerCreate.path, containerCreate.isResponse, containerCreate.method, JSON.stringify(input), options, createContainerOperation);
+    }
+    async createContainerResult(input, options = {}) {
+        return this.requestResult(containerCreate.path, containerCreate.isResponse, containerCreate.method, JSON.stringify(input), options, createContainerOperation);
+    }
+    createContainerWithMetadataDocument(input, options = {}) {
+        return this.request(containerCreateWithMetadataDocument.path, containerCreateWithMetadataDocument.isResponse, containerCreateWithMetadataDocument.method, JSON.stringify(input), options, createContainerWithMetadataDocumentOperation);
+    }
+    createContainerWithMetadataDocumentResult(input, options = {}) {
+        return this.requestResult(containerCreateWithMetadataDocument.path, containerCreateWithMetadataDocument.isResponse, containerCreateWithMetadataDocument.method, JSON.stringify(input), options, createContainerWithMetadataDocumentOperation);
+    }
+    shareContainer(containerId, input, options = {}) {
+        return this.request(containerShare.path(containerId), containerShare.isResponse, containerShare.method, JSON.stringify(input), options, shareContainerOperation).finally(() => {
+            this.clearWriterProjectionCaches();
+        });
+    }
+    revokeContainer(containerId, input, options = {}) {
+        return this.request(containerRevoke.path(containerId), containerRevoke.isResponse, containerRevoke.method, JSON.stringify(input), options, revokeContainerOperation).finally(() => {
+            this.clearWriterProjectionCaches();
+        });
+    }
+    rekeyContainer(containerId, input, options = {}) {
+        return this.request(containerRekey.path(containerId), containerRekey.isResponse, containerRekey.method, JSON.stringify(input), options, rekeyContainerOperation).finally(() => {
+            this.clearWriterProjectionCaches();
+        });
+    }
+    /**
+     * Status-bearing rotations: a caller that must tell a permanent refusal (403
+     * once ancestor write access is revoked, 402) from a transient 5xx or an
+     * offline blip cannot do so through the plain methods, which collapse both to
+     * null. They are also how a rotation learns which descendant rekeys it must
+     * carry.
+     */
+    rekeyContainerResult(containerId, input, options = {}) {
+        return this.rotationResult("rekey", containerId, input, options);
+    }
+    revokeContainerResult(containerId, input, options = {}) {
+        return this.rotationResult("revoke", containerId, input, options);
+    }
+    moveContainerResult(containerId, input, options = {}) {
+        return this.rotationResult("move", containerId, input, options);
+    }
+    async rotationResult(rotation, containerId, input, options) {
+        const { operation, route } = CONTAINER_ROTATIONS[rotation];
+        try {
+            return await this.requestResult(route.path(containerId), route.isResponse, route.method, JSON.stringify(input), options, operation);
+        }
+        finally {
+            this.clearWriterProjectionCaches();
+        }
+    }
+    reciteContainer(containerId, input, options = {}) {
+        return this.request(containerRecite.path(containerId), containerRecite.isResponse, containerRecite.method, JSON.stringify(input), options, reciteContainerOperation).finally(() => this.clearWriterProjectionCaches());
+    }
+    moveContainer(containerId, input, options = {}) {
+        return this.request(containerMove.path(containerId), containerMove.isResponse, containerMove.method, JSON.stringify(input), options, moveContainerOperation).finally(() => {
+            this.clearWriterProjectionCaches();
+        });
+    }
+    deleteContainer(containerId, options = {}) {
+        return this.request(containerDelete.path(containerId), containerDelete.isResponse, containerDelete.method, undefined, options, deleteContainerOperation).finally(() => {
+            this.clearWriterProjectionCaches();
+        });
+    }
+    deleteContainerResult(containerId, options = {}) {
+        return this.requestResult(containerDelete.path(containerId), containerDelete.isResponse, containerDelete.method, undefined, options, deleteContainerOperation).finally(() => {
+            this.clearWriterProjectionCaches();
+        });
+    }
+    getDocumentWriterProjection(documentId) {
+        return cachedRequest(this.documentWriterProjectionRequestsByDocumentId, documentId, () => this.request(documentWriterProjection.path(documentId), documentWriterProjection.isResponseFor(documentId), documentWriterProjection.method, undefined, undefined, getDocumentWriterProjectionOperation));
+    }
+    getDocumentEditAttribution(documentId, requestKey = "") {
+        return this.documentAttributionRequests.get(documentId, requestKey);
+    }
+    listDocumentEditAttributionRanges(documentId, options = {}) {
+        return this.documentAttributionRequests.listRanges(documentId, options);
+    }
+    getDocumentWriterProjectionResult(documentId, options = {}) {
+        return this.writerProjectionResult(this.documentWriterProjectionRequestsByDocumentId, this.documentWriterProjectionResultsInFlightByDocumentId, documentId, documentWriterProjection.path(documentId), documentWriterProjection.isResponseFor(documentId), options, getDocumentWriterProjectionOperation);
+    }
+    /**
+     * Seed the writer-projection cache from a mutation response the client just
+     * authored, so the next read resolves locally instead of a cold
+     * `GET /documents/:documentId/writer-projection`. The seed is the same
+     * material a fresh fetch returns (create/link/sync responses carry the
+     * manifest, content-key bundle, and KEK targets; authorizing paths are the
+     * projection the client supplied). No-op when a fetch is in flight or the
+     * slot is primed — never clobber an existing entry. The existing invalidation
+     * paths (sync-change, share/rekey/move, link/unlink) evict a primed
+     * projection that later goes stale, exactly as they evict a fetched one.
+     */
+    primeDocumentWriterProjection(documentId, projection) {
+        primeWriterProjectionSlot({
+            cache: this.documentWriterProjectionRequestsByDocumentId,
+            describes: documentWriterProjection.isResponseFor(documentId),
+            id: documentId,
+            inFlightResults: this.documentWriterProjectionResultsInFlightByDocumentId,
+            label: "Document",
+            projection,
+        });
+    }
+    /**
+     * Container counterpart of {@link primeDocumentWriterProjection}: seed the
+     * container writer-projection cache from a create the client just authored so
+     * the next write under that container (a child folder, a document) resolves
+     * locally instead of a cold `GET /containers/:containerId/writer-projection`.
+     * The seed is the same material a fresh fetch returns — the create plan's
+     * authorizing path and container KEKs — validated by the caller against the
+     * create response before priming. No-op when a fetch is in flight or the slot
+     * is already primed, so it never clobbers a newer entry. The existing
+     * invalidation (share/revoke/rekey/move/delete -> clearWriterProjectionCaches)
+     * evicts a primed projection that later goes stale exactly as it evicts a
+     * fetched one, so a subsequent write on stale access still fails closed and
+     * retries with a fresh projection.
+     */
+    primeContainerWriterProjection(containerId, projection) {
+        primeWriterProjectionSlot({
+            cache: this.containerWriterProjectionRequestsByContainerId,
+            describes: containerWriterProjection.isResponseFor(containerId),
+            id: containerId,
+            inFlightResults: this.containerWriterProjectionResultsInFlightByContainerId,
+            label: "Container",
+            projection,
+        });
+    }
+    linkDocument(documentId, input, options = {}) {
+        this.invalidateDocumentAttribution(documentId);
+        return this.request(documentLink.path(documentId), documentLink.isResponse, documentLink.method, JSON.stringify(input), options, linkDocumentOperation).finally(() => {
+            this.invalidateDocumentAttribution(documentId);
+            this.evictDocumentWriterProjection(documentId);
+        });
+    }
+    linkDocumentResult(documentId, input, options = {}) {
+        this.invalidateDocumentAttribution(documentId);
+        return this.requestResult(documentLink.path(documentId), documentLink.isResponse, documentLink.method, JSON.stringify(input), options, linkDocumentOperation).finally(() => {
+            this.invalidateDocumentAttribution(documentId);
+            this.evictDocumentWriterProjection(documentId);
+        });
+    }
+    listContainerParentLanes(input) {
+        return dedupedRequest(this.containerParentLaneRequestsByKey, listContainerParentLanesRequestKey(input), () => this.request(containerParentLanes.path, (value) => containerParentLanes.isResponseForRequest(input, value), containerParentLanes.method, JSON.stringify(input), undefined, listContainerParentLanesOperation));
+    }
+    listContainerDocuments(containerId, options) {
+        return dedupedRequest(this.containerDocumentListRequestsByKey, listContainerDocumentsRequestKey(containerId, options), () => this.request(containerDocuments.path(containerId, options), containerDocuments.isResponse, containerDocuments.method, undefined, undefined, listContainerDocumentsOperation));
+    }
+    listContainerDocumentsResult(containerId, options, requestOptions = {}) {
+        return this.requestResult(containerDocuments.path(containerId, options), containerDocuments.isResponse, containerDocuments.method, undefined, requestOptions, listContainerDocumentsOperation);
+    }
+    unlinkDocument(documentId, input, options = {}) {
+        this.invalidateDocumentAttribution(documentId);
+        return this.request(documentUnlink.path(documentId), documentUnlink.isResponse, documentUnlink.method, JSON.stringify(input), options, unlinkDocumentOperation).finally(() => {
+            this.invalidateDocumentAttribution(documentId);
+            this.evictDocumentWriterProjection(documentId);
+        });
+    }
+    unlinkDocumentResult(documentId, input, options = {}) {
+        this.invalidateDocumentAttribution(documentId);
+        return this.requestResult(documentUnlink.path(documentId), documentUnlink.isResponse, documentUnlink.method, JSON.stringify(input), options, unlinkDocumentOperation).finally(() => {
+            this.invalidateDocumentAttribution(documentId);
+            this.evictDocumentWriterProjection(documentId);
+        });
+    }
+    purgeDocument(documentId, input, options = {}) {
+        this.invalidateDocumentAttribution(documentId);
+        return this.request(documentPurge.path(documentId), documentPurge.isResponse, documentPurge.method, JSON.stringify(input), options, purgeDocumentOperation).finally(() => {
+            this.invalidateDocumentAttribution(documentId);
+            this.evictDocumentWriterProjection(documentId);
+        });
+    }
+    getDocumentPurgeProof(documentId, options, requestOptions = {}) {
+        return this.request(documentPurgeProof.path(documentId, options), documentPurgeProof.isResponse, documentPurgeProof.method, undefined, requestOptions, getDocumentPurgeProofOperation);
+    }
+    syncDocument(documentId, input, options = {}) {
+        this.invalidateDocumentAttribution(documentId);
+        const cachedBefore = this.documentWriterProjectionRequestsByDocumentId.get(documentId);
+        return this.transport
+            .request(documentSyncOperation, {
+            body: input,
+            params: { documentId },
+        }, options)
+            .then(async (response) => {
+            if (response) {
+                if (response.updates.length > 0) {
+                    this.documentAttachmentListRequestsByDocumentId.delete(documentId);
+                }
+                await evictWriterProjectionIfSyncChanged(this.documentWriterProjectionRequestsByDocumentId, documentId, response, () => this.documentWriterProjectionResultsInFlightByDocumentId.delete(documentId));
+            }
+            else {
+                if (this.documentWriterProjectionRequestsByDocumentId.get(documentId) === cachedBefore) {
+                    this.documentWriterProjectionRequestsByDocumentId.delete(documentId);
+                    this.documentWriterProjectionResultsInFlightByDocumentId.delete(documentId);
+                }
+            }
+            return response;
+        })
+            .catch((error) => {
+            if (this.documentWriterProjectionRequestsByDocumentId.get(documentId) ===
+                cachedBefore) {
+                this.documentWriterProjectionRequestsByDocumentId.delete(documentId);
+                this.documentWriterProjectionResultsInFlightByDocumentId.delete(documentId);
+            }
+            throw error;
+        })
+            .finally(() => {
+            this.invalidateDocumentAttribution(documentId);
+        });
+    }
+    async syncDocumentResult(documentId, input, options = {}) {
+        this.invalidateDocumentAttribution(documentId);
+        const cachedBefore = this.documentWriterProjectionRequestsByDocumentId.get(documentId);
+        try {
+            const result = await this.transport.requestResult(documentSyncOperation, { body: input, params: { documentId } }, options);
+            if (result.ok) {
+                if (result.data.updates.length > 0) {
+                    this.documentAttachmentListRequestsByDocumentId.delete(documentId);
+                }
+                await evictWriterProjectionIfSyncChanged(this.documentWriterProjectionRequestsByDocumentId, documentId, result.data, () => this.documentWriterProjectionResultsInFlightByDocumentId.delete(documentId));
+            }
+            else if (this.documentWriterProjectionRequestsByDocumentId.get(documentId) ===
+                cachedBefore) {
+                this.documentWriterProjectionRequestsByDocumentId.delete(documentId);
+                this.documentWriterProjectionResultsInFlightByDocumentId.delete(documentId);
+            }
+            return result;
+        }
+        finally {
+            this.invalidateDocumentAttribution(documentId);
+        }
+    }
+    initiateMultipartBlobStage(input) {
+        return this.request(multipartInitiate.path, multipartInitiate.isResponse, multipartInitiate.method, JSON.stringify(input), undefined, initiateMultipartBlobStageOperation);
+    }
+    getMultipartBlobStage(stageId) {
+        return this.request(multipartGet.path(stageId), multipartGet.isResponse, multipartGet.method, undefined, undefined, getMultipartBlobStageOperation);
+    }
+    uploadMultipartBlobPartBytes(stageId, partNumber, input) {
+        // Send the encrypted part as a File — not a raw Uint8Array and not a plain
+        // Blob. CapacitorHttp (enabled on the native builds so API requests bypass the
+        // WKWebView's broken cross-origin fetch) serializes request bodies across the
+        // JS->native bridge in its convertBody(): a Uint8Array octet-stream body is
+        // `TextDecoder().decode()`d to UTF-8 there — which corrupts encrypted
+        // ciphertext (arbitrary, non-UTF-8 bytes) — and a plain Blob is not recognized
+        // at all, falling through as JSON (`{}`). Only a File is read byte-for-byte
+        // (readAsBinaryString -> base64), so the ciphertext survives the bridge intact
+        // and the server's byte-length/SHA-256 validation passes. A File is a Blob, so
+        // it is equally valid on the plain web fetch path (the operation-derived
+        // Content-Type header still wins).
+        return this.transport.requestBinaryRequest(uploadMultipartBlobPartBytesOperation, {
+            headers: {
+                [blobWireHeaderKeys.partByteLength]: input.byteLength.toString(),
+                [blobWireHeaderKeys.partSha256]: input.sha256,
+                [blobWireHeaderKeys.partUploadId]: input.uploadId,
+            },
+            body: input.encryptedBytes,
+            params: { partNumber, stageId },
+        }, {
+            encodeBody: (body) => body instanceof File
+                ? body
+                : new File([body], "encrypted-blob-part", {
+                    type: "application/octet-stream",
+                }),
+        });
+    }
+    completeMultipartBlobStage(stageId, input) {
+        return this.request(multipartComplete.path(stageId), multipartComplete.isResponse, multipartComplete.method, JSON.stringify(input), undefined, completeMultipartBlobStageOperation);
+    }
+    getBlobBytes(blobId) {
+        return getBlobBytes(this.transport, blobId);
+    }
+    bindBlobAttachment(blobId, input, options = {}) {
+        return this.request(blobAttachmentBind.path(blobId), blobAttachmentBind.isResponse, blobAttachmentBind.method, JSON.stringify(input), options, bindBlobAttachmentOperation)
+            .then((response) => {
+            if (response) {
+                this.cacheBlobAttachmentBindResponse(response);
+            }
+            else {
+                this.documentAttachmentListRequestsByDocumentId.clear();
+            }
+            return response;
+        })
+            .catch((error) => {
+            this.documentAttachmentListRequestsByDocumentId.clear();
+            throw error;
+        });
+    }
+    detachBlobAttachment(blobId, bindingId, input, options = {}) {
+        return this.request(blobAttachmentDetach.path(blobId, bindingId), blobAttachmentDetach.isResponse, blobAttachmentDetach.method, JSON.stringify(input), options, detachBlobAttachmentOperation)
+            .then((response) => {
+            if (response) {
+                this.cacheBlobAttachmentDetachResponse(response);
+            }
+            else {
+                this.documentAttachmentListRequestsByDocumentId.clear();
+            }
+            return response;
+        })
+            .catch((error) => {
+            this.documentAttachmentListRequestsByDocumentId.clear();
+            throw error;
+        });
+    }
+    listDocumentAttachments(documentId, options = {}) {
+        if (options.refresh) {
+            this.documentAttachmentListRequestsByDocumentId.delete(documentId);
+        }
+        return cachedRequest(this.documentAttachmentListRequestsByDocumentId, documentId, () => this.request(documentAttachmentsList.path(documentId), documentAttachmentsList.isResponse, documentAttachmentsList.method, undefined, undefined, listDocumentAttachmentsOperation));
+    }
+}
+//# sourceMappingURL=ApiClient.js.map