/** * @license * Copyright 2022-2026 Matter.js Authors * SPDX-License-Identifier: Apache-2.0 */ import { Observable } from "@matter/general"; import { BdxMessenger } from "../BdxMessenger.js"; import { PersistedFileDesignator } from "../PersistedFileDesignator.js"; /** Base class for BDX transfer flows. */ export declare abstract class Flow { #private; readonly progressInfo: Observable<[bytesTransferred: number, totalBytesLength: number | undefined], void>; readonly progressFinished: Observable<[totalBytesTransferred: number], void>; readonly progressCancelled: Observable; constructor(messenger: BdxMessenger, transferParameters: Flow.TransferOptions); protected set dataLength(value: number); get dataLength(): number | undefined; protected set transferredBytes(value: number); get transferredBytes(): number; protected get transferParameters(): Flow.TransferOptions; /** * What this flow settled on, which for a responder is what its own *Accept message granted. * * A snapshot rather than the options themselves: the flow rereads those while it runs, so handing them out * would let an observer retarget a transfer in flight. */ get negotiated(): Flow.NegotiatedParameters; protected get isClosed(): boolean; protected get messenger(): BdxMessenger; protected get bytesLeft(): number | undefined; protected set bytesLeft(value: number); protected set finalBlockCounter(blockCounter: number); protected get finalBlockCounter(): number; /** Determines the next message counter to use for the next message, also handles wrapping around at 2^32. */ protected get nextMessageCounter(): number; /** Utility function to check if a block counter is valid */ protected validateCounter(messageBlockCounter: number, expectedCounter?: number): number; close(_error?: unknown): Promise; /** * Main logic method to execute the flow. * The promise resolves when the flow is complete, or rejects on any error or unexpected conditions. */ processTransfer(): Promise; protected abstract initTransfer(): Promise; protected abstract transferNextChunk(): Promise; protected abstract finalizeTransfer(): Promise; } export declare namespace Flow { interface TransferOptions { transferMode: DriverMode; asynchronousTransfer: false; dataLength?: number; startOffset: number; blockSize: number; isDriver: boolean; fileDesignator: PersistedFileDesignator; } /** {@link TransferOptions} as an observer may read them: no operational objects, and no writes. */ type NegotiatedParameters = Readonly>; enum DriverMode { SenderDrive = "senderDrive", ReceiverDrive = "receiverDrive" } } //# sourceMappingURL=Flow.d.ts.map