puls-dev 0.1.0

package/dist/providers/aws/sqs.js

@@ -0,0 +1,178 @@
+import { GetQueueUrlCommand, GetQueueAttributesCommand, CreateQueueCommand, SetQueueAttributesCommand, DeleteQueueCommand, QueueAttributeName, } from '@aws-sdk/client-sqs';
+import { BaseBuilder } from '../../core/resource.js';
+import { getSQSClient } from './api.js';
+export class SQSBuilder extends BaseBuilder {
+    _fifo = false;
+    _deduplication = false;
+    _visibilityTimeout = 30;
+    _retentionDays = 4;
+    _delaySeconds = 0;
+    _dlqName;
+    _dlqMaxReceives = 3;
+    resolvedUrl = null;
+    resolvedArn = null;
+    resolvedDlqUrl = null;
+    resolvedDlqArn = null;
+    constructor(name) {
+        super(name);
+        this.discoveryPromise = this.discoverQueue(name);
+    }
+    fifo(enabled = true) { this._fifo = enabled; return this; }
+    deduplication(enabled = true) { this._deduplication = enabled; return this; }
+    timeout(seconds) { this._visibilityTimeout = seconds; return this; }
+    retention(days) { this._retentionDays = days; return this; }
+    delay(seconds) { this._delaySeconds = seconds; return this; }
+    dlq(name, maxReceives = 3) {
+        this._dlqName = name;
+        this._dlqMaxReceives = maxReceives;
+        return this;
+    }
+    queueName() {
+        const base = this.name;
+        if (this._fifo && !base.endsWith('.fifo'))
+            return `${base}.fifo`;
+        return base;
+    }
+    async discoverQueue(name) {
+        const sqs = getSQSClient();
+        const qName = this._fifo && !name.endsWith('.fifo') ? `${name}.fifo` : name;
+        try {
+            const urlResult = await sqs.send(new GetQueueUrlCommand({ QueueName: qName }));
+            this.resolvedUrl = urlResult.QueueUrl;
+            const attrResult = await sqs.send(new GetQueueAttributesCommand({
+                QueueUrl: this.resolvedUrl,
+                AttributeNames: [QueueAttributeName.QueueArn],
+            }));
+            this.resolvedArn = attrResult.Attributes?.QueueArn ?? null;
+            return { url: this.resolvedUrl, arn: this.resolvedArn };
+        }
+        catch (e) {
+            if (e.name === 'QueueDoesNotExist' || e.name === 'AWS.SimpleQueueService.NonExistentQueue')
+                return null;
+            if (e.name === 'CredentialsProviderError')
+                return null;
+            throw e;
+        }
+    }
+    async ensureQueue(queueName, attrs) {
+        const sqs = getSQSClient();
+        try {
+            const urlResult = await sqs.send(new GetQueueUrlCommand({ QueueName: queueName }));
+            const url = urlResult.QueueUrl;
+            const attrResult = await sqs.send(new GetQueueAttributesCommand({
+                QueueUrl: url,
+                AttributeNames: [QueueAttributeName.QueueArn],
+            }));
+            return { url, arn: attrResult.Attributes?.QueueArn };
+        }
+        catch (e) {
+            if (e.name !== 'QueueDoesNotExist' && e.name !== 'AWS.SimpleQueueService.NonExistentQueue')
+                throw e;
+        }
+        const created = await sqs.send(new CreateQueueCommand({ QueueName: queueName, Attributes: attrs }));
+        const url = created.QueueUrl;
+        const attrResult = await sqs.send(new GetQueueAttributesCommand({
+            QueueUrl: url,
+            AttributeNames: [QueueAttributeName.QueueArn],
+        }));
+        return { url, arn: attrResult.Attributes?.QueueArn };
+    }
+    buildAttributes(redrivePolicy) {
+        const attrs = {
+            VisibilityTimeout: String(this._visibilityTimeout),
+            MessageRetentionPeriod: String(this._retentionDays * 86400),
+            DelaySeconds: String(this._delaySeconds),
+        };
+        if (this._fifo) {
+            attrs.FifoQueue = 'true';
+            if (this._deduplication)
+                attrs.ContentBasedDeduplication = 'true';
+        }
+        if (redrivePolicy)
+            attrs.RedrivePolicy = redrivePolicy;
+        return attrs;
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const queueName = this.queueName();
+        console.log(`\n⚡ Finalizing SQS Queue "${queueName}"...`);
+        if (dryRun) {
+            const dlqName = this._dlqName ? (this._fifo && !this._dlqName.endsWith('.fifo') ? `${this._dlqName}.fifo` : this._dlqName) : undefined;
+            console.log(`   📝 [PLAN] ${existing ? 'Update' : 'Create'} queue "${queueName}"`);
+            console.log(`      └─ Type: ${this._fifo ? 'FIFO' : 'Standard'}`);
+            console.log(`      └─ Visibility timeout: ${this._visibilityTimeout}s | Retention: ${this._retentionDays}d`);
+            if (this._delaySeconds)
+                console.log(`      └─ Delivery delay: ${this._delaySeconds}s`);
+            if (dlqName)
+                console.log(`      └─ DLQ: ${dlqName} (after ${this._dlqMaxReceives} receives)`);
+            this.resolvedUrl = `https://sqs.DRYRUN.amazonaws.com/000000000000/${queueName}`;
+            this.resolvedArn = `arn:aws:sqs:DRYRUN:000000000000:${queueName}`;
+            return { name: queueName, url: this.resolvedUrl, arn: this.resolvedArn };
+        }
+        const sqs = getSQSClient();
+        // Create DLQ first so we have its ARN for the redrive policy
+        let redrivePolicy;
+        if (this._dlqName) {
+            const dlqQueueName = this._fifo && !this._dlqName.endsWith('.fifo')
+                ? `${this._dlqName}.fifo`
+                : this._dlqName;
+            const dlqAttrs = {
+                VisibilityTimeout: String(this._visibilityTimeout),
+                MessageRetentionPeriod: String(this._retentionDays * 86400),
+            };
+            if (this._fifo)
+                dlqAttrs.FifoQueue = 'true';
+            const dlq = await this.ensureQueue(dlqQueueName, dlqAttrs);
+            this.resolvedDlqUrl = dlq.url;
+            this.resolvedDlqArn = dlq.arn;
+            redrivePolicy = JSON.stringify({ deadLetterTargetArn: dlq.arn, maxReceiveCount: this._dlqMaxReceives });
+            console.log(`   ✅ DLQ ready: ${dlqQueueName}`);
+        }
+        const attrs = this.buildAttributes(redrivePolicy);
+        if (existing) {
+            // FIFO queues reject attribute updates that change queue type — only update mutable attrs
+            const mutableAttrs = {
+                VisibilityTimeout: attrs.VisibilityTimeout,
+                MessageRetentionPeriod: attrs.MessageRetentionPeriod,
+                DelaySeconds: attrs.DelaySeconds,
+            };
+            if (redrivePolicy)
+                mutableAttrs.RedrivePolicy = redrivePolicy;
+            await sqs.send(new SetQueueAttributesCommand({
+                QueueUrl: this.resolvedUrl,
+                Attributes: mutableAttrs,
+            }));
+            console.log(`   ✅ Updated queue "${queueName}"`);
+        }
+        else {
+            const created = await sqs.send(new CreateQueueCommand({ QueueName: queueName, Attributes: attrs }));
+            this.resolvedUrl = created.QueueUrl;
+            const arnResult = await sqs.send(new GetQueueAttributesCommand({
+                QueueUrl: this.resolvedUrl,
+                AttributeNames: [QueueAttributeName.QueueArn],
+            }));
+            this.resolvedArn = arnResult.Attributes?.QueueArn ?? null;
+            console.log(`🚀 Created queue "${queueName}"`);
+        }
+        console.log(`   🔗 URL: ${this.resolvedUrl}`);
+        await this.deploySidecars();
+        return { name: queueName, url: this.resolvedUrl, arn: this.resolvedArn };
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        console.log(`\n🗑️  Destroying SQS Queue "${this.queueName()}"...`);
+        if (!existing) {
+            console.log(`   ✅ Queue "${this.queueName()}" does not exist — nothing to do`);
+            return { destroyed: this.name };
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Delete queue "${this.queueName()}"`);
+            return { destroyed: this.name };
+        }
+        await getSQSClient().send(new DeleteQueueCommand({ QueueUrl: this.resolvedUrl }));
+        console.log(`   ✅ Deleted queue "${this.queueName()}"`);
+        return { destroyed: this.name };
+    }
+}

package/dist/providers/do/api.d.ts

@@ -0,0 +1,11 @@
+export declare class DoApiClient {
+    private token;
+    private static readonly BASE;
+    constructor(token: string);
+    private get authHeaders();
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body: unknown): Promise<T>;
+    put<T>(path: string, body: unknown): Promise<T>;
+    delete(path: string): Promise<void>;
+}
+export declare function getDoApi(): DoApiClient;

package/dist/providers/do/api.js

@@ -0,0 +1,52 @@
+import { Config } from '../../core/config.js';
+export class DoApiClient {
+    token;
+    static BASE = 'https://api.digitalocean.com/v2';
+    constructor(token) {
+        this.token = token;
+    }
+    get authHeaders() {
+        return { Authorization: `Bearer ${this.token}`, 'Content-Type': 'application/json' };
+    }
+    async get(path) {
+        const res = await fetch(`${DoApiClient.BASE}${path}`, { headers: this.authHeaders });
+        if (!res.ok)
+            throw new Error(`DO API GET ${path}: ${res.status} ${await res.text()}`);
+        return res.json();
+    }
+    async post(path, body) {
+        const res = await fetch(`${DoApiClient.BASE}${path}`, {
+            method: 'POST',
+            headers: this.authHeaders,
+            body: JSON.stringify(body),
+        });
+        if (!res.ok)
+            throw new Error(`DO API POST ${path}: ${res.status} ${await res.text()}`);
+        return res.json();
+    }
+    async put(path, body) {
+        const res = await fetch(`${DoApiClient.BASE}${path}`, {
+            method: 'PUT',
+            headers: this.authHeaders,
+            body: JSON.stringify(body),
+        });
+        if (!res.ok)
+            throw new Error(`DO API PUT ${path}: ${res.status} ${await res.text()}`);
+        return res.json();
+    }
+    async delete(path) {
+        const res = await fetch(`${DoApiClient.BASE}${path}`, {
+            method: 'DELETE',
+            headers: this.authHeaders,
+        });
+        if (!res.ok && res.status !== 404) {
+            throw new Error(`DO API DELETE ${path}: ${res.status} ${await res.text()}`);
+        }
+    }
+}
+export function getDoApi() {
+    const token = Config.get().providers.do?.token;
+    if (!token)
+        throw new Error('DO token not configured. Call DO.init({ token: "..." })');
+    return new DoApiClient(token);
+}

package/dist/providers/do/certificate.d.ts

@@ -0,0 +1,7 @@
+import { BaseBuilder } from '../../core/resource.js';
+export declare class CertificateBuilder extends BaseBuilder {
+    domainName: string;
+    constructor(domainName: string);
+    private discoverCertificate;
+    deploy(): Promise<any>;
+}

package/dist/providers/do/certificate.js

@@ -0,0 +1,36 @@
+import { BaseBuilder } from '../../core/resource.js';
+import { getDoApi } from './api.js';
+export class CertificateBuilder extends BaseBuilder {
+    domainName;
+    constructor(domainName) {
+        super(`ssl-${domainName}`);
+        this.domainName = domainName;
+        this.discoveryPromise = this.discoverCertificate(this.name);
+    }
+    async discoverCertificate(name) {
+        const api = getDoApi();
+        const data = await api.get('/certificates?per_page=200');
+        return data.certificates.find(c => c.name === name) ?? null;
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        console.log(`\n🔐 Finalizing SSL certificate for "${this.domainName}"...`);
+        if (existing) {
+            console.log(`   ✅ Certificate ${this.name} already exists (state=${existing.state}).`);
+            return existing;
+        }
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Create Let's Encrypt certificate for *.${this.domainName}`);
+            return { name: this.name };
+        }
+        const api = getDoApi();
+        const result = await api.post('/certificates', {
+            name: this.name,
+            type: 'lets_encrypt',
+            dns_names: [`*.${this.domainName}`, this.domainName],
+        });
+        console.log(`🚀 Requested certificate ${this.name} (id=${result.certificate.id})`);
+        return result.certificate;
+    }
+}

