@unofficialbox/box-open-elements 0.5.0 → 0.7.0

package/dist/patterns/content-picker/controller.d.ts

@@ -0,0 +1,38 @@
+import { Controller } from "../../core/controller.js";
+import { ContentExplorerController } from "../content-explorer/controller.js";
+import type { ExplorerItem } from "../content-explorer/types.js";
+import type { PickerEvents, PickerSessionConfig, PickerState } from "./types.js";
+/**
+ * A constrained explorer session for choosing content: the same browse /
+ * search surface as ContentExplorerController, plus a cross-folder pick
+ * roster with type / extension / count constraints and a choose/cancel
+ * contract. The inner explorer's per-folder selection is kept in sync so
+ * roster members render selected in whatever folder is on screen.
+ */
+export declare class ContentPickerController extends Controller<PickerState, PickerEvents> {
+    readonly explorer: ContentExplorerController;
+    private readonly constraints;
+    private readonly roster;
+    private readonly unsubscribeFns;
+    constructor(config: PickerSessionConfig);
+    connect(): Promise<void>;
+    disconnect(): void;
+    destroy(): void;
+    isItemPickable(item: ExplorerItem): boolean;
+    isPicked(itemId: string): boolean;
+    /**
+     * Toggle an item in or out of the roster. Unpicking works for any roster
+     * member (including items picked in another folder); picking requires the
+     * item to be in the current collection, eligible, and under the limit.
+     * With `maxSelectable: 1` picking replaces the previous pick.
+     */
+    togglePick(itemId: string): void;
+    unpick(itemId: string): void;
+    clearPicks(): void;
+    /** Emit `chosen` with the roster. No-op (returns null) while it is empty. */
+    choose(): ExplorerItem[] | null;
+    /** Abandon the session: clears the roster and emits `cancelled`. */
+    cancel(): void;
+    private publishSelection;
+    private syncExplorerSelection;
+}

package/dist/patterns/content-picker/controller.js

@@ -0,0 +1,141 @@
+import { Controller } from "../../core/controller.js";
+import { ContentExplorerController } from "../content-explorer/controller.js";
+import { isItemPickable } from "./types.js";
+const createInitialState = (config) => ({
+    canChoose: false,
+    maxSelectable: config.maxSelectable ?? null,
+    selectedItems: [],
+});
+/**
+ * A constrained explorer session for choosing content: the same browse /
+ * search surface as ContentExplorerController, plus a cross-folder pick
+ * roster with type / extension / count constraints and a choose/cancel
+ * contract. The inner explorer's per-folder selection is kept in sync so
+ * roster members render selected in whatever folder is on screen.
+ */
+export class ContentPickerController extends Controller {
+    explorer;
+    constraints;
+    roster = new Map();
+    unsubscribeFns;
+    constructor(config) {
+        super(createInitialState(config));
+        const { extensions, maxSelectable, selectableTypes, ...explorerConfig } = config;
+        this.constraints = { extensions, maxSelectable, selectableTypes };
+        this.explorer = new ContentExplorerController({
+            ...explorerConfig,
+            selectionMode: maxSelectable === 1 ? "single" : "multiple",
+        });
+        // Re-mark roster members whenever the visible collection changes —
+        // navigation and search reset the explorer's own selection.
+        const resync = () => {
+            this.syncExplorerSelection();
+        };
+        this.unsubscribeFns = [
+            this.explorer.subscribe("loadSucceeded", resync),
+            this.explorer.subscribe("searchSucceeded", resync),
+        ];
+    }
+    async connect() {
+        await this.explorer.connect();
+    }
+    disconnect() {
+        this.explorer.disconnect();
+        if (this.roster.size > 0) {
+            this.roster.clear();
+            this.publishSelection();
+        }
+    }
+    destroy() {
+        for (const unsubscribe of this.unsubscribeFns) {
+            unsubscribe();
+        }
+        this.explorer.destroy();
+        super.destroy();
+    }
+    isItemPickable(item) {
+        return isItemPickable(item, this.constraints);
+    }
+    isPicked(itemId) {
+        return this.roster.has(itemId);
+    }
+    /**
+     * Toggle an item in or out of the roster. Unpicking works for any roster
+     * member (including items picked in another folder); picking requires the
+     * item to be in the current collection, eligible, and under the limit.
+     * With `maxSelectable: 1` picking replaces the previous pick.
+     */
+    togglePick(itemId) {
+        if (this.roster.has(itemId)) {
+            this.roster.delete(itemId);
+            this.publishSelection();
+            return;
+        }
+        const item = this.explorer.getState().items.find(entry => entry.id === itemId);
+        if (!item) {
+            return;
+        }
+        if (!this.isItemPickable(item)) {
+            this.emit("selectionRejected", { item, reason: "not-selectable" });
+            return;
+        }
+        const max = this.state.maxSelectable;
+        if (max !== null && this.roster.size >= max) {
+            if (max === 1) {
+                this.roster.clear();
+            }
+            else {
+                this.emit("selectionRejected", { item, reason: "limit-reached" });
+                return;
+            }
+        }
+        this.roster.set(itemId, item);
+        this.publishSelection();
+    }
+    unpick(itemId) {
+        if (this.roster.delete(itemId)) {
+            this.publishSelection();
+        }
+    }
+    clearPicks() {
+        if (this.roster.size === 0) {
+            return;
+        }
+        this.roster.clear();
+        this.publishSelection();
+    }
+    /** Emit `chosen` with the roster. No-op (returns null) while it is empty. */
+    choose() {
+        if (this.roster.size === 0) {
+            return null;
+        }
+        const items = [...this.roster.values()];
+        this.emit("chosen", { items });
+        return items;
+    }
+    /** Abandon the session: clears the roster and emits `cancelled`. */
+    cancel() {
+        if (this.roster.size > 0) {
+            this.roster.clear();
+            this.publishSelection();
+        }
+        this.emit("cancelled", undefined);
+    }
+    publishSelection() {
+        this.syncExplorerSelection();
+        const selectedItems = [...this.roster.values()];
+        this.setState({
+            ...this.state,
+            canChoose: selectedItems.length > 0,
+            selectedItems,
+        });
+        this.emit("selectionChanged", { selectedItems });
+    }
+    syncExplorerSelection() {
+        const visibleIds = this.explorer
+            .getState()
+            .items.filter(item => this.roster.has(item.id))
+            .map(item => item.id);
+        this.explorer.select(visibleIds);
+    }
+}

