@klardaten/n8n-nodes-datevconnect 1.0.2 → 1.0.3

package/dist/nodes/DocumentManagement/handlers/BaseResourceHandler.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const utils_1 = require("../utils");
+/**
+ * Abstract base class for resource handlers
+ * Provides common functionality for authentication, parameter parsing, and response handling
+ */
+class BaseResourceHandler {
+    constructor(context, itemIndex) {
+        this.context = context;
+        this.itemIndex = itemIndex;
+    }
+    /**
+     * Main execution method that handles operation routing and error handling
+     */
+    async execute(operation, authContext, returnData) {
+        try {
+            const sendSuccess = (payload) => {
+                const data = payload ? (0, utils_1.normaliseToObjects)(payload) : [{}];
+                data.forEach((item) => {
+                    returnData.push({
+                        json: {
+                            success: true,
+                            ...item,
+                        },
+                    });
+                });
+            };
+            await this.executeOperation(operation, authContext, sendSuccess);
+        }
+        catch (error) {
+            const continueOnFail = this.context.continueOnFail();
+            if (continueOnFail) {
+                returnData.push({
+                    json: {
+                        error: (0, utils_1.toErrorMessage)(error),
+                    },
+                });
+            }
+            else {
+                if (error instanceof n8n_workflow_1.NodeApiError || error instanceof n8n_workflow_1.NodeOperationError) {
+                    throw error;
+                }
+                throw new n8n_workflow_1.NodeApiError(this.context.getNode(), (0, utils_1.toErrorObject)(error), {
+                    itemIndex: this.itemIndex,
+                });
+            }
+        }
+    }
+    /**
+     * Gets DATEVconnect credentials and validates them
+     */
+    async getCredentials() {
+        const credentials = (await this.context.getCredentials("datevConnectApi"));
+        if (!credentials) {
+            throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), "DATEVconnect credentials are missing");
+        }
+        const { host, email, password, clientInstanceId } = credentials;
+        if (!host || !email || !password || !clientInstanceId) {
+            throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), "All DATEVconnect credential fields must be provided");
+        }
+        return credentials;
+    }
+    /**
+     * Creates an authentication context with token
+     */
+    createAuthContext(credentials, token) {
+        return {
+            host: credentials.host,
+            token,
+            clientInstanceId: credentials.clientInstanceId,
+        };
+    }
+    /**
+     * Gets an optional string parameter
+     */
+    getOptionalString(name) {
+        return (0, utils_1.getOptionalString)(this.context, name, this.itemIndex);
+    }
+    /**
+     * Gets a required string parameter
+     */
+    getRequiredString(name) {
+        return (0, utils_1.getRequiredString)(this.context, name, this.itemIndex);
+    }
+    /**
+     * Gets a number parameter with default value
+     */
+    getNumberParameter(name, defaultValue) {
+        return (0, utils_1.getNumberParameter)(this.context, name, this.itemIndex, defaultValue);
+    }
+    /**
+     * Parses a JSON parameter
+     */
+    parseJsonParameter(rawValue, parameterLabel) {
+        return (0, utils_1.parseJsonParameter)(rawValue, parameterLabel, this.context, this.itemIndex);
+    }
+    /**
+     * Gets required JSON data from parameter
+     */
+    getRequiredJsonData(name) {
+        return (0, utils_1.getRequiredJsonData)(this.context, name, this.itemIndex);
+    }
+    /**
+     * Builds query parameters from optional values
+     */
+    buildQueryParams(params) {
+        return (0, utils_1.buildQueryParams)(params);
+    }
+    /**
+     * Validates that request context has required authentication
+     */
+    validateRequestContext(authContext) {
+        if (!authContext.host || !authContext.token || !authContext.clientInstanceId) {
+            throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), "Authentication context is incomplete");
+        }
+    }
+}
+exports.BaseResourceHandler = BaseResourceHandler;

