@tulip-systems/drive-local 0.11.1

package/dist/root/lib/service.server.mjs

@@ -0,0 +1,613 @@
+import { deviceSizes } from "./constants.mjs";
+import { inferLocalDriveNodeSubtype, isLocalDriveFile, isLocalDriveFolder, toLocalDriveNode } from "./helpers.mjs";
+import { getLocalDriveNodesByParentIdInputSchema, getLocalFileURLSchema, getLocalFileURLSchemaDefaults } from "./validators.mjs";
+import { offsetPaginationResponse, parseOffsetPagination } from "@tulip-systems/query";
+import { ORPCError } from "@orpc/server";
+import { after } from "next/server";
+import stream from "node:stream/consumers";
+import { addSeconds } from "date-fns";
+//#region src/root/lib/service.server.ts
+/**
+* Drive Service
+*/
+var LocalDrive = class {
+	#database;
+	storage;
+	constructor({ database, storage }) {
+		this.#database = database;
+		this.storage = storage;
+	}
+	/**
+	* Loads and validates the parent folder for write operations.
+	*
+	* The returned parent is guaranteed to exist, be a folder, belong to the
+	* same namespace, and not be archived. Root-level operations return `null`.
+	*
+	* @param input - Parent identifier and target namespace.
+	* @returns The validated parent node or `null` for root operations.
+	*/
+	async #getWritableParent(input) {
+		if (!input.parentId) return null;
+		const parent = await this.#database.findNodeById(input.parentId);
+		if (!parent) throw new ORPCError("BAD_REQUEST", { message: "Parent not found" });
+		if (!isLocalDriveFolder(parent)) throw new ORPCError("BAD_REQUEST", { message: "Parent is not a folder" });
+		if (parent.namespace !== input.namespace) throw new ORPCError("BAD_REQUEST", { message: "Parent is not in the same namespace" });
+		if (parent.archivedAt) throw new ORPCError("BAD_REQUEST", { message: "Parent is archived" });
+		return parent;
+	}
+	/**
+	* Collects the storage asset ids associated with a node subtree.
+	*
+	* This includes both the main file assets attached to file this.#nodes and any
+	* generated variant assets stored in `node_variants`.
+	*
+	* @param nodeIds - Node ids that belong to the subtree.
+	* @param subtree - Lightweight subtree rows returned by `getNodeChildren`.
+	* @returns A de-duplicated list of storage asset ids.
+	*/
+	async #getSubtreeAssetIds(nodeIds, subtree) {
+		const fileAssetIds = [...new Set(subtree.filter((node) => node.type === "file").map((node) => node.assetId).filter((assetId) => assetId != null))];
+		const variantAssetIds = (await this.#database.findVariants({ filters: { nodeIds } })).map((variant) => variant.assetId);
+		return [.../* @__PURE__ */ new Set([...fileAssetIds, ...variantAssetIds])];
+	}
+	/**
+	* Retrieves the node row for a given id.
+	*
+	* This is a thin lookup helper that returns the raw database result for the
+	* matching node. It does not load children, variants, or perform namespace
+	* validation.
+	*
+	* @param id - The node identifier.
+	* @returns A promise resolving to the matching node row as a single-item array,
+	* or an empty array when no node exists.
+	*/
+	async getNodeById(id) {
+		const node = await this.#database.findNodeById(id);
+		return node ? toLocalDriveNode(node) : null;
+	}
+	/**
+	* Retrieves a node together with its direct children for a namespace.
+	*
+	* This is used by the drive UI when opening a node detail view that expects
+	* the immediate child this.#nodes in the same payload.
+	*
+	* @param input - The target node id and namespace.
+	* @returns The node with its children when found, otherwise `null`.
+	*/
+	async getNodeWithChildren(input) {
+		const node = await this.getNodeById(input.id);
+		if (!node || node.namespace !== input.namespace) return null;
+		const children = await this.getNodesByParentId({
+			filters: {
+				namespace: input.namespace,
+				parentId: node.id,
+				hidden: false,
+				isArchived: false
+			},
+			sorts: []
+		});
+		return {
+			...node,
+			children
+		};
+	}
+	/**
+	* Lists this.#nodes within a folder scope using the current table-query filters.
+	*
+	* Behavior:
+	* - Scopes results to a namespace
+	* - Resolves either root this.#nodes (`parentId = null`) or a specific parent folder
+	* - Applies optional filters such as ids, types, hidden state, and archive state
+	* - Applies search and sorting through the shared table-query utilities
+	*
+	* @param input - Table query input containing drive filters, search, and sorting.
+	* @returns A promise resolving to the matching child this.#nodes.
+	*/
+	async getNodesByParentId(input) {
+		const query = getLocalDriveNodesByParentIdInputSchema.parse(input);
+		return (await this.#database.findNodes({
+			filters: query.filters,
+			sorts: query.sorts
+		})).map(toLocalDriveNode);
+	}
+	/**
+	* Lists tree-scoped this.#nodes with pagination, search, and richer local filters.
+	*
+	* This query is intended for admin table views where additional local fields
+	* such as subtype and contentType are part of the filtering contract.
+	*
+	* @param input - Table query input with tree filters.
+	* @returns A paginated table-query response.
+	*/
+	async listTree({ filters, ...query }) {
+		const pagination = parseOffsetPagination(query.pagination);
+		const result = await this.#database.listNodesWithAsset({
+			filters,
+			sorts: query.sorts,
+			limit: pagination.limit,
+			offset: pagination.offset
+		});
+		return offsetPaginationResponse({
+			data: result.data.map(({ asset, ...node }) => ({
+				...toLocalDriveNode(node),
+				asset
+			})),
+			pagination: query.pagination,
+			total: result.total
+		});
+	}
+	/**
+	* Lists flat this.#nodes with pagination, search, and richer local filters.
+	*
+	* Unlike `listTree`, this query ignores parent scoping and is intended for
+	* flat file-manager style views.
+	*
+	* @param input - Table query input with flat filters.
+	* @returns A paginated table-query response.
+	*/
+	async listFlat({ filters, ...query }) {
+		const pagination = parseOffsetPagination(query.pagination);
+		const result = await this.#database.listNodesWithAsset({
+			filters,
+			sorts: query.sorts,
+			limit: pagination.limit,
+			offset: pagination.offset
+		});
+		return offsetPaginationResponse({
+			data: result.data.map(({ asset, ...node }) => ({
+				...toLocalDriveNode(node),
+				asset
+			})),
+			pagination: query.pagination,
+			total: result.total
+		});
+	}
+	/**
+	* Resolves the ancestor chain for a folder or file node.
+	*
+	* The returned list starts with the root-most ancestor and ends with the
+	* requested node. This is primarily used for breadcrumb navigation.
+	*
+	* @param input - The node id and namespace to resolve.
+	* @returns A promise resolving to the ordered ancestor chain.
+	*/
+	async getFolderParents(input) {
+		return (await this.#database.getNodeParents(input)).map(({ depth, ...parent }) => ({
+			...parent,
+			depth: Number(depth)
+		})).toSorted((a, b) => b.depth - a.depth);
+	}
+	/**
+	* Retrieves the structural subtree for one or more root node ids.
+	*
+	* The result includes the provided start this.#nodes and all descendant this.#nodes,
+	* returned as a lightweight shape containing only the fields needed for
+	* recursive drive operations such as delete, archive, and validation.
+	*
+	* Depth starts at `0` for the provided root this.#nodes and increases for each
+	* descendant level. Duplicate paths are collapsed by keeping the minimum depth.
+	*
+	* @param ids - Root node ids to traverse from.
+	* @returns A promise resolving to the subtree rows for the provided this.#nodes.
+	*/
+	async getNodeChildren(ids) {
+		return (await this.#database.getNodeChildren(ids)).map(({ depth, ...node }) => ({
+			...toLocalDriveNode(node),
+			depth
+		}));
+	}
+	/**
+	* Resolves an access URL for a file node and the requested variant.
+	*
+	* Behavior:
+	* - Rejects folder this.#nodes because only file this.#nodes can resolve a file URL
+	* - Reuses a cached URL when an unexpired entry exists for the requested
+	*   variant and disposition
+	* - Resolves the requested preview variant asset when available
+	* - Falls back to the main file asset when the requested variant does not exist
+	* - Delegates final URL generation to the storage service
+	* - Stores the generated URL in the local cache table for future reuse
+	*
+	* @param node - The file node to resolve.
+	* @param options - URL options such as variant and content disposition.
+	* @returns A promise resolving to a temporary file URL.
+	*/
+	async getURL(node, options = getLocalFileURLSchemaDefaults) {
+		if (!isLocalDriveFile(node)) throw new ORPCError("BAD_REQUEST", { message: "Node is not a file" });
+		const parsedOptions = getLocalFileURLSchema.parse({
+			...options,
+			variant: options.variant === "original" ? "main" : options.variant
+		});
+		const presignedUrl = await this.#database.findFirstPresignedUrl({ filters: {
+			nodeId: node.id,
+			variant: parsedOptions.variant,
+			disposition: parsedOptions.disposition
+		} });
+		if (presignedUrl && presignedUrl.expiresAt > /* @__PURE__ */ new Date()) return presignedUrl.url;
+		const expiresIn = 86400;
+		const [variantRecord] = parsedOptions.variant === "main" ? [] : await this.#database.findVariants({
+			filters: {
+				nodeIds: [node.id],
+				variants: [parsedOptions.variant]
+			},
+			limit: 1
+		});
+		const variant = variantRecord ? parsedOptions.variant : "main";
+		const assetId = variantRecord?.assetId ?? node.assetId;
+		if (!assetId) throw new ORPCError("NOT_FOUND", { message: "Storage asset not found" });
+		console.info(`Generating new signed url for file: ${node.id} with variant: ${variant} and disposition: ${parsedOptions.disposition}`);
+		const url = await this.storage.getObjectURL(assetId, {
+			disposition: `${parsedOptions.disposition}; filename="${node.name}"`,
+			expiresIn
+		});
+		after(async () => {
+			await this.#database.upsertPresignedUrl({
+				nodeId: node.id,
+				url,
+				variant,
+				variantId: variantRecord?.id,
+				disposition: parsedOptions.disposition,
+				expiresAt: addSeconds(/* @__PURE__ */ new Date(), expiresIn)
+			});
+		});
+		return url;
+	}
+	/**
+	* Moves a node to a different parent folder.
+	*
+	* The target parent is validated before the move is persisted. Moving a node
+	* into itself or into one of its descendants is rejected to keep the tree
+	* structure valid.
+	*
+	* @param input - The node id and the target parent id.
+	* @returns A promise resolving to the updated node.
+	* @throws {ORPCError} If the move is invalid.
+	*/
+	async moveNode(input) {
+		const node = await this.#database.findNodeById(input.id);
+		if (!node) throw new ORPCError("BAD_REQUEST", { message: "Node not found" });
+		if (node.readonly) throw new ORPCError("BAD_REQUEST", { message: "Deze node is alleen leesbaar en kan niet worden gewijzigd" });
+		if (input.parentId === node.id) throw new ORPCError("BAD_REQUEST", { message: "Node cannot be moved into itself" });
+		if (input.parentId !== void 0) await this.#getWritableParent({
+			parentId: input.parentId,
+			namespace: node.namespace
+		});
+		if (input.parentId) {
+			if ((await this.getNodeChildren([input.id])).some((child) => child.id === input.parentId)) throw new ORPCError("BAD_REQUEST", { message: "Node cannot be moved into one of its descendants" });
+		}
+		if (node.parentId === input.parentId) return toLocalDriveNode(node);
+		const result = await this.#database.updateNodeById(input.id, { parentId: input.parentId });
+		if (!result) throw new ORPCError("INTERNAL_SERVER_ERROR", { message: "Node kon niet worden gewijzigd" });
+		return toLocalDriveNode(result);
+	}
+	/**
+	* Uploads a file through the storage service and creates the matching node.
+	*
+	* Behavior:
+	* - Validates the parent folder when `parentId` is provided
+	* - Uploads the file bytes through the storage service
+	* - Persists the created storage asset id on the node
+	* - Cleans up the uploaded asset when node creation fails
+	*
+	* @param input - File metadata and body.
+	* @returns A promise resolving to the created file node.
+	* @throws {ORPCError} If validation or persistence fails.
+	*/
+	async uploadFile(input) {
+		await this.#getWritableParent({
+			parentId: input.parentId,
+			namespace: input.namespace
+		});
+		const asset = await this.storage.upload({
+			name: input.name,
+			body: input.body,
+			contentType: input.contentType,
+			size: input.size,
+			visibility: "private"
+		});
+		try {
+			const result = await this.#database.createNode({
+				type: "file",
+				name: input.name,
+				namespace: input.namespace,
+				parentId: input.parentId,
+				size: asset.size ?? input.size,
+				contentType: asset.contentType ?? input.contentType,
+				hidden: input.hidden ?? false,
+				readonly: input.readonly ?? false,
+				subtype: inferLocalDriveNodeSubtype(input),
+				assetId: asset.id
+			});
+			if (!result) throw new ORPCError("INTERNAL_SERVER_ERROR", { message: "Oep! Er is iets fout gegaan" });
+			return toLocalDriveNode(result);
+		} catch (error) {
+			await this.storage.purgeAsset(asset.id).catch(() => void 0);
+			throw error;
+		}
+	}
+	/**
+	* Creates a direct upload intent and the matching file node.
+	*
+	* Behavior:
+	* - Validates the parent folder when `parentId` is provided
+	* - Requests a presigned upload from the storage service
+	* - Creates the file node linked to the pending storage asset
+	* - Purges the pending asset when node creation fails
+	*
+	* @param input - File metadata used to create the upload intent.
+	* @returns The created asset intent, presigned URL, and file node.
+	* @throws {ORPCError} If validation or node creation fails.
+	*/
+	async presignUpload(input) {
+		await this.#getWritableParent(input);
+		const { presignedUrl, ...asset } = await this.storage.presignUpload({
+			uploadId: input.uploadId,
+			name: input.name,
+			contentType: input.contentType,
+			size: input.size,
+			visibility: input.visibility
+		});
+		try {
+			const node = await this.#database.createNode({
+				type: "file",
+				name: input.name,
+				namespace: input.namespace,
+				parentId: input.parentId,
+				size: asset.size ?? input.size,
+				contentType: asset.contentType ?? input.contentType,
+				hidden: input.hidden ?? false,
+				readonly: input.readonly ?? false,
+				assetId: asset.id,
+				subtype: inferLocalDriveNodeSubtype(input)
+			});
+			if (!node) throw new ORPCError("INTERNAL_SERVER_ERROR", { message: "Oep! Er is iets fout gegaan" });
+			return {
+				uploadId: asset.uploadId,
+				presignedUrl,
+				node: toLocalDriveNode(node),
+				asset
+			};
+		} catch (error) {
+			await this.storage.purgeAsset(asset.id).catch(() => void 0);
+			throw error;
+		}
+	}
+	/**
+	* Finalizes a presigned upload and synchronizes the node metadata.
+	*
+	* Behavior:
+	* - Confirms the pending asset through the storage service
+	* - Finds the matching node by `assetId`
+	* - Synchronizes final asset metadata onto the node
+	* - Schedules preview generation for image files
+	*
+	* @param uploadId - The storage upload id returned by the presign step.
+	* @returns A promise resolving to the finalized file node.
+	* @throws {ORPCError} If the asset or node cannot be resolved.
+	*/
+	async confirmUpload(uploadId) {
+		const asset = await this.storage.confirmUpload(uploadId);
+		const node = await this.#database.findFirstNode({ filters: { assetIds: [asset.id] } });
+		if (!node) throw new ORPCError("NOT_FOUND", { message: "File not found" });
+		const result = await this.#database.updateNodeById(node.id, {
+			size: asset.size ?? node.size,
+			contentType: asset.contentType ?? node.contentType
+		});
+		if (!result) throw new ORPCError("NOT_FOUND", { message: "File not found" });
+		/**
+		* Generate the preview version of the file
+		*/
+		after(async () => {
+			await this.generatePreviews({ id: result.id });
+		});
+		return toLocalDriveNode(result);
+	}
+	/**
+	* Generates preview assets for an image node.
+	*
+	* The original file is loaded from storage, resized to the configured device
+	* widths, uploaded as separate storage assets, and linked through
+	* `node_variants`. Existing preview variants are skipped.
+	*
+	* @param input - The target file node identifier.
+	* @returns A promise that resolves once preview generation completes.
+	* @throws {ORPCError} If the source node or asset cannot be resolved.
+	*/
+	async generatePreviews(input) {
+		const node = await this.#database.findNodeById(input.id);
+		if (!node) throw new ORPCError("NOT_FOUND", { message: "Node not found" });
+		if (!node.assetId) throw new ORPCError("BAD_REQUEST", { message: "Node has no storage asset" });
+		/**
+		* Get the main version of the file
+		*/
+		const response = await this.storage.getObject(node.assetId);
+		const contentType = response.contentType;
+		if (!response.body) throw new ORPCError("INTERNAL_SERVER_ERROR", { message: "Oeps! Er is iets fout gegaan" });
+		/**
+		* Transform the main version of the file to a buffer
+		*/
+		const buffer = await stream.buffer(response.body);
+		/**
+		* Generate the preview versions for images
+		*/
+		if (contentType?.startsWith("image/")) {
+			const sharp = await import("sharp");
+			const sourceAsset = await this.storage.getAssetById(node.assetId);
+			if (!sourceAsset) throw new ORPCError("NOT_FOUND", { message: "Storage asset not found" });
+			const existingVariantNames = new Set((await this.#database.findVariants({ filters: { nodeIds: [input.id] } })).map((variant) => variant.variant));
+			await Promise.allSettled(deviceSizes.flatMap(async (width) => {
+				const variant = `preview-${width}`;
+				if (existingVariantNames.has(variant)) return;
+				const preview = await sharp.default(buffer).resize({ width }).webp().toBuffer();
+				const asset = await this.storage.upload({
+					body: preview,
+					name: `${input.id}-preview-${width}.webp`,
+					contentType: "image/webp",
+					size: preview.byteLength,
+					visibility: sourceAsset.visibility
+				});
+				try {
+					await this.#database.createVariant({
+						nodeId: input.id,
+						assetId: asset.id,
+						variant,
+						width
+					});
+				} catch (error) {
+					await this.storage.purgeAsset(asset.id).catch(() => void 0);
+					throw error;
+				}
+			}));
+		}
+	}
+	/**
+	* Creates a folder node in the drive tree.
+	*
+	* The parent folder is validated before the folder is inserted. Folders do
+	* not own a storage asset and are stored purely as drive metadata.
+	*
+	* @param input - Folder metadata.
+	* @returns A promise resolving to the created folder node.
+	* @throws {ORPCError} If validation or insertion fails.
+	*/
+	async createFolder(input) {
+		await this.#getWritableParent({
+			parentId: input.parentId,
+			namespace: input.namespace
+		});
+		/**
+		* Create the folder
+		*/
+		const result = await this.#database.createNode({
+			type: "folder",
+			name: input.name,
+			namespace: input.namespace,
+			parentId: input.parentId,
+			hidden: input.hidden ?? false,
+			readonly: input.readonly ?? false
+		});
+		if (!result) throw new ORPCError("INTERNAL_SERVER_ERROR", { message: "Folder kon niet worden aangemaakt" });
+		return toLocalDriveNode(result);
+	}
+	/**
+	* Updates mutable node metadata.
+	*
+	* Supported updates currently include renaming, reparenting, visibility flags,
+	* and archive state. Structural updates are validated before being persisted.
+	*
+	* @param id - The target node id.
+	* @param data - Partial node fields to update.
+	* @returns A promise resolving to the updated node.
+	* @throws {ORPCError} If the node does not exist or the update is invalid.
+	*/
+	async updateNode(id, data) {
+		const node = await this.#database.findNodeById(id);
+		if (!node) throw new ORPCError("NOT_FOUND", { message: "Node not found" });
+		if (data.parentId !== void 0) await this.#getWritableParent({
+			parentId: data.parentId,
+			namespace: node.namespace
+		});
+		const result = await this.#database.updateNodeById(id, data);
+		if (!result) throw new ORPCError("INTERNAL_SERVER_ERROR", { message: "Node kon niet worden gewijzigd" });
+		return toLocalDriveNode(result);
+	}
+	/**
+	* Sets the readonly state for multiple this.#nodes.
+	*
+	* This method is intended for bulk lock and unlock operations in the drive UI.
+	*
+	* @param ids - The node ids to update.
+	* @param readonly - The readonly state to apply.
+	* @returns A promise resolving to the updated this.#nodes.
+	* @throws {ORPCError} If no ids are provided or no matching this.#nodes are found.
+	*/
+	async setReadonly(ids, readonly) {
+		const nodeIds = [...new Set(ids)];
+		if (nodeIds.length === 0) throw new ORPCError("BAD_REQUEST", { message: "No node ids provided" });
+		const result = await this.#database.updateNodes({
+			filters: { nodeIds },
+			data: { readonly }
+		});
+		if (result.length === 0) throw new ORPCError("BAD_REQUEST", { message: "No matching this.#nodes found" });
+		return result.map(toLocalDriveNode);
+	}
+	/**
+	* Archives this.#nodes by setting their archive timestamp.
+	*
+	* This is a drive-level archive state and does not delete the underlying
+	* storage assets.
+	*
+	* @param ids - The node ids to archive.
+	* @returns A promise resolving to the archived this.#nodes.
+	* @throws {ORPCError} If no ids are provided or no matching this.#nodes are found.
+	*/
+	async archiveNodes(ids) {
+		const nodeIds = [...new Set(ids)];
+		if (nodeIds.length === 0) throw new ORPCError("BAD_REQUEST", { message: "No node ids provided" });
+		const result = await this.#database.updateNodes({
+			filters: { nodeIds },
+			data: { archivedAt: /* @__PURE__ */ new Date() }
+		});
+		if (result.length === 0) throw new ORPCError("BAD_REQUEST", { message: "No matching this.#nodes found" });
+		return result.map(toLocalDriveNode);
+	}
+	/**
+	* Restores archived this.#nodes by clearing their archive timestamp.
+	*
+	* @param ids - The node ids to restore.
+	* @returns A promise resolving to the restored this.#nodes.
+	* @throws {ORPCError} If no ids are provided or no matching this.#nodes are found.
+	*/
+	async restoreNodes(ids) {
+		const nodeIds = [...new Set(ids)];
+		if (nodeIds.length === 0) throw new ORPCError("BAD_REQUEST", { message: "No node ids provided" });
+		const result = await this.#database.updateNodes({
+			filters: { nodeIds },
+			data: { archivedAt: null }
+		});
+		if (result.length === 0) throw new ORPCError("BAD_REQUEST", { message: "No matching this.#nodes found" });
+		return result.map(toLocalDriveNode);
+	}
+	/**
+	* Permanently deletes a node subtree and all linked assets.
+	*
+	* The subtree includes the provided node and all descendants. Associated file
+	* assets and generated preview assets are purged from storage after the this.#nodes
+	* are removed from the drive catalog.
+	*
+	* @param id - The root node id to delete.
+	* @throws {ORPCError} If the node does not exist.
+	*/
+	async deleteNode(id) {
+		const subtree = await this.getNodeChildren([id]);
+		if (subtree.length === 0) throw new ORPCError("NOT_FOUND", { message: "Node not found" });
+		const nodeIds = [...new Set(subtree.map((node) => node.id))];
+		const assetIds = await this.#getSubtreeAssetIds(nodeIds, subtree);
+		await this.#database.deleteNodes({ filters: { nodeIds } });
+		if (assetIds.length > 0) await this.storage.purgeAssets(assetIds);
+	}
+	/**
+	* Permanently deletes multiple node subtrees and their linked assets.
+	*
+	* Each provided id is treated as a subtree root. All descendant this.#nodes are
+	* removed together with their main file assets and generated preview assets.
+	*
+	* @param ids - Root node ids to delete.
+	* @returns A promise that resolves when deletion completes.
+	* @throws {ORPCError} If no ids are provided or no matching this.#nodes are found.
+	*/
+	async deleteNodes(ids) {
+		if (ids.length === 0) throw new ORPCError("BAD_REQUEST", { message: "No node ids provided" });
+		const subtree = await this.getNodeChildren(ids);
+		if (subtree.length === 0) throw new ORPCError("BAD_REQUEST", { message: "No matching this.#nodes found" });
+		const nodeIds = [...new Set(subtree.map((node) => node.id))];
+		const assetIds = await this.#getSubtreeAssetIds(nodeIds, subtree);
+		/**
+		* Delete files and folders in a database
+		*/
+		await this.#database.deleteNodes({ filters: { nodeIds } });
+		if (assetIds.length > 0) await this.storage.purgeAssets(assetIds);
+	}
+};
+//#endregion
+export { LocalDrive };