package/dist/patterns/content-picker/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./controller.js";
+export * from "./content-picker.js";

package/dist/patterns/content-picker/index.js

@@ -0,0 +1,6 @@
+// Picker contracts, constraints, and state types
+export * from "./types.js";
+// Composition root over the explorer headless blocks
+export * from "./controller.js";
+// Composed workflow surface
+export * from "./content-picker.js";

package/dist/patterns/content-picker/types.d.ts

@@ -0,0 +1,52 @@
+import type { ExplorerItem, ExplorerSessionConfig } from "../content-explorer/types.js";
+export type PickerItemType = ExplorerItem["type"];
+/**
+ * Eligibility rules for what the picker lets the user put in its roster.
+ * Items that fail the rules stay visible (folders remain navigable) but their
+ * rows are not pickable.
+ */
+export interface PickerConstraints {
+    /**
+     * Item types eligible for picking. Defaults to `["file"]`, mirroring
+     * box-ui-elements' ContentPicker default type. Folders always stay
+     * navigable whether or not they are pickable.
+     */
+    selectableTypes?: PickerItemType[];
+    /**
+     * Extension allowlist applied to files (case-insensitive, no leading dot).
+     * Empty or omitted allows every extension. Only files are filtered — other
+     * item types have no extension.
+     */
+    extensions?: string[];
+    /**
+     * Maximum roster size. Omitted means unlimited. `1` also switches the
+     * underlying explorer selection to single mode, so picking replaces
+     * instead of rejecting.
+     */
+    maxSelectable?: number;
+}
+export interface PickerSessionConfig extends Omit<ExplorerSessionConfig, "itemActions" | "selectionMode">, PickerConstraints {
+}
+export interface PickerState {
+    /** True when the roster is non-empty — drives the Choose button. */
+    canChoose: boolean;
+    maxSelectable: number | null;
+    /** The cross-folder pick roster, in pick order. */
+    selectedItems: ExplorerItem[];
+}
+export type PickerSelectionRejectionReason = "limit-reached" | "not-selectable";
+export interface PickerEvents {
+    cancelled: undefined;
+    chosen: {
+        items: ExplorerItem[];
+    };
+    selectionChanged: {
+        selectedItems: ExplorerItem[];
+    };
+    selectionRejected: {
+        item: ExplorerItem;
+        reason: PickerSelectionRejectionReason;
+    };
+}
+/** Pure eligibility check — the single source of truth for pickability. */
+export declare const isItemPickable: (item: ExplorerItem, constraints: PickerConstraints) => boolean;

