n8n-nodes-kumiho 0.3.0

package/dist/nodes/KumihoAction/KumihoAction.node.js

@@ -0,0 +1,2581 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KumihoAction = void 0;
+function stripProjectMetadata(value) {
+    if (!value)
+        return value;
+    if (Array.isArray(value)) {
+        return value.map((entry) => stripProjectMetadata(entry));
+    }
+    if (typeof value === 'object') {
+        const obj = value;
+        if (!Object.prototype.hasOwnProperty.call(obj, 'metadata'))
+            return value;
+        const rest = { ...obj };
+        delete rest.metadata;
+        return rest;
+    }
+    return value;
+}
+const n8n_workflow_1 = require("n8n-workflow");
+const kumihoApi_1 = require("../helpers/kumihoApi");
+const splitCsv = (value) => {
+    const raw = String(value !== null && value !== void 0 ? value : '')
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    return raw.length ? raw : undefined;
+};
+const parseOptionalInt = (value) => {
+    const raw = String(value !== null && value !== void 0 ? value : '').trim();
+    if (!raw)
+        return undefined;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed < 0) {
+        throw new n8n_workflow_1.ApplicationError(`Value must be a non-negative integer (got '${raw}')`);
+    }
+    return parsed;
+};
+const normalizeProjectName = (context, raw) => {
+    const input = String(raw !== null && raw !== void 0 ? raw : '').trim();
+    if (!input) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Project Name is required');
+    }
+    const normalized = input.replace(/^\/+/, '');
+    if (!normalized) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Project Name is required');
+    }
+    if (normalized.includes('/')) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Project Name must be a single URL-safe name (no "/"). Example: my-vfx-project');
+    }
+    return normalized;
+};
+const normalizeKumihoPath = (context, raw, fieldLabel) => {
+    const input = String(raw !== null && raw !== void 0 ? raw : '').trim();
+    if (!input) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `${fieldLabel} is required`);
+    }
+    if (input.includes('{{') || input.includes('}}') || input.startsWith('={{') || input.includes('$json')) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `${fieldLabel} looks like a template string ('{{ ... }}'). In n8n use an expression like: ={{ $json.name }}`);
+    }
+    const withoutScheme = input.replace(/^[a-z]+:\/\/[^/]+/i, '').trim();
+    const noLeading = withoutScheme.replace(/^\/+/, '');
+    const noTrailing = noLeading.replace(/\/+$/, '');
+    if (!noTrailing) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `${fieldLabel} is required`);
+    }
+    const normalized = `/${noTrailing}`;
+    const valid = /^\/[A-Za-z0-9][A-Za-z0-9._-]*(\/[A-Za-z0-9][A-Za-z0-9._-]*)*$/.test(normalized);
+    if (!valid) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `${fieldLabel} must be a path like 'my-project' or 'my-project/Assets' (letters, numbers, '-', '_', '.' only). Got: '${input}'`);
+    }
+    return normalized;
+};
+const normalizeSearchContextFilter = (context, raw) => {
+    const input = String(raw !== null && raw !== void 0 ? raw : '').trim();
+    if (!input)
+        return '';
+    if (input.includes('{{') || input.includes('}}') || input.startsWith('={{') || input.includes('$json')) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), "Context Filter looks like a template string ('{{ ... }}'). In n8n use an expression like: ={{ $json.path }}");
+    }
+    const withoutScheme = input.replace(/^[a-z]+:\/\/[^/]+/i, '').trim();
+    const noLeading = withoutScheme.replace(/^\/+/, '');
+    return noLeading.replace(/\/+$/, '');
+};
+const normalizeKrefString = (context, raw, fieldLabel) => {
+    const input = String(raw !== null && raw !== void 0 ? raw : '').trim();
+    if (!input) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `${fieldLabel} is required`);
+    }
+    if (input.includes('{{') || input.includes('}}')) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `${fieldLabel} looks like a template string ('{{ ... }}'). In n8n use an expression like: ={{ $json.source_kref }}`);
+    }
+    const normalized = input
+        .replace(/\bkref:\s*\/\//gi, 'kref://')
+        .replace(/\bkref:\/\//gi, 'kref://')
+        .trim();
+    if (!normalized.toLowerCase().startsWith('kref://')) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `${fieldLabel} must start with 'kref://'. Example: kref://project/space/item.kind?r=1`);
+    }
+    return normalized;
+};
+const emitArray = (out, value, outputFormat, returnAll, limit) => {
+    if (!Array.isArray(value)) {
+        out.push({ json: value });
+        return;
+    }
+    const limited = (0, kumihoApi_1.applyReturnAllLimit)(value, returnAll, limit);
+    if (outputFormat === 'singleArray') {
+        out.push({ json: limited });
+        return;
+    }
+    for (const entry of limited) {
+        out.push({ json: entry });
+    }
+};
+class KumihoAction {
+    constructor() {
+        this.description = {
+            displayName: 'Kumiho Action',
+            name: 'kumihoAction',
+            icon: 'file:../images/Action.svg',
+            usableAsTool: true,
+            group: ['transform'],
+            version: 1,
+            description: 'Create, read, update, or delete Kumiho resources.',
+            defaults: {
+                name: 'Kumiho Action',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'kumihoApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        { name: 'Artifact', value: 'artifact' },
+                        { name: 'Bundle', value: 'bundle' },
+                        { name: 'Item', value: 'item' },
+                        { name: 'Kref', value: 'kref' },
+                        { name: 'Project', value: 'project' },
+                        { name: 'Revision', value: 'revision' },
+                        { name: 'Space', value: 'space' },
+                    ],
+                    default: 'project',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        { name: 'Create', value: 'create' },
+                        { name: 'Read', value: 'read' },
+                        { name: 'Update', value: 'update' },
+                        { name: 'Delete', value: 'delete' },
+                    ],
+                    default: 'read',
+                },
+                {
+                    displayName: 'Create Mode',
+                    name: 'createModeRevision',
+                    type: 'options',
+                    options: [
+                        { name: 'Create Revision', value: 'revisionCreate' },
+                        { name: 'Create Edge', value: 'graphCreateEdge' },
+                    ],
+                    default: 'revisionCreate',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Create Mode',
+                    name: 'createMode',
+                    type: 'options',
+                    options: [{ name: 'Create Edge', value: 'graphCreateEdge' }],
+                    default: 'graphCreateEdge',
+                    displayOptions: {
+                        show: {
+                            resource: ['graph'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Read Mode',
+                    name: 'readModeProject',
+                    type: 'options',
+                    options: [
+                        { name: 'Get Project', value: 'projectGet' },
+                        { name: 'List Projects', value: 'projectList' },
+                    ],
+                    default: 'projectGet',
+                    displayOptions: {
+                        show: {
+                            resource: ['project'],
+                            operation: ['read'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Read Mode',
+                    name: 'readModeSpace',
+                    type: 'options',
+                    options: [
+                        { name: 'Get Space (by Path)', value: 'spaceGet' },
+                        { name: 'List Spaces', value: 'spaceList' },
+                    ],
+                    default: 'spaceGet',
+                    displayOptions: {
+                        show: {
+                            resource: ['space'],
+                            operation: ['read'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Read Mode',
+                    name: 'readModeItem',
+                    type: 'options',
+                    options: [
+                        { name: 'Get Item (by Kref)', value: 'itemGet' },
+                        { name: 'Get Item (by Name / Kind)', value: 'itemGetByPath' },
+                        { name: 'Search Items', value: 'itemSearch' },
+                    ],
+                    default: 'itemGet',
+                    displayOptions: {
+                        show: {
+                            resource: ['item'],
+                            operation: ['read'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Read Mode',
+                    name: 'readModeRevision',
+                    type: 'options',
+                    options: [
+                        { name: 'Analyze Impact', value: 'graphAnalyzeImpact' },
+                        { name: 'Find Path', value: 'graphFindPath' },
+                        { name: 'Get Dependencies', value: 'graphGetDependencies' },
+                        { name: 'Get Revision (by Kref)', value: 'revisionGetByKref' },
+                        { name: 'Get Revision (by Tag)', value: 'revisionGetByTag' },
+                        { name: 'Has Tag', value: 'revisionHasTag' },
+                        { name: 'List Edges', value: 'graphListEdges' },
+                        { name: 'List Revision Artifacts', value: 'revisionListArtifacts' },
+                        { name: 'List Revision Tags', value: 'revisionListTags' },
+                        { name: 'Was Tagged', value: 'revisionWasTagged' },
+                    ],
+                    default: 'revisionGetByKref',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Read Mode',
+                    name: 'readModeArtifact',
+                    type: 'options',
+                    options: [
+                        { name: 'Get Artifact (by Revision Kref + Name)', value: 'artifactGet' },
+                        { name: 'Get Artifacts (by Location)', value: 'artifactGetByLocation' },
+                    ],
+                    default: 'artifactGet',
+                    displayOptions: {
+                        show: {
+                            resource: ['artifact'],
+                            operation: ['read'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Read Mode',
+                    name: 'readModeBundle',
+                    type: 'options',
+                    options: [
+                        { name: 'Get Bundle', value: 'bundleGet' },
+                        { name: 'List Bundle Members', value: 'bundleListMembers' },
+                        { name: 'Bundle History', value: 'bundleHistory' },
+                    ],
+                    default: 'bundleGet',
+                    displayOptions: {
+                        show: {
+                            resource: ['bundle'],
+                            operation: ['read'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Read Mode',
+                    name: 'readModeGraph',
+                    type: 'options',
+                    options: [
+                        { name: 'List Edges', value: 'graphListEdges' },
+                        { name: 'Get Dependencies', value: 'graphGetDependencies' },
+                        { name: 'Find Path', value: 'graphFindPath' },
+                        { name: 'Analyze Impact', value: 'graphAnalyzeImpact' },
+                    ],
+                    default: 'graphListEdges',
+                    displayOptions: {
+                        show: {
+                            resource: ['graph'],
+                            operation: ['read'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Read Mode',
+                    name: 'readModeKref',
+                    type: 'options',
+                    options: [{ name: 'Resolve', value: 'krefResolve' }],
+                    default: 'krefResolve',
+                    displayOptions: {
+                        show: {
+                            resource: ['kref'],
+                            operation: ['read'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Update Mode',
+                    name: 'updateModeItem',
+                    type: 'options',
+                    options: [
+                        { name: 'Update Metadata', value: 'itemUpdateMetadata' },
+                        { name: 'Set Attribute', value: 'itemSetAttribute' },
+                        { name: 'Deprecate', value: 'itemDeprecate' },
+                    ],
+                    default: 'itemUpdateMetadata',
+                    displayOptions: {
+                        show: {
+                            resource: ['item'],
+                            operation: ['update'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Update Mode',
+                    name: 'updateModeRevision',
+                    type: 'options',
+                    options: [
+                        { name: 'Update Metadata', value: 'revisionUpdateMetadata' },
+                        { name: 'Deprecate', value: 'revisionDeprecate' },
+                        { name: 'Set Tag', value: 'revisionSetTag' },
+                        { name: 'Remove Tag', value: 'revisionRemoveTag' },
+                    ],
+                    default: 'revisionUpdateMetadata',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['update'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Update Mode',
+                    name: 'updateModeArtifact',
+                    type: 'options',
+                    options: [
+                        { name: 'Update Metadata', value: 'artifactUpdateMetadata' },
+                        { name: 'Deprecate', value: 'artifactDeprecate' },
+                    ],
+                    default: 'artifactUpdateMetadata',
+                    displayOptions: {
+                        show: {
+                            resource: ['artifact'],
+                            operation: ['update'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Update Mode',
+                    name: 'updateModeBundle',
+                    type: 'options',
+                    options: [
+                        { name: 'Add Member', value: 'bundleAddMember' },
+                        { name: 'Remove Member', value: 'bundleRemoveMember' },
+                    ],
+                    default: 'bundleAddMember',
+                    displayOptions: {
+                        show: {
+                            resource: ['bundle'],
+                            operation: ['update'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Project Name',
+                    name: 'projectName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['project'],
+                            operation: ['create', 'read', 'delete'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Description',
+                    name: 'projectDescription',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['project'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Force Delete',
+                    name: 'force',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to permanently delete and remove all contents',
+                    displayOptions: {
+                        show: {
+                            resource: ['project', 'space', 'item', 'bundle', 'revision', 'artifact'],
+                            operation: ['delete'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Space Path',
+                    name: 'spacePath',
+                    type: 'string',
+                    default: '',
+                    description: 'Example: project/space',
+                    displayOptions: {
+                        show: {
+                            resource: ['space'],
+                            operation: ['read', 'delete'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Parent Path',
+                    name: 'parentPath',
+                    type: 'string',
+                    default: '',
+                    description: 'Required for Space Create and Space List. Example: project or project/parent-space.',
+                    displayOptions: {
+                        show: {
+                            resource: ['space'],
+                            operation: ['create', 'read'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Space Name',
+                    name: 'spaceName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['space'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Recursive',
+                    name: 'recursive',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            resource: ['space'],
+                            operation: ['read'],
+                            readModeSpace: ['spaceList'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Item Kref',
+                    name: 'itemKrefRevisionCreate',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['create'],
+                            createModeRevision: ['revisionCreate'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Item Kref',
+                    name: 'itemKrefRevisionGetByTag',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: ['revisionGetByTag'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Item Kref',
+                    name: 'itemKrefRevisionHasTag',
+                    type: 'string',
+                    default: '',
+                    description: 'Example: kref://project/space/item.kind',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: ['revisionHasTag'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Revision Kref',
+                    name: 'revisionKrefReadGetByKref',
+                    type: 'string',
+                    default: '',
+                    description: 'Example: kref://project/space/item.kind?r=1',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: ['revisionGetByKref'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Kref',
+                    name: 'kref',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision', 'kref'],
+                            operation: ['read'],
+                        },
+                        hide: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: [
+                                'revisionGetByKref',
+                                'revisionGetByTag',
+                                'revisionHasTag',
+                                'revisionListArtifacts',
+                                'graphListEdges',
+                                'graphGetDependencies',
+                                'graphFindPath',
+                                'graphAnalyzeImpact',
+                            ],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Kref',
+                    name: 'krefRevisionUpdate',
+                    type: 'string',
+                    default: '',
+                    description: 'Example: kref://project/space/item.kind?r=1',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['update'],
+                            updateModeRevision: ['__legacy'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Item Kref',
+                    name: 'itemKrefItem',
+                    type: 'string',
+                    default: '',
+                    description: 'Example: kref://project/space/item.kind',
+                    displayOptions: {
+                        show: {
+                            resource: ['item'],
+                            operation: ['read'],
+                            readModeItem: ['itemGet'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Item Kref',
+                    name: 'itemKrefItem',
+                    type: 'string',
+                    default: '',
+                    description: 'Example: kref://project/space/item.kind',
+                    displayOptions: {
+                        show: {
+                            resource: ['item'],
+                            operation: ['update', 'delete'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Metadata',
+                    name: 'itemMetadataCreate',
+                    type: 'json',
+                    default: '{}',
+                    displayOptions: {
+                        show: {
+                            resource: ['item'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Metadata',
+                    name: 'itemMetadataUpdate',
+                    type: 'json',
+                    default: '{}',
+                    displayOptions: {
+                        show: {
+                            resource: ['item'],
+                            operation: ['update'],
+                            updateModeItem: ['itemUpdateMetadata'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Space Path',
+                    name: 'itemSpacePath',
+                    type: 'string',
+                    default: '',
+                    description: 'Example: /project/space',
+                    displayOptions: {
+                        show: {
+                            resource: ['item'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Space Path',
+                    name: 'itemSpacePath',
+                    type: 'string',
+                    default: '',
+                    description: 'Example: /project/space',
+                    displayOptions: {
+                        show: {
+                            resource: ['item'],
+                            operation: ['read'],
+                            readModeItem: ['itemGetByPath'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Item Name',
+                    name: 'itemName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['item'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Item Name',
+                    name: 'itemName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['item'],
+                            operation: ['read'],
+                            readModeItem: ['itemGetByPath'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Kind',
+                    name: 'itemKind',
+                    type: 'string',
+                    default: 'model',
+                    displayOptions: {
+                        show: {
+                            resource: ['item'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Kind',
+                    name: 'itemKind',
+                    type: 'string',
+                    default: 'model',
+                    displayOptions: {
+                        show: {
+                            resource: ['item'],
+                            operation: ['read'],
+                            readModeItem: ['itemGetByPath'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Context Filter',
+                    name: 'contextFilter',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            operation: ['read'],
+                            readModeItem: ['itemSearch'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Name Filter',
+                    name: 'nameFilter',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            operation: ['read'],
+                            readModeItem: ['itemSearch'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Kind Filter',
+                    name: 'kindFilter',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            operation: ['read'],
+                            readModeItem: ['itemSearch'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Attribute Key',
+                    name: 'attributeKey',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            operation: ['update'],
+                            updateModeItem: ['itemSetAttribute'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Attribute Value',
+                    name: 'attributeValue',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            operation: ['update'],
+                            updateModeItem: ['itemSetAttribute'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Deprecated',
+                    name: 'deprecated',
+                    type: 'boolean',
+                    default: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['update'],
+                            updateModeItem: ['itemDeprecate'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Deprecated',
+                    name: 'deprecatedRevision',
+                    type: 'boolean',
+                    default: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['update'],
+                            updateModeRevision: ['revisionDeprecate'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Deprecated',
+                    name: 'deprecatedArtifact',
+                    type: 'boolean',
+                    default: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['update'],
+                            updateModeArtifact: ['artifactDeprecate'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Revision Number',
+                    name: 'revisionNumberCreate',
+                    type: 'string',
+                    default: '',
+                    description: 'Optional. Non-negative integer.',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['create'],
+                            createModeRevision: ['revisionCreate'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Revision Number',
+                    name: 'revisionNumberRead',
+                    type: 'string',
+                    default: '',
+                    description: 'Optional. Non-negative integer.',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: ['revisionListArtifacts', 'revisionListTags', 'revisionWasTagged'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Revision Number',
+                    name: 'revisionNumberUpdateDelete',
+                    type: 'string',
+                    default: '',
+                    description: 'Optional. Non-negative integer.',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['update'],
+                            updateModeRevision: ['__legacy'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Tag',
+                    name: 'tagRead',
+                    type: 'string',
+                    default: 'latest',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: ['revisionGetByTag', 'revisionHasTag', 'revisionWasTagged'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Revision Kref',
+                    name: 'revisionKrefUpdateMetadata',
+                    type: 'string',
+                    default: '',
+                    description: 'Example: kref://project/space/item.kind?r=1',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['update'],
+                            updateModeRevision: ['revisionUpdateMetadata'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Metadata',
+                    name: 'revisionMetadataUpdate',
+                    type: 'json',
+                    default: '{}',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['update'],
+                            updateModeRevision: ['revisionUpdateMetadata'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Revision Kref',
+                    name: 'revisionKrefTagUpdate',
+                    type: 'string',
+                    default: '',
+                    description: 'Example: kref://project/space/item.kind?r=1',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['update'],
+                            updateModeRevision: ['revisionSetTag', 'revisionRemoveTag'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Revision Tag',
+                    name: 'tagUpdate',
+                    type: 'string',
+                    default: 'latest',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['update'],
+                            updateModeRevision: ['revisionSetTag', 'revisionRemoveTag'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Revision Kref',
+                    name: 'revisionKrefDeprecate',
+                    type: 'string',
+                    default: '',
+                    description: 'Example: kref://project/space/item.kind?r=1',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['update'],
+                            updateModeRevision: ['revisionDeprecate'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Revision Kref',
+                    name: 'revisionKrefDelete',
+                    type: 'string',
+                    default: '',
+                    description: 'Example: kref://project/space/item.kind?r=1',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['delete'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Revision Kref',
+                    name: 'revisionKrefRevision',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: ['revisionListArtifacts'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Revision Kref',
+                    name: 'revisionKrefArtifact',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['artifact'],
+                            operation: ['read'],
+                            readModeArtifact: ['artifactGet'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Revision Kref',
+                    name: 'revisionKrefGraph',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: ['graphListEdges', 'graphGetDependencies', 'graphAnalyzeImpact'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Artifact Name',
+                    name: 'artifactName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['artifact', 'kref'],
+                            operation: ['read'],
+                            readModeArtifact: ['artifactGet'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Location',
+                    name: 'locationQuery',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['artifact'],
+                            operation: ['read'],
+                            readModeArtifact: ['artifactGetByLocation'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Bundle Kref',
+                    name: 'bundleKref',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['bundle'],
+                            operation: ['update'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Bundle Kref',
+                    name: 'bundleKref',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['bundle'],
+                            operation: ['read'],
+                            readModeBundle: ['bundleListMembers', 'bundleHistory'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Bundle Kref',
+                    name: 'bundleKrefDelete',
+                    type: 'string',
+                    default: '',
+                    description: 'Example: kref://project/space/bundle.bundle',
+                    displayOptions: {
+                        show: {
+                            resource: ['bundle'],
+                            operation: ['delete'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Bundle Name',
+                    name: 'bundleName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['bundle'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Bundle Name',
+                    name: 'bundleName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['bundle'],
+                            operation: ['read'],
+                            readModeBundle: ['bundleGet'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Space Path',
+                    name: 'bundleSpacePath',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['bundle'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Space Path',
+                    name: 'bundleSpacePath',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['bundle'],
+                            operation: ['read'],
+                            readModeBundle: ['bundleGet'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Advanced: Bundle Kref Override',
+                    name: 'bundleKrefOverrideEnabled',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            resource: ['bundle'],
+                            operation: ['read'],
+                            readModeBundle: ['bundleGet'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Bundle Kref (Override)',
+                    name: 'bundleKrefOverride',
+                    type: 'string',
+                    default: '',
+                    description: 'Optional. When set, this Kref is used instead of computing it from Space Path + Bundle Name.',
+                    displayOptions: {
+                        show: {
+                            resource: ['bundle'],
+                            operation: ['read'],
+                            readModeBundle: ['bundleGet'],
+                            bundleKrefOverrideEnabled: [true],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Item Kref',
+                    name: 'bundleItemKref',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['bundle'],
+                            operation: ['update'],
+                            updateModeBundle: ['bundleAddMember', 'bundleRemoveMember'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Member Revision Number',
+                    name: 'bundleRevisionNumber',
+                    type: 'string',
+                    default: '',
+                    description: 'Optional. Non-negative integer.',
+                    displayOptions: {
+                        show: {
+                            resource: ['bundle'],
+                            operation: ['read'],
+                            readModeBundle: ['bundleListMembers'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Source Kref',
+                    name: 'sourceKref',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['create', 'read'],
+                            createModeRevision: ['graphCreateEdge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Target Kref',
+                    name: 'targetKref',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['create', 'read'],
+                            createModeRevision: ['graphCreateEdge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Edge Type',
+                    name: 'edgeType',
+                    type: 'options',
+                    options: [
+                        { name: 'Belongs To', value: 'BELONGS_TO' },
+                        { name: 'Contains', value: 'CONTAINS' },
+                        { name: 'Created From', value: 'CREATED_FROM' },
+                        { name: 'Depends On', value: 'DEPENDS_ON' },
+                        { name: 'Derived From', value: 'DERIVED_FROM' },
+                        { name: 'Referenced', value: 'REFERENCED' },
+                    ],
+                    default: 'DEPENDS_ON',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['create'],
+                            createModeRevision: ['graphCreateEdge'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Edge Type Filter',
+                    name: 'edgeTypeFilter',
+                    type: 'string',
+                    default: '',
+                    description: 'Optional. Single edge type.',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: ['graphListEdges'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Direction',
+                    name: 'direction',
+                    type: 'options',
+                    options: [
+                        { name: 'Outgoing', value: 0 },
+                        { name: 'Incoming', value: 1 },
+                        { name: 'Both', value: 2 },
+                    ],
+                    default: 0,
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: ['graphListEdges'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Max Depth',
+                    name: 'maxDepth',
+                    type: 'number',
+                    default: 5,
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: ['graphGetDependencies', 'graphFindPath', 'graphAnalyzeImpact'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Edge Types',
+                    name: 'edgeTypes',
+                    type: 'string',
+                    default: '',
+                    description: 'Optional. Comma-separated list (e.g., DEPENDS_ON,DERIVED_FROM).',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: ['graphGetDependencies', 'graphFindPath', 'graphAnalyzeImpact'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Revision Kref',
+                    name: 'artifactRevisionKref',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['artifact'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Name',
+                    name: 'name',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['artifact'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Location',
+                    name: 'locationCreate',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['artifact'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Metadata',
+                    name: 'artifactMetadataCreate',
+                    type: 'json',
+                    default: '{}',
+                    displayOptions: {
+                        show: {
+                            resource: ['artifact'],
+                            operation: ['create'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Metadata',
+                    name: 'metadata',
+                    type: 'json',
+                    default: '{}',
+                    displayOptions: {
+                        show: {
+                            operation: ['create', 'update'],
+                            resource: ['revision', 'bundle', 'graph'],
+                        },
+                        hide: {
+                            resource: ['revision'],
+                            operation: ['update'],
+                            updateModeRevision: ['revisionUpdateMetadata', 'revisionSetTag', 'revisionRemoveTag', 'revisionDeprecate'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Artifact Kref',
+                    name: 'artifactKref',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['artifact'],
+                            operation: ['update', 'delete'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Metadata',
+                    name: 'artifactMetadataUpdate',
+                    type: 'json',
+                    default: '{}',
+                    displayOptions: {
+                        show: {
+                            resource: ['artifact'],
+                            operation: ['update'],
+                            updateModeArtifact: ['artifactUpdateMetadata'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Resolve Revision Number',
+                    name: 'krefResolveRevisionNumber',
+                    type: 'string',
+                    default: '',
+                    description: 'Optional. Non-negative integer (maps to r).',
+                    displayOptions: {
+                        show: {
+                            resource: ['kref'],
+                            operation: ['read'],
+                            readModeKref: ['krefResolveAdvanced'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Resolve Tag',
+                    name: 'krefResolveTag',
+                    type: 'string',
+                    default: '',
+                    description: 'Optional (maps to t)',
+                    displayOptions: {
+                        show: {
+                            resource: ['kref'],
+                            operation: ['read'],
+                            readModeKref: ['krefResolveAdvanced'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Resolve Artifact Name',
+                    name: 'krefResolveArtifactName',
+                    type: 'string',
+                    default: '',
+                    description: 'Optional (maps to a)',
+                    displayOptions: {
+                        show: {
+                            resource: ['kref'],
+                            operation: ['read'],
+                            readModeKref: ['krefResolveAdvanced'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Output Format',
+                    name: 'outputFormatProject',
+                    type: 'options',
+                    options: [
+                        { name: 'Split Into Items', value: 'split' },
+                        { name: 'Single Item (Array)', value: 'singleArray' },
+                    ],
+                    default: 'split',
+                    displayOptions: {
+                        show: {
+                            resource: ['project'],
+                            operation: ['read'],
+                            readModeProject: ['projectList'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Return All',
+                    name: 'returnAllProject',
+                    type: 'boolean',
+                    default: true,
+                    description: 'Whether to return all results or limit the result size',
+                    displayOptions: {
+                        show: {
+                            resource: ['project'],
+                            operation: ['read'],
+                            readModeProject: ['projectList'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limitProject',
+                    type: 'number',
+                    default: 100,
+                    typeOptions: { minValue: 1 },
+                    displayOptions: {
+                        show: {
+                            resource: ['project'],
+                            operation: ['read'],
+                            readModeProject: ['projectList'],
+                            returnAllProject: [false],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Output Format',
+                    name: 'outputFormatSpace',
+                    type: 'options',
+                    options: [
+                        { name: 'Split Into Items', value: 'split' },
+                        { name: 'Single Item (Array)', value: 'singleArray' },
+                    ],
+                    default: 'split',
+                    displayOptions: {
+                        show: {
+                            resource: ['space'],
+                            operation: ['read'],
+                            readModeSpace: ['spaceList'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Return All',
+                    name: 'returnAllSpace',
+                    type: 'boolean',
+                    default: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['space'],
+                            operation: ['read'],
+                            readModeSpace: ['spaceList'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limitSpace',
+                    type: 'number',
+                    default: 100,
+                    typeOptions: { minValue: 1 },
+                    displayOptions: {
+                        show: {
+                            resource: ['space'],
+                            operation: ['read'],
+                            readModeSpace: ['spaceList'],
+                            returnAllSpace: [false],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Output Format',
+                    name: 'outputFormatItem',
+                    type: 'options',
+                    options: [
+                        { name: 'Split Into Items', value: 'split' },
+                        { name: 'Single Item (Array)', value: 'singleArray' },
+                    ],
+                    default: 'split',
+                    displayOptions: {
+                        show: {
+                            resource: ['item'],
+                            operation: ['read'],
+                            readModeItem: ['itemSearch'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Return All',
+                    name: 'returnAllItem',
+                    type: 'boolean',
+                    default: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['item'],
+                            operation: ['read'],
+                            readModeItem: ['itemSearch'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limitItem',
+                    type: 'number',
+                    default: 100,
+                    typeOptions: { minValue: 1 },
+                    displayOptions: {
+                        show: {
+                            resource: ['item'],
+                            operation: ['read'],
+                            readModeItem: ['itemSearch'],
+                            returnAllItem: [false],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Output Format',
+                    name: 'outputFormatRevision',
+                    type: 'options',
+                    options: [
+                        { name: 'Split Into Items', value: 'split' },
+                        { name: 'Single Item (Array)', value: 'singleArray' },
+                    ],
+                    default: 'split',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: ['revisionListArtifacts'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Return All',
+                    name: 'returnAllRevision',
+                    type: 'boolean',
+                    default: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: ['revisionListArtifacts'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limitRevision',
+                    type: 'number',
+                    default: 100,
+                    typeOptions: { minValue: 1 },
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: ['revisionListArtifacts'],
+                            returnAllRevision: [false],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Output Format',
+                    name: 'outputFormatArtifact',
+                    type: 'options',
+                    options: [
+                        { name: 'Split Into Items', value: 'split' },
+                        { name: 'Single Item (Array)', value: 'singleArray' },
+                    ],
+                    default: 'split',
+                    displayOptions: {
+                        show: {
+                            resource: ['artifact'],
+                            operation: ['read'],
+                            readModeArtifact: ['artifactGetByLocation'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Return All',
+                    name: 'returnAllArtifact',
+                    type: 'boolean',
+                    default: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['artifact'],
+                            operation: ['read'],
+                            readModeArtifact: ['artifactGetByLocation'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limitArtifact',
+                    type: 'number',
+                    default: 100,
+                    typeOptions: { minValue: 1 },
+                    displayOptions: {
+                        show: {
+                            resource: ['artifact'],
+                            operation: ['read'],
+                            readModeArtifact: ['artifactGetByLocation'],
+                            returnAllArtifact: [false],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Output Format',
+                    name: 'outputFormatBundle',
+                    type: 'options',
+                    options: [
+                        { name: 'Split Into Items', value: 'split' },
+                        { name: 'Single Item (Array)', value: 'singleArray' },
+                    ],
+                    default: 'split',
+                    displayOptions: {
+                        show: {
+                            resource: ['bundle'],
+                            operation: ['read'],
+                            readModeBundle: ['bundleListMembers', 'bundleHistory'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Return All',
+                    name: 'returnAllBundle',
+                    type: 'boolean',
+                    default: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['bundle'],
+                            operation: ['read'],
+                            readModeBundle: ['bundleListMembers', 'bundleHistory'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limitBundle',
+                    type: 'number',
+                    default: 100,
+                    typeOptions: { minValue: 1 },
+                    displayOptions: {
+                        show: {
+                            resource: ['bundle'],
+                            operation: ['read'],
+                            readModeBundle: ['bundleListMembers', 'bundleHistory'],
+                            returnAllBundle: [false],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Output Format',
+                    name: 'outputFormatGraph',
+                    type: 'options',
+                    options: [
+                        { name: 'Split Into Items', value: 'split' },
+                        { name: 'Single Item (Array)', value: 'singleArray' },
+                    ],
+                    default: 'split',
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: ['graphListEdges'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Return All',
+                    name: 'returnAllGraph',
+                    type: 'boolean',
+                    default: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: ['graphListEdges'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limitGraph',
+                    type: 'number',
+                    default: 100,
+                    typeOptions: { minValue: 1 },
+                    displayOptions: {
+                        show: {
+                            resource: ['revision'],
+                            operation: ['read'],
+                            readModeRevision: ['graphListEdges'],
+                            returnAllGraph: [false],
+                        },
+                    },
+                },
+            ],
+        };
+    }
+    async execute() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30;
+        const items = this.getInputData();
+        const out = [];
+        for (let index = 0; index < items.length; index += 1) {
+            const resource = this.getNodeParameter('resource', index);
+            const operation = this.getNodeParameter('operation', index);
+            let outputFormat = 'split';
+            let returnAll = true;
+            let limit = 100;
+            if (operation === 'read') {
+                if (resource === 'project') {
+                    const readMode = this.getNodeParameter('readModeProject', index);
+                    if (readMode === 'projectList') {
+                        outputFormat = this.getNodeParameter('outputFormatProject', index, 'split');
+                        returnAll = this.getNodeParameter('returnAllProject', index, true);
+                        limit = this.getNodeParameter('limitProject', index, 100);
+                    }
+                }
+                if (resource === 'space') {
+                    const readMode = this.getNodeParameter('readModeSpace', index);
+                    if (readMode === 'spaceList') {
+                        outputFormat = this.getNodeParameter('outputFormatSpace', index, 'split');
+                        returnAll = this.getNodeParameter('returnAllSpace', index, true);
+                        limit = this.getNodeParameter('limitSpace', index, 100);
+                    }
+                }
+                if (resource === 'item') {
+                    const readMode = this.getNodeParameter('readModeItem', index);
+                    if (readMode === 'itemSearch') {
+                        outputFormat = this.getNodeParameter('outputFormatItem', index, 'split');
+                        returnAll = this.getNodeParameter('returnAllItem', index, true);
+                        limit = this.getNodeParameter('limitItem', index, 100);
+                    }
+                }
+                if (resource === 'revision') {
+                    const readMode = this.getNodeParameter('readModeRevision', index);
+                    if (readMode === 'revisionListArtifacts') {
+                        outputFormat = this.getNodeParameter('outputFormatRevision', index, 'split');
+                        returnAll = this.getNodeParameter('returnAllRevision', index, true);
+                        limit = this.getNodeParameter('limitRevision', index, 100);
+                    }
+                    if (readMode === 'graphListEdges') {
+                        outputFormat = this.getNodeParameter('outputFormatGraph', index, 'split');
+                        returnAll = this.getNodeParameter('returnAllGraph', index, true);
+                        limit = this.getNodeParameter('limitGraph', index, 100);
+                    }
+                }
+                if (resource === 'artifact') {
+                    const readMode = this.getNodeParameter('readModeArtifact', index);
+                    if (readMode === 'artifactGetByLocation') {
+                        outputFormat = this.getNodeParameter('outputFormatArtifact', index, 'split');
+                        returnAll = this.getNodeParameter('returnAllArtifact', index, true);
+                        limit = this.getNodeParameter('limitArtifact', index, 100);
+                    }
+                }
+                if (resource === 'bundle') {
+                    const readMode = this.getNodeParameter('readModeBundle', index);
+                    if (readMode === 'bundleListMembers' || readMode === 'bundleHistory') {
+                        outputFormat = this.getNodeParameter('outputFormatBundle', index, 'split');
+                        returnAll = this.getNodeParameter('returnAllBundle', index, true);
+                        limit = this.getNodeParameter('limitBundle', index, 100);
+                    }
+                }
+                if (resource === 'graph') {
+                    const readMode = this.getNodeParameter('readModeGraph', index);
+                    if (readMode === 'graphListEdges') {
+                        outputFormat = this.getNodeParameter('outputFormatGraph', index, 'split');
+                        returnAll = this.getNodeParameter('returnAllGraph', index, true);
+                        limit = this.getNodeParameter('limitGraph', index, 100);
+                    }
+                }
+            }
+            if (resource === 'project') {
+                if (operation === 'create') {
+                    const name = normalizeProjectName(this, this.getNodeParameter('projectName', index));
+                    const description = String((_a = this.getNodeParameter('projectDescription', index, '')) !== null && _a !== void 0 ? _a : '').trim();
+                    const body = { name };
+                    if (description)
+                        body.description = description;
+                    try {
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'POST',
+                            path: '/api/v1/projects',
+                            body,
+                        });
+                        out.push({ json: stripProjectMetadata(data) });
+                        continue;
+                    }
+                    catch (error) {
+                        const err = error;
+                        const httpCode = Number((_b = err === null || err === void 0 ? void 0 : err.httpCode) !== null && _b !== void 0 ? _b : (_c = err === null || err === void 0 ? void 0 : err.kumiho) === null || _c === void 0 ? void 0 : _c.status_code);
+                        if ([500, 502, 503, 504].includes(httpCode)) {
+                            try {
+                                const existing = await (0, kumihoApi_1.kumihoRequest)(this, {
+                                    method: 'GET',
+                                    path: `/api/v1/projects/${encodeURIComponent(name)}`,
+                                    maxAttempts: 1,
+                                    timeoutMs: 15000,
+                                    retryBudgetMs: 15000,
+                                });
+                                out.push({ json: stripProjectMetadata(existing) });
+                                continue;
+                            }
+                            catch {
+                            }
+                        }
+                        throw error;
+                    }
+                }
+                if (operation === 'read') {
+                    const readMode = this.getNodeParameter('readModeProject', index);
+                    if (readMode === 'projectGet') {
+                        const name = normalizeProjectName(this, this.getNodeParameter('projectName', index));
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: `/api/v1/projects/${encodeURIComponent(name)}`,
+                        });
+                        out.push({ json: stripProjectMetadata(data) });
+                        continue;
+                    }
+                    if (readMode === 'projectList') {
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, { method: 'GET', path: '/api/v1/projects' });
+                        emitArray(out, stripProjectMetadata(data), outputFormat, returnAll, limit);
+                        continue;
+                    }
+                }
+                if (operation === 'delete') {
+                    const name = normalizeProjectName(this, this.getNodeParameter('projectName', index));
+                    const force = this.getNodeParameter('force', index, false);
+                    const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                        method: 'DELETE',
+                        path: `/api/v1/projects/${encodeURIComponent(name)}`,
+                        qs: { force },
+                    });
+                    out.push({ json: data });
+                    continue;
+                }
+            }
+            if (resource === 'space') {
+                if (operation === 'create') {
+                    const parentPath = normalizeKumihoPath(this, this.getNodeParameter('parentPath', index), 'Parent Path');
+                    const name = String((_d = this.getNodeParameter('spaceName', index)) !== null && _d !== void 0 ? _d : '').trim();
+                    if (!parentPath) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Parent Path is required');
+                    }
+                    if (!name) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Space Name is required');
+                    }
+                    try {
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'POST',
+                            path: '/api/v1/spaces',
+                            body: { parent_path: parentPath, name },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    catch (error) {
+                        const err = error;
+                        const httpCode = Number((_e = err === null || err === void 0 ? void 0 : err.httpCode) !== null && _e !== void 0 ? _e : (_f = err === null || err === void 0 ? void 0 : err.kumiho) === null || _f === void 0 ? void 0 : _f.status_code);
+                        if ([500, 502, 503, 504].includes(httpCode)) {
+                            try {
+                                const fullPath = `${parentPath}/${name}`;
+                                const existing = await (0, kumihoApi_1.kumihoRequest)(this, {
+                                    method: 'GET',
+                                    path: '/api/v1/spaces/by-path',
+                                    qs: { path: fullPath },
+                                    maxAttempts: 1,
+                                    timeoutMs: 15000,
+                                    retryBudgetMs: 15000,
+                                });
+                                out.push({ json: existing });
+                                continue;
+                            }
+                            catch {
+                            }
+                        }
+                        throw error;
+                    }
+                }
+                if (operation === 'read') {
+                    const readMode = this.getNodeParameter('readModeSpace', index);
+                    if (readMode === 'spaceGet') {
+                        const path = normalizeKumihoPath(this, this.getNodeParameter('spacePath', index), 'Space Path');
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/spaces/by-path',
+                            qs: { path },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (readMode === 'spaceList') {
+                        const parentPath = normalizeKumihoPath(this, this.getNodeParameter('parentPath', index), 'Parent Path');
+                        const recursive = this.getNodeParameter('recursive', index, false);
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/spaces',
+                            qs: { parent_path: parentPath, recursive },
+                        });
+                        emitArray(out, data, outputFormat, returnAll, limit);
+                        continue;
+                    }
+                }
+                if (operation === 'delete') {
+                    const path = normalizeKumihoPath(this, this.getNodeParameter('spacePath', index), 'Space Path');
+                    const force = this.getNodeParameter('force', index, false);
+                    const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                        method: 'DELETE',
+                        path: '/api/v1/spaces/by-path',
+                        qs: { path, force },
+                    });
+                    out.push({ json: data });
+                    continue;
+                }
+            }
+            if (resource === 'item') {
+                if (operation === 'create') {
+                    const spacePath = normalizeKumihoPath(this, this.getNodeParameter('itemSpacePath', index), 'Space Path');
+                    const itemName = this.getNodeParameter('itemName', index);
+                    const kind = this.getNodeParameter('itemKind', index);
+                    const metadata = (0, kumihoApi_1.normalizeMetadata)(this.getNodeParameter('itemMetadataCreate', index, this.getNodeParameter('metadata', index, {})));
+                    const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                        method: 'POST',
+                        path: '/api/v1/items',
+                        body: {
+                            space_path: spacePath,
+                            item_name: itemName,
+                            kind,
+                            metadata,
+                        },
+                    });
+                    out.push({ json: data });
+                    continue;
+                }
+                if (operation === 'read') {
+                    const readMode = this.getNodeParameter('readModeItem', index);
+                    if (readMode === 'itemGet') {
+                        const kref = (String((_g = this.getNodeParameter('itemKrefItem', index, '')) !== null && _g !== void 0 ? _g : '').trim() ||
+                            String((_h = this.getNodeParameter('kref', index, '')) !== null && _h !== void 0 ? _h : '').trim());
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/items/by-kref',
+                            qs: { kref },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (readMode === 'itemGetByPath') {
+                        const spacePath = normalizeKumihoPath(this, this.getNodeParameter('itemSpacePath', index), 'Space Path');
+                        const itemName = this.getNodeParameter('itemName', index);
+                        const kind = this.getNodeParameter('itemKind', index);
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/items/by-path',
+                            qs: { space_path: spacePath, item_name: itemName, kind },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (readMode === 'itemSearch') {
+                        const contextFilter = normalizeSearchContextFilter(this, this.getNodeParameter('contextFilter', index, ''));
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/items/search',
+                            qs: {
+                                context_filter: contextFilter,
+                                name_filter: this.getNodeParameter('nameFilter', index, ''),
+                                kind_filter: this.getNodeParameter('kindFilter', index, ''),
+                            },
+                        });
+                        emitArray(out, data, outputFormat, returnAll, limit);
+                        continue;
+                    }
+                }
+                if (operation === 'update') {
+                    const updateMode = this.getNodeParameter('updateModeItem', index);
+                    const kref = (String((_j = this.getNodeParameter('itemKrefItem', index, '')) !== null && _j !== void 0 ? _j : '').trim() ||
+                        String((_k = this.getNodeParameter('kref', index, '')) !== null && _k !== void 0 ? _k : '').trim());
+                    if (updateMode === 'itemUpdateMetadata') {
+                        const metadata = (0, kumihoApi_1.normalizeMetadata)(this.getNodeParameter('itemMetadataUpdate', index, this.getNodeParameter('metadata', index, {})));
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'PATCH',
+                            path: '/api/v1/items/by-kref',
+                            qs: { kref },
+                            body: { metadata },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (updateMode === 'itemSetAttribute') {
+                        const key = this.getNodeParameter('attributeKey', index);
+                        const value = this.getNodeParameter('attributeValue', index);
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'POST',
+                            path: '/api/v1/attributes',
+                            body: { kref, key, value },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (updateMode === 'itemDeprecate') {
+                        const deprecated = this.getNodeParameter('deprecated', index, true);
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'POST',
+                            path: '/api/v1/items/deprecate',
+                            qs: { kref, deprecated },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                }
+                if (operation === 'delete') {
+                    const kref = (String((_l = this.getNodeParameter('itemKrefItem', index, '')) !== null && _l !== void 0 ? _l : '').trim() ||
+                        String((_m = this.getNodeParameter('kref', index, '')) !== null && _m !== void 0 ? _m : '').trim());
+                    const force = this.getNodeParameter('force', index, false);
+                    const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                        method: 'DELETE',
+                        path: '/api/v1/items/by-kref',
+                        qs: { kref, force },
+                    });
+                    out.push({ json: data });
+                    continue;
+                }
+            }
+            if (resource === 'revision') {
+                const revisionNumber = parseOptionalInt(this.getNodeParameter('revisionNumberRead', index, '') ||
+                    this.getNodeParameter('revisionNumberCreate', index, '') ||
+                    this.getNodeParameter('revisionNumberUpdateDelete', index, '') ||
+                    this.getNodeParameter('revisionNumber', index, ''));
+                if (operation === 'create') {
+                    const createMode = this.getNodeParameter('createModeRevision', index, 'revisionCreate');
+                    if (createMode === 'revisionCreate') {
+                        const itemKref = (String((_o = this.getNodeParameter('itemKrefRevisionCreate', index, '')) !== null && _o !== void 0 ? _o : '').trim() ||
+                            String((_p = this.getNodeParameter('itemKref', index, '')) !== null && _p !== void 0 ? _p : '').trim());
+                        const metadata = (0, kumihoApi_1.normalizeMetadata)(this.getNodeParameter('metadata', index, {}));
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'POST',
+                            path: '/api/v1/revisions',
+                            body: {
+                                item_kref: itemKref,
+                                metadata,
+                                number: revisionNumber,
+                            },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (createMode === 'graphCreateEdge') {
+                        const sourceKref = normalizeKrefString(this, this.getNodeParameter('sourceKref', index, ''), 'Source Kref');
+                        const targetKref = normalizeKrefString(this, this.getNodeParameter('targetKref', index, ''), 'Target Kref');
+                        const edgeType = this.getNodeParameter('edgeType', index);
+                        const metadata = (0, kumihoApi_1.normalizeMetadata)(this.getNodeParameter('metadata', index, {}));
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'POST',
+                            path: '/api/v1/graph/edges',
+                            body: { source_kref: sourceKref, target_kref: targetKref, edge_type: edgeType, metadata },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                }
+                if (operation === 'read') {
+                    const readMode = this.getNodeParameter('readModeRevision', index);
+                    if (readMode === 'revisionGetByKref') {
+                        const revisionKref = (String((_q = this.getNodeParameter('revisionKrefReadGetByKref', index, '')) !== null && _q !== void 0 ? _q : '').trim() ||
+                            String((_r = this.getNodeParameter('kref', index, '')) !== null && _r !== void 0 ? _r : '').trim());
+                        const normalizedRevisionKref = normalizeKrefString(this, revisionKref, 'Revision Kref');
+                        const qs = { kref: normalizedRevisionKref };
+                        if (revisionNumber !== undefined)
+                            qs.r = revisionNumber;
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/revisions/by-kref',
+                            qs,
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (readMode === 'revisionGetByTag') {
+                        const itemKref = (String((_s = this.getNodeParameter('itemKrefRevisionGetByTag', index, '')) !== null && _s !== void 0 ? _s : '').trim() ||
+                            String((_t = this.getNodeParameter('itemKref', index, '')) !== null && _t !== void 0 ? _t : '').trim() ||
+                            String((_u = this.getNodeParameter('kref', index, '')) !== null && _u !== void 0 ? _u : '').trim());
+                        const tag = (String((_v = this.getNodeParameter('tagRead', index, 'latest')) !== null && _v !== void 0 ? _v : '').trim() ||
+                            String((_w = this.getNodeParameter('tag', index, 'latest')) !== null && _w !== void 0 ? _w : '').trim() ||
+                            'latest');
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/revisions/by-kref',
+                            qs: { kref: itemKref, t: tag },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (readMode === 'revisionListArtifacts') {
+                        const revisionKref = this.getNodeParameter('revisionKrefRevision', index);
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/artifacts',
+                            qs: { revision_kref: revisionKref, r: revisionNumber },
+                        });
+                        emitArray(out, data, outputFormat, returnAll, limit);
+                        continue;
+                    }
+                    if (readMode === 'revisionListTags') {
+                        const kref = this.getNodeParameter('kref', index);
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/revisions/by-kref',
+                            qs: { kref, r: revisionNumber },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (readMode === 'revisionHasTag') {
+                        const itemKref = (String((_x = this.getNodeParameter('itemKrefRevisionHasTag', index, '')) !== null && _x !== void 0 ? _x : '').trim() ||
+                            String((_y = this.getNodeParameter('itemKref', index, '')) !== null && _y !== void 0 ? _y : '').trim() ||
+                            String((_z = this.getNodeParameter('kref', index, '')) !== null && _z !== void 0 ? _z : '').trim());
+                        const normalizedItemKref = normalizeKrefString(this, itemKref, 'Item Kref');
+                        const tag = (String((_0 = this.getNodeParameter('tagRead', index, '')) !== null && _0 !== void 0 ? _0 : '').trim() ||
+                            String((_1 = this.getNodeParameter('tag', index, '')) !== null && _1 !== void 0 ? _1 : '').trim());
+                        try {
+                            await (0, kumihoApi_1.kumihoRequest)(this, {
+                                method: 'GET',
+                                path: '/api/v1/revisions/by-kref',
+                                qs: { kref: normalizedItemKref, t: tag },
+                            });
+                            out.push({ json: { has_tag: true, tag } });
+                        }
+                        catch (error) {
+                            const err = error;
+                            const httpCode = Number((_2 = err === null || err === void 0 ? void 0 : err.httpCode) !== null && _2 !== void 0 ? _2 : (_3 = err === null || err === void 0 ? void 0 : err.kumiho) === null || _3 === void 0 ? void 0 : _3.status_code);
+                            if (httpCode === 404) {
+                                out.push({ json: { has_tag: false, tag } });
+                            }
+                            else {
+                                throw error;
+                            }
+                        }
+                        continue;
+                    }
+                    if (readMode === 'revisionWasTagged') {
+                        const kref = this.getNodeParameter('kref', index);
+                        const tag = (String((_4 = this.getNodeParameter('tagRead', index, '')) !== null && _4 !== void 0 ? _4 : '').trim() ||
+                            String((_5 = this.getNodeParameter('tag', index, '')) !== null && _5 !== void 0 ? _5 : '').trim());
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/revisions/tags/history',
+                            qs: { kref, tag, r: revisionNumber },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (readMode === 'graphListEdges') {
+                        const revisionKref = this.getNodeParameter('revisionKrefGraph', index);
+                        const edgeType = String((_6 = this.getNodeParameter('edgeTypeFilter', index, '')) !== null && _6 !== void 0 ? _6 : '').trim();
+                        const direction = this.getNodeParameter('direction', index, 0);
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/graph/edges',
+                            qs: { revision_kref: revisionKref, edge_type: edgeType || undefined, direction },
+                        });
+                        emitArray(out, data, outputFormat, returnAll, limit);
+                        continue;
+                    }
+                    if (readMode === 'graphGetDependencies') {
+                        const revisionKref = this.getNodeParameter('revisionKrefGraph', index);
+                        const maxDepth = this.getNodeParameter('maxDepth', index, 5);
+                        const edgeTypes = splitCsv(this.getNodeParameter('edgeTypes', index, ''));
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/graph/dependencies',
+                            qs: { revision_kref: revisionKref, max_depth: maxDepth, edge_types: edgeTypes },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (readMode === 'graphFindPath') {
+                        const sourceKref = normalizeKrefString(this, this.getNodeParameter('sourceKref', index, ''), 'Source Kref');
+                        const targetKref = normalizeKrefString(this, this.getNodeParameter('targetKref', index, ''), 'Target Kref');
+                        const maxDepth = this.getNodeParameter('maxDepth', index, 5);
+                        const edgeTypes = splitCsv(this.getNodeParameter('edgeTypes', index, ''));
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/graph/path',
+                            qs: { source_kref: sourceKref, target_kref: targetKref, max_depth: maxDepth, edge_types: edgeTypes },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (readMode === 'graphAnalyzeImpact') {
+                        const revisionKref = this.getNodeParameter('revisionKrefGraph', index);
+                        const maxDepth = this.getNodeParameter('maxDepth', index, 5);
+                        const edgeTypes = splitCsv(this.getNodeParameter('edgeTypes', index, ''));
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/graph/impact',
+                            qs: { revision_kref: revisionKref, max_depth: maxDepth, edge_types: edgeTypes },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                }
+                if (operation === 'update') {
+                    const updateMode = this.getNodeParameter('updateModeRevision', index);
+                    if (updateMode === 'revisionUpdateMetadata') {
+                        const revisionKref = (String((_7 = this.getNodeParameter('revisionKrefUpdateMetadata', index, '')) !== null && _7 !== void 0 ? _7 : '').trim() ||
+                            String((_8 = this.getNodeParameter('krefRevisionUpdate', index, '')) !== null && _8 !== void 0 ? _8 : '').trim() ||
+                            String((_9 = this.getNodeParameter('kref', index, '')) !== null && _9 !== void 0 ? _9 : '').trim());
+                        const normalizedRevisionKref = normalizeKrefString(this, revisionKref, 'Revision Kref');
+                        const metadataFromRevisionField = (0, kumihoApi_1.normalizeMetadata)(this.getNodeParameter('revisionMetadataUpdate', index, {}));
+                        const metadataFromLegacyField = (0, kumihoApi_1.normalizeMetadata)(this.getNodeParameter('metadata', index, {}));
+                        const metadata = Object.keys(metadataFromRevisionField).length > 0 ? metadataFromRevisionField : metadataFromLegacyField;
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'PATCH',
+                            path: '/api/v1/revisions/by-kref',
+                            qs: { kref: normalizedRevisionKref },
+                            body: { metadata },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (updateMode === 'revisionDeprecate') {
+                        const revisionKref = (String((_10 = this.getNodeParameter('revisionKrefDeprecate', index, '')) !== null && _10 !== void 0 ? _10 : '').trim() ||
+                            String((_11 = this.getNodeParameter('krefRevisionUpdate', index, '')) !== null && _11 !== void 0 ? _11 : '').trim() ||
+                            String((_12 = this.getNodeParameter('kref', index, '')) !== null && _12 !== void 0 ? _12 : '').trim());
+                        const normalizedRevisionKref = normalizeKrefString(this, revisionKref, 'Revision Kref');
+                        const deprecated = this.getNodeParameter('deprecatedRevision', index, true);
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'POST',
+                            path: '/api/v1/revisions/deprecate',
+                            qs: { kref: normalizedRevisionKref, deprecated },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (updateMode === 'revisionSetTag') {
+                        const revisionKref = (String((_13 = this.getNodeParameter('revisionKrefTagUpdate', index, '')) !== null && _13 !== void 0 ? _13 : '').trim() ||
+                            String((_14 = this.getNodeParameter('kref', index, '')) !== null && _14 !== void 0 ? _14 : '').trim());
+                        const normalizedRevisionKref = normalizeKrefString(this, revisionKref, 'Revision Kref');
+                        const tag = (String((_15 = this.getNodeParameter('tagUpdate', index, '')) !== null && _15 !== void 0 ? _15 : '').trim() ||
+                            String((_16 = this.getNodeParameter('tag', index, '')) !== null && _16 !== void 0 ? _16 : '').trim());
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'POST',
+                            path: '/api/v1/revisions/tags',
+                            qs: { kref: normalizedRevisionKref },
+                            body: { tag },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (updateMode === 'revisionRemoveTag') {
+                        const revisionKref = (String((_17 = this.getNodeParameter('revisionKrefTagUpdate', index, '')) !== null && _17 !== void 0 ? _17 : '').trim() ||
+                            String((_18 = this.getNodeParameter('kref', index, '')) !== null && _18 !== void 0 ? _18 : '').trim());
+                        const normalizedRevisionKref = normalizeKrefString(this, revisionKref, 'Revision Kref');
+                        const tag = (String((_19 = this.getNodeParameter('tagUpdate', index, '')) !== null && _19 !== void 0 ? _19 : '').trim() ||
+                            String((_20 = this.getNodeParameter('tag', index, '')) !== null && _20 !== void 0 ? _20 : '').trim());
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'DELETE',
+                            path: '/api/v1/revisions/tags',
+                            qs: { kref: normalizedRevisionKref, tag },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                }
+                if (operation === 'delete') {
+                    const revisionKref = (String((_21 = this.getNodeParameter('revisionKrefDelete', index, '')) !== null && _21 !== void 0 ? _21 : '').trim() ||
+                        String((_22 = this.getNodeParameter('kref', index, '')) !== null && _22 !== void 0 ? _22 : '').trim());
+                    const normalizedRevisionKref = normalizeKrefString(this, revisionKref, 'Revision Kref');
+                    const force = this.getNodeParameter('force', index, false);
+                    const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                        method: 'DELETE',
+                        path: '/api/v1/revisions/by-kref',
+                        qs: { kref: normalizedRevisionKref, force },
+                    });
+                    out.push({ json: data });
+                    continue;
+                }
+            }
+            if (resource === 'artifact') {
+                if (operation === 'create') {
+                    const revisionKref = this.getNodeParameter('artifactRevisionKref', index);
+                    const name = this.getNodeParameter('name', index);
+                    const location = this.getNodeParameter('locationCreate', index);
+                    const metadataFromArtifactField = (0, kumihoApi_1.normalizeMetadata)(this.getNodeParameter('artifactMetadataCreate', index, {}));
+                    const metadataFromLegacyField = (0, kumihoApi_1.normalizeMetadata)(this.getNodeParameter('metadata', index, {}));
+                    const metadata = Object.keys(metadataFromArtifactField).length > 0 ? metadataFromArtifactField : metadataFromLegacyField;
+                    const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                        method: 'POST',
+                        path: '/api/v1/artifacts',
+                        body: { revision_kref: revisionKref, name, location, metadata },
+                    });
+                    out.push({ json: data });
+                    continue;
+                }
+                if (operation === 'read') {
+                    const readMode = this.getNodeParameter('readModeArtifact', index);
+                    if (readMode === 'artifactGet') {
+                        const revisionKref = this.getNodeParameter('revisionKrefArtifact', index);
+                        const name = this.getNodeParameter('artifactName', index);
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/artifacts/by-kref',
+                            qs: { revision_kref: revisionKref, name },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (readMode === 'artifactGetByLocation') {
+                        const location = this.getNodeParameter('locationQuery', index);
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/artifacts/by-location',
+                            qs: { location },
+                        });
+                        emitArray(out, data, outputFormat, returnAll, limit);
+                        continue;
+                    }
+                }
+                if (operation === 'update') {
+                    const updateMode = this.getNodeParameter('updateModeArtifact', index);
+                    const kref = this.getNodeParameter('artifactKref', index);
+                    if (updateMode === 'artifactUpdateMetadata') {
+                        const metadataFromArtifactField = (0, kumihoApi_1.normalizeMetadata)(this.getNodeParameter('artifactMetadataUpdate', index, {}));
+                        const metadataFromLegacyField = (0, kumihoApi_1.normalizeMetadata)(this.getNodeParameter('metadata', index, {}));
+                        const metadata = Object.keys(metadataFromArtifactField).length > 0 ? metadataFromArtifactField : metadataFromLegacyField;
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'PATCH',
+                            path: '/api/v1/artifacts/by-kref',
+                            qs: { kref },
+                            body: { metadata },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (updateMode === 'artifactDeprecate') {
+                        const deprecated = this.getNodeParameter('deprecatedArtifact', index, true);
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'POST',
+                            path: '/api/v1/artifacts/deprecate',
+                            qs: { kref, deprecated },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                }
+                if (operation === 'delete') {
+                    const kref = this.getNodeParameter('artifactKref', index);
+                    const force = this.getNodeParameter('force', index, false);
+                    const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                        method: 'DELETE',
+                        path: '/api/v1/artifacts/by-kref',
+                        qs: { kref, force },
+                    });
+                    out.push({ json: data });
+                    continue;
+                }
+            }
+            if (resource === 'bundle') {
+                if (operation === 'create') {
+                    const spacePath = normalizeKumihoPath(this, this.getNodeParameter('bundleSpacePath', index), 'Space Path');
+                    const bundleName = this.getNodeParameter('bundleName', index);
+                    const metadata = (0, kumihoApi_1.normalizeMetadata)(this.getNodeParameter('metadata', index, {}));
+                    try {
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'POST',
+                            path: '/api/v1/bundles',
+                            body: { space_path: spacePath, bundle_name: bundleName, metadata },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    catch (error) {
+                        const err = error;
+                        const httpCode = Number((_23 = err === null || err === void 0 ? void 0 : err.httpCode) !== null && _23 !== void 0 ? _23 : (_24 = err === null || err === void 0 ? void 0 : err.kumiho) === null || _24 === void 0 ? void 0 : _24.status_code);
+                        if (httpCode === 409) {
+                            try {
+                                const normalized = spacePath.replace(/^\/+/, '');
+                                const bundleKref = `kref://${normalized}/${bundleName}.bundle`;
+                                const existing = await (0, kumihoApi_1.kumihoRequest)(this, {
+                                    method: 'GET',
+                                    path: '/api/v1/bundles/by-kref',
+                                    qs: { kref: bundleKref },
+                                    maxAttempts: 1,
+                                    timeoutMs: 15000,
+                                    retryBudgetMs: 15000,
+                                });
+                                out.push({ json: existing });
+                                continue;
+                            }
+                            catch {
+                            }
+                        }
+                        throw error;
+                    }
+                }
+                if (operation === 'read') {
+                    const readMode = this.getNodeParameter('readModeBundle', index);
+                    if (readMode === 'bundleGet') {
+                        const spacePath = normalizeKumihoPath(this, this.getNodeParameter('bundleSpacePath', index), 'Space Path');
+                        const bundleName = this.getNodeParameter('bundleName', index);
+                        const overrideEnabled = this.getNodeParameter('bundleKrefOverrideEnabled', index, false);
+                        const overrideKref = String((_25 = this.getNodeParameter('bundleKrefOverride', index, '')) !== null && _25 !== void 0 ? _25 : '').trim();
+                        const normalized = spacePath.replace(/^\/+/, '');
+                        const computedKref = `kref://${normalized}/${bundleName}.bundle`;
+                        const bundleKref = overrideEnabled && overrideKref ? overrideKref : computedKref;
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/bundles/by-kref',
+                            qs: { kref: bundleKref },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (readMode === 'bundleListMembers') {
+                        const bundleKref = this.getNodeParameter('bundleKref', index);
+                        const revisionNumber = parseOptionalInt(this.getNodeParameter('bundleRevisionNumber', index, ''));
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/bundles/members',
+                            qs: { bundle_kref: bundleKref, revision_number: revisionNumber },
+                        });
+                        emitArray(out, data, outputFormat, returnAll, limit);
+                        continue;
+                    }
+                    if (readMode === 'bundleHistory') {
+                        const bundleKref = this.getNodeParameter('bundleKref', index);
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/bundles/history',
+                            qs: { bundle_kref: bundleKref },
+                        });
+                        emitArray(out, data, outputFormat, returnAll, limit);
+                        continue;
+                    }
+                }
+                if (operation === 'update') {
+                    const updateMode = this.getNodeParameter('updateModeBundle', index);
+                    const bundleKref = this.getNodeParameter('bundleKref', index);
+                    const itemKref = this.getNodeParameter('bundleItemKref', index);
+                    const metadata = (0, kumihoApi_1.normalizeMetadata)(this.getNodeParameter('metadata', index, {}));
+                    if (updateMode === 'bundleAddMember') {
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'POST',
+                            path: '/api/v1/bundles/members/add',
+                            body: { bundle_kref: bundleKref, item_kref: itemKref, metadata },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (updateMode === 'bundleRemoveMember') {
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'POST',
+                            path: '/api/v1/bundles/members/remove',
+                            body: { bundle_kref: bundleKref, item_kref: itemKref, metadata },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                }
+                if (operation === 'delete') {
+                    const bundleKref = (String((_26 = this.getNodeParameter('bundleKrefDelete', index, '')) !== null && _26 !== void 0 ? _26 : '').trim() ||
+                        String((_27 = this.getNodeParameter('bundleKref', index, '')) !== null && _27 !== void 0 ? _27 : '').trim());
+                    const normalizedBundleKref = normalizeKrefString(this, bundleKref, 'Bundle Kref');
+                    const force = this.getNodeParameter('force', index, false);
+                    const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                        method: 'DELETE',
+                        path: '/api/v1/bundles/by-kref',
+                        qs: { kref: normalizedBundleKref, force },
+                    });
+                    out.push({ json: data });
+                    continue;
+                }
+            }
+            if (resource === 'graph') {
+                if (operation === 'create') {
+                    const createMode = this.getNodeParameter('createMode', index);
+                    if (createMode === 'graphCreateEdge') {
+                        const sourceKref = this.getNodeParameter('sourceKref', index);
+                        const targetKref = this.getNodeParameter('targetKref', index);
+                        const edgeType = this.getNodeParameter('edgeType', index);
+                        const metadata = (0, kumihoApi_1.normalizeMetadata)(this.getNodeParameter('metadata', index, {}));
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'POST',
+                            path: '/api/v1/graph/edges',
+                            body: { source_kref: sourceKref, target_kref: targetKref, edge_type: edgeType, metadata },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                }
+                if (operation === 'read') {
+                    const readMode = this.getNodeParameter('readModeGraph', index);
+                    const maxDepth = this.getNodeParameter('maxDepth', index, 5);
+                    const edgeTypes = splitCsv(this.getNodeParameter('edgeTypes', index, ''));
+                    if (readMode === 'graphListEdges') {
+                        const revisionKref = this.getNodeParameter('revisionKrefGraph', index);
+                        const edgeType = String((_28 = this.getNodeParameter('edgeTypeFilter', index, '')) !== null && _28 !== void 0 ? _28 : '').trim();
+                        const direction = this.getNodeParameter('direction', index, 0);
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/graph/edges',
+                            qs: { revision_kref: revisionKref, edge_type: edgeType || undefined, direction },
+                        });
+                        emitArray(out, data, outputFormat, returnAll, limit);
+                        continue;
+                    }
+                    if (readMode === 'graphGetDependencies') {
+                        const revisionKref = this.getNodeParameter('revisionKrefGraph', index);
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/graph/dependencies',
+                            qs: { revision_kref: revisionKref, max_depth: maxDepth, edge_types: edgeTypes },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (readMode === 'graphFindPath') {
+                        const sourceKref = this.getNodeParameter('sourceKref', index);
+                        const targetKref = this.getNodeParameter('targetKref', index);
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/graph/path',
+                            qs: { source_kref: sourceKref, target_kref: targetKref, max_depth: maxDepth, edge_types: edgeTypes },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                    if (readMode === 'graphAnalyzeImpact') {
+                        const revisionKref = this.getNodeParameter('revisionKrefGraph', index);
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/graph/impact',
+                            qs: { revision_kref: revisionKref, max_depth: maxDepth, edge_types: edgeTypes },
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                }
+            }
+            if (resource === 'kref') {
+                if (operation === 'read') {
+                    const readMode = this.getNodeParameter('readModeKref', index);
+                    if (readMode === 'krefResolve') {
+                        const kref = this.getNodeParameter('kref', index);
+                        const r = parseOptionalInt(this.getNodeParameter('krefResolveRevisionNumber', index, ''));
+                        const t = String((_29 = this.getNodeParameter('krefResolveTag', index, '')) !== null && _29 !== void 0 ? _29 : '').trim() || undefined;
+                        const a = String((_30 = this.getNodeParameter('krefResolveArtifactName', index, '')) !== null && _30 !== void 0 ? _30 : '').trim() || undefined;
+                        const qs = { kref };
+                        if (r !== undefined)
+                            qs.r = r;
+                        if (t !== undefined)
+                            qs.t = t;
+                        if (a !== undefined)
+                            qs.a = a;
+                        const data = await (0, kumihoApi_1.kumihoRequest)(this, {
+                            method: 'GET',
+                            path: '/api/v1/resolve',
+                            qs,
+                        });
+                        out.push({ json: data });
+                        continue;
+                    }
+                }
+            }
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unsupported combination: resource=${resource}, operation=${operation}`);
+        }
+        return [out];
+    }
+}
+exports.KumihoAction = KumihoAction;
+//# sourceMappingURL=KumihoAction.node.js.map