@zudello/modelcontextprotocol 1.0.0

package/dist/services/zudello/documents.js

@@ -0,0 +1,865 @@
+/**
+ * Zudello Document Services
+ *
+ * Document Status, Export Template, and Document Type CRUD operations.
+ * Extracted from zudello.ts for modularity.
+ */
+import { logger } from "../../utils/logger.js";
+import { buildZudelloRequest } from "./core.js";
+// ============================================================================
+// Document Status Services
+// ============================================================================
+/**
+ * List document statuses with optional filtering
+ */
+export async function listZudelloStatuses(authContext, module, submodule, includePaths) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            resource_type: "document_status",
+        });
+        if (module)
+            params.append("module", module);
+        if (submodule)
+            params.append("submodule", submodule);
+        if (includePaths && includePaths.length > 0) {
+            params.append("include_paths", JSON.stringify(includePaths));
+        }
+        const url = `${apiBase}/general-store/api/v1/resources/?${params.toString()}`;
+        logger.info("Zudello list statuses request", {
+            url,
+            queryParams: Object.fromEntries(params.entries()),
+            module,
+            submodule,
+        });
+        const response = await fetch(url, { method: "GET", headers });
+        if (!response.ok) {
+            throw new Error(`Zudello API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello list statuses response received", {
+            httpStatus: response.status,
+            success: data.success,
+            resultCount: Array.isArray(data.data) ? data.data.length : 0,
+        });
+        return { success: true, data: data.data || [] };
+    }
+    catch (error) {
+        logger.error("Zudello list statuses error", { module, submodule }, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Get a single document status by UUID
+ */
+export async function getZudelloStatus(authContext, statusUuid) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            resource_type: "document_status",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/${statusUuid}?${params.toString()}`;
+        logger.info("Zudello get status request", { url, statusUuid });
+        const response = await fetch(url, { method: "GET", headers });
+        if (!response.ok) {
+            if (response.status === 404) {
+                return { success: false, error: `Status not found: ${statusUuid}` };
+            }
+            throw new Error(`Zudello API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello get status response received", {
+            httpStatus: response.status,
+            success: data.success,
+            hasData: !!data.data,
+        });
+        if (!data.success || !data.data) {
+            return { success: false, error: `Status not found with UUID: ${statusUuid}` };
+        }
+        return { success: true, data: data.data };
+    }
+    catch (error) {
+        logger.error("Zudello get status error", { statusUuid }, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Create a new document status
+ */
+export async function createZudelloStatus(authContext, payload, context) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            resource_type: "document_status",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/?${params.toString()}`;
+        const body = {
+            payload,
+            context,
+        };
+        logger.info("Zudello create status request", {
+            url,
+            key: payload.key,
+            name: payload.name,
+            type: payload.type,
+            context,
+        });
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello create status response received", {
+            httpStatus: response.status,
+            success: data.success,
+            uuid: data.data?.uuid,
+        });
+        if (!data.success) {
+            return { success: false, error: data.message || "Failed to create status" };
+        }
+        return { success: true, data: data.data };
+    }
+    catch (error) {
+        logger.error("Zudello create status error", { key: payload.key }, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Update an existing document status
+ */
+export async function updateZudelloStatus(authContext, statusUuid, payload, context) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            resource_type: "document_status",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/${statusUuid}?${params.toString()}`;
+        const body = {
+            payload,
+            context,
+        };
+        logger.info("Zudello update status request", {
+            url,
+            statusUuid,
+            key: payload.key,
+            name: payload.name,
+        });
+        const response = await fetch(url, {
+            method: "PUT",
+            headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello update status response received", {
+            httpStatus: response.status,
+            success: data.success,
+            version: data.data?.version,
+        });
+        if (!data.success) {
+            return { success: false, error: data.message || "Failed to update status" };
+        }
+        return { success: true, data: data.data };
+    }
+    catch (error) {
+        logger.error("Zudello update status error", { statusUuid }, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Reorder document statuses
+ * Takes an array of {uuid, order} objects to set the display order
+ */
+export async function reorderZudelloStatuses(authContext, statusOrders) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            resource_type: "document_status",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/order?${params.toString()}`;
+        logger.info("Zudello reorder statuses request", {
+            url,
+            statusCount: statusOrders.length,
+        });
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(statusOrders),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json().catch(() => ({ success: true }));
+        logger.info("Zudello reorder statuses response received", {
+            httpStatus: response.status,
+            success: data.success,
+        });
+        return { success: true, data: { success: true } };
+    }
+    catch (error) {
+        logger.error("Zudello reorder statuses error", {}, error);
+        return { success: false, error: error.message };
+    }
+}
+// ============================================================================
+// Export Template Services
+// ============================================================================
+/**
+ * List export templates
+ */
+export async function listZudelloExportTemplates(authContext) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            resource_type: "export_template",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/?${params.toString()}`;
+        logger.info("Zudello list export templates request", { url });
+        const response = await fetch(url, { method: "GET", headers });
+        if (!response.ok) {
+            throw new Error(`Zudello API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello list export templates response received", {
+            httpStatus: response.status,
+            success: data.success,
+            resultCount: Array.isArray(data.data) ? data.data.length : 0,
+        });
+        return { success: true, data: data.data || [] };
+    }
+    catch (error) {
+        logger.error("Zudello list export templates error", {}, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Get a single export template by UUID
+ */
+export async function getZudelloExportTemplate(authContext, templateUuid) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            resource_type: "export_template",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/${templateUuid}?${params.toString()}`;
+        logger.info("Zudello get export template request", { url, templateUuid });
+        const response = await fetch(url, { method: "GET", headers });
+        if (!response.ok) {
+            if (response.status === 404) {
+                return { success: false, error: `Export template not found: ${templateUuid}` };
+            }
+            throw new Error(`Zudello API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello get export template response received", {
+            httpStatus: response.status,
+            success: data.success,
+            hasData: !!data.data,
+        });
+        if (!data.success || !data.data) {
+            return { success: false, error: `Export template not found with UUID: ${templateUuid}` };
+        }
+        return { success: true, data: data.data };
+    }
+    catch (error) {
+        logger.error("Zudello get export template error", { templateUuid }, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Create a new export template
+ */
+export async function createZudelloExportTemplate(authContext, payload) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            resource_type: "export_template",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/?${params.toString()}`;
+        const body = { payload };
+        logger.info("Zudello create export template request", {
+            url,
+            name: payload.name,
+            module: payload.module,
+            submodule: payload.submodule,
+        });
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello create export template response received", {
+            httpStatus: response.status,
+            success: data.success,
+            uuid: data.data?.uuid,
+        });
+        if (!data.success) {
+            return { success: false, error: data.message || "Failed to create export template" };
+        }
+        return { success: true, data: data.data };
+    }
+    catch (error) {
+        logger.error("Zudello create export template error", { name: payload.name }, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Update an existing export template
+ */
+export async function updateZudelloExportTemplate(authContext, templateUuid, payload) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            resource_type: "export_template",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/${templateUuid}?${params.toString()}`;
+        const body = { payload };
+        logger.info("Zudello update export template request", {
+            url,
+            templateUuid,
+            name: payload.name,
+        });
+        const response = await fetch(url, {
+            method: "PUT",
+            headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello update export template response received", {
+            httpStatus: response.status,
+            success: data.success,
+            version: data.data?.version,
+        });
+        if (!data.success) {
+            return { success: false, error: data.message || "Failed to update export template" };
+        }
+        return { success: true, data: data.data };
+    }
+    catch (error) {
+        logger.error("Zudello update export template error", { templateUuid }, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Run an export using a template
+ */
+export async function runZudelloExport(authContext, templateName, userUuid, exportRequest) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            user_uuid: userUuid,
+            template_name: templateName,
+        });
+        const url = `${apiBase}/team-data/v1/export/csv?${params.toString()}`;
+        logger.info("Zudello run export request", {
+            url,
+            templateName,
+            userUuid,
+            model: exportRequest.model,
+        });
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(exportRequest),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
+        }
+        logger.info("Zudello run export response received", {
+            httpStatus: response.status,
+        });
+        return { success: true, data: { success: true } };
+    }
+    catch (error) {
+        logger.error("Zudello run export error", { templateName }, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * List exports that have been run
+ */
+export async function listZudelloExports(authContext, limit = 30, offset = 0) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            ignore_count: "false",
+            paginate: "true",
+        });
+        const url = `${apiBase}/team-data/v1/resources/search?${params.toString()}`;
+        const body = {
+            model: "DataExport",
+            select: [
+                "uuid",
+                "created_by__uuid",
+                "created_at",
+                "status",
+                "s3_location",
+                "download_count",
+                "template_name",
+            ],
+            order_by: ["-created_at"],
+            filter: {},
+            offset,
+            limit,
+        };
+        logger.info("Zudello list exports request", { url, limit, offset });
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            throw new Error(`Zudello API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello list exports response received", {
+            httpStatus: response.status,
+            count: data.count,
+            totalCount: data.total_count,
+        });
+        return { success: true, data: data.data || [] };
+    }
+    catch (error) {
+        logger.error("Zudello list exports error", {}, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Get export download URL (presigned S3 URL)
+ */
+export async function getZudelloExportDownloadUrl(authContext, exportUuid) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const url = `${apiBase}/team-data/v1/export/download/${exportUuid}`;
+        logger.info("Zudello get export download URL request", { url, exportUuid });
+        // Use redirect: 'manual' to capture the redirect location
+        const response = await fetch(url, {
+            method: "GET",
+            headers,
+            redirect: "manual",
+        });
+        // API returns 301/302 redirect with location header containing S3 presigned URL
+        if (response.status === 301 || response.status === 302) {
+            const downloadUrl = response.headers.get("location");
+            if (downloadUrl) {
+                logger.info("Zudello get export download URL success", {
+                    httpStatus: response.status,
+                    hasDownloadUrl: true,
+                });
+                return { success: true, data: { downloadUrl } };
+            }
+        }
+        // If not a redirect, try to get URL from response body
+        if (response.ok) {
+            const data = await response.json();
+            if (data.download_url || data.downloadUrl || data.url) {
+                const downloadUrl = data.download_url || data.downloadUrl || data.url;
+                return { success: true, data: { downloadUrl } };
+            }
+        }
+        throw new Error(`Failed to get download URL: ${response.status}`);
+    }
+    catch (error) {
+        logger.error("Zudello get export download URL error", { exportUuid }, error);
+        return { success: false, error: error.message };
+    }
+}
+// ============================================================================
+// Document Type Services
+// ============================================================================
+/**
+ * List document types with optional filtering
+ */
+export async function listZudelloDocumentTypes(authContext, module, submodule, includePaths, globalResource = false) {
+    try {
+        const { headers, apiBase, teamId } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            resource_type: "document_type",
+            global_resource: String(globalResource),
+            team_uuid: teamId,
+        });
+        if (module)
+            params.append("module", module);
+        if (submodule)
+            params.append("submodule", submodule);
+        if (includePaths && includePaths.length > 0) {
+            params.append("include_paths", JSON.stringify(includePaths));
+        }
+        const url = `${apiBase}/general-store/api/v1/resources/?${params.toString()}`;
+        logger.info("Zudello list document types request", {
+            url,
+            queryParams: Object.fromEntries(params.entries()),
+            module,
+            submodule,
+        });
+        const response = await fetch(url, { method: "GET", headers });
+        if (!response.ok) {
+            throw new Error(`Zudello API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello list document types response received", {
+            httpStatus: response.status,
+            success: data.success,
+            resultCount: Array.isArray(data.data) ? data.data.length : 0,
+        });
+        return { success: true, data: data.data || [] };
+    }
+    catch (error) {
+        logger.error("Zudello list document types error", { module, submodule }, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Get a single document type by UUID
+ */
+export async function getZudelloDocumentType(authContext, documentTypeUuid) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            resource_type: "document_type",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/${documentTypeUuid}?${params.toString()}`;
+        logger.info("Zudello get document type request", { url, documentTypeUuid });
+        const response = await fetch(url, { method: "GET", headers });
+        if (!response.ok) {
+            if (response.status === 404) {
+                return { success: false, error: `Document type not found: ${documentTypeUuid}` };
+            }
+            throw new Error(`Zudello API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello get document type response received", {
+            httpStatus: response.status,
+            success: data.success,
+            hasData: !!data.data,
+        });
+        if (!data.success || !data.data) {
+            return { success: false, error: `Document type not found with UUID: ${documentTypeUuid}` };
+        }
+        return { success: true, data: data.data };
+    }
+    catch (error) {
+        logger.error("Zudello get document type error", { documentTypeUuid }, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Get merged form metadata (rendered view for end users)
+ * This returns the document type with all field metadata merged from field settings
+ */
+export async function getZudelloMergedFormMetadata(authContext, module, submodule, documentType, globalResource = false) {
+    try {
+        const { headers, apiBase, teamId } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            module,
+            submodule,
+            document_type: documentType,
+            team_uuid: teamId,
+            global_resource: String(globalResource),
+        });
+        const url = `${apiBase}/general-store/api/v1/metadata/merge-form-metadata?${params.toString()}`;
+        logger.info("Zudello get merged form metadata request", {
+            url,
+            module,
+            submodule,
+            documentType,
+        });
+        const response = await fetch(url, { method: "GET", headers });
+        if (!response.ok) {
+            if (response.status === 404) {
+                return { success: false, error: `Document type not found: ${module}/${submodule}/${documentType}` };
+            }
+            throw new Error(`Zudello API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello get merged form metadata response received", {
+            httpStatus: response.status,
+            success: data.success,
+            hasData: !!data.data,
+        });
+        if (!data.success || !data.data) {
+            return { success: false, error: `Document type not found: ${module}/${submodule}/${documentType}` };
+        }
+        return { success: true, data: data.data };
+    }
+    catch (error) {
+        logger.error("Zudello get merged form metadata error", { module, submodule, documentType }, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Create a new document type
+ */
+export async function createZudelloDocumentType(authContext, payload, context) {
+    try {
+        const { headers, apiBase, teamId } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            resource_type: "document_type",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/?${params.toString()}`;
+        const body = {
+            payload,
+            context,
+            team_uuid: teamId,
+        };
+        logger.info("Zudello create document type request", {
+            url,
+            display: payload.display,
+            type: payload.type,
+            module: payload.module,
+            submodule: payload.submodule,
+            context,
+        });
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello create document type response received", {
+            httpStatus: response.status,
+            success: data.success,
+            uuid: data.data?.uuid,
+        });
+        if (!data.success) {
+            return { success: false, error: data.message || "Failed to create document type" };
+        }
+        return { success: true, data: data.data };
+    }
+    catch (error) {
+        logger.error("Zudello create document type error", { display: payload.display }, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Update an existing document type
+ */
+export async function updateZudelloDocumentType(authContext, documentTypeUuid, payload, context) {
+    try {
+        const { headers, apiBase, teamId } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            resource_type: "document_type",
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/${documentTypeUuid}?${params.toString()}`;
+        const body = {
+            payload,
+            context,
+            team_uuid: teamId,
+            uuid: documentTypeUuid,
+        };
+        logger.info("Zudello update document type request", {
+            url,
+            documentTypeUuid,
+            display: payload.display,
+            type: payload.type,
+        });
+        const response = await fetch(url, {
+            method: "PUT",
+            headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        logger.info("Zudello update document type response received", {
+            httpStatus: response.status,
+            success: data.success,
+            version: data.data?.version,
+        });
+        if (!data.success) {
+            return { success: false, error: data.message || "Failed to update document type" };
+        }
+        return { success: true, data: data.data };
+    }
+    catch (error) {
+        logger.error("Zudello update document type error", { documentTypeUuid }, error);
+        return { success: false, error: error.message };
+    }
+}
+// ============================================================================
+// Configuration Services
+// ============================================================================
+/**
+ * Get a specific configuration by UUID
+ */
+export async function getZudelloConfig(authContext, configUuid, globalConfig = false, returnDeleted = false) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams();
+        if (globalConfig)
+            params.append("global_config", "true");
+        if (returnDeleted)
+            params.append("return_deleted", "true");
+        const url = `${apiBase}/general-store/api/v1/resources/${configUuid}?${params.toString()}`;
+        logger.info("Zudello get config request", { url, configUuid });
+        const response = await fetch(url, { method: "GET", headers });
+        if (!response.ok) {
+            if (response.status === 404) {
+                return { success: false, error: `Config not found: ${configUuid}` };
+            }
+            throw new Error(`Zudello API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        if (!data.success || !data.data) {
+            return { success: false, error: `Config not found with UUID: ${configUuid}` };
+        }
+        return { success: true, data: data.data };
+    }
+    catch (error) {
+        logger.error("Zudello get config error", { configUuid }, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * List configurations by type
+ */
+export async function listZudelloConfigs(authContext, configType, globalConfig = false, module, submodule) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            resource_type: configType,
+        });
+        if (globalConfig)
+            params.append("global_config", "true");
+        if (module)
+            params.append("module", module);
+        if (submodule)
+            params.append("submodule", submodule);
+        const url = `${apiBase}/general-store/api/v1/resources/?${params.toString()}`;
+        logger.info("Zudello list configs request", { url, configType });
+        const response = await fetch(url, { method: "GET", headers });
+        if (!response.ok) {
+            throw new Error(`Zudello API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        const configs = Array.isArray(data.data) ? data.data : (data.data ? [data.data] : []);
+        return { success: true, data: configs };
+    }
+    catch (error) {
+        logger.error("Zudello list configs error", { configType }, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Create a new configuration
+ */
+export async function createZudelloConfig(authContext, configType, payload, configContext) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            resource_type: configType,
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/?${params.toString()}`;
+        const body = {
+            payload,
+            context: configContext,
+        };
+        logger.info("Zudello create config request", { url, configType });
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        if (!data.success || !data.data) {
+            return { success: false, error: `Failed to create config of type: ${configType}` };
+        }
+        return { success: true, data: data.data };
+    }
+    catch (error) {
+        logger.error("Zudello create config error", { configType }, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Update an existing configuration
+ */
+export async function updateZudelloConfig(authContext, configUuid, configType, payload, configContext) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            resource_type: configType,
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/${configUuid}?${params.toString()}`;
+        const body = {
+            payload,
+            context: configContext,
+        };
+        logger.info("Zudello update config request", { url, configUuid });
+        const response = await fetch(url, {
+            method: "PUT",
+            headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        if (!data.success || !data.data) {
+            return { success: false, error: `Failed to update config: ${configUuid}` };
+        }
+        return { success: true, data: data.data };
+    }
+    catch (error) {
+        logger.error("Zudello update config error", { configUuid }, error);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Update the display order of configurations
+ */
+export async function updateZudelloConfigsOrder(authContext, configType, uuids) {
+    try {
+        const { headers, apiBase } = await buildZudelloRequest(authContext);
+        const params = new URLSearchParams({
+            resource_type: configType,
+        });
+        const url = `${apiBase}/general-store/api/v1/resources/order?${params.toString()}`;
+        logger.info("Zudello update configs order request", { url, configType, count: uuids.length });
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(uuids),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Zudello API error: ${response.status} - ${errorText}`);
+        }
+        return { success: true, data: { success: true } };
+    }
+    catch (error) {
+        logger.error("Zudello update configs order error", { configType }, error);
+        return { success: false, error: error.message };
+    }
+}
+//# sourceMappingURL=documents.js.map