n8n-nodes-miroapp 1.0.1

package/dist/nodes/Miro/Miro.node.js

@@ -0,0 +1,4126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Miro = void 0;
+exports.executeItem = executeItem;
+const n8n_workflow_1 = require("n8n-workflow");
+const BASE_URL = 'https://api.miro.com';
+const MAX_UPLOAD_BYTES = 6 * 1024 * 1024;
+const MAX_BULK_RESOURCES = 20;
+const UPLOAD_OPERATIONS = {
+    createDocumentItemUsingFileFromDevicePost: 'singleResource',
+    createImageItemUsingLocalFilePost: 'singleResource',
+    createItemsInBulkUsingFileFromDevicePost: 'bulkResources',
+    updateDocumentItemUsingFileFromDevicePatch: 'singleResource',
+    updateImageItemUsingFileFromDevicePatch: 'singleResource',
+};
+class Miro {
+    constructor() {
+        this.description = {
+            name: 'miro',
+            displayName: 'Miro',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["resource"] + " → " + $parameter["operation"]}}',
+            description: 'Use the Miro API',
+            defaults: { name: 'Miro' },
+            icon: { light: 'file:miro.svg', dark: 'file:miro.dark.svg' },
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            usableAsTool: true,
+            credentials: [
+                {
+                    name: 'miroApi',
+                    required: true,
+                    displayOptions: { show: { authentication: ['accessToken'] } },
+                },
+                {
+                    name: 'miroOAuth2Api',
+                    required: true,
+                    displayOptions: { show: { authentication: ['oAuth2'] } },
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Authentication',
+                    name: 'authentication',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        { name: 'Access Token', value: 'accessToken' },
+                        { name: 'OAuth2', value: 'oAuth2' },
+                    ],
+                    default: 'accessToken',
+                },
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Apps - Metric',
+                            value: 'appsMetric',
+                            description: 'Usage metrics for a Miro app (experimental Miro API, may change without notice)',
+                        },
+                        {
+                            name: 'Authentication - Token',
+                            value: 'authenticationToken',
+                            description: 'Revoke an OAuth access token',
+                        },
+                        {
+                            name: 'Boards - Board',
+                            value: 'boardsBoard',
+                            description: 'Create, read, update, copy and delete boards',
+                        },
+                        {
+                            name: 'Boards - Export Job',
+                            value: 'boardsExportJob',
+                            description: 'Bulk-export boards through asynchronous export jobs',
+                        },
+                        {
+                            name: 'Boards - Member',
+                            value: 'boardsMember',
+                            description: 'Share a board and manage the roles of its members',
+                        },
+                        {
+                            name: 'Boards - User Group Assignment',
+                            value: 'boardsUserGroupAssignment',
+                            description: 'Share a board with organization user groups',
+                        },
+                        {
+                            name: 'Governance - AI Interaction Log',
+                            value: 'governanceAIInteractionLog',
+                            description: 'Audit how people used Miro AI features',
+                        },
+                        {
+                            name: 'Governance - Audit Log',
+                            value: 'governanceAuditLog',
+                            description: 'Audit events from the last 90 days',
+                        },
+                        {
+                            name: 'Governance - Board Content Log',
+                            value: 'governanceBoardContentLog',
+                            description: 'Track content changes made to board items',
+                        },
+                        {
+                            name: 'Governance - Board Data Classification',
+                            value: 'governanceBoardDataClassification',
+                            description: 'Read and set the classification label of a board',
+                        },
+                        {
+                            name: 'Governance - Legal Hold',
+                            value: 'governanceLegalHold',
+                            description: 'Manage eDiscovery cases and the legal holds they contain',
+                        },
+                        {
+                            name: 'Governance - Organization Data Classification',
+                            value: 'governanceOrganizationDataClassification',
+                            description: 'Read the classification settings of an organization',
+                        },
+                        {
+                            name: 'Governance - Team Data Classification',
+                            value: 'governanceTeamDataClassification',
+                            description: 'Read and update the classification settings of a team',
+                        },
+                        {
+                            name: 'Governance - User Session',
+                            value: 'governanceUserSession',
+                            description: 'Sign a user out of all of their Miro sessions',
+                        },
+                        {
+                            name: 'Items - App Card',
+                            value: 'itemsAppCard',
+                            description: 'Cards that stay in sync with data from an external app',
+                        },
+                        {
+                            name: 'Items - Card',
+                            value: 'itemsCard',
+                            description: 'Task cards with an assignee, a due date and a description',
+                        },
+                        {
+                            name: 'Items - Code Widget',
+                            value: 'itemsCodeWidget',
+                            description: 'Syntax-highlighted code blocks placed on a board (experimental Miro API, may change without notice)',
+                        },
+                        {
+                            name: 'Items - Connector',
+                            value: 'itemsConnector',
+                            description: 'Lines and arrows that link two items together',
+                        },
+                        {
+                            name: 'Items - Doc Format',
+                            value: 'itemsDocFormat',
+                            description: 'Native Miro documents written in Markdown',
+                        },
+                        {
+                            name: 'Items - Document',
+                            value: 'itemsDocument',
+                            description: 'Files such as PDFs, uploaded from a URL or from a file',
+                        },
+                        {
+                            name: 'Items - Embed',
+                            value: 'itemsEmbed',
+                            description: 'Live content embedded from an external URL',
+                        },
+                        {
+                            name: 'Items - Flowchart Shape',
+                            value: 'itemsFlowchartShape',
+                            description: 'Shapes drawn from the flowchart shape vocabulary (experimental Miro API, may change without notice)',
+                        },
+                        {
+                            name: 'Items - Frame',
+                            value: 'itemsFrame',
+                            description: 'Frames that group and lay out the items they contain',
+                        },
+                        {
+                            name: 'Items - Group',
+                            value: 'itemsGroup',
+                            description: 'Group several board items so they move together',
+                        },
+                        {
+                            name: 'Items - Image',
+                            value: 'itemsImage',
+                            description: 'Images, uploaded from a URL or from a file',
+                        },
+                        {
+                            name: 'Items - Item',
+                            value: 'itemsItem',
+                            description: 'Read, move and delete any item, and create items in bulk',
+                        },
+                        {
+                            name: 'Items - Mind Map Node',
+                            value: 'itemsMindMapNode',
+                            description: 'Nodes of a mind map and their hierarchy (experimental Miro API, may change without notice)',
+                        },
+                        {
+                            name: 'Items - Shape',
+                            value: 'itemsShape',
+                            description: 'Geometric shapes with text, fill and border styling',
+                        },
+                        {
+                            name: 'Items - Sticky Note',
+                            value: 'itemsStickyNote',
+                            description: 'Sticky notes, the most common board item',
+                        },
+                        {
+                            name: 'Items - Tag',
+                            value: 'itemsTag',
+                            description: 'Board tags, and attaching them to items',
+                        },
+                        {
+                            name: 'Items - Text',
+                            value: 'itemsText',
+                            description: 'Free-standing text placed on a board',
+                        },
+                        {
+                            name: 'Organization - Member',
+                            value: 'organizationMember',
+                            description: 'Read the members of an organization and their licences',
+                        },
+                        {
+                            name: 'Organization - Organization',
+                            value: 'organizationOrganization',
+                            description: 'Read information about an organization',
+                        },
+                        {
+                            name: 'Organization - Project',
+                            value: 'organizationProject',
+                            description: 'Projects that group boards inside a team',
+                        },
+                        {
+                            name: 'Organization - Project Member',
+                            value: 'organizationProjectMember',
+                            description: 'Add, read, update and remove members of a project',
+                        },
+                        {
+                            name: 'Organization - Project Setting',
+                            value: 'organizationProjectSetting',
+                            description: 'Read and update the settings of a project',
+                        },
+                        {
+                            name: 'Organization - Project User Group Assignment',
+                            value: 'organizationProjectUserGroupAssignment',
+                            description: 'Share a project with organization user groups',
+                        },
+                        {
+                            name: 'Organization - Team',
+                            value: 'organizationTeam',
+                            description: 'Create, read, update and delete the teams of an organization',
+                        },
+                        {
+                            name: 'Organization - Team Member',
+                            value: 'organizationTeamMember',
+                            description: 'Invite, read, update and remove members of a team',
+                        },
+                        {
+                            name: 'Organization - Team Setting',
+                            value: 'organizationTeamSetting',
+                            description: 'Read and update team settings, and the organization defaults',
+                        },
+                        {
+                            name: 'Organization - Team User Group',
+                            value: 'organizationTeamUserGroup',
+                            description: 'Connect organization user groups to a team',
+                        },
+                        {
+                            name: 'Organization - User Group',
+                            value: 'organizationUserGroup',
+                            description: 'Create, read, update and delete organization user groups',
+                        },
+                        {
+                            name: 'Organization - User Group Member',
+                            value: 'organizationUserGroupMember',
+                            description: 'Manage who belongs to an organization user group',
+                        },
+                        {
+                            name: 'Organization - User Group Team',
+                            value: 'organizationUserGroupTeam',
+                            description: 'Read the teams that an organization user group belongs to',
+                        },
+                    ],
+                    default: 'appsMetric',
+                    required: true,
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['appsMetric'] } },
+                    options: [
+                        {
+                            name: 'Get App Metrics',
+                            value: 'getMetricsGet',
+                            action: 'Gets app metrics',
+                            description: 'Returns a list of usage metrics for a specific app for a given time range, grouped by requested time period. This endpoint requires an app management API token. It can be generated in the Your Apps section of Developer Hub (experimental Miro API, may change without notice).',
+                        },
+                        {
+                            name: 'Get Total App Metrics',
+                            value: 'getMetricsTotalGet',
+                            action: 'Gets total app metrics',
+                            description: 'Returns total usage metrics for a specific app since the app was created. This endpoint requires an app management API token. It can be generated in your apps section of Developer Hub (experimental Miro API, may change without notice).',
+                        },
+                    ],
+                    default: 'getMetricsGet',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['authenticationToken'] } },
+                    options: [
+                        {
+                            name: 'Revoke Token',
+                            value: 'revokeTokenV2Post',
+                            action: 'Revokes token',
+                            description: 'Revoke the current access token. Revoking an access token means that the access token will no longer work. When an access token is revoked, the refresh token is also revoked and no longer valid. This does not uninstall the application for the user.',
+                        },
+                    ],
+                    default: 'revokeTokenV2Post',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['boardsBoard'] } },
+                    options: [
+                        {
+                            name: 'Copy Board',
+                            value: 'copyBoardPut',
+                            action: 'Copies board',
+                            description: 'Creates a copy of an existing board. You can also update the name, description, sharing policy, and permissions policy for the new board in the request body.',
+                        },
+                        {
+                            name: 'Create Board',
+                            value: 'createBoardPost',
+                            action: 'Creates board',
+                            description: 'Creates a board with the specified name and sharing policies',
+                        },
+                        {
+                            name: 'Delete Board',
+                            value: 'deleteBoardDelete',
+                            action: 'Deletes board',
+                            description: 'Deletes a board. Deleted boards go to Trash (on paid plans) and can be restored via UI within 90 days after deletion.',
+                        },
+                        {
+                            name: 'Get Boards',
+                            value: 'getBoardsGet',
+                            action: 'Gets boards',
+                            description: 'Retrieves a list of boards accessible to the user associated with the provided access token. This endpoint supports filtering and sorting through URL query parameters.',
+                        },
+                        {
+                            name: 'Get Specific Board',
+                            value: 'getSpecificBoardGet',
+                            action: 'Gets specific board',
+                            description: 'Retrieves information about a board',
+                        },
+                        {
+                            name: 'Update Board',
+                            value: 'updateBoardPatch',
+                            action: 'Updates board',
+                            description: 'Updates a specific board',
+                        },
+                    ],
+                    default: 'copyBoardPut',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['boardsExportJob'] } },
+                    options: [
+                        {
+                            name: 'Create Board Export Job',
+                            value: 'enterpriseCreateBoardExportPost',
+                            action: 'Creates board export job',
+                            description: 'Creates an export job for one or more boards',
+                        },
+                        {
+                            name: 'Create Task Export Link',
+                            value: 'enterpriseCreateBoardExportTaskExportLinkPost',
+                            action: 'Creates task export link',
+                            description: 'Creates a link to download the results of a board export task',
+                        },
+                        {
+                            name: 'Get Board Export Job Status',
+                            value: 'enterpriseBoardExportJobStatusGet',
+                            action: 'Gets board export job status',
+                            description: 'Retrieves the status of the board export job',
+                        },
+                        {
+                            name: 'Get Board Export Job Tasks List',
+                            value: 'enterpriseBoardExportJobTasksGet',
+                            action: 'Gets board export job tasks list',
+                            description: 'Retrieves the list of tasks for the board export job',
+                        },
+                        {
+                            name: 'Get Board Export Jobs List',
+                            value: 'enterpriseBoardExportJobsGet',
+                            action: 'Gets board export jobs list',
+                            description: 'Retrieves the list of board export jobs based on the filters provided in the request',
+                        },
+                        {
+                            name: 'Get Results for Board Export Job',
+                            value: 'enterpriseBoardExportJobResultsGet',
+                            action: 'Gets results for board export job',
+                            description: 'Retrieves the result of the board export job. The response provides more information about the board export job, such as the S3 link to the files created.',
+                        },
+                        {
+                            name: 'Update Board Export Job Status',
+                            value: 'enterpriseUpdateBoardExportJobPut',
+                            action: 'Updates board export job status',
+                            description: 'Updates the status of the board export job',
+                        },
+                    ],
+                    default: 'enterpriseCreateBoardExportPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['boardsMember'] } },
+                    options: [
+                        {
+                            name: 'Get All Board Members',
+                            value: 'getBoardMembersGet',
+                            action: 'Gets all board members',
+                            description: 'Retrieves a pageable list of members for a board',
+                        },
+                        {
+                            name: 'Get Specific Board Member',
+                            value: 'getSpecificBoardMemberGet',
+                            action: 'Gets specific board member',
+                            description: 'Retrieves information for a board member',
+                        },
+                        {
+                            name: 'Remove Board Member',
+                            value: 'removeBoardMemberDelete',
+                            action: 'Removes board member',
+                            description: 'Removes a board member from a board',
+                        },
+                        {
+                            name: 'Share Board',
+                            value: 'shareBoardPost',
+                            action: 'Shares board',
+                            description: 'Shares the board and Invites new members to collaborate on a board by sending an invitation email',
+                        },
+                        {
+                            name: 'Update Board Member',
+                            value: 'updateBoardMemberPatch',
+                            action: 'Updates board member',
+                            description: 'Updates the role of a board member',
+                        },
+                    ],
+                    default: 'getBoardMembersGet',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['boardsUserGroupAssignment'] } },
+                    options: [
+                        {
+                            name: 'Create Board User Group Assignments',
+                            value: 'enterpriseBoardsCreateGroupPost',
+                            action: 'Creates board user group assignments',
+                            description: 'Shares a board with user groups with a specified role. Updates the role if already shared.',
+                        },
+                        {
+                            name: 'Delete Board User Group Assignment',
+                            value: 'enterpriseBoardsDeleteGroupsDelete',
+                            action: 'Deletes board user group assignment',
+                            description: 'Removes a user group from the specified board',
+                        },
+                        {
+                            name: 'Get Board User Group Assignments',
+                            value: 'enterpriseBoardsGetGroupsGet',
+                            action: 'Gets board user group assignments',
+                            description: 'Retrieves information about user groups invited to the specified board',
+                        },
+                    ],
+                    default: 'enterpriseBoardsCreateGroupPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['governanceAIInteractionLog'] } },
+                    options: [
+                        {
+                            name: 'Get AI Interaction Logs',
+                            value: 'enterpriseGetAiInteractionLogsGet',
+                            action: 'Gets AI interaction logs',
+                            description: 'Retrieves AI interaction logs for your organization. AI interaction logs capture user interactions with AI features in Miro. You can retrieve results for a specific time period.',
+                        },
+                    ],
+                    default: 'enterpriseGetAiInteractionLogsGet',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['governanceAuditLog'] } },
+                    options: [
+                        {
+                            name: 'Get Audit Logs',
+                            value: 'enterpriseGetAuditLogsGet',
+                            action: 'Gets audit logs',
+                            description: 'Retrieves a page of audit events from the last 90 days. If you want to retrieve data that is older than 90 days, you can use the CSV export feature.',
+                        },
+                    ],
+                    default: 'enterpriseGetAuditLogsGet',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['governanceBoardContentLog'] } },
+                    options: [
+                        {
+                            name: 'Get Content Change Logs of Board Items',
+                            value: 'enterpriseBoardContentItemLogsFetchGet',
+                            action: 'Gets content change logs of board items',
+                            description: 'Retrieves content changes for board items within your organization. Content changes are actions that users can perform on board items, such as updating a sticky note\'s text. You can retrieve results for a specific time period.',
+                        },
+                    ],
+                    default: 'enterpriseBoardContentItemLogsFetchGet',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['governanceBoardDataClassification'] } },
+                    options: [
+                        {
+                            name: 'Get Board Classification',
+                            value: 'enterpriseDataclassificationBoardGetGet',
+                            action: 'Gets board classification',
+                            description: 'Retrieves board classification for a board',
+                        },
+                        {
+                            name: 'Update Board Classification',
+                            value: 'enterpriseDataclassificationBoardSetPost',
+                            action: 'Updates board classification',
+                            description: 'Updates board classification for an existing board',
+                        },
+                    ],
+                    default: 'enterpriseDataclassificationBoardGetGet',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['governanceLegalHold'] } },
+                    options: [
+                        {
+                            name: 'Close Case',
+                            value: 'deleteCaseDelete',
+                            action: 'Closes case',
+                            description: 'Closing a case is the final stage in the eDiscovery process, marking the conclusion of a legal matter or investigation. You must ensure that all associated legal holds within the case are closed before closing the case.',
+                        },
+                        {
+                            name: 'Close Legal Hold',
+                            value: 'deleteLegalHoldDelete',
+                            action: 'Closes legal hold',
+                            description: 'Closing a legal hold is one of the final steps in the eDiscovery process once the litigation or investigation has concluded',
+                        },
+                        {
+                            name: 'Create Case',
+                            value: 'createCasePost',
+                            action: 'Creates case',
+                            description: 'Creating a case for legal hold is the first critical step in the eDiscovery process when litigation or an investigation is anticipated',
+                        },
+                        {
+                            name: 'Create Legal Hold',
+                            value: 'createLegalHoldPost',
+                            action: 'Creates legal hold',
+                            description: 'After creating a case it is possible to add one or multiple legal holds to the case',
+                        },
+                        {
+                            name: 'Edit Case',
+                            value: 'editCasePut',
+                            action: 'Edits case',
+                            description: 'Editing a case allows eDiscovery Admins to keep case details accurate and aligned with the evolving scope of a legal matter',
+                        },
+                        {
+                            name: 'Edit Legal Hold',
+                            value: 'editLegalHoldPut',
+                            action: 'Edits legal hold',
+                            description: 'Editing a legal hold allows eDiscovery Admins to adjust and refine ongoing legal preservation efforts as case requirements evolve',
+                        },
+                        {
+                            name: 'Get All Cases',
+                            value: 'getAllCasesGet',
+                            action: 'Gets all cases',
+                            description: 'Retrieves the list of eDiscovery cases in an organization',
+                        },
+                        {
+                            name: 'Get All Legal Holds Within a Case',
+                            value: 'getAllLegalHoldsGet',
+                            action: 'Gets all legal holds within a case',
+                            description: 'Retrieves the list of all legal holds within a case for an organization',
+                        },
+                        {
+                            name: 'Get Board Export Jobs of a Case',
+                            value: 'getLegalHoldExportJobsGet',
+                            action: 'Gets board export jobs of a case',
+                            description: 'Retrieves board export jobs for a case',
+                        },
+                        {
+                            name: 'Get Case',
+                            value: 'getCaseGet',
+                            action: 'Gets case',
+                            description: 'Retrieves information about a case in an organization',
+                        },
+                        {
+                            name: 'Get Content Items Under Legal Hold',
+                            value: 'getLegalHoldContentItemsGet',
+                            action: 'Gets content items under legal hold',
+                            description: 'Once a legal hold is in place you can review or explore the preserved Miro boards to ensure that all relevant data is intact and ready for legal proceedings or investigations',
+                        },
+                        {
+                            name: 'Get Legal Hold Information',
+                            value: 'getLegalHoldGet',
+                            action: 'Gets legal hold information',
+                            description: 'Retrieves information about a legal hold within a case for an organization',
+                        },
+                    ],
+                    default: 'deleteCaseDelete',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['governanceOrganizationDataClassification'] } },
+                    options: [
+                        {
+                            name: 'Get Organization Settings',
+                            value: 'enterpriseDataclassificationOrganizationSettingsGetGet',
+                            action: 'Gets organization settings',
+                            description: 'Retrieves board classification settings for an existing organization',
+                        },
+                    ],
+                    default: 'enterpriseDataclassificationOrganizationSettingsGetGet',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['governanceTeamDataClassification'] } },
+                    options: [
+                        {
+                            name: 'Bulk Update Boards Classification',
+                            value: 'enterpriseDataclassificationTeamBoardsBulkPatch',
+                            action: 'Bulk updates boards classification',
+                            description: 'Updates board classification for not-classified only or all boards in an existing team',
+                        },
+                        {
+                            name: 'Get Team Classification Settings',
+                            value: 'enterpriseDataclassificationTeamSettingsGetGet',
+                            action: 'Gets team classification settings',
+                            description: 'Retrieves board classification settings for an existing team',
+                        },
+                        {
+                            name: 'Update Team Classification Settings',
+                            value: 'enterpriseDataclassificationTeamSettingsSetPatch',
+                            action: 'Updates team classification settings',
+                            description: 'Updates board classification settings for an existing team',
+                        },
+                    ],
+                    default: 'enterpriseDataclassificationTeamBoardsBulkPatch',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['governanceUserSession'] } },
+                    options: [
+                        {
+                            name: 'Reset All Sessions of a User',
+                            value: 'enterprisePostUserSessionsResetPost',
+                            action: 'Resets all sessions of a user',
+                            description: 'Reset all sessions of a user. Admins can now take immediate action to restrict user access to company data in case of security concerns.',
+                        },
+                    ],
+                    default: 'enterprisePostUserSessionsResetPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['itemsAppCard'] } },
+                    options: [
+                        {
+                            name: 'Create App Card Item',
+                            value: 'createAppCardItemPost',
+                            action: 'Creates app card item',
+                            description: 'Adds an app card item to a board',
+                        },
+                        {
+                            name: 'Delete App Card Item',
+                            value: 'deleteAppCardItemDelete',
+                            action: 'Deletes app card item',
+                            description: 'Deletes an app card item from a board',
+                        },
+                        {
+                            name: 'Get App Card Item',
+                            value: 'getAppCardItemGet',
+                            action: 'Gets app card item',
+                            description: 'Retrieves information for a specific app card item on a board',
+                        },
+                        {
+                            name: 'Update App Card Item',
+                            value: 'updateAppCardItemPatch',
+                            action: 'Updates app card item',
+                            description: 'Updates an app card item on a board based on the data and style properties provided in the request body',
+                        },
+                    ],
+                    default: 'createAppCardItemPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['itemsCard'] } },
+                    options: [
+                        {
+                            name: 'Create Card Item',
+                            value: 'createCardItemPost',
+                            action: 'Creates card item',
+                            description: 'Adds a card item to a board',
+                        },
+                        {
+                            name: 'Delete Card Item',
+                            value: 'deleteCardItemDelete',
+                            action: 'Deletes card item',
+                            description: 'Deletes a card item from the board',
+                        },
+                        {
+                            name: 'Get Card Item',
+                            value: 'getCardItemGet',
+                            action: 'Gets card item',
+                            description: 'Retrieves information for a specific card item on a board',
+                        },
+                        {
+                            name: 'Update Card Item',
+                            value: 'updateCardItemPatch',
+                            action: 'Updates card item',
+                            description: 'Updates a card item on a board based on the data and style properties provided in the request body',
+                        },
+                    ],
+                    default: 'createCardItemPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['itemsCodeWidget'] } },
+                    options: [
+                        {
+                            name: 'Create Code Widget Item',
+                            value: 'createCodeWidgetItemPost',
+                            action: 'Creates code widget item',
+                            description: 'Adds a code widget item to a board (experimental Miro API, may change without notice)',
+                        },
+                        {
+                            name: 'Delete Code Widget Item',
+                            value: 'deleteCodeWidgetItemDelete',
+                            action: 'Deletes code widget item',
+                            description: 'Deletes a code widget item from the board (experimental Miro API, may change without notice)',
+                        },
+                        {
+                            name: 'Get Code Widget Item',
+                            value: 'getCodeWidgetItemGet',
+                            action: 'Gets code widget item',
+                            description: 'Retrieves information for a specific code widget item on a board (experimental Miro API, may change without notice)',
+                        },
+                        {
+                            name: 'Get Code Widget Items',
+                            value: 'getCodeWidgetItemsGet',
+                            action: 'Gets code widget items',
+                            description: 'Retrieves a list of code widget items for a specific board. This method returns results using a cursor-based approach (experimental Miro API, may change without notice).',
+                        },
+                        {
+                            name: 'Move Code Widget Item',
+                            value: 'moveCodeWidgetItemPatch',
+                            action: 'Moves code widget item',
+                            description: 'Updates the position of a code widget item on a board (experimental Miro API, may change without notice)',
+                        },
+                        {
+                            name: 'Update Code Widget Item',
+                            value: 'updateCodeWidgetItemPatch',
+                            action: 'Updates code widget item',
+                            description: 'Updates a code widget item on a board based on the data properties provided in the request body (experimental Miro API, may change without notice)',
+                        },
+                    ],
+                    default: 'createCodeWidgetItemPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['itemsConnector'] } },
+                    options: [
+                        {
+                            name: 'Create Connector',
+                            value: 'createConnectorPost',
+                            action: 'Creates connector',
+                            description: 'Adds a connector to a board',
+                        },
+                        {
+                            name: 'Delete Connector',
+                            value: 'deleteConnectorDelete',
+                            action: 'Deletes connector',
+                            description: 'Deletes the specified connector from the board',
+                        },
+                        {
+                            name: 'Get Connectors',
+                            value: 'getConnectorsGet',
+                            action: 'Gets connectors',
+                            description: 'Retrieves a list of connectors for a specific board. This method returns results using a cursor-based approach.',
+                        },
+                        {
+                            name: 'Get Specific Connector',
+                            value: 'getConnectorGet',
+                            action: 'Gets specific connector',
+                            description: 'Retrieves information for a specific connector on a board',
+                        },
+                        {
+                            name: 'Update Connector',
+                            value: 'updateConnectorPatch',
+                            action: 'Updates connector',
+                            description: 'Updates a connector on a board based on the data and style properties provided in the request body',
+                        },
+                    ],
+                    default: 'createConnectorPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['itemsDocFormat'] } },
+                    options: [
+                        {
+                            name: 'Create Doc Format Item',
+                            value: 'createDocFormatItemPost',
+                            action: 'Creates doc format item',
+                            description: 'Adds a doc format item to a board',
+                        },
+                        {
+                            name: 'Delete Doc Format Item',
+                            value: 'deleteDocFormatItemDelete',
+                            action: 'Deletes doc format item',
+                            description: 'Deletes a doc format item from the board',
+                        },
+                        {
+                            name: 'Get Doc Format Item',
+                            value: 'getDocFormatItemGet',
+                            action: 'Gets doc format item',
+                            description: 'Retrieves information for a specific doc format item on a board',
+                        },
+                    ],
+                    default: 'createDocFormatItemPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['itemsDocument'] } },
+                    options: [
+                        {
+                            name: 'Create Document Item Using File From Device',
+                            value: 'createDocumentItemUsingFileFromDevicePost',
+                            action: 'Creates document item using file from device',
+                            description: 'Adds a document item to a board by selecting file from device',
+                        },
+                        {
+                            name: 'Create Document Item Using URL',
+                            value: 'createDocumentItemUsingUrlPost',
+                            action: 'Creates document item using URL',
+                            description: 'Adds a document item to a board by specifying the URL where the document is hosted',
+                        },
+                        {
+                            name: 'Delete Document Item',
+                            value: 'deleteDocumentItemDelete',
+                            action: 'Deletes document item',
+                            description: 'Deletes a document item from the board',
+                        },
+                        {
+                            name: 'Get Document Item',
+                            value: 'getDocumentItemGet',
+                            action: 'Gets document item',
+                            description: 'Retrieves information for a specific document item on a board',
+                        },
+                        {
+                            name: 'Update Document Item Using File From Device',
+                            value: 'updateDocumentItemUsingFileFromDevicePatch',
+                            action: 'Updates document item using file from device',
+                            description: 'Updates a document item on a board by using file from a device',
+                        },
+                        {
+                            name: 'Update Document Item Using URL',
+                            value: 'updateDocumentItemUsingUrlPatch',
+                            action: 'Updates document item using URL',
+                            description: 'Updates a document item on a board',
+                        },
+                    ],
+                    default: 'createDocumentItemUsingFileFromDevicePost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['itemsEmbed'] } },
+                    options: [
+                        {
+                            name: 'Create Embed Item',
+                            value: 'createEmbedItemPost',
+                            action: 'Creates embed item',
+                            description: 'Adds an embed item containing external content to a board',
+                        },
+                        {
+                            name: 'Delete Embed Item',
+                            value: 'deleteEmbedItemDelete',
+                            action: 'Deletes embed item',
+                            description: 'Deletes an embed item from the board',
+                        },
+                        {
+                            name: 'Get Embed Item',
+                            value: 'getEmbedItemGet',
+                            action: 'Gets embed item',
+                            description: 'Retrieves information for a specific embed item on a board',
+                        },
+                        {
+                            name: 'Update Embed Item',
+                            value: 'updateEmbedItemPatch',
+                            action: 'Updates embed item',
+                            description: 'Updates an embed item on a board based on the data properties provided in the request body',
+                        },
+                    ],
+                    default: 'createEmbedItemPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['itemsFlowchartShape'] } },
+                    options: [
+                        {
+                            name: 'Create Flowchart Shape Item',
+                            value: 'createShapeItemFlowchartPost',
+                            action: 'Creates flowchart shape item',
+                            description: 'Adds a flowchart shape item to a board (experimental Miro API, may change without notice)',
+                        },
+                        {
+                            name: 'Delete Flowchart Shape Item',
+                            value: 'deleteShapeItemFlowchartDelete',
+                            action: 'Deletes flowchart shape item',
+                            description: 'Deletes a flowchart shape item from the board (experimental Miro API, may change without notice)',
+                        },
+                        {
+                            name: 'Get Flowchart Shape Item',
+                            value: 'getShapeItemFlowchartGet',
+                            action: 'Gets flowchart shape item',
+                            description: 'Retrieves information for a specific shape item on a board (experimental Miro API, may change without notice)',
+                        },
+                        {
+                            name: 'Update Flowchart Shape Item',
+                            value: 'updateShapeItemFlowchartPatch',
+                            action: 'Updates flowchart shape item',
+                            description: 'Updates a flowchart shape item on a board based on the data and style properties provided in the request body (experimental Miro API, may change without notice)',
+                        },
+                    ],
+                    default: 'createShapeItemFlowchartPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['itemsFrame'] } },
+                    options: [
+                        {
+                            name: 'Create Frame',
+                            value: 'createFrameItemPost',
+                            action: 'Creates frame',
+                            description: 'Adds a frame to a board',
+                        },
+                        {
+                            name: 'Delete Frame',
+                            value: 'deleteFrameItemDelete',
+                            action: 'Deletes frame',
+                            description: 'Deletes a frame from a board',
+                        },
+                        {
+                            name: 'Get Frame',
+                            value: 'getFrameItemGet',
+                            action: 'Gets frame',
+                            description: 'Retrieves information for a specific frame on a board',
+                        },
+                        {
+                            name: 'Get Items Within Frame',
+                            value: 'getItemsWithinFrameGet',
+                            action: 'Gets items within frame',
+                            description: 'Retrieves a list of items within a specific frame. A frame is a parent item and all items within a frame are child items. This method returns results using a cursor-based approach.',
+                        },
+                        {
+                            name: 'Update Frame',
+                            value: 'updateFrameItemPatch',
+                            action: 'Updates frame',
+                            description: 'Updates a frame on a board based on the data, style, or geometry properties provided in the request body',
+                        },
+                    ],
+                    default: 'createFrameItemPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['itemsGroup'] } },
+                    options: [
+                        {
+                            name: 'Create Group',
+                            value: 'createGroupPost',
+                            action: 'Creates group',
+                            description: 'Creates a group of items on a board. The group is created with the items that are passed in the request body.',
+                        },
+                        {
+                            name: 'Delete Group and Its Items',
+                            value: 'deleteGroupDelete',
+                            action: 'Deletes group and its items',
+                            description: 'Deletes a group from a board. All the items in the group are deleted along with the group. Note - this endpoint will delete items which are locked as well.',
+                        },
+                        {
+                            name: 'Get a Group by Its ID',
+                            value: 'getGroupByIdGet',
+                            action: 'Gets a group by its ID',
+                            description: 'Returns a list of items in a specific group',
+                        },
+                        {
+                            name: 'Get All Groups on a Board',
+                            value: 'getAllGroupsGet',
+                            action: 'Gets all groups on a board',
+                            description: 'Returns all the groups and the items of the respective groups within a specific board',
+                        },
+                        {
+                            name: 'Get Items of a Group by ID',
+                            value: 'getItemsByGroupIdGet',
+                            action: 'Gets items of a group by ID',
+                            description: 'Returns a list of items that are a part of any group, within a specific board',
+                        },
+                        {
+                            name: 'Ungroup Items',
+                            value: 'unGroupDelete',
+                            action: 'Ungroups items',
+                            description: 'Ungroups items from a group',
+                        },
+                        {
+                            name: 'Update Group with New Items',
+                            value: 'updateGroupPut',
+                            action: 'Updates group with new items',
+                            description: 'This endpoint updates an existing group by replacing it entirely with a new group. When the update is made, the original group is completely replaced, and a new group ID is assigned.',
+                        },
+                    ],
+                    default: 'createGroupPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['itemsImage'] } },
+                    options: [
+                        {
+                            name: 'Create Image Item Using File From Device',
+                            value: 'createImageItemUsingLocalFilePost',
+                            action: 'Creates image item using file from device',
+                            description: 'Adds an image item to a board by specifying a file from device',
+                        },
+                        {
+                            name: 'Create Image Item Using URL',
+                            value: 'createImageItemUsingUrlPost',
+                            action: 'Creates image item using URL',
+                            description: 'Adds an image item to a board by specifying an image URL',
+                        },
+                        {
+                            name: 'Delete Image Item',
+                            value: 'deleteImageItemDelete',
+                            action: 'Deletes image item',
+                            description: 'Deletes an image item from the board',
+                        },
+                        {
+                            name: 'Get Image Item',
+                            value: 'getImageItemGet',
+                            action: 'Gets image item',
+                            description: 'Retrieves information for a specific image item on a board',
+                        },
+                        {
+                            name: 'Update Image Item Using File From Device',
+                            value: 'updateImageItemUsingFileFromDevicePatch',
+                            action: 'Updates image item using file from device',
+                            description: 'Updates an image item on a board',
+                        },
+                        {
+                            name: 'Update Image Item Using URL',
+                            value: 'updateImageItemUsingUrlPatch',
+                            action: 'Updates image item using URL',
+                            description: 'Updates an image item on a board',
+                        },
+                    ],
+                    default: 'createImageItemUsingLocalFilePost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['itemsItem'] } },
+                    options: [
+                        {
+                            name: 'Create Items in Bulk',
+                            value: 'createItemsPost',
+                            action: 'Creates items in bulk',
+                            description: 'Adds different types of items to a board. You can add up to 20 items of the same or different type per create call. For example, you can create 3 shape items, 4 card items, and 5 sticky notes in one create call.',
+                        },
+                        {
+                            name: 'Create Items in Bulk Using File From Device',
+                            value: 'createItemsInBulkUsingFileFromDevicePost',
+                            action: 'Creates items in bulk using file from device',
+                            description: 'Adds different types of items to a board using files from a device. You can add up to 20 items of the same or different type per create call. For example, you can create 5 document items and 5 images in one create call.',
+                        },
+                        {
+                            name: 'Delete Experimental Item',
+                            value: 'deleteItemExperimentalDelete',
+                            action: 'Deletes experimental item',
+                            description: 'Deletes an item from a board (experimental Miro API, may change without notice)',
+                        },
+                        {
+                            name: 'Delete Item',
+                            value: 'deleteItemDelete',
+                            action: 'Deletes item',
+                            description: 'Deletes an item from a board',
+                        },
+                        {
+                            name: 'Get Experimental Items on Board',
+                            value: 'getItemsExperimentalGet',
+                            action: 'Gets experimental items on board',
+                            description: 'Retrieves a list of items for a specific board. You can retrieve all items on the board, a list of child items inside a parent item, or a list of specific types of items by specifying URL query parameter values (experimental Miro API, may change without notice).',
+                        },
+                        {
+                            name: 'Get Items on Board',
+                            value: 'getItemsGet',
+                            action: 'Gets items on board',
+                            description: 'Retrieves a list of items for a specific board. You can retrieve all items on the board, a list of child items inside a parent item, or a list of specific types of items by specifying URL query parameter values.',
+                        },
+                        {
+                            name: 'Get Specific Experimental Item on Board',
+                            value: 'getSpecificItemExperimentalGet',
+                            action: 'Gets specific experimental item on board',
+                            description: 'Retrieves information for a specific item on a board (experimental Miro API, may change without notice)',
+                        },
+                        {
+                            name: 'Get Specific Item on Board',
+                            value: 'getSpecificItemGet',
+                            action: 'Gets specific item on board',
+                            description: 'Retrieves information for a specific item on a board',
+                        },
+                        {
+                            name: 'Update Item Position or Parent',
+                            value: 'updateItemPositionOrParentPatch',
+                            action: 'Updates item position or parent',
+                            description: 'Updates the position or the parent of an item on a board',
+                        },
+                    ],
+                    default: 'createItemsPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['itemsMindMapNode'] } },
+                    options: [
+                        {
+                            name: 'Create Mind Map Node',
+                            value: 'createMindmapNodesExperimentalPost',
+                            action: 'Creates mind map node',
+                            description: 'Adds a mind map node to a board. A root node is the starting point of a mind map. A node that is created under a root node is a child node. For information on mind maps, use cases, mind map structure, and more, see the Mind Map Overview page (experimental Miro API, may change without notice).',
+                        },
+                        {
+                            name: 'Delete Mind Map Node',
+                            value: 'deleteMindmapNodeExperimentalDelete',
+                            action: 'Deletes mind map node',
+                            description: 'Deletes a mind map node item and its child nodes from the board (experimental Miro API, may change without notice)',
+                        },
+                        {
+                            name: 'Get Mind Map Nodes',
+                            value: 'getMindmapNodesExperimentalGet',
+                            action: 'Gets mind map nodes',
+                            description: 'Retrieves a list of mind map nodes for a specific board. This method returns results using a cursor-based approach (experimental Miro API, may change without notice).',
+                        },
+                        {
+                            name: 'Get Specific Mind Map Node',
+                            value: 'getMindmapNodeExperimentalGet',
+                            action: 'Gets specific mind map node',
+                            description: 'Retrieves information for a specific mind map node on a board (experimental Miro API, may change without notice)',
+                        },
+                    ],
+                    default: 'createMindmapNodesExperimentalPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['itemsShape'] } },
+                    options: [
+                        {
+                            name: 'Create Shape Item',
+                            value: 'createShapeItemPost',
+                            action: 'Creates shape item',
+                            description: 'Adds a shape item to a board',
+                        },
+                        {
+                            name: 'Delete Shape Item',
+                            value: 'deleteShapeItemDelete',
+                            action: 'Deletes shape item',
+                            description: 'Deletes a shape item from the board',
+                        },
+                        {
+                            name: 'Get Shape Item',
+                            value: 'getShapeItemGet',
+                            action: 'Gets shape item',
+                            description: 'Retrieves information for a specific shape item on a board',
+                        },
+                        {
+                            name: 'Update Shape Item',
+                            value: 'updateShapeItemPatch',
+                            action: 'Updates shape item',
+                            description: 'Updates a shape item on a board based on the data and style properties provided in the request body',
+                        },
+                    ],
+                    default: 'createShapeItemPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['itemsStickyNote'] } },
+                    options: [
+                        {
+                            name: 'Create Sticky Note Item',
+                            value: 'createStickyNoteItemPost',
+                            action: 'Creates sticky note item',
+                            description: 'Adds a sticky note item to a board',
+                        },
+                        {
+                            name: 'Delete Sticky Note Item',
+                            value: 'deleteStickyNoteItemDelete',
+                            action: 'Deletes sticky note item',
+                            description: 'Deletes a sticky note item from the board',
+                        },
+                        {
+                            name: 'Get Sticky Note Item',
+                            value: 'getStickyNoteItemGet',
+                            action: 'Gets sticky note item',
+                            description: 'Retrieves information for a specific sticky note item on a board',
+                        },
+                        {
+                            name: 'Update Sticky Note Item',
+                            value: 'updateStickyNoteItemPatch',
+                            action: 'Updates sticky note item',
+                            description: 'Updates a sticky note item on a board based on the data and style properties provided in the request body',
+                        },
+                    ],
+                    default: 'createStickyNoteItemPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['itemsTag'] } },
+                    options: [
+                        {
+                            name: 'Attach Tag to Item',
+                            value: 'attachTagToItemPost',
+                            action: 'Attaches tag to item',
+                            description: 'Attach an existing tag to the specified item. Card and sticky note items can have up to 8 tags.',
+                        },
+                        {
+                            name: 'Create Tag',
+                            value: 'createTagPost',
+                            action: 'Creates tag',
+                            description: 'Creates a tag on a board',
+                        },
+                        {
+                            name: 'Delete Tag',
+                            value: 'deleteTagDelete',
+                            action: 'Deletes tag',
+                            description: 'Deletes the specified tag from the board. The tag is also removed from all cards and sticky notes on the board.',
+                        },
+                        {
+                            name: 'Get Items by Tag',
+                            value: 'getItemsByTagGet',
+                            action: 'Gets items by tag',
+                            description: 'Retrieves all the items that have the specified tag',
+                        },
+                        {
+                            name: 'Get Tag',
+                            value: 'getTagGet',
+                            action: 'Gets tag',
+                            description: 'Retrieves information for a specific tag',
+                        },
+                        {
+                            name: 'Get Tags From Board',
+                            value: 'getTagsFromBoardGet',
+                            action: 'Gets tags from board',
+                            description: 'Retrieves all the tags from the specified board',
+                        },
+                        {
+                            name: 'Get Tags From Item',
+                            value: 'getTagsFromItemGet',
+                            action: 'Gets tags from item',
+                            description: 'Retrieves all the tags from the specified item',
+                        },
+                        {
+                            name: 'Remove Tag From Item',
+                            value: 'removeTagFromItemDelete',
+                            action: 'Removes tag from item',
+                            description: 'Removes the specified tag from the specified item. The tag still exists on the board.',
+                        },
+                        {
+                            name: 'Update Tag',
+                            value: 'updateTagPatch',
+                            action: 'Updates tag',
+                            description: 'Updates a tag based on the data properties provided in the request body',
+                        },
+                    ],
+                    default: 'attachTagToItemPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['itemsText'] } },
+                    options: [
+                        {
+                            name: 'Create Text Item',
+                            value: 'createTextItemPost',
+                            action: 'Creates text item',
+                            description: 'Adds a text item to a board',
+                        },
+                        {
+                            name: 'Delete Text Item',
+                            value: 'deleteTextItemDelete',
+                            action: 'Deletes text item',
+                            description: 'Deletes a text item from the board',
+                        },
+                        {
+                            name: 'Get Text Item',
+                            value: 'getTextItemGet',
+                            action: 'Gets text item',
+                            description: 'Retrieves information for a specific text item on a board',
+                        },
+                        {
+                            name: 'Update Text Item',
+                            value: 'updateTextItemPatch',
+                            action: 'Updates text item',
+                            description: 'Updates a text item on a board based on the data and style properties provided in the request body',
+                        },
+                    ],
+                    default: 'createTextItemPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['organizationMember'] } },
+                    options: [
+                        {
+                            name: 'Get Organization Member',
+                            value: 'enterpriseGetOrganizationMemberGet',
+                            action: 'Gets organization member',
+                            description: 'Retrieves organization member information for an existing organization',
+                        },
+                        {
+                            name: 'Get Organization Members',
+                            value: 'enterpriseGetOrganizationMembersGet',
+                            action: 'Gets organization members',
+                            description: 'Retrieves organization members based on the organization ID and the cursor, or based on the user emails provided in the request',
+                        },
+                    ],
+                    default: 'enterpriseGetOrganizationMemberGet',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['organizationOrganization'] } },
+                    options: [
+                        {
+                            name: 'Get Organization Info',
+                            value: 'enterpriseGetOrganizationGet',
+                            action: 'Gets organization info',
+                            description: 'Retrieves organization information',
+                        },
+                    ],
+                    default: 'enterpriseGetOrganizationGet',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['organizationProject'] } },
+                    options: [
+                        {
+                            name: 'Create Project',
+                            value: 'enterpriseCreateProjectPost',
+                            action: 'Creates project',
+                            description: 'Projects are essentially folders of boards with the option to manage user access for a smaller group of people within a team. Projects are here to help you organize your boards and make them easier to find and share.',
+                        },
+                        {
+                            name: 'Delete Project',
+                            value: 'enterpriseDeleteProjectDelete',
+                            action: 'Deletes project',
+                            description: 'Deletes a project. After a project is deleted, all boards and users that belong to the project remain in the team.',
+                        },
+                        {
+                            name: 'Get Project',
+                            value: 'enterpriseGetProjectGet',
+                            action: 'Gets project',
+                            description: 'Retrieves project information, such as a name for an existing project',
+                        },
+                        {
+                            name: 'Get Projects',
+                            value: 'enterpriseGetProjectsGet',
+                            action: 'Gets projects',
+                            description: 'Retrieves the list of projects in an existing team of an organization. You can retrieve all projects, including all private projects (projects that haven\'t been specifically shared with you) by enabling Content Admin permissions.',
+                        },
+                        {
+                            name: 'Update Project',
+                            value: 'enterpriseUpdateProjectPatch',
+                            action: 'Updates project',
+                            description: 'Update information about a project, such as the project name',
+                        },
+                    ],
+                    default: 'enterpriseCreateProjectPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['organizationProjectMember'] } },
+                    options: [
+                        {
+                            name: 'Add Member in a Project',
+                            value: 'enterpriseAddProjectMemberPost',
+                            action: 'Adds member in a project',
+                            description: 'Add a Miro user to a project',
+                        },
+                        {
+                            name: 'Get Project Member',
+                            value: 'enterpriseGetProjectMemberGet',
+                            action: 'Gets project member',
+                            description: 'Retrieves information for a specific project member',
+                        },
+                        {
+                            name: 'Get Project Members',
+                            value: 'enterpriseGetProjectMembersGet',
+                            action: 'Gets project members',
+                            description: 'Retrieves the list of members for a specific project',
+                        },
+                        {
+                            name: 'Remove Project Member',
+                            value: 'enterpriseDeleteProjectMemberDelete',
+                            action: 'Removes project member',
+                            description: 'Remove a member from a project. The user remains in the team even after the member is removed from a project.',
+                        },
+                        {
+                            name: 'Update Project Member',
+                            value: 'enterpriseUpdateProjectMemberPatch',
+                            action: 'Updates project member',
+                            description: 'Updates details of a project member, such as the member\'s role',
+                        },
+                    ],
+                    default: 'enterpriseAddProjectMemberPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['organizationProjectSetting'] } },
+                    options: [
+                        {
+                            name: 'Get Project Settings',
+                            value: 'enterpriseGetProjectSettingsGet',
+                            action: 'Gets project settings',
+                            description: 'Retrieves the project settings',
+                        },
+                        {
+                            name: 'Update Project Settings',
+                            value: 'enterpriseUpdateProjectSettingsPatch',
+                            action: 'Updates project settings',
+                            description: 'Updates the settings of a project',
+                        },
+                    ],
+                    default: 'enterpriseGetProjectSettingsGet',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['organizationProjectUserGroupAssignment'] } },
+                    options: [
+                        {
+                            name: 'Create Project User Group Assignments',
+                            value: 'enterpriseProjectCreateGroupPost',
+                            action: 'Creates project user group assignments',
+                            description: 'Shares a project with user groups with a specified role. Updates the role if already shared.',
+                        },
+                        {
+                            name: 'Delete Project User Group Assignment',
+                            value: 'enterpriseProjectDeleteGroupsDelete',
+                            action: 'Deletes project user group assignment',
+                            description: 'Removes a user group from the specified project',
+                        },
+                        {
+                            name: 'Get Project User Group Assignments',
+                            value: 'enterpriseProjectsGetGroupsGet',
+                            action: 'Gets project user group assignments',
+                            description: 'Retrieves information about user groups invited to the specified project',
+                        },
+                    ],
+                    default: 'enterpriseProjectCreateGroupPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['organizationTeam'] } },
+                    options: [
+                        {
+                            name: 'Create Team',
+                            value: 'enterpriseCreateTeamPost',
+                            action: 'Creates team',
+                            description: 'Creates a new team in an existing organization',
+                        },
+                        {
+                            name: 'Delete Team',
+                            value: 'enterpriseDeleteTeamDelete',
+                            action: 'Deletes team',
+                            description: 'Deletes an existing team',
+                        },
+                        {
+                            name: 'Get Team',
+                            value: 'enterpriseGetTeamGet',
+                            action: 'Gets team',
+                            description: 'Retrieves team information for an existing team',
+                        },
+                        {
+                            name: 'Get Teams',
+                            value: 'enterpriseGetTeamsGet',
+                            action: 'Gets teams',
+                            description: 'Retrieves list of teams in an existing organization',
+                        },
+                        {
+                            name: 'Update Team',
+                            value: 'enterpriseUpdateTeamPatch',
+                            action: 'Updates team',
+                            description: 'Updates an existing team',
+                        },
+                    ],
+                    default: 'enterpriseCreateTeamPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['organizationTeamMember'] } },
+                    options: [
+                        {
+                            name: 'Delete Team Member From Team',
+                            value: 'enterpriseDeleteTeamMemberDelete',
+                            action: 'Deletes team member from team',
+                            description: 'Deletes team member from team by ID',
+                        },
+                        {
+                            name: 'Get Team Member',
+                            value: 'enterpriseGetTeamMemberGet',
+                            action: 'Gets team member',
+                            description: 'Retrieves team member by ID',
+                        },
+                        {
+                            name: 'Get Team Members',
+                            value: 'enterpriseGetTeamMembersGet',
+                            action: 'Gets team members',
+                            description: 'Retrieves team members by cursor',
+                        },
+                        {
+                            name: 'Invite Team Members',
+                            value: 'enterpriseInviteTeamMemberPost',
+                            action: 'Invites team members',
+                            description: 'Invites a new Miro user to an existing team. The user must exist in your Miro organization.',
+                        },
+                        {
+                            name: 'Update Team Member',
+                            value: 'enterpriseUpdateTeamMemberPatch',
+                            action: 'Updates team member',
+                            description: 'Updates team member role in team by ID',
+                        },
+                    ],
+                    default: 'enterpriseDeleteTeamMemberDelete',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['organizationTeamSetting'] } },
+                    options: [
+                        {
+                            name: 'Get Default Team Settings',
+                            value: 'enterpriseGetDefaultTeamSettingsGet',
+                            action: 'Gets default team settings',
+                            description: 'Retrieves default team settings of an existing organization',
+                        },
+                        {
+                            name: 'Get Team Settings',
+                            value: 'enterpriseGetTeamSettingsGet',
+                            action: 'Gets team settings',
+                            description: 'Retrieves team settings of an existing team',
+                        },
+                        {
+                            name: 'Update Team Settings',
+                            value: 'enterpriseUpdateTeamSettingsPatch',
+                            action: 'Updates team settings',
+                            description: 'Updates team settings of an existing team',
+                        },
+                    ],
+                    default: 'enterpriseGetDefaultTeamSettingsGet',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['organizationTeamUserGroup'] } },
+                    options: [
+                        {
+                            name: 'Create User Group to Team Connection',
+                            value: 'enterpriseTeamsCreateGroupPost',
+                            action: 'Creates user group to team connection',
+                            description: 'Adds a user group to a team in an organization',
+                        },
+                        {
+                            name: 'Delete User Group to Team Connection',
+                            value: 'enterpriseTeamsDeleteGroupDelete',
+                            action: 'Deletes user group to team connection',
+                            description: 'Removes a user group from a team in an existing organization',
+                        },
+                        {
+                            name: 'Get User Group of a Team',
+                            value: 'enterpriseTeamsGetGroupGet',
+                            action: 'Gets user group of a team',
+                            description: 'Retrieves information about a specific user group of a team',
+                        },
+                        {
+                            name: 'Get User Group to Team Connections',
+                            value: 'enterpriseTeamsGetGroupsGet',
+                            action: 'Gets user group to team connections',
+                            description: 'Retrieves the list of user groups that are part of a team in an organization',
+                        },
+                    ],
+                    default: 'enterpriseTeamsCreateGroupPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['organizationUserGroup'] } },
+                    options: [
+                        {
+                            name: 'Create User Group',
+                            value: 'enterpriseCreateGroupPost',
+                            action: 'Creates user group',
+                            description: 'Creates a new user group in an organization',
+                        },
+                        {
+                            name: 'Delete User Group',
+                            value: 'enterpriseDeleteGroupDelete',
+                            action: 'Deletes user group',
+                            description: 'Deletes a user group from an organization',
+                        },
+                        {
+                            name: 'Get User Group',
+                            value: 'enterpriseGetGroupGet',
+                            action: 'Gets user group',
+                            description: 'Retrieves a user group in an organization',
+                        },
+                        {
+                            name: 'Get User Groups',
+                            value: 'enterpriseGetGroupsGet',
+                            action: 'Gets user groups',
+                            description: 'Retrieves the list of user groups in an organization',
+                        },
+                        {
+                            name: 'Update User Group',
+                            value: 'enterpriseUpdateGroupPatch',
+                            action: 'Updates user group',
+                            description: 'Updates a user group in an organization',
+                        },
+                    ],
+                    default: 'enterpriseCreateGroupPost',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['organizationUserGroupMember'] } },
+                    options: [
+                        {
+                            name: 'Bulk Edit of Membership in User Group',
+                            value: 'enterpriseUpdateGroupMembersPatch',
+                            action: 'Bulk edits of membership in user group',
+                            description: 'Add and remove members in one request. For example, remove user A and add user B. You can add or remove up to 500 users at a time.',
+                        },
+                        {
+                            name: 'Create User Group Member',
+                            value: 'enterpriseCreateGroupMemberPost',
+                            action: 'Creates user group member',
+                            description: 'Adds a member to a user group in an organization',
+                        },
+                        {
+                            name: 'Delete User Group Member',
+                            value: 'enterpriseDeleteGroupMemberDelete',
+                            action: 'Deletes user group member',
+                            description: 'Removes a member from a user group in an organization',
+                        },
+                        {
+                            name: 'Get User Group Member',
+                            value: 'enterpriseGetGroupMemberGet',
+                            action: 'Gets user group member',
+                            description: 'Retrieves information about a user group member in an organization',
+                        },
+                        {
+                            name: 'Get User Group Members',
+                            value: 'enterpriseGetGroupMembersGet',
+                            action: 'Gets user group members',
+                            description: 'Retrieves the list of members who are part of a team in an existing organization',
+                        },
+                    ],
+                    default: 'enterpriseUpdateGroupMembersPatch',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['organizationUserGroupTeam'] } },
+                    options: [
+                        {
+                            name: 'Get Teams of a User Group',
+                            value: 'enterpriseGroupsGetTeamsGet',
+                            action: 'Gets teams of a user group',
+                            description: 'Retrieves the list of teams that the user group is a part of',
+                        },
+                        {
+                            name: 'Get User Group Team',
+                            value: 'enterpriseGroupsGetTeamGet',
+                            action: 'Gets user group team',
+                            description: 'Retrieves information of a team that the user group is a part of in an organization',
+                        },
+                    ],
+                    default: 'enterpriseGroupsGetTeamsGet',
+                },
+                {
+                    displayName: 'App ID',
+                    name: 'app_id',
+                    type: 'string',
+                    default: '',
+                    description: 'Unique identifier (ID) of the app',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'getMetricsGet',
+                                'getMetricsTotalGet',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Board ID',
+                    name: 'board_id',
+                    type: 'string',
+                    default: '',
+                    description: 'Unique identifier (ID) of the board',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'attachTagToItemPost',
+                                'createAppCardItemPost',
+                                'createCardItemPost',
+                                'createCodeWidgetItemPost',
+                                'createConnectorPost',
+                                'createDocFormatItemPost',
+                                'createDocumentItemUsingFileFromDevicePost',
+                                'createDocumentItemUsingUrlPost',
+                                'createEmbedItemPost',
+                                'createFrameItemPost',
+                                'createGroupPost',
+                                'createImageItemUsingLocalFilePost',
+                                'createImageItemUsingUrlPost',
+                                'createItemsInBulkUsingFileFromDevicePost',
+                                'createItemsPost',
+                                'createMindmapNodesExperimentalPost',
+                                'createShapeItemFlowchartPost',
+                                'createShapeItemPost',
+                                'createStickyNoteItemPost',
+                                'createTagPost',
+                                'createTextItemPost',
+                                'deleteAppCardItemDelete',
+                                'deleteBoardDelete',
+                                'deleteCardItemDelete',
+                                'deleteCodeWidgetItemDelete',
+                                'deleteConnectorDelete',
+                                'deleteDocFormatItemDelete',
+                                'deleteDocumentItemDelete',
+                                'deleteEmbedItemDelete',
+                                'deleteFrameItemDelete',
+                                'deleteGroupDelete',
+                                'deleteImageItemDelete',
+                                'deleteItemDelete',
+                                'deleteItemExperimentalDelete',
+                                'deleteMindmapNodeExperimentalDelete',
+                                'deleteShapeItemDelete',
+                                'deleteShapeItemFlowchartDelete',
+                                'deleteStickyNoteItemDelete',
+                                'deleteTagDelete',
+                                'deleteTextItemDelete',
+                                'enterpriseBoardsCreateGroupPost',
+                                'enterpriseBoardsDeleteGroupsDelete',
+                                'enterpriseBoardsGetGroupsGet',
+                                'enterpriseDataclassificationBoardGetGet',
+                                'enterpriseDataclassificationBoardSetPost',
+                                'getAllGroupsGet',
+                                'getAppCardItemGet',
+                                'getBoardMembersGet',
+                                'getCardItemGet',
+                                'getCodeWidgetItemGet',
+                                'getCodeWidgetItemsGet',
+                                'getConnectorGet',
+                                'getConnectorsGet',
+                                'getDocFormatItemGet',
+                                'getDocumentItemGet',
+                                'getEmbedItemGet',
+                                'getFrameItemGet',
+                                'getGroupByIdGet',
+                                'getImageItemGet',
+                                'getItemsByGroupIdGet',
+                                'getItemsByTagGet',
+                                'getItemsExperimentalGet',
+                                'getItemsGet',
+                                'getItemsWithinFrameGet',
+                                'getMindmapNodeExperimentalGet',
+                                'getMindmapNodesExperimentalGet',
+                                'getShapeItemFlowchartGet',
+                                'getShapeItemGet',
+                                'getSpecificBoardGet',
+                                'getSpecificBoardMemberGet',
+                                'getSpecificItemExperimentalGet',
+                                'getSpecificItemGet',
+                                'getStickyNoteItemGet',
+                                'getTagGet',
+                                'getTagsFromBoardGet',
+                                'getTagsFromItemGet',
+                                'getTextItemGet',
+                                'moveCodeWidgetItemPatch',
+                                'removeBoardMemberDelete',
+                                'removeTagFromItemDelete',
+                                'shareBoardPost',
+                                'unGroupDelete',
+                                'updateAppCardItemPatch',
+                                'updateBoardMemberPatch',
+                                'updateBoardPatch',
+                                'updateCardItemPatch',
+                                'updateCodeWidgetItemPatch',
+                                'updateConnectorPatch',
+                                'updateDocumentItemUsingFileFromDevicePatch',
+                                'updateDocumentItemUsingUrlPatch',
+                                'updateEmbedItemPatch',
+                                'updateFrameItemPatch',
+                                'updateGroupPut',
+                                'updateImageItemUsingFileFromDevicePatch',
+                                'updateImageItemUsingUrlPatch',
+                                'updateItemPositionOrParentPatch',
+                                'updateShapeItemFlowchartPatch',
+                                'updateShapeItemPatch',
+                                'updateStickyNoteItemPatch',
+                                'updateTagPatch',
+                                'updateTextItemPatch',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Board Member ID',
+                    name: 'board_member_id',
+                    type: 'string',
+                    default: '',
+                    description: 'Unique identifier (ID) of the board member',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'getSpecificBoardMemberGet',
+                                'removeBoardMemberDelete',
+                                'updateBoardMemberPatch',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Case ID',
+                    name: 'case_id',
+                    type: 'string',
+                    default: '',
+                    description: 'Unique identifier (ID) of the case',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'createLegalHoldPost',
+                                'deleteCaseDelete',
+                                'deleteLegalHoldDelete',
+                                'editCasePut',
+                                'editLegalHoldPut',
+                                'getAllLegalHoldsGet',
+                                'getCaseGet',
+                                'getLegalHoldContentItemsGet',
+                                'getLegalHoldExportJobsGet',
+                                'getLegalHoldGet',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Connector ID',
+                    name: 'connector_id',
+                    type: 'string',
+                    default: '',
+                    description: 'Unique identifier (ID) of the connector',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'deleteConnectorDelete',
+                                'getConnectorGet',
+                                'updateConnectorPatch',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Group ID',
+                    name: 'group_id',
+                    type: 'string',
+                    default: '',
+                    description: 'Unique identifier (ID) of the group',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'deleteGroupDelete',
+                                'enterpriseBoardsDeleteGroupsDelete',
+                                'enterpriseCreateGroupMemberPost',
+                                'enterpriseDeleteGroupDelete',
+                                'enterpriseDeleteGroupMemberDelete',
+                                'enterpriseGetGroupGet',
+                                'enterpriseGetGroupMemberGet',
+                                'enterpriseGetGroupMembersGet',
+                                'enterpriseGroupsGetTeamGet',
+                                'enterpriseGroupsGetTeamsGet',
+                                'enterpriseProjectDeleteGroupsDelete',
+                                'enterpriseTeamsDeleteGroupDelete',
+                                'enterpriseTeamsGetGroupGet',
+                                'enterpriseUpdateGroupMembersPatch',
+                                'enterpriseUpdateGroupPatch',
+                                'getGroupByIdGet',
+                                'unGroupDelete',
+                                'updateGroupPut',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Item ID',
+                    name: 'item_id',
+                    type: 'string',
+                    default: '',
+                    description: 'Unique identifier (ID) of the item',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'attachTagToItemPost',
+                                'deleteAppCardItemDelete',
+                                'deleteCardItemDelete',
+                                'deleteCodeWidgetItemDelete',
+                                'deleteDocFormatItemDelete',
+                                'deleteDocumentItemDelete',
+                                'deleteEmbedItemDelete',
+                                'deleteFrameItemDelete',
+                                'deleteImageItemDelete',
+                                'deleteItemDelete',
+                                'deleteItemExperimentalDelete',
+                                'deleteMindmapNodeExperimentalDelete',
+                                'deleteShapeItemDelete',
+                                'deleteShapeItemFlowchartDelete',
+                                'deleteStickyNoteItemDelete',
+                                'deleteTextItemDelete',
+                                'getAppCardItemGet',
+                                'getCardItemGet',
+                                'getCodeWidgetItemGet',
+                                'getDocFormatItemGet',
+                                'getDocumentItemGet',
+                                'getEmbedItemGet',
+                                'getFrameItemGet',
+                                'getImageItemGet',
+                                'getMindmapNodeExperimentalGet',
+                                'getShapeItemFlowchartGet',
+                                'getShapeItemGet',
+                                'getSpecificItemExperimentalGet',
+                                'getSpecificItemGet',
+                                'getStickyNoteItemGet',
+                                'getTagsFromItemGet',
+                                'getTextItemGet',
+                                'moveCodeWidgetItemPatch',
+                                'removeTagFromItemDelete',
+                                'updateAppCardItemPatch',
+                                'updateCardItemPatch',
+                                'updateCodeWidgetItemPatch',
+                                'updateDocumentItemUsingFileFromDevicePatch',
+                                'updateDocumentItemUsingUrlPatch',
+                                'updateEmbedItemPatch',
+                                'updateFrameItemPatch',
+                                'updateImageItemUsingFileFromDevicePatch',
+                                'updateImageItemUsingUrlPatch',
+                                'updateItemPositionOrParentPatch',
+                                'updateShapeItemFlowchartPatch',
+                                'updateShapeItemPatch',
+                                'updateStickyNoteItemPatch',
+                                'updateTextItemPatch',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Job ID',
+                    name: 'job_id',
+                    type: 'string',
+                    default: '',
+                    description: 'Unique identifier (ID) of the board export job',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'enterpriseBoardExportJobResultsGet',
+                                'enterpriseBoardExportJobStatusGet',
+                                'enterpriseBoardExportJobTasksGet',
+                                'enterpriseCreateBoardExportTaskExportLinkPost',
+                                'enterpriseUpdateBoardExportJobPut',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Legal Hold ID',
+                    name: 'legal_hold_id',
+                    type: 'string',
+                    default: '',
+                    description: 'Unique identifier (ID) of the legal hold',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'deleteLegalHoldDelete',
+                                'editLegalHoldPut',
+                                'getLegalHoldContentItemsGet',
+                                'getLegalHoldGet',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Member ID',
+                    name: 'member_id',
+                    type: 'string',
+                    default: '',
+                    description: 'Unique identifier (ID) of the member',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'enterpriseDeleteGroupMemberDelete',
+                                'enterpriseDeleteProjectMemberDelete',
+                                'enterpriseDeleteTeamMemberDelete',
+                                'enterpriseGetGroupMemberGet',
+                                'enterpriseGetOrganizationMemberGet',
+                                'enterpriseGetProjectMemberGet',
+                                'enterpriseGetTeamMemberGet',
+                                'enterpriseUpdateProjectMemberPatch',
+                                'enterpriseUpdateTeamMemberPatch',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Organization ID',
+                    name: 'org_id',
+                    type: 'string',
+                    default: '',
+                    description: 'Unique identifier (ID) of the organization',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'createCasePost',
+                                'createLegalHoldPost',
+                                'deleteCaseDelete',
+                                'deleteLegalHoldDelete',
+                                'editCasePut',
+                                'editLegalHoldPut',
+                                'enterpriseAddProjectMemberPost',
+                                'enterpriseBoardContentItemLogsFetchGet',
+                                'enterpriseBoardExportJobResultsGet',
+                                'enterpriseBoardExportJobStatusGet',
+                                'enterpriseBoardExportJobTasksGet',
+                                'enterpriseBoardExportJobsGet',
+                                'enterpriseBoardsCreateGroupPost',
+                                'enterpriseBoardsDeleteGroupsDelete',
+                                'enterpriseBoardsGetGroupsGet',
+                                'enterpriseCreateBoardExportPost',
+                                'enterpriseCreateBoardExportTaskExportLinkPost',
+                                'enterpriseCreateGroupMemberPost',
+                                'enterpriseCreateGroupPost',
+                                'enterpriseCreateProjectPost',
+                                'enterpriseCreateTeamPost',
+                                'enterpriseDataclassificationBoardGetGet',
+                                'enterpriseDataclassificationBoardSetPost',
+                                'enterpriseDataclassificationOrganizationSettingsGetGet',
+                                'enterpriseDataclassificationTeamBoardsBulkPatch',
+                                'enterpriseDataclassificationTeamSettingsGetGet',
+                                'enterpriseDataclassificationTeamSettingsSetPatch',
+                                'enterpriseDeleteGroupDelete',
+                                'enterpriseDeleteGroupMemberDelete',
+                                'enterpriseDeleteProjectDelete',
+                                'enterpriseDeleteProjectMemberDelete',
+                                'enterpriseDeleteTeamDelete',
+                                'enterpriseDeleteTeamMemberDelete',
+                                'enterpriseGetAiInteractionLogsGet',
+                                'enterpriseGetDefaultTeamSettingsGet',
+                                'enterpriseGetGroupGet',
+                                'enterpriseGetGroupMemberGet',
+                                'enterpriseGetGroupMembersGet',
+                                'enterpriseGetGroupsGet',
+                                'enterpriseGetOrganizationGet',
+                                'enterpriseGetOrganizationMemberGet',
+                                'enterpriseGetOrganizationMembersGet',
+                                'enterpriseGetProjectGet',
+                                'enterpriseGetProjectMemberGet',
+                                'enterpriseGetProjectMembersGet',
+                                'enterpriseGetProjectSettingsGet',
+                                'enterpriseGetProjectsGet',
+                                'enterpriseGetTeamGet',
+                                'enterpriseGetTeamMemberGet',
+                                'enterpriseGetTeamMembersGet',
+                                'enterpriseGetTeamSettingsGet',
+                                'enterpriseGetTeamsGet',
+                                'enterpriseGroupsGetTeamGet',
+                                'enterpriseGroupsGetTeamsGet',
+                                'enterpriseInviteTeamMemberPost',
+                                'enterpriseProjectCreateGroupPost',
+                                'enterpriseProjectDeleteGroupsDelete',
+                                'enterpriseProjectsGetGroupsGet',
+                                'enterpriseTeamsCreateGroupPost',
+                                'enterpriseTeamsDeleteGroupDelete',
+                                'enterpriseTeamsGetGroupGet',
+                                'enterpriseTeamsGetGroupsGet',
+                                'enterpriseUpdateBoardExportJobPut',
+                                'enterpriseUpdateGroupMembersPatch',
+                                'enterpriseUpdateGroupPatch',
+                                'enterpriseUpdateProjectMemberPatch',
+                                'enterpriseUpdateProjectPatch',
+                                'enterpriseUpdateProjectSettingsPatch',
+                                'enterpriseUpdateTeamMemberPatch',
+                                'enterpriseUpdateTeamPatch',
+                                'enterpriseUpdateTeamSettingsPatch',
+                                'getAllCasesGet',
+                                'getAllLegalHoldsGet',
+                                'getCaseGet',
+                                'getLegalHoldContentItemsGet',
+                                'getLegalHoldExportJobsGet',
+                                'getLegalHoldGet',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Project ID',
+                    name: 'project_id',
+                    type: 'string',
+                    default: '',
+                    description: 'Unique identifier (ID) of the project',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'enterpriseAddProjectMemberPost',
+                                'enterpriseDeleteProjectDelete',
+                                'enterpriseDeleteProjectMemberDelete',
+                                'enterpriseGetProjectGet',
+                                'enterpriseGetProjectMemberGet',
+                                'enterpriseGetProjectMembersGet',
+                                'enterpriseGetProjectSettingsGet',
+                                'enterpriseProjectCreateGroupPost',
+                                'enterpriseProjectDeleteGroupsDelete',
+                                'enterpriseProjectsGetGroupsGet',
+                                'enterpriseUpdateProjectMemberPatch',
+                                'enterpriseUpdateProjectPatch',
+                                'enterpriseUpdateProjectSettingsPatch',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Tag ID',
+                    name: 'tag_id',
+                    type: 'string',
+                    default: '',
+                    description: 'Unique identifier (ID) of the tag',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'deleteTagDelete',
+                                'getTagGet',
+                                'updateTagPatch',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Task ID',
+                    name: 'task_id',
+                    type: 'string',
+                    default: '',
+                    description: 'Unique identifier (ID) of the board export task',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'enterpriseCreateBoardExportTaskExportLinkPost',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Team ID',
+                    name: 'team_id',
+                    type: 'string',
+                    default: '',
+                    description: 'Unique identifier (ID) of the team',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'enterpriseAddProjectMemberPost',
+                                'enterpriseCreateProjectPost',
+                                'enterpriseDataclassificationBoardGetGet',
+                                'enterpriseDataclassificationBoardSetPost',
+                                'enterpriseDataclassificationTeamBoardsBulkPatch',
+                                'enterpriseDataclassificationTeamSettingsGetGet',
+                                'enterpriseDataclassificationTeamSettingsSetPatch',
+                                'enterpriseDeleteProjectDelete',
+                                'enterpriseDeleteProjectMemberDelete',
+                                'enterpriseDeleteTeamDelete',
+                                'enterpriseDeleteTeamMemberDelete',
+                                'enterpriseGetProjectGet',
+                                'enterpriseGetProjectMemberGet',
+                                'enterpriseGetProjectMembersGet',
+                                'enterpriseGetProjectSettingsGet',
+                                'enterpriseGetProjectsGet',
+                                'enterpriseGetTeamGet',
+                                'enterpriseGetTeamMemberGet',
+                                'enterpriseGetTeamMembersGet',
+                                'enterpriseGetTeamSettingsGet',
+                                'enterpriseGroupsGetTeamGet',
+                                'enterpriseInviteTeamMemberPost',
+                                'enterpriseTeamsCreateGroupPost',
+                                'enterpriseTeamsDeleteGroupDelete',
+                                'enterpriseTeamsGetGroupGet',
+                                'enterpriseTeamsGetGroupsGet',
+                                'enterpriseUpdateProjectMemberPatch',
+                                'enterpriseUpdateProjectPatch',
+                                'enterpriseUpdateProjectSettingsPatch',
+                                'enterpriseUpdateTeamMemberPatch',
+                                'enterpriseUpdateTeamPatch',
+                                'enterpriseUpdateTeamSettingsPatch',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Binary Property',
+                    name: 'binaryPropertyName',
+                    type: 'string',
+                    default: 'data',
+                    required: true,
+                    description: 'Name of the binary property that holds the file to upload. Miro rejects uploads larger than 6 MB.',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'createDocumentItemUsingFileFromDevicePost',
+                                'createImageItemUsingLocalFilePost',
+                                'createItemsInBulkUsingFileFromDevicePost',
+                                'updateDocumentItemUsingFileFromDevicePatch',
+                                'updateImageItemUsingFileFromDevicePatch',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Resource Binary Properties',
+                    name: 'resourceBinaryProperties',
+                    type: 'string',
+                    default: 'resource',
+                    required: true,
+                    description: 'Comma-separated names of the binary properties that hold the files to create, 20 at most',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'createItemsInBulkUsingFileFromDevicePost',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Query Parameters',
+                    name: 'queryParameters',
+                    type: 'collection',
+                    placeholder: 'Add Query Parameters',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Active',
+                            name: 'active',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to return only active organization members',
+                        },
+                        {
+                            displayName: 'Board IDs',
+                            name: 'board_ids',
+                            type: 'string',
+                            default: '',
+                            description: 'List of board IDs for which you want to retrieve the content logs Provide a comma-separated list',
+                        },
+                        {
+                            displayName: 'Copy From',
+                            name: 'copy_from',
+                            type: 'string',
+                            default: '',
+                            description: 'Unique identifier (ID) of the board that you want to copy',
+                        },
+                        {
+                            displayName: 'Created After',
+                            name: 'createdAfter',
+                            type: 'string',
+                            default: '',
+                            description: 'Retrieve audit logs created after this date, as an ISO-8601 timestamp',
+                        },
+                        {
+                            displayName: 'Created Before',
+                            name: 'createdBefore',
+                            type: 'string',
+                            default: '',
+                            description: 'Retrieve audit logs created before this date, as an ISO-8601 timestamp',
+                        },
+                        {
+                            displayName: 'Creator ID',
+                            name: 'creatorId',
+                            type: 'string',
+                            default: '',
+                            description: 'Unique identifier of the board export job creator Provide a comma-separated list',
+                        },
+                        {
+                            displayName: 'Cursor',
+                            name: 'cursor',
+                            type: 'string',
+                            default: '',
+                            description: 'A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results',
+                        },
+                        {
+                            displayName: 'Email',
+                            name: 'email',
+                            placeholder: 'name@email.com',
+                            type: 'string',
+                            default: '',
+                            description: 'Email address of the user whose sessions you want to reset',
+                        },
+                        {
+                            displayName: 'Emails',
+                            name: 'emails',
+                            type: 'string',
+                            default: '',
+                            description: 'Filters AI interaction logs using a list of user emails. Only AI interactions associated with the provided emails will be included in the response. Provide a comma-separated list.',
+                        },
+                        {
+                            displayName: 'End Date',
+                            name: 'endDate',
+                            type: 'string',
+                            default: '',
+                            description: 'End date of the reporting period, as YYYY-MM-DD',
+                        },
+                        {
+                            displayName: 'From',
+                            name: 'from',
+                            type: 'string',
+                            default: '',
+                            description: 'Start of the period to retrieve, as an ISO-8601 timestamp',
+                        },
+                        {
+                            displayName: 'Group Item ID',
+                            name: 'group_item_id',
+                            type: 'string',
+                            default: '',
+                            description: 'Unique identifier (ID) of the group whose items you want to retrieve',
+                        },
+                        {
+                            displayName: 'License',
+                            name: 'license',
+                            type: 'options',
+                            options: [
+                                { name: 'Advanced', value: 'advanced' },
+                                { name: 'Basic', value: 'basic' },
+                                { name: 'Free', value: 'free' },
+                                { name: 'Free Restricted', value: 'free_restricted' },
+                                { name: 'Full', value: 'full' },
+                                { name: 'Full Trial', value: 'full_trial' },
+                                { name: 'Occasional', value: 'occasional' },
+                                { name: 'Standard', value: 'standard' },
+                                { name: 'Unknown', value: 'unknown' },
+                            ],
+                            default: 'advanced',
+                            description: 'Filter organization members by the license assigned to them',
+                        },
+                        {
+                            displayName: 'Limit',
+                            name: 'limit',
+                            type: 'number',
+                            typeOptions: { minValue: 1 },
+                            default: 50,
+                            description: 'Max number of results to return',
+                        },
+                        {
+                            displayName: 'Name',
+                            name: 'name',
+                            type: 'string',
+                            default: '',
+                            description: 'Name query. Filters teams by name using case insensitive partial match. A value "dev" will return both "Developer\'s team" and "Team for developers".',
+                        },
+                        {
+                            displayName: 'Object IDs',
+                            name: 'object_ids',
+                            type: 'string',
+                            default: '',
+                            description: 'List of object IDs used to retrieve AI interaction logs. Currently, supported object types include board IDs and organization IDs. Provide a comma-separated list.',
+                        },
+                        {
+                            displayName: 'Offset',
+                            name: 'offset',
+                            type: 'string',
+                            default: '',
+                            description: 'Number of results to skip before returning results',
+                        },
+                        {
+                            displayName: 'Owner',
+                            name: 'owner',
+                            type: 'string',
+                            default: '',
+                            description: 'Filter boards by the email address of their owner',
+                        },
+                        {
+                            displayName: 'Parent Item ID',
+                            name: 'parent_item_id',
+                            type: 'string',
+                            default: '',
+                            description: 'Unique identifier (ID) of the frame whose items you want to retrieve',
+                        },
+                        {
+                            displayName: 'Period',
+                            name: 'period',
+                            type: 'options',
+                            options: [
+                                { name: 'Day', value: 'DAY' },
+                                { name: 'Month', value: 'MONTH' },
+                                { name: 'Week', value: 'WEEK' },
+                            ],
+                            default: 'WEEK',
+                            description: 'Group data by this time period',
+                        },
+                        {
+                            displayName: 'Project ID',
+                            name: 'project_id',
+                            type: 'string',
+                            default: '',
+                            description: 'Unique identifier (ID) of the project',
+                        },
+                        {
+                            displayName: 'Query',
+                            name: 'query',
+                            type: 'string',
+                            default: '',
+                            description: 'Search term to filter boards by name or description',
+                        },
+                        {
+                            displayName: 'Request ID',
+                            name: 'request_id',
+                            type: 'string',
+                            default: '',
+                            description: 'Unique identifier (UUID) that you generate for this export request',
+                        },
+                        {
+                            displayName: 'Role',
+                            name: 'role',
+                            type: 'options',
+                            options: [
+                                { name: 'Organization External User', value: 'organization_external_user' },
+                                { name: 'Organization Internal Admin', value: 'organization_internal_admin' },
+                                { name: 'Organization Internal User', value: 'organization_internal_user' },
+                                { name: 'Organization Team Guest User', value: 'organization_team_guest_user' },
+                                { name: 'Unknown', value: 'unknown' },
+                            ],
+                            default: 'organization_external_user',
+                            description: 'Filter members by the role assigned to them',
+                        },
+                        {
+                            displayName: 'Sort',
+                            name: 'sort',
+                            type: 'options',
+                            options: [
+                                { name: 'Alphabetically', value: 'alphabetically' },
+                                { name: 'Default', value: 'default' },
+                                { name: 'Last Created', value: 'last_created' },
+                                { name: 'Last Modified', value: 'last_modified' },
+                                { name: 'Last Opened', value: 'last_opened' },
+                            ],
+                            default: 'default',
+                            description: 'Order in which you want to view the result set',
+                        },
+                        {
+                            displayName: 'Sorting',
+                            name: 'sorting',
+                            type: 'options',
+                            options: [
+                                { name: 'Asc', value: 'asc' },
+                                { name: 'Desc', value: 'desc' },
+                            ],
+                            default: 'asc',
+                            description: 'Sort order in which you want to view the result set based on the interaction date. To sort by an ascending date, specify `asc`.',
+                        },
+                        {
+                            displayName: 'Start Date',
+                            name: 'startDate',
+                            type: 'string',
+                            default: '',
+                            description: 'Start date of the reporting period, as YYYY-MM-DD',
+                        },
+                        {
+                            displayName: 'Status',
+                            name: 'status',
+                            type: 'string',
+                            default: '',
+                            description: 'Status of the board export jobs that you want to retrieve, such as JOB_STATUS_CREATED, JOB_STATUS_IN_PROGRESS, JOB_STATUS_CANCELLED or JOB_STATUS_FINISHED Provide a comma-separated list',
+                        },
+                        {
+                            displayName: 'Tag ID',
+                            name: 'tag_id',
+                            type: 'string',
+                            default: '',
+                            description: 'Unique identifier (ID) of the tag',
+                        },
+                        {
+                            displayName: 'Team ID',
+                            name: 'team_id',
+                            type: 'string',
+                            default: '',
+                            description: 'Unique identifier (ID) of the team',
+                        },
+                        {
+                            displayName: 'Text Content Type',
+                            name: 'textContentType',
+                            type: 'options',
+                            options: [
+                                { name: 'Html', value: 'html' },
+                                { name: 'Markdown', value: 'markdown' },
+                            ],
+                            default: 'html',
+                            description: 'Controls the contentType of the returned doc\'s content',
+                        },
+                        {
+                            displayName: 'To',
+                            name: 'to',
+                            type: 'string',
+                            default: '',
+                            description: 'End of the period to retrieve, as an ISO-8601 timestamp',
+                        },
+                        {
+                            displayName: 'Type',
+                            name: 'type',
+                            type: 'options',
+                            options: [
+                                { name: 'App Card', value: 'app_card' },
+                                { name: 'Card', value: 'card' },
+                                { name: 'Data Table Format', value: 'data_table_format' },
+                                { name: 'Doc Format', value: 'doc_format' },
+                                { name: 'Document', value: 'document' },
+                                { name: 'Embed', value: 'embed' },
+                                { name: 'Frame', value: 'frame' },
+                                { name: 'Image', value: 'image' },
+                                { name: 'Preview', value: 'preview' },
+                                { name: 'Shape', value: 'shape' },
+                                { name: 'Sticky Note', value: 'sticky_note' },
+                                { name: 'Text', value: 'text' },
+                            ],
+                            default: 'app_card',
+                            description: 'Type of items to retrieve',
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Request Body',
+                    name: 'requestBody',
+                    type: 'json',
+                    default: '{}',
+                    description: 'Raw JSON request body. See the Miro API reference of the selected operation for its schema.',
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                'copyBoardPut',
+                                'createAppCardItemPost',
+                                'createBoardPost',
+                                'createCardItemPost',
+                                'createCasePost',
+                                'createCodeWidgetItemPost',
+                                'createConnectorPost',
+                                'createDocFormatItemPost',
+                                'createDocumentItemUsingFileFromDevicePost',
+                                'createDocumentItemUsingUrlPost',
+                                'createEmbedItemPost',
+                                'createFrameItemPost',
+                                'createGroupPost',
+                                'createImageItemUsingLocalFilePost',
+                                'createImageItemUsingUrlPost',
+                                'createItemsInBulkUsingFileFromDevicePost',
+                                'createItemsPost',
+                                'createLegalHoldPost',
+                                'createMindmapNodesExperimentalPost',
+                                'createShapeItemFlowchartPost',
+                                'createShapeItemPost',
+                                'createStickyNoteItemPost',
+                                'createTagPost',
+                                'createTextItemPost',
+                                'editCasePut',
+                                'editLegalHoldPut',
+                                'enterpriseAddProjectMemberPost',
+                                'enterpriseBoardsCreateGroupPost',
+                                'enterpriseCreateBoardExportPost',
+                                'enterpriseCreateGroupMemberPost',
+                                'enterpriseCreateGroupPost',
+                                'enterpriseCreateProjectPost',
+                                'enterpriseCreateTeamPost',
+                                'enterpriseDataclassificationBoardSetPost',
+                                'enterpriseDataclassificationTeamBoardsBulkPatch',
+                                'enterpriseDataclassificationTeamSettingsSetPatch',
+                                'enterpriseInviteTeamMemberPost',
+                                'enterpriseProjectCreateGroupPost',
+                                'enterpriseTeamsCreateGroupPost',
+                                'enterpriseUpdateBoardExportJobPut',
+                                'enterpriseUpdateGroupMembersPatch',
+                                'enterpriseUpdateGroupPatch',
+                                'enterpriseUpdateProjectMemberPatch',
+                                'enterpriseUpdateProjectPatch',
+                                'enterpriseUpdateProjectSettingsPatch',
+                                'enterpriseUpdateTeamMemberPatch',
+                                'enterpriseUpdateTeamPatch',
+                                'enterpriseUpdateTeamSettingsPatch',
+                                'moveCodeWidgetItemPatch',
+                                'revokeTokenV2Post',
+                                'shareBoardPost',
+                                'updateAppCardItemPatch',
+                                'updateBoardMemberPatch',
+                                'updateBoardPatch',
+                                'updateCardItemPatch',
+                                'updateCodeWidgetItemPatch',
+                                'updateConnectorPatch',
+                                'updateDocumentItemUsingFileFromDevicePatch',
+                                'updateDocumentItemUsingUrlPatch',
+                                'updateEmbedItemPatch',
+                                'updateFrameItemPatch',
+                                'updateGroupPut',
+                                'updateImageItemUsingFileFromDevicePatch',
+                                'updateImageItemUsingUrlPatch',
+                                'updateItemPositionOrParentPatch',
+                                'updateShapeItemFlowchartPatch',
+                                'updateShapeItemPatch',
+                                'updateStickyNoteItemPatch',
+                                'updateTagPatch',
+                                'updateTextItemPatch',
+                            ],
+                        },
+                    },
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            if (!this.continueOnFail()) {
+                returnData.push(...(await executeItem.call(this, i)));
+                continue;
+            }
+            try {
+                returnData.push(...(await executeItem.call(this, i)));
+            }
+            catch (error) {
+                returnData.push({
+                    json: { error: error.message },
+                    pairedItem: { item: i },
+                });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Miro = Miro;
+async function executeItem(i) {
+    var _a;
+    const resource = this.getNodeParameter('resource', i, '');
+    const operation = this.getNodeParameter('operation', i, '');
+    const authentication = this.getNodeParameter('authentication', 0, 'accessToken');
+    const credentialType = authentication === 'oAuth2' ? 'miroOAuth2Api' : 'miroApi';
+    const appId = this.getNodeParameter('app_id', i, '');
+    const boardId = this.getNodeParameter('board_id', i, '');
+    const boardMemberId = this.getNodeParameter('board_member_id', i, '');
+    const caseId = this.getNodeParameter('case_id', i, '');
+    const connectorId = this.getNodeParameter('connector_id', i, '');
+    const groupId = this.getNodeParameter('group_id', i, '');
+    const itemId = this.getNodeParameter('item_id', i, '');
+    const jobId = this.getNodeParameter('job_id', i, '');
+    const legalHoldId = this.getNodeParameter('legal_hold_id', i, '');
+    const memberId = this.getNodeParameter('member_id', i, '');
+    const orgId = this.getNodeParameter('org_id', i, '');
+    const projectId = this.getNodeParameter('project_id', i, '');
+    const tagId = this.getNodeParameter('tag_id', i, '');
+    const taskId = this.getNodeParameter('task_id', i, '');
+    const teamId = this.getNodeParameter('team_id', i, '');
+    const queryParameters = this.getNodeParameter('queryParameters', i, {});
+    const queryParams = new URLSearchParams();
+    Object.entries(queryParameters).forEach(([key, value]) => {
+        if (value === '' || value === null || value === undefined)
+            return;
+        queryParams.append(key, String(value));
+    });
+    switch (operation) {
+        case 'attachTagToItemPost':
+        case 'getItemsByTagGet':
+        case 'removeTagFromItemDelete':
+            if (!queryParams.has('tag_id')) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'This operation needs the Tag ID query parameter. Add it under Query Parameters', { itemIndex: i });
+            }
+            break;
+        case 'copyBoardPut':
+            if (!queryParams.has('copy_from')) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'This operation needs the Copy From query parameter. Add it under Query Parameters', { itemIndex: i });
+            }
+            break;
+        case 'deleteGroupDelete':
+            queryParams.set('delete_items', 'true');
+            break;
+        case 'enterpriseBoardContentItemLogsFetchGet':
+        case 'enterpriseGetAiInteractionLogsGet':
+            if (!queryParams.has('from') || !queryParams.has('to')) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'This operation needs the From and To query parameters. Add them under Query Parameters', { itemIndex: i });
+            }
+            break;
+        case 'enterpriseCreateBoardExportPost':
+            if (!queryParams.has('request_id')) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'This operation needs the Request ID query parameter. Add it under Query Parameters', { itemIndex: i });
+            }
+            break;
+        case 'enterpriseGetAuditLogsGet':
+            if (!queryParams.has('createdAfter') || !queryParams.has('createdBefore')) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'This operation needs the Created After and Created Before query parameters. Add them under Query Parameters', { itemIndex: i });
+            }
+            break;
+        case 'enterprisePostUserSessionsResetPost':
+            if (!queryParams.has('email')) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'This operation needs the Email query parameter. Add it under Query Parameters', { itemIndex: i });
+            }
+            break;
+        case 'getItemsByGroupIdGet':
+            if (!queryParams.has('group_item_id')) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'This operation needs the Group Item ID query parameter. Add it under Query Parameters', { itemIndex: i });
+            }
+            break;
+        case 'getItemsWithinFrameGet':
+            if (!queryParams.has('parent_item_id')) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'This operation needs the Parent Item ID query parameter. Add it under Query Parameters', { itemIndex: i });
+            }
+            break;
+        case 'getMetricsGet':
+            if (!queryParams.has('endDate') || !queryParams.has('startDate')) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'This operation needs the End Date and Start Date query parameters. Add them under Query Parameters', { itemIndex: i });
+            }
+            break;
+        case 'unGroupDelete':
+            queryParams.set('delete_items', 'false');
+            break;
+        default:
+            break;
+    }
+    const queryString = queryParams.toString() ? `?${queryParams.toString()}` : '';
+    let endpointPath = '';
+    switch (resource) {
+        case 'appsMetric':
+            switch (operation) {
+                case 'getMetricsGet':
+                    if (!appId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'App ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2-experimental/apps/${appId}/metrics${queryString}`;
+                    break;
+                case 'getMetricsTotalGet':
+                    if (!appId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'App ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2-experimental/apps/${appId}/metrics-total${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'authenticationToken':
+            switch (operation) {
+                case 'revokeTokenV2Post':
+                    endpointPath = `/v2/oauth/revoke${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'boardsBoard':
+            switch (operation) {
+                case 'copyBoardPut':
+                case 'createBoardPost':
+                case 'getBoardsGet':
+                    endpointPath = `/v2/boards${queryString}`;
+                    break;
+                case 'deleteBoardDelete':
+                case 'getSpecificBoardGet':
+                case 'updateBoardPatch':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'boardsExportJob':
+            switch (operation) {
+                case 'enterpriseBoardExportJobResultsGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!jobId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Job ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/boards/export/jobs/${jobId}/results${queryString}`;
+                    break;
+                case 'enterpriseBoardExportJobStatusGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!jobId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Job ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/boards/export/jobs/${jobId}${queryString}`;
+                    break;
+                case 'enterpriseBoardExportJobTasksGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!jobId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Job ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/boards/export/jobs/${jobId}/tasks${queryString}`;
+                    break;
+                case 'enterpriseBoardExportJobsGet':
+                case 'enterpriseCreateBoardExportPost':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/boards/export/jobs${queryString}`;
+                    break;
+                case 'enterpriseCreateBoardExportTaskExportLinkPost':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!jobId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Job ID is required', { itemIndex: i });
+                    }
+                    if (!taskId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Task ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/boards/export/jobs/${jobId}/tasks/${taskId}/export-link${queryString}`;
+                    break;
+                case 'enterpriseUpdateBoardExportJobPut':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!jobId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Job ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/boards/export/jobs/${jobId}/status${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'boardsMember':
+            switch (operation) {
+                case 'getBoardMembersGet':
+                case 'shareBoardPost':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/members${queryString}`;
+                    break;
+                case 'getSpecificBoardMemberGet':
+                case 'removeBoardMemberDelete':
+                case 'updateBoardMemberPatch':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!boardMemberId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board Member ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/members/${boardMemberId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'boardsUserGroupAssignment':
+            switch (operation) {
+                case 'enterpriseBoardsCreateGroupPost':
+                case 'enterpriseBoardsGetGroupsGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/boards/${boardId}/groups${queryString}`;
+                    break;
+                case 'enterpriseBoardsDeleteGroupsDelete':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!groupId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Group ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/boards/${boardId}/groups/${groupId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'governanceAIInteractionLog':
+            switch (operation) {
+                case 'enterpriseGetAiInteractionLogsGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/ai-interaction-logs${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'governanceAuditLog':
+            switch (operation) {
+                case 'enterpriseGetAuditLogsGet':
+                    endpointPath = `/v2/audit/logs${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'governanceBoardContentLog':
+            switch (operation) {
+                case 'enterpriseBoardContentItemLogsFetchGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/content-logs/items${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'governanceBoardDataClassification':
+            switch (operation) {
+                case 'enterpriseDataclassificationBoardGetGet':
+                case 'enterpriseDataclassificationBoardSetPost':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!teamId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Team ID is required', { itemIndex: i });
+                    }
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/teams/${teamId}/boards/${boardId}/data-classification${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'governanceLegalHold':
+            switch (operation) {
+                case 'createCasePost':
+                case 'getAllCasesGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/cases${queryString}`;
+                    break;
+                case 'createLegalHoldPost':
+                case 'getAllLegalHoldsGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!caseId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Case ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/cases/${caseId}/legal-holds${queryString}`;
+                    break;
+                case 'deleteCaseDelete':
+                case 'editCasePut':
+                case 'getCaseGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!caseId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Case ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/cases/${caseId}${queryString}`;
+                    break;
+                case 'deleteLegalHoldDelete':
+                case 'editLegalHoldPut':
+                case 'getLegalHoldGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!caseId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Case ID is required', { itemIndex: i });
+                    }
+                    if (!legalHoldId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Legal Hold ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/cases/${caseId}/legal-holds/${legalHoldId}${queryString}`;
+                    break;
+                case 'getLegalHoldContentItemsGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!caseId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Case ID is required', { itemIndex: i });
+                    }
+                    if (!legalHoldId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Legal Hold ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/cases/${caseId}/legal-holds/${legalHoldId}/content-items${queryString}`;
+                    break;
+                case 'getLegalHoldExportJobsGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!caseId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Case ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/cases/${caseId}/export-jobs${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'governanceOrganizationDataClassification':
+            switch (operation) {
+                case 'enterpriseDataclassificationOrganizationSettingsGetGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/data-classification-settings${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'governanceTeamDataClassification':
+            switch (operation) {
+                case 'enterpriseDataclassificationTeamBoardsBulkPatch':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!teamId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Team ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/teams/${teamId}/data-classification${queryString}`;
+                    break;
+                case 'enterpriseDataclassificationTeamSettingsGetGet':
+                case 'enterpriseDataclassificationTeamSettingsSetPatch':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!teamId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Team ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/teams/${teamId}/data-classification-settings${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'governanceUserSession':
+            switch (operation) {
+                case 'enterprisePostUserSessionsResetPost':
+                    endpointPath = `/v2/sessions/reset_all${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'itemsAppCard':
+            switch (operation) {
+                case 'createAppCardItemPost':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/app_cards${queryString}`;
+                    break;
+                case 'deleteAppCardItemDelete':
+                case 'getAppCardItemGet':
+                case 'updateAppCardItemPatch':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/app_cards/${itemId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'itemsCard':
+            switch (operation) {
+                case 'createCardItemPost':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/cards${queryString}`;
+                    break;
+                case 'deleteCardItemDelete':
+                case 'getCardItemGet':
+                case 'updateCardItemPatch':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/cards/${itemId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'itemsCodeWidget':
+            switch (operation) {
+                case 'createCodeWidgetItemPost':
+                case 'getCodeWidgetItemsGet':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2-experimental/boards/${boardId}/code_widgets${queryString}`;
+                    break;
+                case 'deleteCodeWidgetItemDelete':
+                case 'getCodeWidgetItemGet':
+                case 'updateCodeWidgetItemPatch':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2-experimental/boards/${boardId}/code_widgets/${itemId}${queryString}`;
+                    break;
+                case 'moveCodeWidgetItemPatch':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2-experimental/boards/${boardId}/code_widgets/${itemId}/position${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'itemsConnector':
+            switch (operation) {
+                case 'createConnectorPost':
+                case 'getConnectorsGet':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/connectors${queryString}`;
+                    break;
+                case 'deleteConnectorDelete':
+                case 'getConnectorGet':
+                case 'updateConnectorPatch':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!connectorId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Connector ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/connectors/${connectorId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'itemsDocFormat':
+            switch (operation) {
+                case 'createDocFormatItemPost':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/docs${queryString}`;
+                    break;
+                case 'deleteDocFormatItemDelete':
+                case 'getDocFormatItemGet':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/docs/${itemId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'itemsDocument':
+            switch (operation) {
+                case 'createDocumentItemUsingFileFromDevicePost':
+                case 'createDocumentItemUsingUrlPost':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/documents${queryString}`;
+                    break;
+                case 'deleteDocumentItemDelete':
+                case 'getDocumentItemGet':
+                case 'updateDocumentItemUsingFileFromDevicePatch':
+                case 'updateDocumentItemUsingUrlPatch':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/documents/${itemId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'itemsEmbed':
+            switch (operation) {
+                case 'createEmbedItemPost':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/embeds${queryString}`;
+                    break;
+                case 'deleteEmbedItemDelete':
+                case 'getEmbedItemGet':
+                case 'updateEmbedItemPatch':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/embeds/${itemId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'itemsFlowchartShape':
+            switch (operation) {
+                case 'createShapeItemFlowchartPost':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2-experimental/boards/${boardId}/shapes${queryString}`;
+                    break;
+                case 'deleteShapeItemFlowchartDelete':
+                case 'getShapeItemFlowchartGet':
+                case 'updateShapeItemFlowchartPatch':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2-experimental/boards/${boardId}/shapes/${itemId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'itemsFrame':
+            switch (operation) {
+                case 'createFrameItemPost':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/frames${queryString}`;
+                    break;
+                case 'deleteFrameItemDelete':
+                case 'getFrameItemGet':
+                case 'updateFrameItemPatch':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/frames/${itemId}${queryString}`;
+                    break;
+                case 'getItemsWithinFrameGet':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/items${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'itemsGroup':
+            switch (operation) {
+                case 'createGroupPost':
+                case 'getAllGroupsGet':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/groups${queryString}`;
+                    break;
+                case 'deleteGroupDelete':
+                case 'getGroupByIdGet':
+                case 'unGroupDelete':
+                case 'updateGroupPut':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!groupId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Group ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/groups/${groupId}${queryString}`;
+                    break;
+                case 'getItemsByGroupIdGet':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/groups/items${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'itemsImage':
+            switch (operation) {
+                case 'createImageItemUsingLocalFilePost':
+                case 'createImageItemUsingUrlPost':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/images${queryString}`;
+                    break;
+                case 'deleteImageItemDelete':
+                case 'getImageItemGet':
+                case 'updateImageItemUsingFileFromDevicePatch':
+                case 'updateImageItemUsingUrlPatch':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/images/${itemId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'itemsItem':
+            switch (operation) {
+                case 'createItemsInBulkUsingFileFromDevicePost':
+                case 'createItemsPost':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/items/bulk${queryString}`;
+                    break;
+                case 'deleteItemDelete':
+                case 'getSpecificItemGet':
+                case 'updateItemPositionOrParentPatch':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/items/${itemId}${queryString}`;
+                    break;
+                case 'deleteItemExperimentalDelete':
+                case 'getSpecificItemExperimentalGet':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2-experimental/boards/${boardId}/items/${itemId}${queryString}`;
+                    break;
+                case 'getItemsExperimentalGet':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2-experimental/boards/${boardId}/items${queryString}`;
+                    break;
+                case 'getItemsGet':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/items${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'itemsMindMapNode':
+            switch (operation) {
+                case 'createMindmapNodesExperimentalPost':
+                case 'getMindmapNodesExperimentalGet':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2-experimental/boards/${boardId}/mindmap_nodes${queryString}`;
+                    break;
+                case 'deleteMindmapNodeExperimentalDelete':
+                case 'getMindmapNodeExperimentalGet':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2-experimental/boards/${boardId}/mindmap_nodes/${itemId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'itemsShape':
+            switch (operation) {
+                case 'createShapeItemPost':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/shapes${queryString}`;
+                    break;
+                case 'deleteShapeItemDelete':
+                case 'getShapeItemGet':
+                case 'updateShapeItemPatch':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/shapes/${itemId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'itemsStickyNote':
+            switch (operation) {
+                case 'createStickyNoteItemPost':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/sticky_notes${queryString}`;
+                    break;
+                case 'deleteStickyNoteItemDelete':
+                case 'getStickyNoteItemGet':
+                case 'updateStickyNoteItemPatch':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/sticky_notes/${itemId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'itemsTag':
+            switch (operation) {
+                case 'attachTagToItemPost':
+                case 'removeTagFromItemDelete':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/items/${itemId}${queryString}`;
+                    break;
+                case 'createTagPost':
+                case 'getTagsFromBoardGet':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/tags${queryString}`;
+                    break;
+                case 'deleteTagDelete':
+                case 'getTagGet':
+                case 'updateTagPatch':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!tagId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Tag ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/tags/${tagId}${queryString}`;
+                    break;
+                case 'getItemsByTagGet':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/items${queryString}`;
+                    break;
+                case 'getTagsFromItemGet':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/items/${itemId}/tags${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'itemsText':
+            switch (operation) {
+                case 'createTextItemPost':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/texts${queryString}`;
+                    break;
+                case 'deleteTextItemDelete':
+                case 'getTextItemGet':
+                case 'updateTextItemPatch':
+                    if (!boardId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Board ID is required', { itemIndex: i });
+                    }
+                    if (!itemId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Item ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/boards/${boardId}/texts/${itemId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'organizationMember':
+            switch (operation) {
+                case 'enterpriseGetOrganizationMemberGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!memberId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Member ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/members/${memberId}${queryString}`;
+                    break;
+                case 'enterpriseGetOrganizationMembersGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/members${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'organizationOrganization':
+            switch (operation) {
+                case 'enterpriseGetOrganizationGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'organizationProject':
+            switch (operation) {
+                case 'enterpriseCreateProjectPost':
+                case 'enterpriseGetProjectsGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!teamId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Team ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/teams/${teamId}/projects${queryString}`;
+                    break;
+                case 'enterpriseDeleteProjectDelete':
+                case 'enterpriseGetProjectGet':
+                case 'enterpriseUpdateProjectPatch':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!teamId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Team ID is required', { itemIndex: i });
+                    }
+                    if (!projectId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Project ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/teams/${teamId}/projects/${projectId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'organizationProjectMember':
+            switch (operation) {
+                case 'enterpriseAddProjectMemberPost':
+                case 'enterpriseGetProjectMembersGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!teamId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Team ID is required', { itemIndex: i });
+                    }
+                    if (!projectId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Project ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/teams/${teamId}/projects/${projectId}/members${queryString}`;
+                    break;
+                case 'enterpriseDeleteProjectMemberDelete':
+                case 'enterpriseGetProjectMemberGet':
+                case 'enterpriseUpdateProjectMemberPatch':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!teamId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Team ID is required', { itemIndex: i });
+                    }
+                    if (!projectId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Project ID is required', { itemIndex: i });
+                    }
+                    if (!memberId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Member ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/teams/${teamId}/projects/${projectId}/members/${memberId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'organizationProjectSetting':
+            switch (operation) {
+                case 'enterpriseGetProjectSettingsGet':
+                case 'enterpriseUpdateProjectSettingsPatch':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!teamId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Team ID is required', { itemIndex: i });
+                    }
+                    if (!projectId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Project ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/teams/${teamId}/projects/${projectId}/settings${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'organizationProjectUserGroupAssignment':
+            switch (operation) {
+                case 'enterpriseProjectCreateGroupPost':
+                case 'enterpriseProjectsGetGroupsGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!projectId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Project ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/projects/${projectId}/groups${queryString}`;
+                    break;
+                case 'enterpriseProjectDeleteGroupsDelete':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!projectId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Project ID is required', { itemIndex: i });
+                    }
+                    if (!groupId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Group ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/projects/${projectId}/groups/${groupId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'organizationTeam':
+            switch (operation) {
+                case 'enterpriseCreateTeamPost':
+                case 'enterpriseGetTeamsGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/teams${queryString}`;
+                    break;
+                case 'enterpriseDeleteTeamDelete':
+                case 'enterpriseGetTeamGet':
+                case 'enterpriseUpdateTeamPatch':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!teamId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Team ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/teams/${teamId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'organizationTeamMember':
+            switch (operation) {
+                case 'enterpriseDeleteTeamMemberDelete':
+                case 'enterpriseGetTeamMemberGet':
+                case 'enterpriseUpdateTeamMemberPatch':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!teamId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Team ID is required', { itemIndex: i });
+                    }
+                    if (!memberId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Member ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/teams/${teamId}/members/${memberId}${queryString}`;
+                    break;
+                case 'enterpriseGetTeamMembersGet':
+                case 'enterpriseInviteTeamMemberPost':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!teamId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Team ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/teams/${teamId}/members${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'organizationTeamSetting':
+            switch (operation) {
+                case 'enterpriseGetDefaultTeamSettingsGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/default_teams_settings${queryString}`;
+                    break;
+                case 'enterpriseGetTeamSettingsGet':
+                case 'enterpriseUpdateTeamSettingsPatch':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!teamId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Team ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/teams/${teamId}/settings${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'organizationTeamUserGroup':
+            switch (operation) {
+                case 'enterpriseTeamsCreateGroupPost':
+                case 'enterpriseTeamsGetGroupsGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!teamId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Team ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/teams/${teamId}/groups${queryString}`;
+                    break;
+                case 'enterpriseTeamsDeleteGroupDelete':
+                case 'enterpriseTeamsGetGroupGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!teamId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Team ID is required', { itemIndex: i });
+                    }
+                    if (!groupId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Group ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/teams/${teamId}/groups/${groupId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'organizationUserGroup':
+            switch (operation) {
+                case 'enterpriseCreateGroupPost':
+                case 'enterpriseGetGroupsGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/groups${queryString}`;
+                    break;
+                case 'enterpriseDeleteGroupDelete':
+                case 'enterpriseGetGroupGet':
+                case 'enterpriseUpdateGroupPatch':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!groupId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Group ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/groups/${groupId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'organizationUserGroupMember':
+            switch (operation) {
+                case 'enterpriseCreateGroupMemberPost':
+                case 'enterpriseGetGroupMembersGet':
+                case 'enterpriseUpdateGroupMembersPatch':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!groupId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Group ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/groups/${groupId}/members${queryString}`;
+                    break;
+                case 'enterpriseDeleteGroupMemberDelete':
+                case 'enterpriseGetGroupMemberGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!groupId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Group ID is required', { itemIndex: i });
+                    }
+                    if (!memberId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Member ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/groups/${groupId}/members/${memberId}${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        case 'organizationUserGroupTeam':
+            switch (operation) {
+                case 'enterpriseGroupsGetTeamGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!groupId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Group ID is required', { itemIndex: i });
+                    }
+                    if (!teamId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Team ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/groups/${groupId}/teams/${teamId}${queryString}`;
+                    break;
+                case 'enterpriseGroupsGetTeamsGet':
+                    if (!orgId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Organization ID is required', { itemIndex: i });
+                    }
+                    if (!groupId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Group ID is required', { itemIndex: i });
+                    }
+                    endpointPath = `/v2/orgs/${orgId}/groups/${groupId}/teams${queryString}`;
+                    break;
+                default:
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+            }
+            break;
+        default:
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown resource: ${resource}`);
+    }
+    const method = operation.endsWith('Delete')
+        ? 'DELETE'
+        : operation.endsWith('Patch')
+            ? 'PATCH'
+            : operation.endsWith('Put')
+                ? 'PUT'
+                : operation.endsWith('Post')
+                    ? 'POST'
+                    : 'GET';
+    const url = `${BASE_URL}${endpointPath}`;
+    if (UPLOAD_OPERATIONS[operation]) {
+        const uploaded = await uploadRequest.call(this, i, credentialType, method, url, operation);
+        return this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(normalizeResponse(uploaded)), { itemData: { item: i } });
+    }
+    const headers = { Accept: 'application/json' };
+    let body;
+    if (['PATCH', 'POST', 'PUT'].includes(method)) {
+        const raw = ((_a = this.getNodeParameter('requestBody', i, '')) !== null && _a !== void 0 ? _a : '').trim();
+        if (raw !== '' && raw !== '{}') {
+            try {
+                body = JSON.parse(raw);
+            }
+            catch {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Request Body is not valid JSON', {
+                    itemIndex: i,
+                });
+            }
+            headers['Content-Type'] = 'application/json';
+        }
+    }
+    const options = {
+        method,
+        url,
+        headers,
+        json: true,
+        ...(body !== undefined ? { body } : {}),
+    };
+    let response;
+    try {
+        response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, options);
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), error, {
+            message: `Miro API request failed: ${method} ${endpointPath}`,
+            itemIndex: i,
+        });
+    }
+    return this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(normalizeResponse(response)), { itemData: { item: i } });
+}
+function normalizeResponse(response) {
+    if (response === null || response === undefined || response === '') {
+        return { success: true, statusCode: 204 };
+    }
+    if (typeof response === 'string') {
+        const trimmed = response.trim();
+        if (trimmed === '') {
+            return { success: true, statusCode: 204 };
+        }
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return { message: trimmed };
+        }
+    }
+    return response;
+}
+async function buildFilePart(i, propertyName) {
+    const binaryData = this.helpers.assertBinaryData(i, propertyName.trim());
+    if (!binaryData.fileName) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `No file name set on binary property "${propertyName}"`, { itemIndex: i });
+    }
+    let value;
+    if (binaryData.id) {
+        value = await this.helpers.getBinaryStream(binaryData.id);
+    }
+    else {
+        const buffer = Buffer.from(binaryData.data, n8n_workflow_1.BINARY_ENCODING);
+        if (buffer.byteLength > MAX_UPLOAD_BYTES) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `File "${binaryData.fileName}" is ${Math.round(buffer.byteLength / 1024 / 1024)} MB. Miro rejects uploads larger than 6 MB`, { itemIndex: i });
+        }
+        value = buffer;
+    }
+    return {
+        value,
+        options: { filename: binaryData.fileName, contentType: binaryData.mimeType },
+    };
+}
+async function uploadRequest(i, credentialType, method, url, operation) {
+    var _a;
+    const shape = UPLOAD_OPERATIONS[operation];
+    const binaryPropertyName = this.getNodeParameter('binaryPropertyName', i, 'data');
+    const formData = {};
+    if (shape === 'singleResource') {
+        formData.resource = await buildFilePart.call(this, i, binaryPropertyName);
+        const raw = ((_a = this.getNodeParameter('requestBody', i, '')) !== null && _a !== void 0 ? _a : '').trim();
+        if (raw !== '' && raw !== '{}') {
+            try {
+                JSON.parse(raw);
+            }
+            catch {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Request Body is not valid JSON', {
+                    itemIndex: i,
+                });
+            }
+            formData.data = { value: raw, options: { contentType: 'application/json' } };
+        }
+    }
+    else {
+        formData.data = await buildFilePart.call(this, i, binaryPropertyName);
+        const names = this.getNodeParameter('resourceBinaryProperties', i, 'resource')
+            .split(',')
+            .map((name) => name.trim())
+            .filter((name) => name !== '');
+        if (names.length === 0) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'At least one resource binary property is required', { itemIndex: i });
+        }
+        if (names.length > MAX_BULK_RESOURCES) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Miro accepts a maximum of 20 items per bulk file upload', { itemIndex: i });
+        }
+        formData.resources = await Promise.all(names.map(async (name) => await buildFilePart.call(this, i, name)));
+    }
+    try {
+        return await this.helpers.requestWithAuthentication.call(this, credentialType, {
+            method,
+            url,
+            headers: { Accept: 'application/json' },
+            formData,
+            json: true,
+        });
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), error, {
+            message: `Miro file upload failed: ${method} ${url}`,
+            itemIndex: i,
+        });
+    }
+}
+//# sourceMappingURL=Miro.node.js.map