@unisource/sdk 0.1.2 → 0.3.0

package/dist/index.mjs

@@ -1,9 +1,10 @@
 import { z } from "zod";
-//#region src/index.ts
+//#region src/primitives.ts
+const nonEmptyString = z.string().trim().min(1);
+const positiveInt = z.number().int().positive();
+const unixTimestamp = z.number().int().nonnegative();
 const FILES_DEFAULT_LIMIT = 25;
 const FILES_MAX_LIMIT = 100;
-const nonEmptyStringSchema = z.string().trim().min(1);
-const positiveIntegerSchema = z.number().int().positive();
 const uploadDestinationSchema = z.enum(["r2", "appwrite"]);
 const uploadStatusSchema = z.enum([
 	"pending",
@@ -11,84 +12,699 @@ const uploadStatusSchema = z.enum([
 	"failed"
 ]);
 const apiErrorSchema = z.object({
-	error: nonEmptyStringSchema,
-	message: nonEmptyStringSchema
+	error: nonEmptyString,
+	message: nonEmptyString
 });
+//#endregion
+//#region src/uploads.ts
 const uploadR2InitRequestSchema = z.object({
-	filename: nonEmptyStringSchema,
-	size: positiveIntegerSchema,
-	mime_type: nonEmptyStringSchema,
-	bucket: nonEmptyStringSchema.optional()
+	filename: nonEmptyString,
+	size: positiveInt,
+	mime_type: nonEmptyString,
+	folder_id: nonEmptyString.optional(),
+	is_main_storage: z.boolean().optional().default(false)
 });
 const uploadR2InitResponseSchema = z.object({
-	upload_id: nonEmptyStringSchema,
+	upload_id: nonEmptyString,
 	destination: z.literal("r2"),
 	presigned_url: z.string().url(),
-	storage_key: nonEmptyStringSchema,
-	bucket: nonEmptyStringSchema,
-	expires_at: positiveIntegerSchema
+	storage_key: nonEmptyString,
+	bucket: nonEmptyString,
+	expires_at: positiveInt
 });
 const uploadAppwriteInitRequestSchema = z.object({
-	filename: nonEmptyStringSchema,
-	size: positiveIntegerSchema,
-	mime_type: nonEmptyStringSchema
+	filename: nonEmptyString,
+	size: positiveInt,
+	mime_type: nonEmptyString,
+	folder_id: nonEmptyString.optional(),
+	is_main_storage: z.boolean().optional().default(false)
 });
 const uploadAppwriteInitResponseSchema = z.object({
-	upload_id: nonEmptyStringSchema,
+	upload_id: nonEmptyString,
 	destination: z.literal("appwrite"),
 	appwrite_endpoint: z.string().url(),
-	appwrite_project_id: nonEmptyStringSchema,
-	appwrite_bucket_id: nonEmptyStringSchema,
-	file_id: nonEmptyStringSchema,
-	expires_at: positiveIntegerSchema
+	appwrite_project_id: nonEmptyString,
+	appwrite_bucket_id: nonEmptyString,
+	file_id: nonEmptyString,
+	expires_at: positiveInt
+});
+const uploadLifecycleRequestSchema = z.object({
+	upload_id: nonEmptyString,
+	is_main_storage: z.boolean().optional().default(false)
 });
-const uploadLifecycleRequestSchema = z.object({ upload_id: nonEmptyStringSchema });
 const uploadCompleteResponseSchema = z.object({
 	success: z.literal(true),
-	upload_id: nonEmptyStringSchema,
+	upload_id: nonEmptyString,
 	status: z.literal("completed")
 });
 const uploadFailResponseSchema = z.object({
 	success: z.literal(true),
-	upload_id: nonEmptyStringSchema,
+	upload_id: nonEmptyString,
 	status: z.literal("failed")
 });
-const fileRecordSchema = z.object({
-	id: nonEmptyStringSchema,
-	filename: nonEmptyStringSchema,
-	size: positiveIntegerSchema,
-	mime_type: nonEmptyStringSchema,
+/** Raw upload record — returned by admin `/files` endpoints. */
+const uploadRecordSchema = z.object({
+	id: nonEmptyString,
+	service_id: nonEmptyString,
+	user_id: nonEmptyString.nullable(),
+	filename: nonEmptyString,
+	size: positiveInt,
+	mime_type: nonEmptyString,
 	destination: uploadDestinationSchema,
-	storage_key: nonEmptyStringSchema,
-	bucket: nonEmptyStringSchema,
 	status: uploadStatusSchema,
-	expires_at: positiveIntegerSchema,
-	created_at: positiveIntegerSchema,
-	updated_at: positiveIntegerSchema
+	expires_at: positiveInt,
+	created_at: positiveInt,
+	updated_at: positiveInt
 });
-const filesListQuerySchema = z.object({
-	limit: z.number().int().min(1).max(100).optional(),
-	cursor: nonEmptyStringSchema.optional(),
-	destination: uploadDestinationSchema.optional(),
-	status: uploadStatusSchema.optional()
+const uploadsListResponseSchema = z.object({
+	items: z.array(uploadRecordSchema),
+	next_cursor: z.string().nullable(),
+	limit: positiveInt
 });
-const filesListResponseSchema = z.object({
+const uploadRecordDetailResponseSchema = z.object({ upload: uploadRecordSchema });
+//#endregion
+//#region src/fileRecords.ts
+/**
+* A confirmed file record owned by a user.
+* Internal fields (storage_key, bucket) are intentionally excluded from the public API.
+*/
+const fileRecordSchema = z.object({
+	id: nonEmptyString,
+	service_id: nonEmptyString,
+	user_id: nonEmptyString,
+	folder_id: nonEmptyString.nullable(),
+	upload_id: nonEmptyString.nullable(),
+	filename: nonEmptyString,
+	size: positiveInt,
+	mime_type: nonEmptyString,
+	storage_destination: uploadDestinationSchema,
+	is_trashed: z.boolean(),
+	trashed_at: positiveInt.nullable(),
+	created_at: positiveInt,
+	updated_at: positiveInt
+});
+const fileRecordsListQuerySchema = z.object({
+	folder_id: nonEmptyString.nullable().optional(),
+	is_trashed: z.boolean().optional(),
+	cursor: nonEmptyString.optional(),
+	limit: z.number().int().min(1).max(100).optional()
+});
+const fileRecordsListResponseSchema = z.object({
 	items: z.array(fileRecordSchema),
 	next_cursor: z.string().nullable(),
-	limit: z.number().int().min(1).max(100)
+	limit: positiveInt
 });
-const fileDetailsResponseSchema = z.object({ file: fileRecordSchema });
+const fileRecordDetailResponseSchema = z.object({ file: fileRecordSchema });
+const fileMoveRequestSchema = z.object({ folder_id: nonEmptyString.nullable().optional() });
 const fileDownloadUrlResponseSchema = z.object({
-	upload_id: nonEmptyStringSchema,
+	upload_id: nonEmptyString,
 	destination: uploadDestinationSchema,
 	download_url: z.string().url(),
-	expires_at: positiveIntegerSchema
+	expires_at: positiveInt
 });
 const fileDeleteResponseSchema = z.object({
 	success: z.literal(true),
-	upload_id: nonEmptyStringSchema,
-	destination: uploadDestinationSchema,
-	storage_not_found: z.boolean()
+	id: nonEmptyString,
+	permanent: z.boolean()
+});
+const fileRestoreResponseSchema = z.object({
+	success: z.literal(true),
+	id: nonEmptyString
+});
+const fileUpdateRequestSchema = z.object({ filename: nonEmptyString });
+const fileUpdateResponseSchema = z.object({ file: fileRecordSchema });
+//#endregion
+//#region src/folders.ts
+const folderSchema = z.object({
+	id: nonEmptyString,
+	service_id: nonEmptyString,
+	user_id: nonEmptyString,
+	parent_id: nonEmptyString.nullable(),
+	name: nonEmptyString,
+	color_tag: z.string().nullable(),
+	is_trashed: z.boolean(),
+	trashed_at: positiveInt.nullable(),
+	created_at: positiveInt,
+	updated_at: positiveInt
+});
+const folderListQuerySchema = z.object({
+	parent_id: nonEmptyString.nullable().optional(),
+	trashed: z.boolean().optional(),
+	is_trashed: z.boolean().optional(),
+	cursor: nonEmptyString.optional(),
+	limit: z.number().int().min(1).max(100).optional()
+}).refine((v) => !(v.trashed !== void 0 && v.is_trashed !== void 0), { message: "Use either trashed or is_trashed, not both" });
+const folderListResponseSchema = z.object({
+	items: z.array(folderSchema),
+	next_cursor: z.string().nullable(),
+	limit: positiveInt
+});
+const folderCreateRequestSchema = z.object({
+	name: nonEmptyString,
+	parent_id: nonEmptyString.optional(),
+	color_tag: z.string().optional()
+});
+const folderCreateResponseSchema = z.object({ folder: folderSchema });
+const folderUpdateRequestSchema = z.object({
+	name: nonEmptyString.optional(),
+	color_tag: z.string().nullable().optional()
+}).refine((v) => v.name !== void 0 || v.color_tag !== void 0, { message: "At least one of name or color_tag must be provided" });
+const folderUpdateResponseSchema = z.object({ folder: folderSchema });
+const folderDeleteResponseSchema = z.object({
+	success: z.literal(true),
+	id: nonEmptyString,
+	permanent: z.boolean(),
+	folders_deleted: z.number().int().nonnegative().optional()
+});
+const folderDetailResponseSchema = z.object({ folder: folderSchema });
+const folderRestoreResponseSchema = z.object({
+	success: z.literal(true),
+	id: nonEmptyString
+});
+//#endregion
+//#region src/services.ts
+/** Public service info returned to admins. Never exposes secrets. */
+const serviceSchema = z.object({
+	id: nonEmptyString,
+	name: nonEmptyString,
+	max_storage_bytes: positiveInt,
+	current_used_bytes: z.number().int().nonnegative(),
+	max_file_size_bytes: positiveInt,
+	created_at: unixTimestamp
+});
+const serviceDetailResponseSchema = z.object({ service: serviceSchema });
+const adminServiceUpdateRequestSchema = z.object({
+	max_storage_bytes: positiveInt.optional(),
+	max_file_size_bytes: positiveInt.optional()
+}).refine((v) => v.max_storage_bytes !== void 0 || v.max_file_size_bytes !== void 0, { message: "At least one of max_storage_bytes or max_file_size_bytes must be provided" });
+const adminServiceUpdateResponseSchema = serviceDetailResponseSchema;
+const serviceUsageResponseSchema = z.object({
+	service_id: nonEmptyString,
+	max_storage_bytes: positiveInt,
+	current_used_bytes: z.number().int().nonnegative(),
+	used_percent: z.number().min(0).max(100)
+});
+const auditEventActionSchema = z.enum([
+	"upload_completed",
+	"file_deleted",
+	"folder_deleted",
+	"quota_exceeded",
+	"share_link_accessed",
+	"quota_reconciled"
+]);
+const auditEventSchema = z.object({
+	id: nonEmptyString,
+	service_id: nonEmptyString,
+	user_id: nonEmptyString,
+	action: auditEventActionSchema,
+	resource_type: z.enum([
+		"file",
+		"folder",
+		"service"
+	]),
+	resource_id: nonEmptyString,
+	metadata: z.record(z.string(), z.unknown()).nullable(),
+	ip_address: z.string().nullable(),
+	created_at: unixTimestamp
+});
+const auditLogListQuerySchema = z.object({
+	user_id: nonEmptyString.optional(),
+	action: auditEventActionSchema.optional(),
+	resource_type: z.enum([
+		"file",
+		"folder",
+		"service"
+	]).optional(),
+	cursor: nonEmptyString.optional(),
+	limit: z.number().int().min(1).max(200).optional()
 });
+const auditLogListResponseSchema = z.object({
+	items: z.array(auditEventSchema),
+	next_cursor: z.string().nullable(),
+	limit: positiveInt
+});
+const adminUserSchema = z.object({
+	id: nonEmptyString,
+	name: z.string(),
+	email: z.string().email(),
+	status: z.boolean(),
+	labels: z.array(z.string()),
+	role: nonEmptyString,
+	has_service_access: z.boolean(),
+	max_storage_bytes: positiveInt.nullable(),
+	effective_max_storage_bytes: positiveInt,
+	current_used_bytes: z.number().int().nonnegative(),
+	registration: unixTimestamp,
+	email_verification: z.boolean()
+});
+const adminUserListResponseSchema = z.object({
+	items: z.array(adminUserSchema),
+	total: z.number().int().nonnegative(),
+	offset: z.number().int().nonnegative(),
+	limit: positiveInt
+});
+const adminUserUpdateRequestSchema = z.object({
+	name: z.string().trim().min(1).max(128).optional(),
+	email: z.string().trim().email().optional(),
+	status: z.boolean().optional(),
+	labels: z.array(z.string().trim().min(1)).max(32).optional(),
+	role: z.enum([
+		"user",
+		"plus",
+		"admin"
+	]).optional(),
+	max_storage_bytes: positiveInt.nullable().optional()
+});
+const adminUserUpdateResponseSchema = z.object({ user: adminUserSchema });
+const adminUserPasswordResetRequestSchema = z.object({ password: z.string().min(8).max(256) });
+const adminUserPasswordResetResponseSchema = z.object({
+	success: z.literal(true),
+	user_id: nonEmptyString
+});
+//#endregion
+//#region src/mainStorage.ts
+const mainStorageListQuerySchema = z.object({
+	limit: z.number().int().positive().optional(),
+	cursor: nonEmptyString.optional()
+});
+const mainStorageListResponseSchema = z.object({
+	items: z.array(fileRecordSchema),
+	next_cursor: z.string().nullable()
+});
+const mainStorageRenameRequestSchema = z.object({ filename: nonEmptyString });
+const mainStorageDeleteResponseSchema = z.object({
+	success: z.boolean(),
+	file_id: nonEmptyString
+});
+const mainStorageRestoreResponseSchema = z.object({
+	success: z.boolean(),
+	file_id: nonEmptyString
+});
+//#endregion
+//#region src/releases.ts
+const releaseIdSchema = z.string().trim().min(1).max(128);
+const releaseNameSchema = z.string().trim().min(1).max(256);
+const releaseFilenameSchema = z.string().trim().min(1).max(255);
+const releaseTagsSchema = z.array(z.string().trim().min(1).max(64)).max(32);
+const releaseNotesSchema = z.string().trim().max(1e4).nullable().optional();
+const releaseR2KeySchema = z.string().trim().min(1).max(1024);
+const releaseDTOSchema = z.object({
+	id: nonEmptyString,
+	service_id: nonEmptyString,
+	name: nonEmptyString,
+	size: z.number().int().nonnegative(),
+	r2_key: nonEmptyString,
+	tags: z.array(nonEmptyString),
+	notes: z.string().nullable(),
+	force_update: z.boolean(),
+	uploaded_by: nonEmptyString,
+	upload_status: uploadStatusSchema,
+	created_at: nonEmptyString
+});
+const releaseUploadInitRequestSchema = z.object({
+	name: releaseNameSchema,
+	filename: releaseFilenameSchema,
+	tags: releaseTagsSchema.optional().default([]),
+	notes: releaseNotesSchema,
+	force_update: z.boolean().optional().default(false)
+});
+const releaseUploadInitResponseSchema = z.object({
+	release_id: nonEmptyString,
+	presigned_url: z.string().url(),
+	r2_key: nonEmptyString,
+	expires_at: positiveInt
+});
+const releaseUploadCompleteRequestSchema = z.object({
+	release_id: releaseIdSchema,
+	size: z.number().int().nonnegative()
+});
+const releaseUploadCompleteResponseSchema = z.object({
+	success: z.literal(true),
+	release_id: nonEmptyString,
+	status: z.literal("completed")
+});
+const releaseUploadFailResponseSchema = z.object({
+	success: z.literal(true),
+	release_id: nonEmptyString,
+	status: z.literal("failed")
+});
+const releasesListQuerySchema = z.object({
+	limit: z.number().int().positive().max(100).optional(),
+	cursor: nonEmptyString.optional()
+});
+const releasesListResponseSchema = z.object({
+	items: z.array(releaseDTOSchema),
+	next_cursor: z.string().nullable()
+});
+const releaseUpdateRequestSchema = z.object({
+	name: releaseNameSchema.optional(),
+	tags: releaseTagsSchema.optional(),
+	notes: releaseNotesSchema,
+	force_update: z.boolean().optional()
+}).refine((body) => Object.values(body).some((value) => value !== void 0), { message: "At least one field must be provided" });
+const releaseDeleteResponseSchema = z.object({
+	success: z.literal(true),
+	release_id: nonEmptyString
+});
+const releaseSyncManifestSchema = z.object({
+	id: releaseIdSchema.optional(),
+	name: releaseNameSchema,
+	r2_key: releaseR2KeySchema,
+	size: z.number().int().nonnegative(),
+	tags: releaseTagsSchema.optional().default([]),
+	notes: releaseNotesSchema,
+	force_update: z.boolean().optional().default(false)
+});
+const releaseSyncRequestSchema = z.object({ releases: z.array(releaseSyncManifestSchema).min(1).max(100) });
+const releaseSyncResultSchema = z.object({
+	release_id: nonEmptyString,
+	success: z.boolean(),
+	status: uploadStatusSchema
+});
+const releaseSyncResponseSchema = z.object({
+	synced: z.number().int().nonnegative(),
+	results: z.array(releaseSyncResultSchema)
+});
+//#endregion
+//#region src/shareLinks.ts
+const shareLinkSchema = z.object({
+	id: nonEmptyString,
+	service_id: nonEmptyString,
+	file_id: nonEmptyString,
+	user_id: nonEmptyString,
+	slug: nonEmptyString,
+	name: z.string().nullable(),
+	has_password: z.boolean(),
+	expires_at: unixTimestamp.nullable(),
+	download_count: z.number().int().nonnegative(),
+	max_downloads: positiveInt.nullable(),
+	is_active: z.boolean(),
+	created_at: unixTimestamp,
+	updated_at: unixTimestamp
+});
+const shareLinkCreateRequestSchema = z.object({
+	slug: z.string().trim().min(3).max(64).optional(),
+	name: z.string().trim().max(128).optional(),
+	password: z.string().min(1).optional(),
+	expires_at: unixTimestamp.optional(),
+	max_downloads: positiveInt.optional()
+});
+const shareLinkUpdateRequestSchema = z.object({
+	name: z.string().trim().max(128).nullable().optional(),
+	is_active: z.boolean().optional(),
+	password: z.string().min(1).nullable().optional(),
+	expires_at: unixTimestamp.nullable().optional(),
+	max_downloads: positiveInt.nullable().optional()
+}).refine((v) => v.name !== void 0 || v.is_active !== void 0 || v.password !== void 0 || v.expires_at !== void 0 || v.max_downloads !== void 0, { message: "At least one field must be provided" });
+const shareLinkListResponseSchema = z.object({ items: z.array(shareLinkSchema) });
+const shareLinkCreateResponseSchema = z.object({ link: shareLinkSchema });
+const shareLinkUpdateResponseSchema = z.object({ link: shareLinkSchema });
+const publicFileAccessResponseSchema = z.object({
+	file_id: nonEmptyString,
+	filename: nonEmptyString,
+	size: positiveInt,
+	mime_type: nonEmptyString,
+	requires_password: z.literal(false),
+	download_url: z.string().url(),
+	url_expires_at: unixTimestamp,
+	link_name: z.string().nullable(),
+	link_expires_at: unixTimestamp.nullable()
+});
+const publicFileLockedResponseSchema = z.object({
+	filename: nonEmptyString,
+	size: positiveInt,
+	mime_type: nonEmptyString,
+	requires_password: z.literal(true),
+	link_name: z.string().nullable()
+});
+const shareLinkDeleteResponseSchema = z.object({
+	success: z.literal(true),
+	id: nonEmptyString
+});
+//#endregion
+//#region src/client.ts
+var UnisourceError = class extends Error {
+	constructor(message, status, body) {
+		super(message);
+		this.status = status;
+		this.body = body;
+		this.name = "UnisourceError";
+	}
+};
+var UnisourceNetworkError = class extends Error {
+	constructor(message, cause) {
+		super(message);
+		this.cause = cause;
+		this.name = "UnisourceNetworkError";
+	}
+};
+async function fetchApi(baseUrl, method, path, options = {}) {
+	const url = new URL(path, baseUrl);
+	if (options.query) {
+		for (const [key, value] of Object.entries(options.query)) if (value !== void 0 && value !== null) url.searchParams.set(key, String(value));
+	}
+	const headers = { ...options.authHeaders };
+	if (options.body !== void 0) headers["Content-Type"] = "application/json";
+	let response;
+	try {
+		response = await fetch(url.toString(), {
+			method,
+			headers,
+			body: options.body !== void 0 ? JSON.stringify(options.body) : void 0,
+			signal: options.signal
+		});
+	} catch (err) {
+		throw new UnisourceNetworkError("Network request failed", err);
+	}
+	if (!response.ok) {
+		let body;
+		try {
+			body = await response.json();
+		} catch {
+			body = {
+				error: "Unknown",
+				message: response.statusText
+			};
+		}
+		throw new UnisourceError(body.message, response.status, body);
+	}
+	return response.json();
+}
+async function apiRequest(config, method, path, options = {}) {
+	const token = await config.getToken();
+	const authHeaders = {
+		...options.extraHeaders ?? {},
+		"X-Service-ID": config.serviceId
+	};
+	if (token) authHeaders["Authorization"] = `Bearer ${token}`;
+	return fetchApi(config.baseUrl, method, path, {
+		...options,
+		authHeaders
+	});
+}
+async function getPublicFileInfo(baseUrl, slug, signal) {
+	return fetchApi(baseUrl, "GET", `/public/${encodeURIComponent(slug)}`, { signal });
+}
+async function unlockPublicFile(baseUrl, slug, password, signal) {
+	return fetchApi(baseUrl, "POST", `/public/${encodeURIComponent(slug)}/unlock`, {
+		body: { password },
+		signal
+	});
+}
+var UnisourceClient = class {
+	config;
+	constructor(config) {
+		this.config = config;
+	}
+	request(method, path, options = {}) {
+		return apiRequest(this.config, method, path, options);
+	}
+	withAsUser(options) {
+		return options?.asUser ? { "X-Target-User-ID": options.asUser } : {};
+	}
+	upload = {
+		r2Init: (body, signal) => apiRequest(this.config, "POST", "/upload/r2/init", {
+			body,
+			signal
+		}),
+		appwriteInit: (body, signal) => apiRequest(this.config, "POST", "/upload/appwrite/init", {
+			body,
+			signal
+		}),
+		complete: (body, signal) => apiRequest(this.config, "POST", "/upload/complete", {
+			body,
+			signal
+		}),
+		fail: (body, signal) => apiRequest(this.config, "POST", "/upload/fail", {
+			body,
+			signal
+		})
+	};
+	myFiles = {
+		list: (query, signal, options) => apiRequest(this.config, "GET", "/my-files", {
+			query,
+			signal,
+			extraHeaders: this.withAsUser(options)
+		}),
+		trash: (query, signal, options) => apiRequest(this.config, "GET", "/my-files/trash", {
+			query,
+			signal,
+			extraHeaders: this.withAsUser(options)
+		}),
+		get: (id, signal, options) => apiRequest(this.config, "GET", `/my-files/${id}`, {
+			signal,
+			extraHeaders: this.withAsUser(options)
+		}),
+		downloadUrl: (id, signal, options) => apiRequest(this.config, "GET", `/my-files/${id}/download-url`, {
+			signal,
+			extraHeaders: this.withAsUser(options)
+		}),
+		move: (id, body, signal, options) => apiRequest(this.config, "PATCH", `/my-files/${id}/move`, {
+			body,
+			signal,
+			extraHeaders: this.withAsUser(options)
+		}),
+		delete: (id, query, signal, options) => apiRequest(this.config, "DELETE", `/my-files/${id}`, {
+			query,
+			signal,
+			extraHeaders: this.withAsUser(options)
+		}),
+		restore: (id, signal, options) => apiRequest(this.config, "POST", `/my-files/${id}/restore`, {
+			signal,
+			extraHeaders: this.withAsUser(options)
+		}),
+		update: (id, body, signal, options) => apiRequest(this.config, "PATCH", `/my-files/${id}`, {
+			body,
+			signal,
+			extraHeaders: this.withAsUser(options)
+		})
+	};
+	folders = {
+		list: (query, signal, options) => apiRequest(this.config, "GET", "/folders", {
+			query,
+			signal,
+			extraHeaders: this.withAsUser(options)
+		}),
+		get: (id, signal, options) => apiRequest(this.config, "GET", `/folders/${id}`, {
+			signal,
+			extraHeaders: this.withAsUser(options)
+		}),
+		create: (body, signal, options) => apiRequest(this.config, "POST", "/folders", {
+			body,
+			signal,
+			extraHeaders: this.withAsUser(options)
+		}),
+		update: (id, body, signal, options) => apiRequest(this.config, "PATCH", `/folders/${id}`, {
+			body,
+			signal,
+			extraHeaders: this.withAsUser(options)
+		}),
+		delete: (id, query, signal, options) => apiRequest(this.config, "DELETE", `/folders/${id}`, {
+			query,
+			signal,
+			extraHeaders: this.withAsUser(options)
+		}),
+		restore: (id, signal, options) => apiRequest(this.config, "POST", `/folders/${id}/restore`, {
+			signal,
+			extraHeaders: this.withAsUser(options)
+		})
+	};
+	mainStorage = {
+		list: (query) => this.request("GET", "/main", { query }),
+		get: (fileId) => this.request("GET", `/main/${fileId}`),
+		rename: (fileId, filename) => this.request("PATCH", `/main/${fileId}`, { body: { filename } }),
+		delete: (fileId, permanent = false) => this.request("DELETE", `/main/${fileId}${permanent ? "?permanent=true" : ""}`),
+		restore: (fileId) => this.request("POST", `/main/${fileId}/restore`),
+		upload: {
+			r2Init: (input) => this.request("POST", "/upload/r2/init", { body: {
+				...input,
+				is_main_storage: true
+			} }),
+			appwriteInit: (input) => this.request("POST", "/upload/appwrite/init", { body: {
+				...input,
+				is_main_storage: true
+			} }),
+			complete: (uploadId) => this.request("POST", "/upload/complete", { body: {
+				upload_id: uploadId,
+				is_main_storage: true
+			} }),
+			fail: (uploadId) => this.request("POST", "/upload/fail", { body: { upload_id: uploadId } })
+		}
+	};
+	releases = {
+		upload: {
+			init: (body, signal) => apiRequest(this.config, "POST", "/releases/upload/init", {
+				body,
+				signal
+			}),
+			complete: (body, signal) => apiRequest(this.config, "POST", "/releases/upload/complete", {
+				body,
+				signal
+			}),
+			fail: (releaseId, signal) => apiRequest(this.config, "POST", "/releases/upload/fail", {
+				body: { release_id: releaseId },
+				signal
+			})
+		},
+		list: (query, signal) => apiRequest(this.config, "GET", "/releases", {
+			query,
+			signal
+		}),
+		get: (releaseId, signal) => apiRequest(this.config, "GET", `/releases/${releaseId}`, { signal }),
+		latest: (signal) => apiRequest(this.config, "GET", "/releases/latest", { signal }),
+		update: (releaseId, body, signal) => apiRequest(this.config, "PATCH", `/releases/${releaseId}`, {
+			body,
+			signal
+		}),
+		delete: (releaseId, signal) => apiRequest(this.config, "DELETE", `/releases/${releaseId}`, { signal }),
+		sync: (body, signal) => apiRequest(this.config, "POST", "/releases/sync", {
+			body,
+			signal
+		})
+	};
+	admin = {
+		serviceDetail: (signal) => apiRequest(this.config, "GET", "/admin/service", { signal }),
+		updateService: (body, signal) => apiRequest(this.config, "PATCH", "/admin/service", {
+			body,
+			signal
+		}),
+		usage: (signal) => apiRequest(this.config, "GET", "/admin/service/usage", { signal }),
+		listUploads: (query, signal) => apiRequest(this.config, "GET", "/files", {
+			query,
+			signal
+		}),
+		getUpload: (id, signal) => apiRequest(this.config, "GET", `/files/${id}`, { signal }),
+		downloadUploadUrl: (id, signal) => apiRequest(this.config, "GET", `/files/${id}/download-url`, { signal }),
+		deleteUpload: (id, signal) => apiRequest(this.config, "DELETE", `/files/${id}`, { signal }),
+		auditLog: (query, signal) => apiRequest(this.config, "GET", "/admin/audit-log", {
+			query,
+			signal
+		}),
+		listUsers: (query, signal) => apiRequest(this.config, "GET", "/admin/users", {
+			query,
+			signal
+		}),
+		updateUser: (userId, body, signal) => apiRequest(this.config, "PATCH", `/admin/users/${userId}`, {
+			body,
+			signal
+		}),
+		resetUserPassword: (userId, body, signal) => apiRequest(this.config, "POST", `/admin/users/${userId}/password`, {
+			body,
+			signal
+		})
+	};
+	shareLinks = {
+		create: (fileId, body, signal) => apiRequest(this.config, "POST", `/my-files/${fileId}/share-links`, {
+			body,
+			signal
+		}),
+		list: (fileId, signal) => apiRequest(this.config, "GET", `/my-files/${fileId}/share-links`, { signal }),
+		update: (linkId, body, signal) => apiRequest(this.config, "PATCH", `/share-links/${linkId}`, {
+			body,
+			signal
+		}),
+		delete: (linkId, signal) => apiRequest(this.config, "DELETE", `/share-links/${linkId}`, { signal })
+	};
+};
 //#endregion
-export { FILES_DEFAULT_LIMIT, FILES_MAX_LIMIT, apiErrorSchema, fileDeleteResponseSchema, fileDetailsResponseSchema, fileDownloadUrlResponseSchema, fileRecordSchema, filesListQuerySchema, filesListResponseSchema, uploadAppwriteInitRequestSchema, uploadAppwriteInitResponseSchema, uploadCompleteResponseSchema, uploadDestinationSchema, uploadFailResponseSchema, uploadLifecycleRequestSchema, uploadR2InitRequestSchema, uploadR2InitResponseSchema, uploadStatusSchema };
+export { FILES_DEFAULT_LIMIT, FILES_MAX_LIMIT, UnisourceClient, UnisourceError, UnisourceNetworkError, adminServiceUpdateRequestSchema, adminServiceUpdateResponseSchema, adminUserListResponseSchema, adminUserPasswordResetRequestSchema, adminUserPasswordResetResponseSchema, adminUserSchema, adminUserUpdateRequestSchema, adminUserUpdateResponseSchema, apiErrorSchema, auditEventActionSchema, auditEventSchema, auditLogListQuerySchema, auditLogListResponseSchema, fileDeleteResponseSchema, fileDownloadUrlResponseSchema, fileMoveRequestSchema, fileRecordDetailResponseSchema, fileRecordSchema, fileRecordsListQuerySchema, fileRecordsListResponseSchema, fileRestoreResponseSchema, fileUpdateRequestSchema, fileUpdateResponseSchema, folderCreateRequestSchema, folderCreateResponseSchema, folderDeleteResponseSchema, folderDetailResponseSchema, folderListQuerySchema, folderListResponseSchema, folderRestoreResponseSchema, folderSchema, folderUpdateRequestSchema, folderUpdateResponseSchema, getPublicFileInfo, mainStorageDeleteResponseSchema, mainStorageListQuerySchema, mainStorageListResponseSchema, mainStorageRenameRequestSchema, mainStorageRestoreResponseSchema, nonEmptyString, positiveInt, publicFileAccessResponseSchema, publicFileLockedResponseSchema, releaseDTOSchema, releaseDeleteResponseSchema, releaseSyncManifestSchema, releaseSyncRequestSchema, releaseSyncResponseSchema, releaseSyncResultSchema, releaseUpdateRequestSchema, releaseUploadCompleteRequestSchema, releaseUploadCompleteResponseSchema, releaseUploadFailResponseSchema, releaseUploadInitRequestSchema, releaseUploadInitResponseSchema, releasesListQuerySchema, releasesListResponseSchema, serviceDetailResponseSchema, serviceSchema, serviceUsageResponseSchema, shareLinkCreateRequestSchema, shareLinkCreateResponseSchema, shareLinkDeleteResponseSchema, shareLinkListResponseSchema, shareLinkSchema, shareLinkUpdateRequestSchema, shareLinkUpdateResponseSchema, unixTimestamp, unlockPublicFile, uploadAppwriteInitRequestSchema, uploadAppwriteInitResponseSchema, uploadCompleteResponseSchema, uploadDestinationSchema, uploadFailResponseSchema, uploadLifecycleRequestSchema, uploadR2InitRequestSchema, uploadR2InitResponseSchema, uploadRecordDetailResponseSchema, uploadRecordSchema, uploadStatusSchema, uploadsListResponseSchema };