package/dist/nodes/DocumentManagement/handlers/DocumentFileResourceHandler.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentFileResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const documentManagementClient_1 = require("../../../src/services/documentManagementClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+const utils_1 = require("../utils");
+/**
+ * Handler for document file operations
+ *
+ * IMPORTANT: This handler deals with binary file transfers that require special headers:
+ * - GET /document-files/{file-id}: Returns application/octet-stream binary data
+ * - POST /document-files: Accepts application/octet-stream binary data
+ *
+ * The DATEV Document Management API uses octet-stream for all file operations
+ * as specified in the document management-2.3.1.yaml specification.
+ */
+class DocumentFileResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    executeOperation() {
+        throw new Error("Method not implemented.");
+    }
+    /**
+     * Override execute method to handle binary data for document file operations
+     */
+    async execute(operation, authContext, returnData) {
+        try {
+            this.validateRequestContext(authContext);
+            switch (operation) {
+                case "get":
+                    await this.getDocumentFileBinary(authContext, returnData);
+                    break;
+                case "upload":
+                    {
+                        // Use the standard base handler for upload operations
+                        const sendSuccess = (payload) => {
+                            const data = payload ? (0, utils_1.normaliseToObjects)(payload) : [{}];
+                            data.forEach((item) => {
+                                returnData.push({
+                                    json: {
+                                        success: true,
+                                        ...item,
+                                    },
+                                });
+                            });
+                        };
+                        await this.uploadDocumentFile(authContext, sendSuccess);
+                        break;
+                    }
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `The operation "${operation}" is not supported for document files`);
+            }
+        }
+        catch (error) {
+            const continueOnFail = this.context.continueOnFail();
+            if (continueOnFail) {
+                returnData.push({
+                    json: {
+                        error: (0, utils_1.toErrorMessage)(error),
+                    },
+                });
+            }
+            else {
+                if (error instanceof Error) {
+                    throw error;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), String(error), {
+                    itemIndex: this.itemIndex,
+                });
+            }
+        }
+    }
+    /**
+     * Get document file and return it as binary data
+     */
+    async getDocumentFileBinary(authContext, returnData) {
+        const documentFileId = this.getRequiredString("documentFileId");
+        const response = await documentManagementClient_1.DocumentManagementClient.fetchDocumentFile({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            fileId: documentFileId,
+        });
+        // Handle binary response - return as actual binary data
+        const binaryData = await response.arrayBuffer();
+        const contentType = response.headers.get('content-type') || 'application/octet-stream';
+        // Create binary data object for n8n
+        const binaryDataObject = {
+            data: Buffer.from(binaryData).toString('base64'),
+            mimeType: contentType,
+            fileName: documentFileId, // Use the file ID as filename
+            fileSize: binaryData.byteLength.toString(),
+        };
+        // Add execution data with binary content
+        returnData.push({
+            json: {
+                success: true,
+                id: documentFileId,
+                contentType,
+                size: binaryData.byteLength,
+            },
+            binary: {
+                data: binaryDataObject,
+            },
+        });
+    }
+    async uploadDocumentFile(authContext, sendSuccess) {
+        var _a;
+        // Get binary data from the input data
+        const inputData = this.context.getInputData();
+        const currentItem = inputData[this.itemIndex];
+        if (!((_a = currentItem === null || currentItem === void 0 ? void 0 : currentItem.binary) === null || _a === void 0 ? void 0 : _a.data)) {
+            throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), "No binary data found. Please provide binary data through the 'data' binary property.", { itemIndex: this.itemIndex });
+        }
+        // Get from binary property
+        const binaryDataObj = currentItem.binary.data;
+        const bufferData = Buffer.from(binaryDataObj.data, 'base64');
+        const response = await documentManagementClient_1.DocumentManagementClient.uploadDocumentFile({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            binaryData: bufferData,
+        });
+        sendSuccess(response);
+    }
+}
+exports.DocumentFileResourceHandler = DocumentFileResourceHandler;