package/dist/patterns/content-picker/types.js

@@ -0,0 +1,26 @@
+const normalizeExtension = (value) => value.replace(/^\./, "").toLowerCase();
+/** File extension resolved from the item's own field or its name's suffix. */
+const resolveItemExtension = (item) => {
+    if (item.extension) {
+        return normalizeExtension(item.extension);
+    }
+    const dotIndex = item.name.lastIndexOf(".");
+    if (dotIndex <= 0 || dotIndex === item.name.length - 1) {
+        return null;
+    }
+    return normalizeExtension(item.name.slice(dotIndex + 1));
+};
+/** Pure eligibility check — the single source of truth for pickability. */
+export const isItemPickable = (item, constraints) => {
+    const selectableTypes = constraints.selectableTypes?.length ? constraints.selectableTypes : ["file"];
+    if (!selectableTypes.includes(item.type)) {
+        return false;
+    }
+    if (item.type === "file" && constraints.extensions?.length) {
+        const extension = resolveItemExtension(item);
+        if (!extension || !constraints.extensions.map(normalizeExtension).includes(extension)) {
+            return false;
+        }
+    }
+    return true;
+};

package/dist/patterns/content-sidebar/content-sidebar.d.ts

@@ -0,0 +1,43 @@
+import type { SidebarTab } from "./types.js";
+import { BaseElement } from "../../core/index.js";
+export declare class ContentSidebar extends BaseElement {
+    static readonly tagName: string;
+    static get observedAttributes(): string[];
+    private asideEl;
+    private titleEl;
+    private toggleEl;
+    private bodyEl;
+    private emptyEl;
+    private tabsHost;
+    private readonly presentSlots;
+    private forwardedSlotsSignature;
+    private suppressTabsEvent;
+    get heading(): string;
+    set heading(value: string);
+    /**
+     * Explicit tab configuration; JSON `[{"id","label"}]`. Overrides slot
+     * detection — an explicit `[]` renders no tabs. Malformed payloads
+     * (non-array JSON, records without a string id/label) are ignored.
+     */
+    get tabs(): SidebarTab[] | null;
+    set tabs(value: SidebarTab[] | null);
+    get activeTab(): string;
+    set activeTab(value: string);
+    get collapsible(): boolean;
+    set collapsible(value: boolean);
+    get collapsed(): boolean;
+    set collapsed(value: boolean);
+    /** The tabs the sidebar is currently showing. */
+    get resolvedTabs(): SidebarTab[];
+    protected renderTemplate(): void;
+    protected setupListeners(): void;
+    /**
+     * The forwarded slots live inside box-tabs: host content slotted as
+     * `slot="details"` chains through `<slot name="details" slot="details">`
+     * into the matching tabpanel. One forwarded slot exists per known tab id
+     * (defaults + configured), so presence detection works before tabs render.
+     */
+    private syncForwardedSlots;
+    private refreshSlotPresence;
+    protected update(): void;
+}

package/dist/patterns/content-sidebar/content-sidebar.js