package/dist/providers/do/domain.d.ts

@@ -0,0 +1,21 @@
+import { BaseBuilder } from '../../core/resource.js';
+import { Output } from '../../core/output.js';
+import { DropletBuilder } from './droplet.js';
+export interface DNSRecord {
+    type: 'A' | 'CNAME' | 'TXT' | 'MX';
+    name: string;
+    value: string | DropletBuilder | Output<string>;
+}
+export declare class DomainBuilder extends BaseBuilder {
+    domainName: string;
+    private records;
+    constructor(domainName: string);
+    private discoverDomain;
+    withSSL(): this;
+    pointer(name: string, target: DropletBuilder | Output<string> | string): this;
+    cname(name: string, target: string): this;
+    deploy(): Promise<{
+        domain: string;
+        records: DNSRecord[];
+    }>;
+}

package/dist/providers/do/domain.js

@@ -0,0 +1,81 @@
+import { BaseBuilder } from '../../core/resource.js';
+import { Output } from '../../core/output.js';
+import { DropletBuilder } from './droplet.js';
+import { CertificateBuilder } from './certificate.js';
+import { getDoApi } from './api.js';
+export class DomainBuilder extends BaseBuilder {
+    domainName;
+    records = [];
+    constructor(domainName) {
+        super(domainName);
+        this.domainName = domainName;
+        this.discoveryPromise = this.discoverDomain(domainName);
+    }
+    async discoverDomain(name) {
+        const api = getDoApi();
+        try {
+            return await api.get(`/domains/${name}`).then(d => d.domain);
+        }
+        catch {
+            return null;
+        }
+    }
+    withSSL() {
+        const cert = new CertificateBuilder(this.domainName);
+        this.sidecars.push(cert);
+        return this;
+    }
+    pointer(name, target) {
+        this.records.push({ type: 'A', name, value: target });
+        return this;
+    }
+    cname(name, target) {
+        this.records.push({ type: 'CNAME', name, value: target });
+        return this;
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const api = getDoApi();
+        console.log(`\n🌐 Finalizing DNS for "${this.domainName}"...`);
+        if (!existing) {
+            if (dryRun) {
+                console.log(`   📝 [PLAN] Create domain ${this.domainName}`);
+            }
+            else {
+                await api.post('/domains', { name: this.domainName });
+                console.log(`🚀 Created domain ${this.domainName}`);
+            }
+        }
+        for (const record of this.records) {
+            let data;
+            if (record.value instanceof Output) {
+                data = await record.value.get();
+            }
+            else if (record.value instanceof DropletBuilder) {
+                data = (await record.value.getPublicIp()) ?? `[IP of ${record.value.name} — not found]`;
+            }
+            else {
+                data = record.value;
+            }
+            if (dryRun) {
+                console.log(`   📝 [PLAN] ${record.type} ${record.name}.${this.domainName} → ${data}`);
+                continue;
+            }
+            // Delete existing record with same type+name before creating
+            const existing_records = await api.get(`/domains/${this.domainName}/records?per_page=200`);
+            const dupe = existing_records.domain_records.find(r => r.type === record.type && r.name === record.name);
+            if (dupe)
+                await api.delete(`/domains/${this.domainName}/records/${dupe.id}`);
+            await api.post(`/domains/${this.domainName}/records`, {
+                type: record.type,
+                name: record.name,
+                data,
+                ttl: 3600,
+            });
+            console.log(`   ✅ ${record.type} ${record.name}.${this.domainName} → ${data}`);
+        }
+        await this.deploySidecars();
+        return { domain: this.domainName, records: this.records };
+    }
+}