package/dist/nodes/DocumentManagement/handlers/DocumentResourceHandler.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const documentManagementClient_1 = require("../../../src/services/documentManagementClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+/**
+ * Handler for document operations
+ */
+class DocumentResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async executeOperation(operation, authContext, sendSuccess) {
+        this.validateRequestContext(authContext);
+        switch (operation) {
+            case "getAll":
+                await this.getDocuments(authContext, sendSuccess);
+                break;
+            case "get":
+                await this.getDocument(authContext, sendSuccess);
+                break;
+            case "create":
+                await this.createDocument(authContext, sendSuccess);
+                break;
+            case "update":
+                await this.updateDocument(authContext, sendSuccess);
+                break;
+            case "delete":
+                await this.deleteDocument(authContext, sendSuccess);
+                break;
+            case "deletePermanently":
+                await this.deleteDocumentPermanently(authContext, sendSuccess);
+                break;
+            case "getStructureItems":
+                await this.getStructureItems(authContext, sendSuccess);
+                break;
+            case "addStructureItem":
+                await this.addStructureItem(authContext, sendSuccess);
+                break;
+            case "getStructureItem":
+                await this.getStructureItem(authContext, sendSuccess);
+                break;
+            case "updateStructureItem":
+                await this.updateStructureItem(authContext, sendSuccess);
+                break;
+            case "createDispatcherInformation":
+                await this.createDispatcherInformation(authContext, sendSuccess);
+                break;
+            default:
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `The operation "${operation}" is not supported for documents`);
+        }
+    }
+    async getDocuments(authContext, sendSuccess) {
+        const filter = this.getOptionalString("filter");
+        const top = this.getNumberParameter("top", 0);
+        const skip = this.getNumberParameter("skip", 0);
+        const response = await documentManagementClient_1.DocumentManagementClient.fetchDocuments({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            filter,
+            top: top || undefined,
+            skip: skip || undefined,
+        });
+        sendSuccess(response);
+    }
+    async getDocument(authContext, sendSuccess) {
+        const documentId = this.getRequiredString("documentId");
+        const response = await documentManagementClient_1.DocumentManagementClient.fetchDocument({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            documentId,
+        });
+        sendSuccess(response);
+    }
+    async createDocument(authContext, sendSuccess) {
+        const documentData = this.getRequiredJsonData("documentData");
+        const response = await documentManagementClient_1.DocumentManagementClient.createDocument({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            document: documentData,
+        });
+        sendSuccess(response);
+    }
+    async updateDocument(authContext, sendSuccess) {
+        const documentId = this.getRequiredString("documentId");
+        const documentData = this.getRequiredJsonData("documentData");
+        const response = await documentManagementClient_1.DocumentManagementClient.updateDocument({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            documentId,
+            document: documentData,
+        });
+        sendSuccess(response);
+    }
+    async deleteDocument(authContext, sendSuccess) {
+        const documentId = this.getRequiredString("documentId");
+        await documentManagementClient_1.DocumentManagementClient.deleteDocument({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            documentId,
+        });
+        sendSuccess({ success: true, documentId, deleted: true });
+    }
+    async deleteDocumentPermanently(authContext, sendSuccess) {
+        const documentId = this.getRequiredString("documentId");
+        await documentManagementClient_1.DocumentManagementClient.deleteDocumentPermanently({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            documentId,
+        });
+        sendSuccess({ success: true, documentId, permanentlyDeleted: true });
+    }
+    async getStructureItems(authContext, sendSuccess) {
+        const documentId = this.getRequiredString("documentId");
+        const top = this.getNumberParameter("top", 0);
+        const skip = this.getNumberParameter("skip", 0);
+        const response = await documentManagementClient_1.DocumentManagementClient.fetchStructureItems({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            documentId,
+            top: top || undefined,
+            skip: skip || undefined,
+        });
+        sendSuccess(response);
+    }
+    async addStructureItem(authContext, sendSuccess) {
+        const documentId = this.getRequiredString("documentId");
+        const structureItemData = this.getRequiredJsonData("structureItemData");
+        const insertPosition = this.getOptionalString("insertPosition") || "last";
+        const response = await documentManagementClient_1.DocumentManagementClient.addStructureItem({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            documentId,
+            structureItem: structureItemData,
+            insertPosition,
+        });
+        sendSuccess(response);
+    }
+    async getStructureItem(authContext, sendSuccess) {
+        const documentId = this.getRequiredString("documentId");
+        const structureItemId = this.getRequiredString("structureItemId");
+        const response = await documentManagementClient_1.DocumentManagementClient.fetchStructureItem({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            documentId,
+            structureItemId,
+        });
+        sendSuccess(response);
+    }
+    async updateStructureItem(authContext, sendSuccess) {
+        const documentId = this.getRequiredString("documentId");
+        const structureItemId = this.getRequiredString("structureItemId");
+        const structureItemData = this.getRequiredJsonData("structureItemData");
+        const response = await documentManagementClient_1.DocumentManagementClient.updateStructureItem({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            documentId,
+            structureItemId,
+            structureItem: structureItemData,
+        });
+        sendSuccess(response);
+    }
+    async createDispatcherInformation(authContext, sendSuccess) {
+        const documentId = this.getRequiredString("documentId");
+        const dispatcherData = this.getRequiredJsonData("dispatcherData");
+        const response = await documentManagementClient_1.DocumentManagementClient.createDispatcherInformation({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            documentId,
+            dispatcherInformation: dispatcherData,
+        });
+        sendSuccess(response);
+    }
+}
+exports.DocumentResourceHandler = DocumentResourceHandler;