@@ -0,0 +1,293 @@
+import { DEFAULT_SIDEBAR_TABS, resolveSidebarTabs } from "./types.js";
+import { Tabs } from "../../components/navigation/tabs.js";
+import { BaseElement } from "../../core/index.js";
+import { boeMotionDuration, boeMotionEasing } from "../../foundations/motion/index.js";
+import { boePanel, boeRadius } from "../../foundations/geometry/index.js";
+const DEFAULT_TAG_NAME = "box-content-sidebar";
+const escapeHtml = (value) => value
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+/** Attribute payloads are author input — validate every record, not just the array. */
+const isSidebarTabRecord = (value) => {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const tab = value;
+    return typeof tab.id === "string" && tab.id.length > 0 && typeof tab.label === "string";
+};
+const elementStyles = `
+        :host {
+          display: block;
+          color: inherit;
+          font: inherit;
+        }
+
+        [part="sidebar"] {
+          display: grid;
+          gap: ${boePanel.gap};
+          padding: ${boePanel.padding};
+          border: 1px solid color-mix(in srgb, var(--boe-token-stroke-stroke, #e8e8e8) 82%, transparent);
+          border-radius: ${boePanel.radius};
+          background: var(--boe-token-surface-surface, #ffffff);
+        }
+
+        [part="header"] {
+          display: flex;
+          align-items: center;
+          gap: ${boePanel.gap};
+        }
+
+        [part="title"] {
+          flex: 1;
+          margin: 0;
+          font: inherit;
+          font-size: 1.05rem;
+          font-weight: 700;
+          overflow: hidden;
+          text-overflow: ellipsis;
+          white-space: nowrap;
+          color: var(--boe-token-text-text, #1f1e1b);
+        }
+
+        [part="toggle"] {
+          appearance: none;
+          font: inherit;
+          font-size: 0.8rem;
+          font-weight: 600;
+          padding: 0.3rem 0.65rem;
+          border-radius: 999px;
+          border: 1px solid color-mix(in srgb, var(--boe-token-stroke-stroke, #e8e8e8) 60%, transparent);
+          background: var(--boe-token-surface-surface, #ffffff);
+          color: inherit;
+          cursor: pointer;
+          transition: background ${boeMotionDuration.interactive} ${boeMotionEasing.standard}, border-color ${boeMotionDuration.interactive} ${boeMotionEasing.standard};
+        }
+
+        [part="toggle"]:hover {
+          background: var(--boe-token-surface-surface-hover, #f4f4f4);
+          border-color: var(--boe-token-stroke-stroke-hover, #bcbcbc);
+        }
+
+        [part="toggle"]:focus-visible {
+          outline: none;
+          box-shadow: 0 0 0 3px color-mix(in srgb, var(--boe-token-surface-surface-brand, #0061d5) 18%, transparent);
+        }
+
+        [part="body"][hidden] {
+          display: none;
+        }
+
+        [part="empty"] {
+          padding: ${boePanel.padding};
+          border-radius: ${boeRadius.large};
+          border: 1px dashed color-mix(in srgb, var(--boe-token-stroke-stroke, #e8e8e8) 70%, transparent);
+          color: var(--boe-token-text-text-secondary, #6f6f6f);
+        }
+
+        [part="empty"][hidden] {
+          display: none;
+        }
+      `;
+export class ContentSidebar extends BaseElement {
+    static tagName = DEFAULT_TAG_NAME;
+    static get observedAttributes() {
+        return ["active-tab", "collapsed", "collapsible", "heading", "tabs"];
+    }
+    asideEl;
+    titleEl;
+    toggleEl;
+    bodyEl;
+    emptyEl;
+    tabsHost;
+    presentSlots = new Set();
+    forwardedSlotsSignature = "";
+    suppressTabsEvent = false;
+    get heading() {
+        return this.getAttribute("heading") ?? "Sidebar";
+    }
+    set heading(value) {
+        this.setAttribute("heading", value);
+    }
+    /**
+     * Explicit tab configuration; JSON `[{"id","label"}]`. Overrides slot
+     * detection — an explicit `[]` renders no tabs. Malformed payloads
+     * (non-array JSON, records without a string id/label) are ignored.
+     */
+    get tabs() {
+        const raw = this.getAttribute("tabs");
+        if (!raw) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            return Array.isArray(parsed) && parsed.every(isSidebarTabRecord) ? parsed : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    set tabs(value) {
+        if (value) {
+            this.setAttribute("tabs", JSON.stringify(value));
+            return;
+        }
+        this.removeAttribute("tabs");
+    }
+    get activeTab() {
+        return this.getAttribute("active-tab") ?? "";
+    }
+    set activeTab(value) {
+        if (!value) {
+            this.removeAttribute("active-tab");
+            return;
+        }
+        this.setAttribute("active-tab", value);
+    }
+    get collapsible() {
+        return this.hasAttribute("collapsible");
+    }
+    set collapsible(value) {
+        this.toggleAttribute("collapsible", value);
+    }
+    get collapsed() {
+        return this.hasAttribute("collapsed");
+    }
+    set collapsed(value) {
+        this.toggleAttribute("collapsed", value);
+    }
+    /** The tabs the sidebar is currently showing. */
+    get resolvedTabs() {
+        return resolveSidebarTabs(this.tabs, this.presentSlots);
+    }
+    renderTemplate() {
+        if (!this.shadowRoot) {
+            return;
+        }
+        this.shadowRoot.innerHTML = `
+      <style>${elementStyles}</style>
+      <aside part="sidebar">
+        <header part="header">
+          <h2 part="title"></h2>
+          <button type="button" part="toggle" hidden></button>
+        </header>
+        <div part="body">
+          <box-tabs part="tabs"></box-tabs>
+          <div part="empty" hidden>No sidebar panels provided.</div>
+        </div>
+      </aside>
+    `;
+        this.asideEl = this.shadowRoot.querySelector('[part="sidebar"]');
+        this.titleEl = this.shadowRoot.querySelector('[part="title"]');
+        this.toggleEl = this.shadowRoot.querySelector('[part="toggle"]');
+        this.bodyEl = this.shadowRoot.querySelector('[part="body"]');
+        this.emptyEl = this.shadowRoot.querySelector('[part="empty"]');
+        this.tabsHost = this.shadowRoot.querySelector('[part="tabs"]');
+    }
+    setupListeners() {
+        this.toggleEl.addEventListener("click", () => {
+            this.collapsed = !this.collapsed;
+            this.dispatchEvent(new CustomEvent("collapsed-changed", {
+                bubbles: true,
+                composed: true,
+                detail: { collapsed: this.collapsed },
+            }));
+        });
+        this.tabsHost.addEventListener("value-changed", event => {
+            // box-tabs re-emits when we push a value into it; only user-driven
+            // changes should surface as tab-changed.
+            event.stopPropagation();
+            const tabId = event.detail?.value ?? "";
+            if (this.suppressTabsEvent || !tabId || tabId === this.activeTab) {
+                return;
+            }
+            this.activeTab = tabId;
+            this.dispatchEvent(new CustomEvent("tab-changed", {
+                bubbles: true,
+                composed: true,
+                detail: { tabId },
+            }));
+        });
+    }
+    /**
+     * The forwarded slots live inside box-tabs: host content slotted as
+     * `slot="details"` chains through `<slot name="details" slot="details">`
+     * into the matching tabpanel. One forwarded slot exists per known tab id
+     * (defaults + configured), so presence detection works before tabs render.
+     */
+    syncForwardedSlots() {
+        const ids = new Set(DEFAULT_SIDEBAR_TABS.map(tab => tab.id));
+        for (const tab of this.tabs ?? []) {
+            ids.add(tab.id);
+        }
+        const signature = JSON.stringify([...ids].sort());
+        if (signature === this.forwardedSlotsSignature) {
+            return;
+        }
+        this.forwardedSlotsSignature = signature;
+        this.tabsHost.innerHTML = [...ids]
+            .map(id => `<slot name="${escapeHtml(id)}" slot="${escapeHtml(id)}"></slot>`)
+            .join("");
+        this.tabsHost.querySelectorAll("slot").forEach(slot => {
+            slot.addEventListener("slotchange", () => {
+                this.refreshSlotPresence();
+                if (this.isRendered) {
+                    this.update();
+                }
+            });
+        });
+        this.refreshSlotPresence();
+    }
+    refreshSlotPresence() {
+        this.presentSlots.clear();
+        this.tabsHost.querySelectorAll("slot").forEach(slot => {
+            if (slot.assignedNodes().length > 0) {
+                this.presentSlots.add(slot.name);
+            }
+        });
+    }
+    update() {
+        if (!this.tabsHost) {
+            return;
+        }
+        this.syncForwardedSlots();
+        this.titleEl.textContent = this.heading;
+        this.asideEl.setAttribute("role", "complementary");
+        this.asideEl.setAttribute("aria-label", this.heading);
+        const collapsible = this.collapsible;
+        const collapsed = this.collapsed;
+        this.toggleEl.hidden = !collapsible;
+        this.toggleEl.textContent = collapsed ? "Expand" : "Collapse";
+        this.toggleEl.setAttribute("aria-expanded", collapsed ? "false" : "true");
+        this.bodyEl.hidden = collapsible && collapsed;
+        this.asideEl.setAttribute("data-collapsed", collapsed ? "true" : "false");
+        const tabs = this.resolvedTabs;
+        this.emptyEl.hidden = tabs.length > 0;
+        this.tabsHost.hidden = tabs.length === 0;
+        this.tabsHost.label = `${this.heading} tabs`;
+        this.suppressTabsEvent = true;
+        try {
+            this.tabsHost.options = tabs.map(tab => ({ label: tab.label, value: tab.id }));
+            const active = this.activeTab;
+            const validActive = tabs.some(tab => tab.id === active) ? active : (tabs[0]?.id ?? "");
+            if (validActive && this.tabsHost.value !== validActive) {
+                this.tabsHost.value = validActive;
+            }
+            if (validActive !== active) {
+                if (validActive) {
+                    this.setAttribute("active-tab", validActive);
+                }
+                else {
+                    this.removeAttribute("active-tab");
+                }
+            }
+        }
+        finally {
+            this.suppressTabsEvent = false;
+        }
+    }
+}
+Tabs.register();
+ContentSidebar.register();

package/dist/patterns/content-sidebar/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./content-sidebar.js";

package/dist/patterns/content-sidebar/index.js

@@ -0,0 +1,4 @@
+// Sidebar tab model and resolution
+export * from "./types.js";
+// Composed workflow surface
+export * from "./content-sidebar.js";

package/dist/patterns/content-sidebar/types.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A tab in the content sidebar. `id` doubles as the slot name that feeds the
+ * tab's panel, so custom tabs work the same way as the built-in four.
+ */
+export interface SidebarTab {
+    id: string;
+    label: string;
+}
+/** The upstream ContentSidebar tab set, in its canonical order. */
+export declare const DEFAULT_SIDEBAR_TABS: readonly SidebarTab[];
+/**
+ * Resolve which tabs the sidebar shows. An explicit configuration wins
+ * verbatim (the host is declaring its surface — an empty array means "no
+ * tabs", not "use the defaults"); otherwise the default tabs are filtered
+ * to the ones with slotted panel content, so an integration that only
+ * provides a details panel gets a details-only sidebar.
+ */
+export declare const resolveSidebarTabs: (configured: readonly SidebarTab[] | null, presentSlots: ReadonlySet<string>) => SidebarTab[];

package/dist/patterns/content-sidebar/types.js

@@ -0,0 +1,20 @@
+/** The upstream ContentSidebar tab set, in its canonical order. */
+export const DEFAULT_SIDEBAR_TABS = [
+    { id: "details", label: "Details" },
+    { id: "activity", label: "Activity" },
+    { id: "metadata", label: "Metadata" },
+    { id: "versions", label: "Versions" },
+];
+/**
+ * Resolve which tabs the sidebar shows. An explicit configuration wins
+ * verbatim (the host is declaring its surface — an empty array means "no
+ * tabs", not "use the defaults"); otherwise the default tabs are filtered
+ * to the ones with slotted panel content, so an integration that only
+ * provides a details panel gets a details-only sidebar.
+ */
+export const resolveSidebarTabs = (configured, presentSlots) => {
+    if (configured) {
+        return [...configured];
+    }
+    return DEFAULT_SIDEBAR_TABS.filter(tab => presentSlots.has(tab.id));
+};

package/dist/patterns/content-uploader/box-transport.d.ts

@@ -0,0 +1,14 @@
+import type { ExplorerFetchLike } from "../content-explorer/types.js";
+import type { UploadTransport } from "./types.js";
+export interface BoxUploadTransportOptions {
+    /** Box upload host — uploads do NOT go to api.box.com. */
+    uploadBaseUrl?: string;
+    fetch?: ExplorerFetchLike;
+}
+/**
+ * Multipart upload against `POST {uploadBase}/files/content` (the Box
+ * pre-flight-free path). fetch cannot observe upload progress, so
+ * `onProgress` fires once at completion; a chunked upload-session transport
+ * can implement the same `UploadTransport` contract with real fractions.
+ */
+export declare const createBoxUploadTransport: (options?: BoxUploadTransportOptions) => UploadTransport;