package/dist/root/lib/upload.client.d.mts

@@ -0,0 +1,60 @@
+import { LocalDriveFileNode, LocalDriveNode, PresignLocalDriveFileInput, UpdateLocalDriveNodeInput } from "./validators.mjs";
+import { BulkActionSchema } from "@tulip-systems/query";
+import { SelectStorageAssetSchema } from "@tulip-systems/storage";
+//#region src/root/lib/upload.client.d.ts
+/**
+ * Upload request
+ */
+type PrepareLocalDriveUploadInput = Omit<LocalDriveUploadFileRequest, "name" | "size" | "contentType">;
+type LocalDriveUploadFileRequest = PresignLocalDriveFileInput & {
+  file: File;
+};
+type LocalDriveUploadHooks = {
+  beforePresign?: (input: LocalDriveUploadFileRequest) => Promise<void> | void;
+  afterPresign?: (presignResult: {
+    asset: SelectStorageAssetSchema;
+    node: LocalDriveFileNode;
+    uploadId: string;
+    presignedUrl: string;
+  }) => Promise<void> | void;
+  beforeConfirm?: (presignResult: {
+    asset: SelectStorageAssetSchema;
+    node: LocalDriveFileNode;
+    uploadId: string;
+    presignedUrl: string;
+  }) => Promise<void> | void;
+  afterConfirm?: (node: LocalDriveFileNode) => Promise<void> | void;
+};
+/**
+ * Upload client
+ */
+type LocalDriveUploadClient = {
+  prepareUpload: (input: PrepareLocalDriveUploadInput) => LocalDriveUploadFileRequest;
+  upload: (input: LocalDriveUploadFileRequest, hooks?: LocalDriveUploadHooks) => Promise<LocalDriveFileNode>;
+  deleteFiles: (ids: string[]) => Promise<void>;
+  updateNode: (id: string, data: UpdateLocalDriveNodeInput) => Promise<LocalDriveNode>;
+};
+/**
+ * Create upload client
+ */
+type CreateLocalDriveUploadClientProps = {
+  endpoints: {
+    presignUpload: (input: PresignLocalDriveFileInput) => Promise<{
+      asset: SelectStorageAssetSchema;
+      node: LocalDriveFileNode;
+      uploadId: string;
+      presignedUrl: string;
+    }>;
+    confirmUpload: (input: {
+      uploadId: string;
+    }) => Promise<LocalDriveFileNode>;
+    deleteNodes: (input: BulkActionSchema) => Promise<void>;
+    updateNode: (input: {
+      id: string;
+      data: UpdateLocalDriveNodeInput;
+    }) => Promise<LocalDriveNode>;
+  };
+};
+declare function createLocalDriveUploadClient(props: CreateLocalDriveUploadClientProps): LocalDriveUploadClient;
+//#endregion
+export { LocalDriveUploadClient, LocalDriveUploadFileRequest, LocalDriveUploadHooks, PrepareLocalDriveUploadInput, createLocalDriveUploadClient };