package/dist/nodes/DocumentManagement/handlers/DocumentStateResourceHandler.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentStateResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const documentManagementClient_1 = require("../../../src/services/documentManagementClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+/**
+ * Handler for document state operations
+ */
+class DocumentStateResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async executeOperation(operation, authContext, sendSuccess) {
+        this.validateRequestContext(authContext);
+        switch (operation) {
+            case "getAll":
+                await this.getDocumentStates(authContext, sendSuccess);
+                break;
+            case "get":
+                await this.getDocumentState(authContext, sendSuccess);
+                break;
+            case "create":
+                await this.createDocumentState(authContext, sendSuccess);
+                break;
+            default:
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `The operation "${operation}" is not supported for document states`);
+        }
+    }
+    async getDocumentStates(authContext, sendSuccess) {
+        const filter = this.getOptionalString("filter");
+        const response = await documentManagementClient_1.DocumentManagementClient.fetchDocumentStates({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            filter,
+        });
+        sendSuccess(response);
+    }
+    async getDocumentState(authContext, sendSuccess) {
+        const stateId = this.getRequiredString("stateId");
+        const response = await documentManagementClient_1.DocumentManagementClient.fetchDocumentState({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            stateId,
+        });
+        sendSuccess(response);
+    }
+    async createDocumentState(authContext, sendSuccess) {
+        const stateData = this.getRequiredJsonData("stateData");
+        const response = await documentManagementClient_1.DocumentManagementClient.createDocumentState({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            state: stateData,
+        });
+        sendSuccess(response);
+    }
+}
+exports.DocumentStateResourceHandler = DocumentStateResourceHandler;

package/dist/nodes/DocumentManagement/handlers/DomainResourceHandler.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomainResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const documentManagementClient_1 = require("../../../src/services/documentManagementClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+/**
+ * Handler for domain operations
+ */
+class DomainResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async executeOperation(operation, authContext, sendSuccess) {
+        this.validateRequestContext(authContext);
+        switch (operation) {
+            case "getAll":
+                await this.getDomains(authContext, sendSuccess);
+                break;
+            default:
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `The operation "${operation}" is not supported for domains`);
+        }
+    }
+    async getDomains(authContext, sendSuccess) {
+        const filter = this.getOptionalString("filter");
+        const response = await documentManagementClient_1.DocumentManagementClient.fetchDomains({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            filter,
+        });
+        sendSuccess(response);
+    }
+}
+exports.DomainResourceHandler = DomainResourceHandler;

