n8n-nodes-do 1.0.0

package/dist/nodes/DigitalOcean/DigitalOcean.node.js

@@ -0,0 +1,1648 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DigitalOcean = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const BASE_URL = 'https://api.digitalocean.com/v2';
+async function makePaginatedRequest(method, path, qs, headers, limit) {
+    var _a, _b;
+    const returnData = [];
+    let page = 1;
+    const perPage = 200;
+    do {
+        const response = await this.helpers.httpRequest({
+            method,
+            url: `${BASE_URL}${path}`,
+            qs: { ...qs, page, per_page: perPage },
+            headers,
+        });
+        const dataKey = Object.keys(response).find(k => Array.isArray(response[k]));
+        if (dataKey && response[dataKey]) {
+            returnData.push(...response[dataKey]);
+        }
+        const hasNextPage = (_b = (_a = response.links) === null || _a === void 0 ? void 0 : _a.pages) === null || _b === void 0 ? void 0 : _b.next;
+        if (!hasNextPage)
+            break;
+        page++;
+    } while (returnData.length < limit);
+    return returnData.slice(0, limit);
+}
+class DigitalOcean {
+    constructor() {
+        this.description = {
+            displayName: 'DigitalOcean',
+            name: 'digitalOcean',
+            icon: 'file:digitalocean.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["resource"] + ": " + $parameter["operation"]}}',
+            description: 'Manage DigitalOcean cloud resources including Droplets, Volumes, Databases, Kubernetes, and more.',
+            defaults: { name: 'DigitalOcean' },
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            credentials: [{ name: 'digitalOceanApi', required: true }],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        { name: 'Account', value: 'account' },
+                        { name: 'Database', value: 'database' },
+                        { name: 'Domain', value: 'domain' },
+                        { name: 'Droplet', value: 'droplet' },
+                        { name: 'Image', value: 'image' },
+                        { name: 'Kubernete', value: 'kubernetes' },
+                        { name: 'Load Balancer', value: 'loadBalancer' },
+                        { name: 'Project', value: 'project' },
+                        { name: 'Reserved IP', value: 'reservedIp' },
+                        { name: 'Snapshot', value: 'snapshot' },
+                        { name: 'SSH Key', value: 'sshKey' },
+                        { name: 'VPC', value: 'vpc' },
+                        { name: 'Volume', value: 'volume' },
+                    ],
+                    default: 'droplet',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['account'] } },
+                    options: [
+                        { name: 'Get', value: 'get', description: 'Get account information', action: 'Get account information' },
+                    ],
+                    default: 'get',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['droplet'] } },
+                    options: [
+                        { name: 'Create', value: 'create', description: 'Create a new droplet', action: 'Create a droplet' },
+                        { name: 'Delete', value: 'delete', description: 'Delete a droplet', action: 'Delete a droplet' },
+                        { name: 'Get', value: 'get', description: 'Get a droplet by ID', action: 'Get a droplet' },
+                        { name: 'Get Many', value: 'getAll', description: 'Get many droplets', action: 'Get many droplets' },
+                        { name: 'Power Off', value: 'powerOff', description: 'Power off a droplet', action: 'Power off a droplet' },
+                        { name: 'Power On', value: 'powerOn', description: 'Power on a droplet', action: 'Power on a droplet' },
+                        { name: 'Reboot', value: 'reboot', description: 'Reboot a droplet', action: 'Reboot a droplet' },
+                        { name: 'Shutdown', value: 'shutdown', description: 'Shutdown a droplet', action: 'Shutdown a droplet' },
+                    ],
+                    default: 'getAll',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['volume'] } },
+                    options: [
+                        { name: 'Create', value: 'create', description: 'Create a new volume', action: 'Create a volume' },
+                        { name: 'Delete', value: 'delete', description: 'Delete a volume', action: 'Delete a volume' },
+                        { name: 'Get', value: 'get', description: 'Get a volume by ID', action: 'Get a volume' },
+                        { name: 'Get Many', value: 'getAll', description: 'Get many volumes', action: 'Get many volumes' },
+                    ],
+                    default: 'getAll',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['database'] } },
+                    options: [
+                        { name: 'Create', value: 'create', description: 'Create a new database cluster', action: 'Create a database' },
+                        { name: 'Delete', value: 'delete', description: 'Delete a database cluster', action: 'Delete a database' },
+                        { name: 'Get', value: 'get', description: 'Get a database cluster by ID', action: 'Get a database' },
+                        { name: 'Get Many', value: 'getAll', description: 'Get many database clusters', action: 'Get many databases' },
+                    ],
+                    default: 'getAll',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['domain'] } },
+                    options: [
+                        { name: 'Create', value: 'create', description: 'Create a new domain', action: 'Create a domain' },
+                        { name: 'Delete', value: 'delete', description: 'Delete a domain', action: 'Delete a domain' },
+                        { name: 'Get', value: 'get', description: 'Get a domain by name', action: 'Get a domain' },
+                        { name: 'Get Many', value: 'getAll', description: 'Get many domains', action: 'Get many domains' },
+                        { name: 'Get Records', value: 'getRecords', description: 'Get domain records', action: 'Get domain records' },
+                    ],
+                    default: 'getAll',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['image'] } },
+                    options: [
+                        { name: 'Delete', value: 'delete', description: 'Delete an image', action: 'Delete an image' },
+                        { name: 'Get', value: 'get', description: 'Get an image by ID', action: 'Get an image' },
+                        { name: 'Get Many', value: 'getAll', description: 'Get many images', action: 'Get many images' },
+                    ],
+                    default: 'getAll',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['kubernetes'] } },
+                    options: [
+                        { name: 'Delete Cluster', value: 'deleteCluster', description: 'Delete a Kubernetes cluster', action: 'Delete a kubernetes cluster' },
+                        { name: 'Get Cluster', value: 'getCluster', description: 'Get a Kubernetes cluster', action: 'Get a kubernetes cluster' },
+                        { name: 'Get All Clusters', value: 'getAllClusters', description: 'Get all Kubernetes clusters', action: 'Get all kubernetes clusters' },
+                        { name: 'Get Kubeconfig', value: 'getKubeconfig', description: 'Get kubeconfig for a cluster', action: 'Get kubeconfig' },
+                    ],
+                    default: 'getAllClusters',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['loadBalancer'] } },
+                    options: [
+                        { name: 'Create', value: 'create', description: 'Create a load balancer', action: 'Create a load balancer' },
+                        { name: 'Delete', value: 'delete', description: 'Delete a load balancer', action: 'Delete a load balancer' },
+                        { name: 'Get', value: 'get', description: 'Get a load balancer', action: 'Get a load balancer' },
+                        { name: 'Get Many', value: 'getAll', description: 'Get many load balancers', action: 'Get many load balancers' },
+                    ],
+                    default: 'getAll',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['project'] } },
+                    options: [
+                        { name: 'Create', value: 'create', description: 'Create a project', action: 'Create a project' },
+                        { name: 'Delete', value: 'delete', description: 'Delete a project', action: 'Delete a project' },
+                        { name: 'Get', value: 'get', description: 'Get a project', action: 'Get a project' },
+                        { name: 'Get Many', value: 'getAll', description: 'Get many projects', action: 'Get many projects' },
+                    ],
+                    default: 'getAll',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['reservedIp'] } },
+                    options: [
+                        { name: 'Create', value: 'create', description: 'Create a reserved IP', action: 'Create a reserved IP' },
+                        { name: 'Delete', value: 'delete', description: 'Delete a reserved IP', action: 'Delete a reserved IP' },
+                        { name: 'Get', value: 'get', description: 'Get a reserved IP', action: 'Get a reserved IP' },
+                        { name: 'Get Many', value: 'getAll', description: 'Get many reserved IPs', action: 'Get many reserved i ps' },
+                    ],
+                    default: 'getAll',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['snapshot'] } },
+                    options: [
+                        { name: 'Delete', value: 'delete', description: 'Delete a snapshot', action: 'Delete a snapshot' },
+                        { name: 'Get', value: 'get', description: 'Get a snapshot', action: 'Get a snapshot' },
+                        { name: 'Get Many', value: 'getAll', description: 'Get many snapshots', action: 'Get many snapshots' },
+                    ],
+                    default: 'getAll',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['sshKey'] } },
+                    options: [
+                        { name: 'Create', value: 'create', description: 'Create an SSH key', action: 'Create an SSH key' },
+                        { name: 'Delete', value: 'delete', description: 'Delete an SSH key', action: 'Delete an SSH key' },
+                        { name: 'Get', value: 'get', description: 'Get an SSH key', action: 'Get an SSH key' },
+                        { name: 'Get Many', value: 'getAll', description: 'Get many SSH keys', action: 'Get many SSH keys' },
+                    ],
+                    default: 'getAll',
+                },
+                {
+                    displayName: 'Droplet Name or ID',
+                    name: 'dropletId',
+                    type: 'options',
+                    required: true,
+                    typeOptions: { loadOptionsMethod: 'getDroplets' },
+                    displayOptions: {
+                        show: {
+                            resource: ['droplet'],
+                            operation: ['get', 'delete', 'reboot', 'shutdown', 'powerOn', 'powerOff'],
+                        },
+                    },
+                    default: '',
+                    description: 'The droplet to operate on. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Name',
+                    name: 'dropletName',
+                    type: 'string',
+                    required: true,
+                    displayOptions: { show: { resource: ['droplet'], operation: ['create'] } },
+                    default: '',
+                    description: 'The name of the droplet',
+                },
+                {
+                    displayName: 'Region',
+                    name: 'dropletRegion',
+                    type: 'options',
+                    required: true,
+                    displayOptions: { show: { resource: ['droplet'], operation: ['create'] } },
+                    options: [
+                        { name: 'Amsterdam (Ams1)', value: 'ams1' },
+                        { name: 'Amsterdam (Ams2)', value: 'ams2' },
+                        { name: 'Amsterdam (Ams3)', value: 'ams3' },
+                        { name: 'Bangalore (Blr1)', value: 'blr1' },
+                        { name: 'Frankfurt (Fra1)', value: 'fra1' },
+                        { name: 'London (Lon1)', value: 'lon1' },
+                        { name: 'New York (Nyc1)', value: 'nyc1' },
+                        { name: 'New York (Nyc2)', value: 'nyc2' },
+                        { name: 'New York (Nyc3)', value: 'nyc3' },
+                        { name: 'San Francisco (Sfo1)', value: 'sfo1' },
+                        { name: 'San Francisco (Sfo2)', value: 'sfo2' },
+                        { name: 'San Francisco (Sfo3)', value: 'sfo3' },
+                        { name: 'Singapore (Sgp1)', value: 'sgp1' },
+                        { name: 'Sydney (Syd1)', value: 'syd1' },
+                        { name: 'Toronto (Tor1)', value: 'tor1' },
+                    ],
+                    default: 'nyc1',
+                    description: 'The region where the droplet will be created',
+                },
+                {
+                    displayName: 'Size',
+                    name: 'dropletSize',
+                    type: 'options',
+                    required: true,
+                    displayOptions: { show: { resource: ['droplet'], operation: ['create'] } },
+                    options: [
+                        { name: 's-1vcpu-1gb', value: 's-1vcpu-1gb' },
+                        { name: 's-1vcpu-2gb', value: 's-1vcpu-2gb' },
+                        { name: 's-2vcpu-2gb', value: 's-2vcpu-2gb' },
+                        { name: 's-2vcpu-4gb', value: 's-2vcpu-4gb' },
+                        { name: 's-4vcpu-8gb', value: 's-4vcpu-8gb' },
+                        { name: 's-8vcpu-16gb', value: 's-8vcpu-16gb' },
+                        { name: 's-8vcpu-32gb', value: 's-8vcpu-32gb' },
+                        { name: 's-16vcpu-64gb', value: 's-16vcpu-64gb' },
+                    ],
+                    default: 's-1vcpu-1gb',
+                    description: 'The size slug for the droplet',
+                },
+                {
+                    displayName: 'Image Name or ID',
+                    name: 'dropletImage',
+                    type: 'options',
+                    required: true,
+                    typeOptions: { loadOptionsMethod: 'getImages' },
+                    displayOptions: { show: { resource: ['droplet'], operation: ['create'] } },
+                    default: '',
+                    description: 'The image to use for the droplet. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Additional Fields',
+                    name: 'additionalFields',
+                    type: 'collection',
+                    placeholder: 'Add Field',
+                    default: {},
+                    displayOptions: { show: { resource: ['droplet'], operation: ['create'] } },
+                    options: [
+                        { displayName: 'Backups', name: 'backups', type: 'boolean', default: false, description: 'Whether to enable automated backups' },
+                        { displayName: 'IPv6', name: 'ipv6', type: 'boolean', default: false, description: 'Whether to enable IPv6' },
+                        { displayName: 'Monitoring', name: 'monitoring', type: 'boolean', default: true, description: 'Whether to enable monitoring' },
+                        { displayName: 'Private Networking', name: 'privateNetworking', type: 'boolean', default: false, description: 'Whether to enable private networking' },
+                        { displayName: 'SSH Key Names or IDs', name: 'sshKeys', type: 'multiOptions', typeOptions: { loadOptionsMethod: 'getSshKeys' }, default: [], description: 'SSH keys to add to the droplet. Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.' },
+                        { displayName: 'Tags', name: 'tags', type: 'string', default: '', description: 'Comma-separated list of tags' },
+                        { displayName: 'User Data', name: 'userData', type: 'string', default: '', description: 'Cloud-init user data script' },
+                        { displayName: 'Volume Names or IDs', name: 'volumes', type: 'multiOptions', typeOptions: { loadOptionsMethod: 'getVolumes' }, default: [], description: 'Volumes to attach to the droplet. Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.' },
+                        { displayName: 'VPC UUID Name or ID', name: 'vpcUuid', type: 'options', typeOptions: { loadOptionsMethod: 'getVpcs' }, default: '', description: 'The VPC to place the droplet in. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.' },
+                    ],
+                },
+                {
+                    displayName: 'Volume Name or ID',
+                    name: 'volumeId',
+                    type: 'options',
+                    required: true,
+                    typeOptions: { loadOptionsMethod: 'getVolumes' },
+                    displayOptions: { show: { resource: ['volume'], operation: ['get', 'delete'] } },
+                    default: '',
+                    description: 'The volume to operate on. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Name',
+                    name: 'volumeName',
+                    type: 'string',
+                    required: true,
+                    displayOptions: { show: { resource: ['volume'], operation: ['create'] } },
+                    default: '',
+                    description: 'The name of the volume',
+                },
+                {
+                    displayName: 'Size (GB)',
+                    name: 'volumeSizeGigabytes',
+                    type: 'number',
+                    required: true,
+                    typeOptions: { minValue: 1, maxValue: 16000 },
+                    displayOptions: { show: { resource: ['volume'], operation: ['create'] } },
+                    default: 10,
+                    description: 'The size of the volume in GB',
+                },
+                {
+                    displayName: 'Region',
+                    name: 'volumeRegion',
+                    type: 'options',
+                    required: true,
+                    displayOptions: { show: { resource: ['volume'], operation: ['create'] } },
+                    options: [
+                        { name: 'Amsterdam (Ams1)', value: 'ams1' },
+                        { name: 'Amsterdam (Ams2)', value: 'ams2' },
+                        { name: 'Amsterdam (Ams3)', value: 'ams3' },
+                        { name: 'Bangalore (Blr1)', value: 'blr1' },
+                        { name: 'Frankfurt (Fra1)', value: 'fra1' },
+                        { name: 'London (Lon1)', value: 'lon1' },
+                        { name: 'New York (Nyc1)', value: 'nyc1' },
+                        { name: 'New York (Nyc2)', value: 'nyc2' },
+                        { name: 'New York (Nyc3)', value: 'nyc3' },
+                        { name: 'San Francisco (Sfo1)', value: 'sfo1' },
+                        { name: 'San Francisco (Sfo2)', value: 'sfo2' },
+                        { name: 'San Francisco (Sfo3)', value: 'sfo3' },
+                        { name: 'Singapore (Sgp1)', value: 'sgp1' },
+                        { name: 'Sydney (Syd1)', value: 'syd1' },
+                        { name: 'Toronto (Tor1)', value: 'tor1' },
+                    ],
+                    default: 'nyc1',
+                    description: 'The region where the volume will be created',
+                },
+                {
+                    displayName: 'Description',
+                    name: 'volumeDescription',
+                    type: 'string',
+                    displayOptions: { show: { resource: ['volume'], operation: ['create'] } },
+                    default: '',
+                    description: 'A description for the volume',
+                },
+                {
+                    displayName: 'Snapshot Name or ID',
+                    name: 'volumeSnapshotId',
+                    type: 'options',
+                    typeOptions: { loadOptionsMethod: 'getSnapshots' },
+                    displayOptions: { show: { resource: ['volume'], operation: ['create'] } },
+                    default: '',
+                    description: 'Create volume from a snapshot. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Database Name or ID',
+                    name: 'databaseId',
+                    type: 'options',
+                    required: true,
+                    typeOptions: { loadOptionsMethod: 'getDatabases' },
+                    displayOptions: { show: { resource: ['database'], operation: ['get', 'delete'] } },
+                    default: '',
+                    description: 'The database cluster to operate on. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Name',
+                    name: 'databaseName',
+                    type: 'string',
+                    required: true,
+                    displayOptions: { show: { resource: ['database'], operation: ['create'] } },
+                    default: '',
+                    description: 'The name of the database cluster',
+                },
+                {
+                    displayName: 'Engine',
+                    name: 'databaseEngine',
+                    type: 'options',
+                    required: true,
+                    displayOptions: { show: { resource: ['database'], operation: ['create'] } },
+                    options: [
+                        { name: 'MySQL', value: 'mysql' },
+                        { name: 'PostgreSQL', value: 'pg' },
+                        { name: 'Redis', value: 'redis' },
+                        { name: 'MongoDB', value: 'mongodb' },
+                    ],
+                    default: 'pg',
+                    description: 'The database engine',
+                },
+                {
+                    displayName: 'Version',
+                    name: 'databaseVersion',
+                    type: 'string',
+                    displayOptions: { show: { resource: ['database'], operation: ['create'] } },
+                    default: '',
+                    description: 'The engine version (e.g., 14 for PostgreSQL)',
+                },
+                {
+                    displayName: 'Region',
+                    name: 'databaseRegion',
+                    type: 'options',
+                    required: true,
+                    displayOptions: { show: { resource: ['database'], operation: ['create'] } },
+                    options: [
+                        { name: 'Amsterdam (Ams3)', value: 'ams3' },
+                        { name: 'Bangalore (Blr1)', value: 'blr1' },
+                        { name: 'Frankfurt (Fra1)', value: 'fra1' },
+                        { name: 'London (Lon1)', value: 'lon1' },
+                        { name: 'New York (Nyc1)', value: 'nyc1' },
+                        { name: 'New York (Nyc3)', value: 'nyc3' },
+                        { name: 'San Francisco (Sfo2)', value: 'sfo2' },
+                        { name: 'San Francisco (Sfo3)', value: 'sfo3' },
+                        { name: 'Singapore (Sgp1)', value: 'sgp1' },
+                        { name: 'Sydney (Syd1)', value: 'syd1' },
+                        { name: 'Toronto (Tor1)', value: 'tor1' },
+                    ],
+                    default: 'nyc1',
+                    description: 'The region where the database will be created',
+                },
+                {
+                    displayName: 'Size',
+                    name: 'databaseSize',
+                    type: 'options',
+                    required: true,
+                    displayOptions: { show: { resource: ['database'], operation: ['create'] } },
+                    options: [
+                        { name: 'db-s-1vcpu-1gb', value: 'db-s-1vcpu-1gb' },
+                        { name: 'db-s-1vcpu-2gb', value: 'db-s-1vcpu-2gb' },
+                        { name: 'db-s-2vcpu-4gb', value: 'db-s-2vcpu-4gb' },
+                        { name: 'db-s-4vcpu-8gb', value: 'db-s-4vcpu-8gb' },
+                        { name: 'db-s-6vcpu-16gb', value: 'db-s-6vcpu-16gb' },
+                        { name: 'db-s-8vcpu-32gb', value: 'db-s-8vcpu-32gb' },
+                    ],
+                    default: 'db-s-1vcpu-1gb',
+                    description: 'The database size slug',
+                },
+                {
+                    displayName: 'Number of Nodes',
+                    name: 'databaseNumNodes',
+                    type: 'number',
+                    typeOptions: { minValue: 1, maxValue: 3 },
+                    displayOptions: { show: { resource: ['database'], operation: ['create'] } },
+                    default: 1,
+                    description: 'Number of nodes in the cluster (1-3)',
+                },
+                {
+                    displayName: 'Domain Name or ID',
+                    name: 'domainName',
+                    type: 'options',
+                    required: true,
+                    typeOptions: { loadOptionsMethod: 'getDomains' },
+                    displayOptions: { show: { resource: ['domain'], operation: ['get', 'delete', 'getRecords'] } },
+                    default: '',
+                    description: 'The domain to operate on. Choose from the list, or specify a name using an <a href="https://docs.n8n.io/code/expressions/">expression</a>. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Domain Name',
+                    name: 'domainNameCreate',
+                    type: 'string',
+                    required: true,
+                    displayOptions: { show: { resource: ['domain'], operation: ['create'] } },
+                    default: '',
+                    description: 'The domain name to create',
+                },
+                {
+                    displayName: 'IP Address',
+                    name: 'domainIp',
+                    type: 'string',
+                    displayOptions: { show: { resource: ['domain'], operation: ['create'] } },
+                    default: '',
+                    description: 'IP address to create an A record for the domain',
+                },
+                {
+                    displayName: 'Image Name or ID',
+                    name: 'imageId',
+                    type: 'options',
+                    required: true,
+                    typeOptions: { loadOptionsMethod: 'getImages' },
+                    displayOptions: { show: { resource: ['image'], operation: ['get', 'delete'] } },
+                    default: '',
+                    description: 'The image to operate on. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Cluster Name or ID',
+                    name: 'clusterId',
+                    type: 'options',
+                    required: true,
+                    typeOptions: { loadOptionsMethod: 'getClusters' },
+                    displayOptions: { show: { resource: ['kubernetes'], operation: ['getCluster', 'deleteCluster', 'getKubeconfig'] } },
+                    default: '',
+                    description: 'The Kubernetes cluster to operate on. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Load Balancer Name or ID',
+                    name: 'loadBalancerId',
+                    type: 'options',
+                    required: true,
+                    typeOptions: { loadOptionsMethod: 'getLoadBalancers' },
+                    displayOptions: { show: { resource: ['loadBalancer'], operation: ['get', 'delete'] } },
+                    default: '',
+                    description: 'The load balancer to operate on. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Name',
+                    name: 'loadBalancerName',
+                    type: 'string',
+                    required: true,
+                    displayOptions: { show: { resource: ['loadBalancer'], operation: ['create'] } },
+                    default: '',
+                    description: 'The name of the load balancer',
+                },
+                {
+                    displayName: 'Region',
+                    name: 'loadBalancerRegion',
+                    type: 'options',
+                    required: true,
+                    displayOptions: { show: { resource: ['loadBalancer'], operation: ['create'] } },
+                    options: [
+                        { name: 'Amsterdam (Ams1)', value: 'ams1' },
+                        { name: 'Amsterdam (Ams2)', value: 'ams2' },
+                        { name: 'Amsterdam (Ams3)', value: 'ams3' },
+                        { name: 'Bangalore (Blr1)', value: 'blr1' },
+                        { name: 'Frankfurt (Fra1)', value: 'fra1' },
+                        { name: 'London (Lon1)', value: 'lon1' },
+                        { name: 'New York (Nyc1)', value: 'nyc1' },
+                        { name: 'New York (Nyc2)', value: 'nyc2' },
+                        { name: 'New York (Nyc3)', value: 'nyc3' },
+                        { name: 'San Francisco (Sfo1)', value: 'sfo1' },
+                        { name: 'San Francisco (Sfo2)', value: 'sfo2' },
+                        { name: 'San Francisco (Sfo3)', value: 'sfo3' },
+                        { name: 'Singapore (Sgp1)', value: 'sgp1' },
+                        { name: 'Sydney (Syd1)', value: 'syd1' },
+                        { name: 'Toronto (Tor1)', value: 'tor1' },
+                    ],
+                    default: 'nyc1',
+                    description: 'The region where the load balancer will be created',
+                },
+                {
+                    displayName: 'Droplet ID Names or IDs',
+                    name: 'loadBalancerDropletIds',
+                    type: 'multiOptions',
+                    typeOptions: { loadOptionsMethod: 'getDroplets' },
+                    displayOptions: { show: { resource: ['loadBalancer'], operation: ['create'] } },
+                    default: [],
+                    description: 'Droplets to add to the load balancer. Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Project Name or ID',
+                    name: 'projectId',
+                    type: 'options',
+                    required: true,
+                    typeOptions: { loadOptionsMethod: 'getProjects' },
+                    displayOptions: { show: { resource: ['project'], operation: ['get', 'delete'] } },
+                    default: '',
+                    description: 'The project to operate on. Choose from the list, or specify a UUID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Name',
+                    name: 'projectName',
+                    type: 'string',
+                    required: true,
+                    displayOptions: { show: { resource: ['project'], operation: ['create'] } },
+                    default: '',
+                    description: 'The name of the project',
+                },
+                {
+                    displayName: 'Description',
+                    name: 'projectDescription',
+                    type: 'string',
+                    displayOptions: { show: { resource: ['project'], operation: ['create'] } },
+                    default: '',
+                    description: 'A description for the project',
+                },
+                {
+                    displayName: 'Purpose',
+                    name: 'projectPurpose',
+                    type: 'string',
+                    displayOptions: { show: { resource: ['project'], operation: ['create'] } },
+                    default: '',
+                    description: 'The purpose of the project',
+                },
+                {
+                    displayName: 'Environment',
+                    name: 'projectEnvironment',
+                    type: 'options',
+                    displayOptions: { show: { resource: ['project'], operation: ['create'] } },
+                    options: [
+                        { name: 'Development', value: 'Development' },
+                        { name: 'Staging', value: 'Staging' },
+                        { name: 'Production', value: 'Production' },
+                    ],
+                    default: 'Development',
+                    description: 'The environment of the project',
+                },
+                {
+                    displayName: 'Reserved IP Name or ID',
+                    name: 'reservedIp',
+                    type: 'options',
+                    required: true,
+                    typeOptions: { loadOptionsMethod: 'getReservedIps' },
+                    displayOptions: { show: { resource: ['reservedIp'], operation: ['get', 'delete'] } },
+                    default: '',
+                    description: 'The reserved IP to operate on. Choose from the list, or specify an IP using an <a href="https://docs.n8n.io/code/expressions/">expression</a>. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Region',
+                    name: 'reservedIpRegion',
+                    type: 'options',
+                    required: true,
+                    displayOptions: { show: { resource: ['reservedIp'], operation: ['create'] } },
+                    options: [
+                        { name: 'Amsterdam (Ams1)', value: 'ams1' },
+                        { name: 'Amsterdam (Ams2)', value: 'ams2' },
+                        { name: 'Amsterdam (Ams3)', value: 'ams3' },
+                        { name: 'Bangalore (Blr1)', value: 'blr1' },
+                        { name: 'Frankfurt (Fra1)', value: 'fra1' },
+                        { name: 'London (Lon1)', value: 'lon1' },
+                        { name: 'New York (Nyc1)', value: 'nyc1' },
+                        { name: 'New York (Nyc2)', value: 'nyc2' },
+                        { name: 'New York (Nyc3)', value: 'nyc3' },
+                        { name: 'San Francisco (Sfo1)', value: 'sfo1' },
+                        { name: 'San Francisco (Sfo2)', value: 'sfo2' },
+                        { name: 'San Francisco (Sfo3)', value: 'sfo3' },
+                        { name: 'Singapore (Sgp1)', value: 'sgp1' },
+                        { name: 'Sydney (Syd1)', value: 'syd1' },
+                        { name: 'Toronto (Tor1)', value: 'tor1' },
+                    ],
+                    default: 'nyc1',
+                    description: 'The region where the reserved IP will be created',
+                },
+                {
+                    displayName: 'Droplet Name or ID',
+                    name: 'reservedIpDropletId',
+                    type: 'options',
+                    typeOptions: { loadOptionsMethod: 'getDroplets' },
+                    displayOptions: { show: { resource: ['reservedIp'], operation: ['create'] } },
+                    default: '',
+                    description: 'The droplet to assign the reserved IP to. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Snapshot Name or ID',
+                    name: 'snapshotId',
+                    type: 'options',
+                    required: true,
+                    typeOptions: { loadOptionsMethod: 'getSnapshots' },
+                    displayOptions: { show: { resource: ['snapshot'], operation: ['get', 'delete'] } },
+                    default: '',
+                    description: 'The snapshot to operate on. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'SSH Key Name or ID',
+                    name: 'sshKeyId',
+                    type: 'options',
+                    required: true,
+                    typeOptions: { loadOptionsMethod: 'getSshKeys' },
+                    displayOptions: { show: { resource: ['sshKey'], operation: ['get', 'delete'] } },
+                    default: '',
+                    description: 'The SSH key to operate on. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Name',
+                    name: 'sshKeyName',
+                    type: 'string',
+                    required: true,
+                    displayOptions: { show: { resource: ['sshKey'], operation: ['create'] } },
+                    default: '',
+                    description: 'The name for the SSH key',
+                },
+                {
+                    displayName: 'Public Key',
+                    name: 'sshPublicKey',
+                    type: 'string',
+                    required: true,
+                    displayOptions: { show: { resource: ['sshKey'], operation: ['create'] } },
+                    default: '',
+                    description: 'The SSH public key',
+                },
+                {
+                    displayName: 'VPC Name or ID',
+                    name: 'vpcId',
+                    type: 'options',
+                    required: true,
+                    typeOptions: { loadOptionsMethod: 'getVpcs' },
+                    displayOptions: { show: { resource: ['vpc'], operation: ['get', 'delete'] } },
+                    default: '',
+                    description: 'The VPC to operate on. Choose from the list, or specify a UUID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Name',
+                    name: 'vpcName',
+                    type: 'string',
+                    required: true,
+                    displayOptions: { show: { resource: ['vpc'], operation: ['create'] } },
+                    default: '',
+                    description: 'The name of the VPC',
+                },
+                {
+                    displayName: 'Region',
+                    name: 'vpcRegion',
+                    type: 'options',
+                    required: true,
+                    displayOptions: { show: { resource: ['vpc'], operation: ['create'] } },
+                    options: [
+                        { name: 'Amsterdam (Ams3)', value: 'ams3' },
+                        { name: 'Bangalore (Blr1)', value: 'blr1' },
+                        { name: 'Frankfurt (Fra1)', value: 'fra1' },
+                        { name: 'London (Lon1)', value: 'lon1' },
+                        { name: 'New York (Nyc1)', value: 'nyc1' },
+                        { name: 'New York (Nyc3)', value: 'nyc3' },
+                        { name: 'San Francisco (Sfo2)', value: 'sfo2' },
+                        { name: 'San Francisco (Sfo3)', value: 'sfo3' },
+                        { name: 'Singapore (Sgp1)', value: 'sgp1' },
+                        { name: 'Sydney (Syd1)', value: 'syd1' },
+                        { name: 'Toronto (Tor1)', value: 'tor1' },
+                    ],
+                    default: 'nyc1',
+                    description: 'The region where the VPC will be created',
+                },
+                {
+                    displayName: 'Description',
+                    name: 'vpcDescription',
+                    type: 'string',
+                    displayOptions: { show: { resource: ['vpc'], operation: ['create'] } },
+                    default: '',
+                    description: 'A description for the VPC',
+                },
+                {
+                    displayName: 'IP Range',
+                    name: 'vpcIpRange',
+                    type: 'string',
+                    displayOptions: { show: { resource: ['vpc'], operation: ['create'] } },
+                    default: '',
+                    description: 'The IP range for the VPC (e.g., 10.116.0.0/20)',
+                },
+                {
+                    displayName: 'Return All',
+                    name: 'returnAll',
+                    type: 'boolean',
+                    displayOptions: {
+                        show: {
+                            operation: ['getAll', 'getAllClusters', 'getRecords'],
+                        },
+                    },
+                    default: false,
+                    description: 'Whether to return all results or only up to a given limit',
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limit',
+                    type: 'number',
+                    displayOptions: {
+                        show: {
+                            operation: ['getAll', 'getAllClusters', 'getRecords'],
+                            returnAll: [false],
+                        },
+                    },
+                    typeOptions: { minValue: 1, maxValue: 1000 },
+                    default: 50,
+                    description: 'Max number of results to return',
+                },
+            ],
+            usableAsTool: true,
+        };
+        this.methods = {
+            loadOptions: {
+                async getDroplets() {
+                    const returnData = [];
+                    try {
+                        const credentials = await this.getCredentials('digitalOceanApi');
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/droplets`,
+                            headers: { Authorization: `Bearer ${credentials.accessToken}` },
+                            qs: { per_page: 200 },
+                        });
+                        if (response === null || response === void 0 ? void 0 : response.droplets) {
+                            for (const item of response.droplets) {
+                                returnData.push({
+                                    name: `${item.name} (ID: ${item.id})`,
+                                    value: item.id.toString(),
+                                });
+                            }
+                        }
+                    }
+                    catch (error) { }
+                    return returnData;
+                },
+                async getVolumes() {
+                    const returnData = [];
+                    try {
+                        const credentials = await this.getCredentials('digitalOceanApi');
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/volumes`,
+                            headers: { Authorization: `Bearer ${credentials.accessToken}` },
+                            qs: { per_page: 200 },
+                        });
+                        if (response === null || response === void 0 ? void 0 : response.volumes) {
+                            for (const item of response.volumes) {
+                                returnData.push({
+                                    name: `${item.name} (${item.size_gigabytes}GB)`,
+                                    value: item.id,
+                                });
+                            }
+                        }
+                    }
+                    catch (error) { }
+                    return returnData;
+                },
+                async getDatabases() {
+                    const returnData = [];
+                    try {
+                        const credentials = await this.getCredentials('digitalOceanApi');
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/databases`,
+                            headers: { Authorization: `Bearer ${credentials.accessToken}` },
+                            qs: { per_page: 200 },
+                        });
+                        if (response === null || response === void 0 ? void 0 : response.databases) {
+                            for (const item of response.databases) {
+                                returnData.push({
+                                    name: `${item.name} (${item.engine})`,
+                                    value: item.id,
+                                });
+                            }
+                        }
+                    }
+                    catch (error) { }
+                    return returnData;
+                },
+                async getDomains() {
+                    const returnData = [];
+                    try {
+                        const credentials = await this.getCredentials('digitalOceanApi');
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/domains`,
+                            headers: { Authorization: `Bearer ${credentials.accessToken}` },
+                            qs: { per_page: 200 },
+                        });
+                        if (response === null || response === void 0 ? void 0 : response.domains) {
+                            for (const item of response.domains) {
+                                returnData.push({ name: item.name, value: item.name });
+                            }
+                        }
+                    }
+                    catch (error) { }
+                    return returnData;
+                },
+                async getImages() {
+                    const returnData = [];
+                    try {
+                        const credentials = await this.getCredentials('digitalOceanApi');
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/images`,
+                            headers: { Authorization: `Bearer ${credentials.accessToken}` },
+                            qs: { per_page: 200, type: 'distribution' },
+                        });
+                        if (response === null || response === void 0 ? void 0 : response.images) {
+                            for (const item of response.images) {
+                                returnData.push({
+                                    name: `${item.name} (${item.distribution})`,
+                                    value: item.id.toString(),
+                                });
+                            }
+                        }
+                    }
+                    catch (error) { }
+                    return returnData;
+                },
+                async getClusters() {
+                    const returnData = [];
+                    try {
+                        const credentials = await this.getCredentials('digitalOceanApi');
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/kubernetes/clusters`,
+                            headers: { Authorization: `Bearer ${credentials.accessToken}` },
+                            qs: { per_page: 200 },
+                        });
+                        if (response === null || response === void 0 ? void 0 : response.kubernetes_clusters) {
+                            for (const item of response.kubernetes_clusters) {
+                                returnData.push({
+                                    name: `${item.name} (${item.region})`,
+                                    value: item.id,
+                                });
+                            }
+                        }
+                    }
+                    catch (error) { }
+                    return returnData;
+                },
+                async getLoadBalancers() {
+                    var _a;
+                    const returnData = [];
+                    try {
+                        const credentials = await this.getCredentials('digitalOceanApi');
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/load_balancers`,
+                            headers: { Authorization: `Bearer ${credentials.accessToken}` },
+                            qs: { per_page: 200 },
+                        });
+                        if (response === null || response === void 0 ? void 0 : response.load_balancers) {
+                            for (const item of response.load_balancers) {
+                                returnData.push({
+                                    name: `${item.name} (${((_a = item.region) === null || _a === void 0 ? void 0 : _a.name) || item.region})`,
+                                    value: item.id,
+                                });
+                            }
+                        }
+                    }
+                    catch (error) { }
+                    return returnData;
+                },
+                async getProjects() {
+                    const returnData = [];
+                    try {
+                        const credentials = await this.getCredentials('digitalOceanApi');
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/projects`,
+                            headers: { Authorization: `Bearer ${credentials.accessToken}` },
+                            qs: { per_page: 200 },
+                        });
+                        if (response === null || response === void 0 ? void 0 : response.projects) {
+                            for (const item of response.projects) {
+                                returnData.push({ name: item.name, value: item.id });
+                            }
+                        }
+                    }
+                    catch (error) { }
+                    return returnData;
+                },
+                async getReservedIps() {
+                    const returnData = [];
+                    try {
+                        const credentials = await this.getCredentials('digitalOceanApi');
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/reserved_ips`,
+                            headers: { Authorization: `Bearer ${credentials.accessToken}` },
+                            qs: { per_page: 200 },
+                        });
+                        if (response === null || response === void 0 ? void 0 : response.reserved_ips) {
+                            for (const item of response.reserved_ips) {
+                                returnData.push({ name: item.ip, value: item.ip });
+                            }
+                        }
+                    }
+                    catch (error) { }
+                    return returnData;
+                },
+                async getSnapshots() {
+                    const returnData = [];
+                    try {
+                        const credentials = await this.getCredentials('digitalOceanApi');
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/snapshots`,
+                            headers: { Authorization: `Bearer ${credentials.accessToken}` },
+                            qs: { per_page: 200 },
+                        });
+                        if (response === null || response === void 0 ? void 0 : response.snapshots) {
+                            for (const item of response.snapshots) {
+                                returnData.push({
+                                    name: `${item.name} (${item.resource_type || 'snapshot'})`,
+                                    value: item.id,
+                                });
+                            }
+                        }
+                    }
+                    catch (error) { }
+                    return returnData;
+                },
+                async getSshKeys() {
+                    var _a;
+                    const returnData = [];
+                    try {
+                        const credentials = await this.getCredentials('digitalOceanApi');
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/account/keys`,
+                            headers: { Authorization: `Bearer ${credentials.accessToken}` },
+                            qs: { per_page: 200 },
+                        });
+                        if (response === null || response === void 0 ? void 0 : response.ssh_keys) {
+                            for (const item of response.ssh_keys) {
+                                returnData.push({
+                                    name: `${item.name} (${(_a = item.fingerprint) === null || _a === void 0 ? void 0 : _a.substring(0, 8)}...)`,
+                                    value: item.id.toString(),
+                                });
+                            }
+                        }
+                    }
+                    catch (error) { }
+                    return returnData;
+                },
+                async getVpcs() {
+                    const returnData = [];
+                    try {
+                        const credentials = await this.getCredentials('digitalOceanApi');
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/vpcs`,
+                            headers: { Authorization: `Bearer ${credentials.accessToken}` },
+                            qs: { per_page: 200 },
+                        });
+                        if (response === null || response === void 0 ? void 0 : response.vpcs) {
+                            for (const item of response.vpcs) {
+                                returnData.push({
+                                    name: `${item.name} (${item.region})`,
+                                    value: item.id,
+                                });
+                            }
+                        }
+                    }
+                    catch (error) { }
+                    return returnData;
+                },
+                async getFirewalls() {
+                    const returnData = [];
+                    try {
+                        const credentials = await this.getCredentials('digitalOceanApi');
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/firewalls`,
+                            headers: { Authorization: `Bearer ${credentials.accessToken}` },
+                            qs: { per_page: 200 },
+                        });
+                        if (response === null || response === void 0 ? void 0 : response.firewalls) {
+                            for (const item of response.firewalls) {
+                                returnData.push({ name: item.name, value: item.id });
+                            }
+                        }
+                    }
+                    catch (error) { }
+                    return returnData;
+                },
+            },
+        };
+    }
+    async execute() {
+        var _a, _b;
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials('digitalOceanApi');
+        const headers = { Authorization: `Bearer ${credentials.accessToken}` };
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const resource = this.getNodeParameter('resource', i);
+                const operation = this.getNodeParameter('operation', i);
+                let responseData;
+                if (resource === 'account') {
+                    const response = await this.helpers.httpRequest({
+                        method: 'GET',
+                        url: `${BASE_URL}/account`,
+                        headers,
+                    });
+                    responseData = response.account;
+                }
+                else if (resource === 'droplet') {
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const limit = returnAll ? Infinity : this.getNodeParameter('limit', i);
+                        responseData = await makePaginatedRequest.call(this, 'GET', '/droplets', {}, headers, limit);
+                    }
+                    else if (operation === 'get') {
+                        const dropletId = this.getNodeParameter('dropletId', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/droplets/${dropletId}`,
+                            headers,
+                        });
+                        responseData = response.droplet;
+                    }
+                    else if (operation === 'create') {
+                        const name = this.getNodeParameter('dropletName', i);
+                        const region = this.getNodeParameter('dropletRegion', i);
+                        const size = this.getNodeParameter('dropletSize', i);
+                        const image = this.getNodeParameter('dropletImage', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i, {});
+                        const body = { name, region, size, image };
+                        if (additionalFields.backups)
+                            body.backups = true;
+                        if (additionalFields.ipv6)
+                            body.ipv6 = true;
+                        if (additionalFields.monitoring)
+                            body.monitoring = true;
+                        if (additionalFields.privateNetworking)
+                            body.private_networking = true;
+                        if ((_a = additionalFields.sshKeys) === null || _a === void 0 ? void 0 : _a.length)
+                            body.ssh_keys = additionalFields.sshKeys.map((id) => parseInt(id));
+                        if (additionalFields.tags)
+                            body.tags = additionalFields.tags.split(',').map((t) => t.trim());
+                        if (additionalFields.userData)
+                            body.user_data = additionalFields.userData;
+                        if (additionalFields.vpcUuid)
+                            body.vpc_uuid = additionalFields.vpcUuid;
+                        if ((_b = additionalFields.volumes) === null || _b === void 0 ? void 0 : _b.length)
+                            body.volumes = additionalFields.volumes;
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${BASE_URL}/droplets`,
+                            headers,
+                            body,
+                        });
+                        responseData = response.droplet;
+                    }
+                    else if (operation === 'delete') {
+                        const dropletId = this.getNodeParameter('dropletId', i);
+                        await this.helpers.httpRequest({
+                            method: 'DELETE',
+                            url: `${BASE_URL}/droplets/${dropletId}`,
+                            headers,
+                        });
+                        responseData = { success: true };
+                    }
+                    else if (operation === 'reboot') {
+                        const dropletId = this.getNodeParameter('dropletId', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${BASE_URL}/droplets/${dropletId}/actions`,
+                            headers,
+                            body: { type: 'reboot' },
+                        });
+                        responseData = response.action;
+                    }
+                    else if (operation === 'shutdown') {
+                        const dropletId = this.getNodeParameter('dropletId', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${BASE_URL}/droplets/${dropletId}/actions`,
+                            headers,
+                            body: { type: 'shutdown' },
+                        });
+                        responseData = response.action;
+                    }
+                    else if (operation === 'powerOn') {
+                        const dropletId = this.getNodeParameter('dropletId', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${BASE_URL}/droplets/${dropletId}/actions`,
+                            headers,
+                            body: { type: 'power_on' },
+                        });
+                        responseData = response.action;
+                    }
+                    else if (operation === 'powerOff') {
+                        const dropletId = this.getNodeParameter('dropletId', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${BASE_URL}/droplets/${dropletId}/actions`,
+                            headers,
+                            body: { type: 'power_off' },
+                        });
+                        responseData = response.action;
+                    }
+                }
+                else if (resource === 'volume') {
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const limit = returnAll ? Infinity : this.getNodeParameter('limit', i);
+                        responseData = await makePaginatedRequest.call(this, 'GET', '/volumes', {}, headers, limit);
+                    }
+                    else if (operation === 'get') {
+                        const volumeId = this.getNodeParameter('volumeId', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/volumes/${volumeId}`,
+                            headers,
+                        });
+                        responseData = response.volume;
+                    }
+                    else if (operation === 'create') {
+                        const name = this.getNodeParameter('volumeName', i);
+                        const sizeGigabytes = this.getNodeParameter('volumeSizeGigabytes', i);
+                        const region = this.getNodeParameter('volumeRegion', i);
+                        const body = { name, size_gigabytes: sizeGigabytes, region };
+                        const description = this.getNodeParameter('volumeDescription', i, '');
+                        const snapshotId = this.getNodeParameter('volumeSnapshotId', i, '');
+                        if (description)
+                            body.description = description;
+                        if (snapshotId)
+                            body.snapshot_id = snapshotId;
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${BASE_URL}/volumes`,
+                            headers,
+                            body,
+                        });
+                        responseData = response.volume;
+                    }
+                    else if (operation === 'delete') {
+                        const volumeId = this.getNodeParameter('volumeId', i);
+                        await this.helpers.httpRequest({
+                            method: 'DELETE',
+                            url: `${BASE_URL}/volumes/${volumeId}`,
+                            headers,
+                        });
+                        responseData = { success: true };
+                    }
+                }
+                else if (resource === 'database') {
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const limit = returnAll ? Infinity : this.getNodeParameter('limit', i);
+                        responseData = await makePaginatedRequest.call(this, 'GET', '/databases', {}, headers, limit);
+                    }
+                    else if (operation === 'get') {
+                        const databaseId = this.getNodeParameter('databaseId', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/databases/${databaseId}`,
+                            headers,
+                        });
+                        responseData = response.database;
+                    }
+                    else if (operation === 'create') {
+                        const name = this.getNodeParameter('databaseName', i);
+                        const engine = this.getNodeParameter('databaseEngine', i);
+                        const version = this.getNodeParameter('databaseVersion', i, '');
+                        const region = this.getNodeParameter('databaseRegion', i);
+                        const size = this.getNodeParameter('databaseSize', i);
+                        const numNodes = this.getNodeParameter('databaseNumNodes', i, 1);
+                        const body = { name, engine, region, size, num_nodes: numNodes };
+                        if (version)
+                            body.version = version;
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${BASE_URL}/databases`,
+                            headers,
+                            body,
+                        });
+                        responseData = response.database;
+                    }
+                    else if (operation === 'delete') {
+                        const databaseId = this.getNodeParameter('databaseId', i);
+                        await this.helpers.httpRequest({
+                            method: 'DELETE',
+                            url: `${BASE_URL}/databases/${databaseId}`,
+                            headers,
+                        });
+                        responseData = { success: true };
+                    }
+                }
+                else if (resource === 'domain') {
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const limit = returnAll ? Infinity : this.getNodeParameter('limit', i);
+                        responseData = await makePaginatedRequest.call(this, 'GET', '/domains', {}, headers, limit);
+                    }
+                    else if (operation === 'get') {
+                        const domainName = this.getNodeParameter('domainName', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/domains/${domainName}`,
+                            headers,
+                        });
+                        responseData = response.domain;
+                    }
+                    else if (operation === 'create') {
+                        const name = this.getNodeParameter('domainNameCreate', i);
+                        const ip = this.getNodeParameter('domainIp', i, '');
+                        const body = { name };
+                        if (ip)
+                            body.ip_address = ip;
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${BASE_URL}/domains`,
+                            headers,
+                            body,
+                        });
+                        responseData = response.domain;
+                    }
+                    else if (operation === 'delete') {
+                        const domainName = this.getNodeParameter('domainName', i);
+                        await this.helpers.httpRequest({
+                            method: 'DELETE',
+                            url: `${BASE_URL}/domains/${domainName}`,
+                            headers,
+                        });
+                        responseData = { success: true };
+                    }
+                    else if (operation === 'getRecords') {
+                        const domainName = this.getNodeParameter('domainName', i);
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const limit = returnAll ? Infinity : this.getNodeParameter('limit', i);
+                        responseData = await makePaginatedRequest.call(this, 'GET', `/domains/${domainName}/records`, {}, headers, limit);
+                    }
+                }
+                else if (resource === 'image') {
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const limit = returnAll ? Infinity : this.getNodeParameter('limit', i);
+                        responseData = await makePaginatedRequest.call(this, 'GET', '/images', { type: 'distribution' }, headers, limit);
+                    }
+                    else if (operation === 'get') {
+                        const imageId = this.getNodeParameter('imageId', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/images/${imageId}`,
+                            headers,
+                        });
+                        responseData = response.image;
+                    }
+                    else if (operation === 'delete') {
+                        const imageId = this.getNodeParameter('imageId', i);
+                        await this.helpers.httpRequest({
+                            method: 'DELETE',
+                            url: `${BASE_URL}/images/${imageId}`,
+                            headers,
+                        });
+                        responseData = { success: true };
+                    }
+                }
+                else if (resource === 'kubernetes') {
+                    if (operation === 'getAllClusters') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const limit = returnAll ? Infinity : this.getNodeParameter('limit', i);
+                        responseData = await makePaginatedRequest.call(this, 'GET', '/kubernetes/clusters', {}, headers, limit);
+                    }
+                    else if (operation === 'getCluster') {
+                        const clusterId = this.getNodeParameter('clusterId', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/kubernetes/clusters/${clusterId}`,
+                            headers,
+                        });
+                        responseData = response.kubernetes_cluster;
+                    }
+                    else if (operation === 'deleteCluster') {
+                        const clusterId = this.getNodeParameter('clusterId', i);
+                        await this.helpers.httpRequest({
+                            method: 'DELETE',
+                            url: `${BASE_URL}/kubernetes/clusters/${clusterId}`,
+                            headers,
+                        });
+                        responseData = { success: true };
+                    }
+                    else if (operation === 'getKubeconfig') {
+                        const clusterId = this.getNodeParameter('clusterId', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/kubernetes/clusters/${clusterId}/kubeconfig`,
+                            headers,
+                        });
+                        responseData = { kubeconfig: response };
+                    }
+                }
+                else if (resource === 'loadBalancer') {
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const limit = returnAll ? Infinity : this.getNodeParameter('limit', i);
+                        responseData = await makePaginatedRequest.call(this, 'GET', '/load_balancers', {}, headers, limit);
+                    }
+                    else if (operation === 'get') {
+                        const loadBalancerId = this.getNodeParameter('loadBalancerId', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/load_balancers/${loadBalancerId}`,
+                            headers,
+                        });
+                        responseData = response.load_balancer;
+                    }
+                    else if (operation === 'create') {
+                        const name = this.getNodeParameter('loadBalancerName', i);
+                        const region = this.getNodeParameter('loadBalancerRegion', i);
+                        const dropletIds = this.getNodeParameter('loadBalancerDropletIds', i, []);
+                        const body = { name, region };
+                        if (dropletIds.length)
+                            body.droplet_ids = dropletIds.map((id) => parseInt(id));
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${BASE_URL}/load_balancers`,
+                            headers,
+                            body,
+                        });
+                        responseData = response.load_balancer;
+                    }
+                    else if (operation === 'delete') {
+                        const loadBalancerId = this.getNodeParameter('loadBalancerId', i);
+                        await this.helpers.httpRequest({
+                            method: 'DELETE',
+                            url: `${BASE_URL}/load_balancers/${loadBalancerId}`,
+                            headers,
+                        });
+                        responseData = { success: true };
+                    }
+                }
+                else if (resource === 'project') {
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const limit = returnAll ? Infinity : this.getNodeParameter('limit', i);
+                        responseData = await makePaginatedRequest.call(this, 'GET', '/projects', {}, headers, limit);
+                    }
+                    else if (operation === 'get') {
+                        const projectId = this.getNodeParameter('projectId', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/projects/${projectId}`,
+                            headers,
+                        });
+                        responseData = response.project;
+                    }
+                    else if (operation === 'create') {
+                        const name = this.getNodeParameter('projectName', i);
+                        const description = this.getNodeParameter('projectDescription', i, '');
+                        const purpose = this.getNodeParameter('projectPurpose', i, '');
+                        const environment = this.getNodeParameter('projectEnvironment', i, 'Development');
+                        const body = { name, environment };
+                        if (description)
+                            body.description = description;
+                        if (purpose)
+                            body.purpose = purpose;
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${BASE_URL}/projects`,
+                            headers,
+                            body,
+                        });
+                        responseData = response.project;
+                    }
+                    else if (operation === 'delete') {
+                        const projectId = this.getNodeParameter('projectId', i);
+                        await this.helpers.httpRequest({
+                            method: 'DELETE',
+                            url: `${BASE_URL}/projects/${projectId}`,
+                            headers,
+                        });
+                        responseData = { success: true };
+                    }
+                }
+                else if (resource === 'reservedIp') {
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const limit = returnAll ? Infinity : this.getNodeParameter('limit', i);
+                        responseData = await makePaginatedRequest.call(this, 'GET', '/reserved_ips', {}, headers, limit);
+                    }
+                    else if (operation === 'get') {
+                        const reservedIp = this.getNodeParameter('reservedIp', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/reserved_ips/${reservedIp}`,
+                            headers,
+                        });
+                        responseData = response.reserved_ip;
+                    }
+                    else if (operation === 'create') {
+                        const region = this.getNodeParameter('reservedIpRegion', i);
+                        const dropletId = this.getNodeParameter('reservedIpDropletId', i, '');
+                        const body = { region };
+                        if (dropletId)
+                            body.droplet_id = parseInt(dropletId);
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${BASE_URL}/reserved_ips`,
+                            headers,
+                            body,
+                        });
+                        responseData = response.reserved_ip;
+                    }
+                    else if (operation === 'delete') {
+                        const reservedIp = this.getNodeParameter('reservedIp', i);
+                        await this.helpers.httpRequest({
+                            method: 'DELETE',
+                            url: `${BASE_URL}/reserved_ips/${reservedIp}`,
+                            headers,
+                        });
+                        responseData = { success: true };
+                    }
+                }
+                else if (resource === 'snapshot') {
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const limit = returnAll ? Infinity : this.getNodeParameter('limit', i);
+                        responseData = await makePaginatedRequest.call(this, 'GET', '/snapshots', {}, headers, limit);
+                    }
+                    else if (operation === 'get') {
+                        const snapshotId = this.getNodeParameter('snapshotId', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/snapshots/${snapshotId}`,
+                            headers,
+                        });
+                        responseData = response.snapshot;
+                    }
+                    else if (operation === 'delete') {
+                        const snapshotId = this.getNodeParameter('snapshotId', i);
+                        await this.helpers.httpRequest({
+                            method: 'DELETE',
+                            url: `${BASE_URL}/snapshots/${snapshotId}`,
+                            headers,
+                        });
+                        responseData = { success: true };
+                    }
+                }
+                else if (resource === 'sshKey') {
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const limit = returnAll ? Infinity : this.getNodeParameter('limit', i);
+                        responseData = await makePaginatedRequest.call(this, 'GET', '/account/keys', {}, headers, limit);
+                    }
+                    else if (operation === 'get') {
+                        const sshKeyId = this.getNodeParameter('sshKeyId', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/account/keys/${sshKeyId}`,
+                            headers,
+                        });
+                        responseData = response.ssh_key;
+                    }
+                    else if (operation === 'create') {
+                        const name = this.getNodeParameter('sshKeyName', i);
+                        const publicKey = this.getNodeParameter('sshPublicKey', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${BASE_URL}/account/keys`,
+                            headers,
+                            body: { name, public_key: publicKey },
+                        });
+                        responseData = response.ssh_key;
+                    }
+                    else if (operation === 'delete') {
+                        const sshKeyId = this.getNodeParameter('sshKeyId', i);
+                        await this.helpers.httpRequest({
+                            method: 'DELETE',
+                            url: `${BASE_URL}/account/keys/${sshKeyId}`,
+                            headers,
+                        });
+                        responseData = { success: true };
+                    }
+                }
+                else if (resource === 'vpc') {
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const limit = returnAll ? Infinity : this.getNodeParameter('limit', i);
+                        responseData = await makePaginatedRequest.call(this, 'GET', '/vpcs', {}, headers, limit);
+                    }
+                    else if (operation === 'get') {
+                        const vpcId = this.getNodeParameter('vpcId', i);
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${BASE_URL}/vpcs/${vpcId}`,
+                            headers,
+                        });
+                        responseData = response.vpc;
+                    }
+                    else if (operation === 'create') {
+                        const name = this.getNodeParameter('vpcName', i);
+                        const region = this.getNodeParameter('vpcRegion', i);
+                        const description = this.getNodeParameter('vpcDescription', i, '');
+                        const ipRange = this.getNodeParameter('vpcIpRange', i, '');
+                        const body = { name, region };
+                        if (description)
+                            body.description = description;
+                        if (ipRange)
+                            body.ip_range = ipRange;
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${BASE_URL}/vpcs`,
+                            headers,
+                            body,
+                        });
+                        responseData = response.vpc;
+                    }
+                    else if (operation === 'delete') {
+                        const vpcId = this.getNodeParameter('vpcId', i);
+                        await this.helpers.httpRequest({
+                            method: 'DELETE',
+                            url: `${BASE_URL}/vpcs/${vpcId}`,
+                            headers,
+                        });
+                        responseData = { success: true };
+                    }
+                }
+                if (Array.isArray(responseData)) {
+                    for (const item of responseData) {
+                        returnData.push({ json: item, pairedItem: { item: i } });
+                    }
+                }
+                else if (responseData) {
+                    returnData.push({ json: responseData, pairedItem: { item: i } });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message }, pairedItem: { item: i } });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex: i });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.DigitalOcean = DigitalOcean;
+//# sourceMappingURL=DigitalOcean.node.js.map