@hustleops/n8n-nodes-hustleops 0.1.5

package/dist/nodes/HustleOps/resourceDefinitions.js

@@ -0,0 +1,629 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CORE_RESOURCE_OPTIONS = exports.CORE_RESOURCE_DEFINITIONS = void 0;
+exports.getCoreResourceDefinition = getCoreResourceDefinition;
+exports.sanitizeDtoBody = sanitizeDtoBody;
+exports.buildGenericSearchRequest = buildGenericSearchRequest;
+exports.buildSearchRequest = buildSearchRequest;
+const n8n_workflow_1 = require("n8n-workflow");
+const GenericFunctions_1 = require("./GenericFunctions");
+const SEARCH_REQUEST_FIELDS = new Set(['filter', 'pagination', 'excludeIds']);
+const SEARCH_PAGINATION_FIELDS = new Set(['page', 'pageSize', 'sortBy', 'sortOrder']);
+const SEARCH_OPERATORS = new Set([
+    'eq',
+    'neq',
+    'contains',
+    'startsWith',
+    'in',
+    'notIn',
+    'gt',
+    'gte',
+    'lt',
+    'lte',
+    'isNull',
+    'isNotNull',
+]);
+const SEARCH_GROUP_OPERATORS = new Set(['AND', 'OR']);
+const MAX_SEARCH_GROUPS = 20;
+const MAX_SEARCH_CONDITIONS = 50;
+const MAX_SEARCH_DEPTH = 4;
+const MAX_PAGE = 10000;
+const MAX_PAGE_SIZE = 100;
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const ALERT_SOURCE_PATTERN = /^[a-zA-Z0-9:\-_]+$/;
+const SEVERITY_VALUES = ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW', 'INFO'];
+const TLP_VALUES = ['RED', 'AMBER_STRICT', 'AMBER', 'GREEN', 'CLEAR'];
+const THREAT_LEVEL_VALUES = ['MALICIOUS', 'SUSPICIOUS', 'UNKNOWN', 'BENIGN'];
+const CRITICALITY_VALUES = ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW'];
+const RESOURCE_DEFINITION_NODE = {
+    id: 'hustleops-resource-definitions',
+    name: 'HustleOps',
+    type: 'hustleOps',
+    typeVersion: 1,
+    position: [0, 0],
+    parameters: {},
+};
+const alertSearchFields = [
+    'seq',
+    'name',
+    'description',
+    'summary',
+    'severity',
+    'tlp',
+    'source',
+    'type',
+    'sourceRef',
+    'alertRefUrl',
+    'status',
+    'stage',
+    'detectedAt',
+    'closedAt',
+    'closedById',
+    'assigneeId',
+    'incidentId',
+    'createdById',
+    'startedAt',
+    'startedById',
+    'createdAt',
+    'updatedAt',
+    'tags',
+];
+const incidentSearchFields = [
+    'seq',
+    'name',
+    'description',
+    'summary',
+    'severity',
+    'tlp',
+    'status',
+    'stage',
+    'category',
+    'closedAt',
+    'closedById',
+    'assigneeId',
+    'createdById',
+    'startedAt',
+    'startedById',
+    'detectedAt',
+    'createdAt',
+    'updatedAt',
+    'tags',
+];
+const observableSearchFields = [
+    'seq',
+    'value',
+    'description',
+    'type',
+    'threatLevel',
+    'tlp',
+    'criticality',
+    'firstSeen',
+    'lastSeen',
+    'createdById',
+    'createdAt',
+    'updatedAt',
+    'tags',
+];
+const knowledgeSearchFields = [
+    'seq',
+    'value',
+    'description',
+    'type',
+    'tlp',
+    'createdById',
+    'updatedById',
+    'createdAt',
+    'updatedAt',
+    'tags',
+];
+exports.CORE_RESOURCE_DEFINITIONS = {
+    alert: {
+        resource: 'alert',
+        displayName: 'Alert',
+        description: 'Security alert created by a source system or analyst',
+        entityType: 'ALERT',
+        path: '/alerts',
+        defaultSortBy: 'detectedAt',
+        defaultSortOrder: 'desc',
+        searchFields: alertSearchFields,
+        sortFields: [...alertSearchFields, 'displayId'],
+        createFields: [
+            'name',
+            'description',
+            'severity',
+            'tlp',
+            'source',
+            'type',
+            'sourceRef',
+            'alertRefUrl',
+            'status',
+            'detectedAt',
+            'incidentId',
+            'assigneeId',
+            'tags',
+        ],
+        updateFields: [
+            'name',
+            'description',
+            'severity',
+            'tlp',
+            'source',
+            'type',
+            'sourceRef',
+            'alertRefUrl',
+            'status',
+            'detectedAt',
+            'incidentId',
+            'assigneeId',
+            'summary',
+            'version',
+        ],
+        requiredCreateFields: [
+            'name',
+            'description',
+            'severity',
+            'tlp',
+            'source',
+            'type',
+            'sourceRef',
+            'detectedAt',
+        ],
+        fieldSpecs: {
+            name: { name: 'name', type: 'string', requiredForCreate: true, maxLength: 200 },
+            description: {
+                name: 'description',
+                type: 'string',
+                requiredForCreate: true,
+                maxLength: 15000,
+            },
+            severity: {
+                name: 'severity',
+                type: 'enum',
+                requiredForCreate: true,
+                allowedValues: SEVERITY_VALUES,
+            },
+            tlp: {
+                name: 'tlp',
+                type: 'enum',
+                requiredForCreate: true,
+                allowedValues: TLP_VALUES,
+            },
+            source: {
+                name: 'source',
+                type: 'string',
+                requiredForCreate: true,
+                nonEmpty: true,
+                maxLength: 50,
+                pattern: ALERT_SOURCE_PATTERN,
+                patternDescription: 'may only contain letters, digits, colons, hyphens, and underscores',
+            },
+            type: {
+                name: 'type',
+                type: 'string',
+                requiredForCreate: true,
+                nonEmpty: true,
+                picklistDomain: 'alertType',
+                description: 'Must match an active alertType picklist value in HustleOps, such as authentication, endpoint, email, network, dns, user_activity, or other on a default instance.',
+            },
+            sourceRef: {
+                name: 'sourceRef',
+                type: 'string',
+                requiredForCreate: true,
+                nonEmpty: true,
+                maxLength: 255,
+            },
+            alertRefUrl: { name: 'alertRefUrl', type: 'url', maxLength: 2048 },
+            status: {
+                name: 'status',
+                type: 'string',
+                nonEmpty: true,
+                picklistDomain: 'alertStatus',
+                description: 'Must match an active alertStatus picklist value in HustleOps when provided.',
+            },
+            detectedAt: { name: 'detectedAt', type: 'date-time', requiredForCreate: true },
+            incidentId: { name: 'incidentId', type: 'uuid' },
+            assigneeId: { name: 'assigneeId', type: 'uuid' },
+            summary: { name: 'summary', type: 'string' },
+            version: { name: 'version', type: 'number' },
+            tags: { name: 'tags', type: 'tags' },
+        },
+    },
+    incident: {
+        resource: 'incident',
+        displayName: 'Incident',
+        description: 'Incident case that groups investigation and response work',
+        entityType: 'INCIDENT',
+        path: '/incidents',
+        defaultSortBy: 'createdAt',
+        defaultSortOrder: 'desc',
+        searchFields: incidentSearchFields,
+        sortFields: [...incidentSearchFields, 'displayId'],
+        createFields: [
+            'name',
+            'description',
+            'severity',
+            'tlp',
+            'status',
+            'category',
+            'assigneeId',
+            'tags',
+        ],
+        updateFields: [
+            'name',
+            'description',
+            'severity',
+            'tlp',
+            'status',
+            'category',
+            'assigneeId',
+            'detectedAt',
+            'closedAt',
+            'summary',
+            'version',
+        ],
+        requiredCreateFields: ['name', 'description', 'severity', 'tlp', 'category'],
+        fieldSpecs: {
+            name: { name: 'name', type: 'string', requiredForCreate: true, maxLength: 200 },
+            description: {
+                name: 'description',
+                type: 'string',
+                requiredForCreate: true,
+                maxLength: 15000,
+            },
+            severity: {
+                name: 'severity',
+                type: 'enum',
+                requiredForCreate: true,
+                allowedValues: SEVERITY_VALUES,
+            },
+            tlp: {
+                name: 'tlp',
+                type: 'enum',
+                requiredForCreate: true,
+                allowedValues: TLP_VALUES,
+            },
+            status: {
+                name: 'status',
+                type: 'string',
+                nonEmpty: true,
+                picklistDomain: 'incidentStatus',
+                description: 'Must match an active incidentStatus picklist value in HustleOps when provided.',
+            },
+            category: {
+                name: 'category',
+                type: 'string',
+                requiredForCreate: true,
+                nonEmpty: true,
+                picklistDomain: 'incidentCategory',
+                description: 'Must match an active incidentCategory picklist value in HustleOps.',
+            },
+            assigneeId: { name: 'assigneeId', type: 'uuid' },
+            detectedAt: { name: 'detectedAt', type: 'date-time' },
+            closedAt: { name: 'closedAt', type: 'date-time' },
+            summary: { name: 'summary', type: 'string' },
+            version: { name: 'version', type: 'number' },
+            tags: { name: 'tags', type: 'tags' },
+        },
+    },
+    observable: {
+        resource: 'observable',
+        displayName: 'Observable',
+        description: 'Indicator or artifact observed during detection or investigation',
+        entityType: 'OBSERVABLE',
+        path: '/observables',
+        defaultSortBy: 'lastSeen',
+        defaultSortOrder: 'desc',
+        searchFields: observableSearchFields,
+        sortFields: [...observableSearchFields, 'displayId'],
+        createFields: [
+            'value',
+            'description',
+            'type',
+            'threatLevel',
+            'tlp',
+            'criticality',
+            'firstSeen',
+            'lastSeen',
+            'tags',
+        ],
+        updateFields: [
+            'value',
+            'description',
+            'type',
+            'threatLevel',
+            'tlp',
+            'criticality',
+            'firstSeen',
+            'lastSeen',
+            'version',
+        ],
+        requiredCreateFields: ['value', 'type', 'threatLevel', 'tlp', 'firstSeen', 'lastSeen'],
+        fieldSpecs: {
+            value: { name: 'value', type: 'string', requiredForCreate: true, maxLength: 2048 },
+            description: { name: 'description', type: 'string', maxLength: 5000 },
+            type: {
+                name: 'type',
+                type: 'string',
+                requiredForCreate: true,
+                nonEmpty: true,
+                picklistDomain: 'observableType',
+                description: 'Must match an active observableType picklist value in HustleOps.',
+            },
+            threatLevel: {
+                name: 'threatLevel',
+                type: 'enum',
+                requiredForCreate: true,
+                allowedValues: THREAT_LEVEL_VALUES,
+                picklistDomain: 'threatLevel',
+                picklistValueTransform: 'uppercase',
+            },
+            tlp: {
+                name: 'tlp',
+                type: 'enum',
+                requiredForCreate: true,
+                allowedValues: TLP_VALUES,
+            },
+            criticality: {
+                name: 'criticality',
+                type: 'enum',
+                allowedValues: CRITICALITY_VALUES,
+                picklistDomain: 'criticality',
+                picklistValueTransform: 'uppercase',
+            },
+            firstSeen: { name: 'firstSeen', type: 'date-time', requiredForCreate: true },
+            lastSeen: { name: 'lastSeen', type: 'date-time', requiredForCreate: true },
+            version: { name: 'version', type: 'number' },
+            tags: { name: 'tags', type: 'tags' },
+        },
+    },
+    knowledge: {
+        resource: 'knowledge',
+        displayName: 'Knowledge',
+        description: 'Reusable knowledge, runbook, or note entry',
+        entityType: 'KNOWLEDGE',
+        path: '/knowledge',
+        defaultSortBy: 'createdAt',
+        defaultSortOrder: 'desc',
+        searchFields: knowledgeSearchFields,
+        sortFields: [...knowledgeSearchFields, 'displayId'],
+        createFields: ['value', 'description', 'type', 'tlp', 'tags'],
+        updateFields: ['value', 'description', 'type', 'tlp', 'version'],
+        requiredCreateFields: ['value', 'type', 'tlp'],
+        fieldSpecs: {
+            value: {
+                name: 'value',
+                type: 'string',
+                requiredForCreate: true,
+                nonEmpty: true,
+                maxLength: 500,
+            },
+            description: { name: 'description', type: 'string', maxLength: 15000 },
+            type: {
+                name: 'type',
+                type: 'string',
+                requiredForCreate: true,
+                nonEmpty: true,
+                picklistDomain: 'knowledgeType',
+                description: 'Must match an active knowledgeType picklist value in HustleOps.',
+            },
+            tlp: {
+                name: 'tlp',
+                type: 'enum',
+                requiredForCreate: true,
+                allowedValues: TLP_VALUES,
+            },
+            version: { name: 'version', type: 'number' },
+            tags: { name: 'tags', type: 'tags' },
+        },
+    },
+};
+exports.CORE_RESOURCE_OPTIONS = Object.values(exports.CORE_RESOURCE_DEFINITIONS).map((definition) => ({
+    name: definition.displayName,
+    value: definition.resource,
+    description: definition.description,
+}));
+function assertSupportedFields(definition, operationLabel, body, allowedFields) {
+    for (const field of Object.keys(body)) {
+        if (!allowedFields.includes(field)) {
+            throw new Error(`Unsupported ${definition.displayName} ${operationLabel} field: ${field}`);
+        }
+    }
+}
+function validateDtoField(definition, field, value) {
+    var _a;
+    const spec = definition.fieldSpecs[field];
+    if (!spec || value === undefined || value === null) {
+        return;
+    }
+    if (spec.type === 'string' && typeof value !== 'string') {
+        throw new Error(`${definition.displayName} field ${field} must be a string.`);
+    }
+    if (spec.type === 'number' && typeof value !== 'number') {
+        throw new Error(`${definition.displayName} field ${field} must be a number.`);
+    }
+    if (spec.type === 'uuid' && (typeof value !== 'string' || !UUID_PATTERN.test(value))) {
+        throw new Error(`${definition.displayName} field ${field} must be a UUID.`);
+    }
+    if (spec.type === 'date-time' && (typeof value !== 'string' || Number.isNaN(Date.parse(value)))) {
+        throw new Error(`${definition.displayName} field ${field} must be an ISO date-time string.`);
+    }
+    if (spec.type === 'url' && typeof value !== 'string') {
+        throw new Error(`${definition.displayName} field ${field} must be a string.`);
+    }
+    if (spec.type === 'url') {
+        try {
+            const url = new URL(value);
+            if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+                throw new Error('Unsupported protocol.');
+            }
+        }
+        catch {
+            throw new n8n_workflow_1.NodeOperationError(RESOURCE_DEFINITION_NODE, `${definition.displayName} field ${field} must be a valid HTTP or HTTPS URL.`);
+        }
+    }
+    if (spec.type === 'enum' && spec.allowedValues && !spec.allowedValues.includes(value)) {
+        throw new Error(`${definition.displayName} field ${field} must be one of: ${spec.allowedValues.join(', ')}.`);
+    }
+    if (spec.type === 'tags' &&
+        (!Array.isArray(value) || value.some((tag) => typeof tag !== 'string'))) {
+        throw new Error(`${definition.displayName} field ${field} must be an array of tag names.`);
+    }
+    if (typeof value !== 'string') {
+        return;
+    }
+    if (spec.nonEmpty && value === '') {
+        throw new Error(`${definition.displayName} field ${field} cannot be empty when provided.`);
+    }
+    if (spec.maxLength !== undefined && value.length > spec.maxLength) {
+        throw new Error(`${definition.displayName} field ${field} cannot exceed ${spec.maxLength} characters.`);
+    }
+    if (spec.pattern && !spec.pattern.test(value)) {
+        throw new Error(`${definition.displayName} field ${field} ${(_a = spec.patternDescription) !== null && _a !== void 0 ? _a : 'has an invalid format'}.`);
+    }
+}
+function assertRequiredCreateFields(definition, body) {
+    for (const field of definition.requiredCreateFields) {
+        if (body[field] === undefined || body[field] === null || body[field] === '') {
+            throw new Error(`Missing required ${definition.displayName} create field: ${field}`);
+        }
+    }
+}
+function getCoreResourceDefinition(resource) {
+    const definition = exports.CORE_RESOURCE_DEFINITIONS[resource];
+    if (!definition) {
+        throw new Error(`Unsupported HustleOps resource: ${resource}`);
+    }
+    return definition;
+}
+function sanitizeDtoBody(definition, operation, body) {
+    const allowedFields = operation === 'create' ? definition.createFields : definition.updateFields;
+    assertSupportedFields(definition, operation, body, allowedFields);
+    const compacted = (0, GenericFunctions_1.compactObject)(body);
+    if (operation === 'create') {
+        assertRequiredCreateFields(definition, compacted);
+    }
+    else if (Object.keys(compacted).length === 0) {
+        throw new Error(`${definition.displayName} update body must include at least one supported field.`);
+    }
+    for (const [field, value] of Object.entries(compacted)) {
+        validateDtoField(definition, field, value);
+    }
+    return compacted;
+}
+function assertAllowedKeys(definition, label, value, allowedKeys) {
+    for (const key of Object.keys(value)) {
+        if (!allowedKeys.has(key)) {
+            throw new Error(`Unsupported ${definition.displayName} ${label} field: ${key}`);
+        }
+    }
+}
+function validateExcludeIds(definition, value) {
+    if (value === undefined) {
+        return;
+    }
+    if (!Array.isArray(value) ||
+        value.some((id) => typeof id !== 'string' || !UUID_PATTERN.test(id))) {
+        throw new Error(`${definition.displayName} search excludeIds must contain valid UUIDs.`);
+    }
+}
+function validateSearchFilter(definition, value, depth = 0, state = { groups: 0, conditions: 0 }) {
+    if (value === undefined || value === null) {
+        return;
+    }
+    if (depth > MAX_SEARCH_DEPTH) {
+        throw new Error(`${definition.displayName} search filter is nested too deeply.`);
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${definition.displayName} search filter must be an object.`);
+    }
+    const objectValue = value;
+    if (objectValue.operator !== undefined &&
+        !SEARCH_GROUP_OPERATORS.has(objectValue.operator)) {
+        throw new Error(`${definition.displayName} search filter operator must be AND or OR.`);
+    }
+    if (objectValue.groups !== undefined && !Array.isArray(objectValue.groups)) {
+        throw new Error(`${definition.displayName} search filter groups must be an array.`);
+    }
+    if (objectValue.conditions !== undefined && !Array.isArray(objectValue.conditions)) {
+        throw new Error(`${definition.displayName} search filter conditions must be an array.`);
+    }
+    const groups = Array.isArray(objectValue.groups) ? objectValue.groups : [];
+    if (depth === 0 && groups.length === 0) {
+        throw new Error(`${definition.displayName} search filter must contain at least one group.`);
+    }
+    state.groups += groups.length;
+    if (state.groups > MAX_SEARCH_GROUPS) {
+        throw new Error(`${definition.displayName} search filter cannot contain more than ${MAX_SEARCH_GROUPS} groups.`);
+    }
+    const conditions = Array.isArray(objectValue.conditions) ? objectValue.conditions : [];
+    if (depth > 0 && conditions.length === 0 && groups.length === 0) {
+        throw new Error(`${definition.displayName} search filter groups must contain at least one condition.`);
+    }
+    state.conditions += conditions.length;
+    if (state.conditions > MAX_SEARCH_CONDITIONS) {
+        throw new Error(`${definition.displayName} search filter cannot contain more than ${MAX_SEARCH_CONDITIONS} conditions.`);
+    }
+    for (const condition of conditions) {
+        if (!condition || typeof condition !== 'object' || Array.isArray(condition)) {
+            throw new Error(`${definition.displayName} search condition must be an object.`);
+        }
+        const conditionObject = condition;
+        if (typeof conditionObject.field !== 'string' ||
+            !definition.searchFields.includes(conditionObject.field)) {
+            throw new Error(`Unsupported ${definition.displayName} search field: ${conditionObject.field}`);
+        }
+        if (!SEARCH_OPERATORS.has(conditionObject.operator)) {
+            throw new Error(`Unsupported ${definition.displayName} search operator: ${conditionObject.operator}`);
+        }
+        if ((conditionObject.operator === 'in' || conditionObject.operator === 'notIn') &&
+            !Array.isArray(conditionObject.value)) {
+            throw new Error(`${definition.displayName} search operator ${conditionObject.operator} requires an array value.`);
+        }
+        if (conditionObject.operator !== 'isNull' &&
+            conditionObject.operator !== 'isNotNull' &&
+            !Object.prototype.hasOwnProperty.call(conditionObject, 'value')) {
+            throw new Error(`${definition.displayName} search condition value is required for operator ${conditionObject.operator}.`);
+        }
+    }
+    for (const group of groups) {
+        validateSearchFilter(definition, group, depth + 1, state);
+    }
+}
+function buildGenericSearchRequest(definition, input) {
+    var _a;
+    assertAllowedKeys(definition, 'search request', input, SEARCH_REQUEST_FIELDS);
+    const pagination = ((_a = input.pagination) !== null && _a !== void 0 ? _a : {});
+    assertAllowedKeys(definition, 'search pagination', pagination, SEARCH_PAGINATION_FIELDS);
+    const sortBy = typeof pagination.sortBy === 'string' && pagination.sortBy !== ''
+        ? pagination.sortBy
+        : definition.defaultSortBy;
+    const sortOrder = pagination.sortOrder === 'asc' || pagination.sortOrder === 'desc'
+        ? pagination.sortOrder
+        : definition.defaultSortOrder;
+    if (!definition.sortFields.includes(sortBy)) {
+        throw new Error(`Unsupported ${definition.displayName} search sort field: ${sortBy}`);
+    }
+    const page = typeof pagination.page === 'number' ? pagination.page : 1;
+    const pageSize = typeof pagination.pageSize === 'number' ? pagination.pageSize : 25;
+    if (!Number.isInteger(page) || page < 1 || page > MAX_PAGE) {
+        throw new Error(`${definition.displayName} search pagination.page must be between 1 and ${MAX_PAGE}.`);
+    }
+    if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > MAX_PAGE_SIZE) {
+        throw new Error(`${definition.displayName} search pagination.pageSize must be between 1 and ${MAX_PAGE_SIZE}.`);
+    }
+    validateSearchFilter(definition, input.filter);
+    validateExcludeIds(definition, input.excludeIds);
+    return (0, GenericFunctions_1.compactObject)({
+        ...input,
+        pagination: {
+            ...pagination,
+            page,
+            pageSize,
+            sortBy,
+            sortOrder,
+        },
+    });
+}
+function buildSearchRequest(definition, input) {
+    return buildGenericSearchRequest(definition, input);
+}

package/dist/nodes/HustleOps/structuredCoreFields.d.ts

@@ -0,0 +1,7 @@
+import type { CoreResource, DtoOperation } from './resourceDefinitions';
+export declare const CORE_WRITE_OPERATIONS: DtoOperation[];
+export declare function toPascalCase(value: string): string;
+export declare function fieldDisplayName(field: string): string;
+export declare function structuredFieldParameterName(resource: CoreResource, operation: DtoOperation, field: string): string;
+export declare function createAdditionalFieldsParameterName(resource: CoreResource): string;
+export declare function updateFieldsParameterName(resource: CoreResource): string;

package/dist/nodes/HustleOps/structuredCoreFields.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CORE_WRITE_OPERATIONS = void 0;
+exports.toPascalCase = toPascalCase;
+exports.fieldDisplayName = fieldDisplayName;
+exports.structuredFieldParameterName = structuredFieldParameterName;
+exports.createAdditionalFieldsParameterName = createAdditionalFieldsParameterName;
+exports.updateFieldsParameterName = updateFieldsParameterName;
+exports.CORE_WRITE_OPERATIONS = ['create', 'update'];
+function toPascalCase(value) {
+    return value.replace(/(^|[-_\s]+)([a-z0-9])/g, (_match, _separator, character) => character.toUpperCase());
+}
+function fieldDisplayName(field) {
+    return field
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/\b\w/g, (character) => character.toUpperCase())
+        .replace(/\bId\b/g, 'ID')
+        .replace(/\bUrl\b/g, 'URL')
+        .replace(/\bTlp\b/g, 'TLP');
+}
+function structuredFieldParameterName(resource, operation, field) {
+    return `${resource}${toPascalCase(operation)}${toPascalCase(field)}`;
+}
+function createAdditionalFieldsParameterName(resource) {
+    return `${resource}CreateAdditionalFields`;
+}
+function updateFieldsParameterName(resource) {
+    return `${resource}UpdateFields`;
+}

package/dist/nodes/HustleOps/tagDefinitions.d.ts

@@ -0,0 +1,15 @@
+import type { IDataObject, IExecuteFunctions, INodePropertyOptions } from 'n8n-workflow';
+export type TagOperation = 'list' | 'search' | 'create' | 'updateColor' | 'bulkUpdateColor' | 'delete' | 'bulkDelete';
+export type EntityTagOperation = 'setTags' | 'addTags' | 'removeTag';
+type ValidationContext = Pick<IExecuteFunctions, 'getNode'>;
+export declare const TAG_RESOURCE_OPTION: INodePropertyOptions;
+export declare const TAG_OPERATION_OPTIONS: INodePropertyOptions[];
+export declare const ENTITY_TAG_OPERATION_OPTIONS: INodePropertyOptions[];
+type ParseTagValuesOptions = {
+    allowEmpty?: boolean;
+    emptyMessage?: string;
+};
+export declare function parseTagValues(context: ValidationContext, value: unknown, label: string, itemIndex: number, options?: ParseTagValuesOptions): string[];
+export declare function parseEntityTagValues(context: ValidationContext, value: unknown, operationLabel: 'Set Tags' | 'Add Tags', itemIndex: number): string[];
+export declare function sanitizeTagBody(context: ValidationContext, operation: TagOperation, body: IDataObject, itemIndex: number): IDataObject;
+export {};