package/dist/nodes/DocumentManagement/handlers/IndividualPropertyResourceHandler.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndividualPropertyResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const documentManagementClient_1 = require("../../../src/services/documentManagementClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+/**
+ * Handler for individual property operations
+ */
+class IndividualPropertyResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async executeOperation(operation, authContext, sendSuccess) {
+        this.validateRequestContext(authContext);
+        switch (operation) {
+            case 'getAll':
+                await this.getIndividualProperties(authContext, sendSuccess);
+                break;
+            default:
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `Unsupported operation: ${operation}`, {
+                    itemIndex: this.itemIndex,
+                });
+        }
+    }
+    async getIndividualProperties(authContext, sendSuccess) {
+        const response = await documentManagementClient_1.DocumentManagementClient.fetchIndividualProperties({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+        });
+        sendSuccess(response);
+    }
+}
+exports.IndividualPropertyResourceHandler = IndividualPropertyResourceHandler;

package/dist/nodes/DocumentManagement/handlers/IndividualReference1ResourceHandler.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndividualReference1ResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const documentManagementClient_1 = require("../../../src/services/documentManagementClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+/**
+ * Handler for individual references 1 operations
+ */
+class IndividualReference1ResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async executeOperation(operation, authContext, sendSuccess) {
+        this.validateRequestContext(authContext);
+        switch (operation) {
+            case 'getAll':
+                await this.getIndividualReferences1(authContext, sendSuccess);
+                break;
+            case 'create':
+                await this.createIndividualReference1(authContext, sendSuccess);
+                break;
+            default:
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `Unsupported operation: ${operation}`, {
+                    itemIndex: this.itemIndex,
+                });
+        }
+    }
+    async getIndividualReferences1(authContext, sendSuccess) {
+        const top = this.getNumberParameter('top', 0);
+        const skip = this.getNumberParameter('skip', 0);
+        const response = await documentManagementClient_1.DocumentManagementClient.fetchIndividualReferences1({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            top: top || undefined,
+            skip: skip || undefined,
+        });
+        sendSuccess(response);
+    }
+    async createIndividualReference1(authContext, sendSuccess) {
+        const individualReferenceData = this.getRequiredJsonData('individualReferenceData');
+        const response = await documentManagementClient_1.DocumentManagementClient.createIndividualReference1({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            individualReference: individualReferenceData,
+        });
+        sendSuccess(response);
+    }
+}
+exports.IndividualReference1ResourceHandler = IndividualReference1ResourceHandler;

package/dist/nodes/DocumentManagement/handlers/IndividualReference2ResourceHandler.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndividualReference2ResourceHandler = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const documentManagementClient_1 = require("../../../src/services/documentManagementClient");
+const BaseResourceHandler_1 = require("./BaseResourceHandler");
+/**
+ * Handler for individual references 2 operations
+ */
+class IndividualReference2ResourceHandler extends BaseResourceHandler_1.BaseResourceHandler {
+    async executeOperation(operation, authContext, sendSuccess) {
+        this.validateRequestContext(authContext);
+        switch (operation) {
+            case 'getAll':
+                await this.getIndividualReferences2(authContext, sendSuccess);
+                break;
+            case 'create':
+                await this.createIndividualReference2(authContext, sendSuccess);
+                break;
+            default:
+                throw new n8n_workflow_1.NodeOperationError(this.context.getNode(), `Unsupported operation: ${operation}`, {
+                    itemIndex: this.itemIndex,
+                });
+        }
+    }
+    async getIndividualReferences2(authContext, sendSuccess) {
+        const top = this.getNumberParameter('top', 0);
+        const skip = this.getNumberParameter('skip', 0);
+        const response = await documentManagementClient_1.DocumentManagementClient.fetchIndividualReferences2({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            top: top || undefined,
+            skip: skip || undefined,
+        });
+        sendSuccess(response);
+    }
+    async createIndividualReference2(authContext, sendSuccess) {
+        const individualReferenceData = this.getRequiredJsonData('individualReferenceData');
+        const response = await documentManagementClient_1.DocumentManagementClient.createIndividualReference2({
+            host: authContext.host,
+            token: authContext.token,
+            clientInstanceId: authContext.clientInstanceId,
+            individualReference: individualReferenceData,
+        });
+        sendSuccess(response);
+    }
+}
+exports.IndividualReference2ResourceHandler = IndividualReference2ResourceHandler;