package/dist/providers/do/droplet.d.ts

@@ -0,0 +1,35 @@
+import { OS, REGION, SIZE } from '../../types/do.js';
+import { BaseBuilder } from '../../core/resource.js';
+import { Output } from '../../core/output.js';
+import { DomainBuilder } from './domain.js';
+import { LoadBalancerBuilder } from './load_balancer.js';
+export declare class DropletBuilder extends BaseBuilder {
+    readonly out: {
+        ip: Output<string>;
+        id: Output<number>;
+    };
+    config: any;
+    private dropletId?;
+    private resolvedIp?;
+    private sshKeyPath?;
+    constructor(name: string);
+    private discoverDroplet;
+    getPublicIp(): Promise<string | undefined>;
+    allowPublicWeb(sources?: string[]): this;
+    image(image: (typeof OS)[keyof typeof OS] | string): this;
+    region(region: (typeof REGION)[keyof typeof REGION] | string): this;
+    size(size: (typeof SIZE)[keyof typeof SIZE] | string): this;
+    sslKey(keyPath: string): this;
+    private resolveOrRegisterSshKey;
+    deploy(): Promise<any>;
+    destroy(): Promise<any>;
+}
+export declare const DO: {
+    init: (opts: {
+        token: string;
+        defaultRegion?: string;
+    }) => void;
+    Droplet: (name: string) => DropletBuilder;
+    Domain: (name: string) => DomainBuilder;
+    LoadBalancer: (name: string) => LoadBalancerBuilder;
+};

