@unisource/sdk 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -3,6 +3,8 @@ import { z } from "zod";
 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 uploadDestinationSchema = z.enum(["r2", "appwrite"]);
 const uploadStatusSchema = z.enum([
 	"pending",
@@ -18,7 +20,9 @@ const apiErrorSchema = z.object({
 const uploadR2InitRequestSchema = z.object({
 	filename: nonEmptyString,
 	size: positiveInt,
-	mime_type: nonEmptyString
+	mime_type: nonEmptyString,
+	folder_id: nonEmptyString.optional(),
+	is_main_storage: z.boolean().optional().default(false)
 });
 const uploadR2InitResponseSchema = z.object({
 	upload_id: nonEmptyString,
@@ -31,7 +35,9 @@ const uploadR2InitResponseSchema = z.object({
 const uploadAppwriteInitRequestSchema = z.object({
 	filename: nonEmptyString,
 	size: positiveInt,
-	mime_type: nonEmptyString
+	mime_type: nonEmptyString,
+	folder_id: nonEmptyString.optional(),
+	is_main_storage: z.boolean().optional().default(false)
 });
 const uploadAppwriteInitResponseSchema = z.object({
 	upload_id: nonEmptyString,
@@ -42,7 +48,10 @@ const uploadAppwriteInitResponseSchema = z.object({
 	file_id: nonEmptyString,
 	expires_at: positiveInt
 });
-const uploadLifecycleRequestSchema = z.object({ upload_id: nonEmptyString });
+const uploadLifecycleRequestSchema = z.object({
+	upload_id: nonEmptyString,
+	is_main_storage: z.boolean().optional().default(false)
+});
 const uploadCompleteResponseSchema = z.object({
 	success: z.literal(true),
 	upload_id: nonEmptyString,
@@ -53,8 +62,6 @@ const uploadFailResponseSchema = z.object({
 	upload_id: nonEmptyString,
 	status: z.literal("failed")
 });
-const FILES_DEFAULT_LIMIT = 25;
-const FILES_MAX_LIMIT = 100;
 /** Raw upload record — returned by admin `/files` endpoints. */
 const uploadRecordSchema = z.object({
 	id: nonEmptyString,
@@ -64,11 +71,7 @@ const uploadRecordSchema = z.object({
 	size: positiveInt,
 	mime_type: nonEmptyString,
 	destination: uploadDestinationSchema,
-	status: z.enum([
-		"pending",
-		"completed",
-		"failed"
-	]),
+	status: uploadStatusSchema,
 	expires_at: positiveInt,
 	created_at: positiveInt,
 	updated_at: positiveInt
@@ -78,6 +81,7 @@ const uploadsListResponseSchema = z.object({
 	next_cursor: z.string().nullable(),
 	limit: positiveInt
 });
+const uploadRecordDetailResponseSchema = z.object({ upload: uploadRecordSchema });
 //#endregion
 //#region src/fileRecords.ts
 /**
@@ -127,6 +131,8 @@ 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({
@@ -143,10 +149,11 @@ const folderSchema = z.object({
 });
 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(),
@@ -169,6 +176,7 @@ const folderDeleteResponseSchema = z.object({
 	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
@@ -185,6 +193,11 @@ const serviceSchema = z.object({
 	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,
@@ -195,7 +208,9 @@ const auditEventActionSchema = z.enum([
 	"upload_completed",
 	"file_deleted",
 	"folder_deleted",
-	"quota_exceeded"
+	"quota_exceeded",
+	"share_link_accessed",
+	"quota_reconciled"
 ]);
 const auditEventSchema = z.object({
 	id: nonEmptyString,
@@ -228,6 +243,204 @@ const auditLogListResponseSchema = z.object({
 	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 {
@@ -245,21 +458,20 @@ var UnisourceNetworkError = class extends Error {
 		this.name = "UnisourceNetworkError";
 	}
 };
-async function apiRequest(config, method, path, options = {}) {
-	const token = await config.getToken();
-	const url = new URL(path, config.baseUrl);
+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 = { "X-Service-ID": config.serviceId };
-	if (token) headers["Authorization"] = `Bearer ${token}`;
+	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
+			body: options.body !== void 0 ? JSON.stringify(options.body) : void 0,
+			signal: options.signal
 		});
 	} catch (err) {
 		throw new UnisourceNetworkError("Network request failed", err);
@@ -278,38 +490,221 @@ async function apiRequest(config, method, path, options = {}) {
 	}
 	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) => apiRequest(this.config, "POST", "/upload/r2/init", { body }),
-		appwriteInit: (body) => apiRequest(this.config, "POST", "/upload/appwrite/init", { body }),
-		complete: (body) => apiRequest(this.config, "POST", "/upload/complete", { body }),
-		fail: (body) => apiRequest(this.config, "POST", "/upload/fail", { body })
+		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) => apiRequest(this.config, "GET", "/my-files", { query }),
-		get: (id) => apiRequest(this.config, "GET", `/my-files/${id}`),
-		downloadUrl: (id) => apiRequest(this.config, "GET", `/my-files/${id}/download-url`),
-		move: (id, body) => apiRequest(this.config, "PATCH", `/my-files/${id}/move`, { body }),
-		delete: (id, query) => apiRequest(this.config, "DELETE", `/my-files/${id}`, { query }),
-		restore: (id) => apiRequest(this.config, "POST", `/my-files/${id}/restore`)
+		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) => apiRequest(this.config, "GET", "/folders", { query }),
-		create: (body) => apiRequest(this.config, "POST", "/folders", { body }),
-		update: (id, body) => apiRequest(this.config, "PATCH", `/folders/${id}`, { body }),
-		delete: (id, query) => apiRequest(this.config, "DELETE", `/folders/${id}`, { query }),
-		restore: (id) => apiRequest(this.config, "POST", `/folders/${id}/restore`)
+		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: () => apiRequest(this.config, "GET", "/admin/service"),
-		usage: () => apiRequest(this.config, "GET", "/admin/service/usage"),
-		listUploads: (query) => apiRequest(this.config, "GET", "/files", { query }),
-		auditLog: (query) => apiRequest(this.config, "GET", "/admin/audit-log", { query })
+		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, UnisourceClient, UnisourceError, UnisourceNetworkError, apiErrorSchema, auditEventActionSchema, auditEventSchema, auditLogListQuerySchema, auditLogListResponseSchema, fileDeleteResponseSchema, fileDownloadUrlResponseSchema, fileMoveRequestSchema, fileRecordDetailResponseSchema, fileRecordSchema, fileRecordsListQuerySchema, fileRecordsListResponseSchema, fileRestoreResponseSchema, folderCreateRequestSchema, folderCreateResponseSchema, folderDeleteResponseSchema, folderListQuerySchema, folderListResponseSchema, folderRestoreResponseSchema, folderSchema, folderUpdateRequestSchema, folderUpdateResponseSchema, nonEmptyString, positiveInt, serviceDetailResponseSchema, serviceSchema, serviceUsageResponseSchema, unixTimestamp, uploadAppwriteInitRequestSchema, uploadAppwriteInitResponseSchema, uploadCompleteResponseSchema, uploadDestinationSchema, uploadFailResponseSchema, uploadLifecycleRequestSchema, uploadR2InitRequestSchema, uploadR2InitResponseSchema, uploadRecordSchema, uploadStatusSchema, uploadsListResponseSchema };
+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 };

package/package.json

@@ -2,17 +2,21 @@
   "name": "@unisource/sdk",
   "private": false,
   "type": "module",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Wspolne kontrakty danych dla backendu i frontendu UniSource.",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
   "exports": {
-    ".": "./dist/index.mjs",
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
     "./package.json": "./package.json"
   },
-  "types": "./src/index.ts",
+  "types": "./dist/index.d.mts",
   "files": [
     "dist",
     "src"
@@ -28,7 +32,7 @@
     "zod": "^4.3.6"
   },
   "scripts": {
-    "build": "tsdown && node -e \"const fs=require('node:fs'); if (fs.existsSync('dist/index.d.mts')) fs.copyFileSync('dist/index.d.mts','dist/index.d.ts');\"",
+    "build": "tsdown",
     "dev": "tsdown --watch",
     "test": "pnpm run build && vitest",
     "typecheck": "tsc --noEmit"