package/dist/providers/do/droplet.js

@@ -0,0 +1,180 @@
+import { readFileSync } from 'fs';
+import { homedir } from 'os';
+import { OS, REGION, SIZE, NETWORK } from '../../types/do.js';
+import { Config } from '../../core/config.js';
+import { BaseBuilder } from '../../core/resource.js';
+import { Output } from '../../core/output.js';
+import { FirewallBuilder } from './firewall.js';
+import { DomainBuilder } from './domain.js';
+import { LoadBalancerBuilder } from './load_balancer.js';
+import { getDoApi } from './api.js';
+export class DropletBuilder extends BaseBuilder {
+    out = {
+        ip: new Output(),
+        id: new Output(),
+    };
+    config = {
+        image: OS.UBUNTU_22_04,
+        region: Config.get().providers.do?.defaultRegion || REGION.NYC,
+        size: SIZE.SMALL,
+    };
+    dropletId;
+    resolvedIp;
+    sshKeyPath;
+    constructor(name) {
+        super(name);
+        this.discoveryPromise = this.discoverDroplet(name);
+    }
+    async discoverDroplet(name) {
+        const api = getDoApi();
+        const data = await api.get(`/droplets?name=${encodeURIComponent(name)}&per_page=200`);
+        const match = data.droplets.find(d => d.name === name) ?? null;
+        if (match) {
+            this.dropletId = match.id;
+            const pub = (match.networks?.v4 ?? []).find((n) => n.type === 'public');
+            this.resolvedIp = pub?.ip_address;
+            if (this.dropletId)
+                this.out.id.resolve(this.dropletId);
+            if (this.resolvedIp)
+                this.out.ip.resolve(this.resolvedIp);
+        }
+        return match;
+    }
+    async getPublicIp() {
+        await this.discoveryPromise;
+        return this.resolvedIp;
+    }
+    allowPublicWeb(sources = [NETWORK.ANY, NETWORK.ANY_V6]) {
+        const fw = new FirewallBuilder(`${this.name}-web-fw`)
+            .ingress('tcp', 80, sources)
+            .ingress('tcp', 443, sources)
+            .egress('tcp', 'all', [NETWORK.ANY, NETWORK.ANY_V6])
+            .attachTo(this.name);
+        this.sidecars.push(fw);
+        return this;
+    }
+    image(image) {
+        this.config.image = image;
+        return this;
+    }
+    region(region) {
+        this.config.region = region;
+        return this;
+    }
+    size(size) {
+        this.config.size = size;
+        return this;
+    }
+    sslKey(keyPath) {
+        this.sshKeyPath = keyPath.replace('~', homedir());
+        return this;
+    }
+    async resolveOrRegisterSshKey(api) {
+        const pubPath = this.sshKeyPath.replace(/\.pub$/, '') + '.pub';
+        const pubKey = readFileSync(pubPath, 'utf8').trim();
+        const { ssh_keys } = await api.get('/account/keys?per_page=200');
+        const existing = ssh_keys.find(k => k.public_key.trim() === pubKey);
+        if (existing)
+            return existing.id;
+        const keyName = pubPath.split('/').pop().replace('.pub', '');
+        const result = await api.post('/account/keys', { name: keyName, public_key: pubKey });
+        console.log(`   🔑 Registered SSH key "${keyName}" (id=${result.ssh_key.id})`);
+        return result.ssh_key.id;
+    }
+    async deploy() {
+        const dryRun = this.isDryRunActive();
+        const existing = await this.discoveryPromise;
+        const api = getDoApi();
+        const hasChanges = existing
+            ? existing.size_slug !== this.config.size || existing.region.slug !== this.config.region
+            : true;
+        if (await this.checkProtection(hasChanges))
+            return null;
+        if (dryRun) {
+            console.log(`\n🔍 [DRY RUN] "${this.name}"...`);
+            if (!existing) {
+                const keyHint = this.sshKeyPath ? ` + key ${this.sshKeyPath.split('/').pop()}` : '';
+                console.log(`   📝 Plan: Create droplet ${this.name} (${this.config.size} in ${this.config.region}${keyHint})`);
+                this.out.id.resolve(-1);
+                this.out.ip.resolve('0.0.0.0');
+            }
+            else if (hasChanges) {
+                console.log(`   📝 Plan: Resize ${this.name} → ${this.config.size}`);
+            }
+            else {
+                console.log(`   ✅ ${this.name} is up to date.`);
+            }
+            for (const sidecar of this.sidecars)
+                await sidecar.deploy();
+            return this.config;
+        }
+        console.log(`\n⏳ Finalizing "${this.name}"...`);
+        if (!existing) {
+            const sshKeyIds = this.sshKeyPath ? [await this.resolveOrRegisterSshKey(api)] : [];
+            const result = await api.post('/droplets', {
+                name: this.name,
+                region: this.config.region,
+                size: this.config.size,
+                image: this.config.image,
+                ...(sshKeyIds.length && { ssh_keys: sshKeyIds }),
+            });
+            this.dropletId = result.droplet.id;
+            this.out.id.resolve(this.dropletId);
+            console.log(`🚀 Created droplet ${this.name} (id=${this.dropletId})`);
+            await this.waitFor('droplet to become active', async () => {
+                const d = await api.get(`/droplets/${this.dropletId}`);
+                if (d.droplet.status === 'active') {
+                    const pub = (d.droplet.networks?.v4 ?? []).find((n) => n.type === 'public');
+                    this.resolvedIp = pub?.ip_address;
+                    return true;
+                }
+                return false;
+            });
+            if (this.resolvedIp) {
+                this.out.ip.resolve(this.resolvedIp);
+                console.log(`   🌐 Public IP: ${this.resolvedIp}`);
+            }
+        }
+        else if (hasChanges) {
+            console.log(`✨ Resizing ${this.name} → ${this.config.size}...`);
+            await api.post(`/droplets/${this.dropletId}/actions`, { type: 'resize', size: this.config.size });
+        }
+        else {
+            console.log(`✅ ${this.name} is up to date.`);
+        }
+        for (const sidecar of this.sidecars)
+            await sidecar.deploy();
+        return this.config;
+    }
+    async destroy() {
+        const dryRun = this.isDryRunActive();
+        await this.discoveryPromise;
+        if (!this.dropletId) {
+            console.log(`\n🗑️  "${this.name}" not found, nothing to destroy.`);
+            return { destroyed: null };
+        }
+        console.log(`\n🗑️  Destroying "${this.name}" (id=${this.dropletId})...`);
+        if (dryRun) {
+            console.log(`   📝 [PLAN] Would delete droplet id=${this.dropletId}`);
+        }
+        else {
+            await getDoApi().delete(`/droplets/${this.dropletId}`);
+            console.log(`   ✅ Deleted.`);
+        }
+        await this.destroySidecars();
+        return { destroyed: this.name };
+    }
+}
+export const DO = {
+    init: (opts) => {
+        Config.set({
+            providers: {
+                ...Config.get().providers,
+                do: opts,
+            },
+        });
+    },
+    Droplet: (name) => new DropletBuilder(name),
+    Domain: (name) => new DomainBuilder(name),
+    LoadBalancer: (name) => new LoadBalancerBuilder(name),
+};

package/dist/providers/do/firewall.d.ts

@@ -0,0 +1,23 @@
+import { BaseBuilder } from '../../core/resource.js';
+export interface FirewallRule {
+    type: 'ingress' | 'egress';
+    protocol: 'tcp' | 'udp' | 'icmp';
+    port: number | string;
+    sources?: string[];
+    destinations?: string[];
+}
+export declare class FirewallBuilder extends BaseBuilder {
+    private rules;
+    private dropletNames;
+    constructor(name: string);
+    private discoverFirewall;
+    ingress(protocol: 'tcp' | 'udp' | 'icmp', port: number | string, sources: string[]): this;
+    egress(protocol: 'tcp' | 'udp' | 'icmp', port: number | string, destinations: string[]): this;
+    attachTo(dropletName: string): this;
+    private resolveDropletIds;
+    private buildApiRules;
+    deploy(): Promise<{
+        name: string;
+        rules: FirewallRule[];
+    }>;
+}