@takashito/linode-mcp-server/dist/client/networking.d.ts

MCP server for Linode API

import { AxiosInstance } from 'axios';
import { PaginatedResponse, PaginationParams } from './common';
export interface IPAddress {
    address: string;
    gateway: string | null;
    subnet_mask: string | null;
    prefix: number | null;
    type: string;
    public: boolean;
    rdns: string | null;
    linode_id: number | null;
    region: string | null;
}
export interface IPv6Range {
    range: string;
    prefix: number;
    region: string;
    route_target: string | null;
}
export interface IPv6Pool {
    range: string;
    prefix: number;
    region: string;
}
export interface AllocateIPRequest {
    type: 'ipv4';
    public: boolean;
    linode_id?: number;
}
export interface UpdateIPRequest {
    rdns: string | null;
}
export interface ShareIPsRequest {
    linode_id: number;
    ips: string[];
}
export interface Firewall {
    id: number;
    label: string;
    created: string;
    updated: string;
    status: string;
    rules: {
        inbound_policy: 'ACCEPT' | 'DROP';
        outbound_policy: 'ACCEPT' | 'DROP';
        inbound: FirewallRule[];
        outbound: FirewallRule[];
    };
    tags: string[];
}
export interface FirewallRule {
    ports: string;
    protocol: 'TCP' | 'UDP' | 'ICMP';
    addresses: {
        ipv4?: string[];
        ipv6?: string[];
    };
    action: 'ACCEPT' | 'DROP';
}
export interface CreateFirewallRequest {
    label: string;
    rules: {
        inbound_policy: 'ACCEPT' | 'DROP';
        outbound_policy: 'ACCEPT' | 'DROP';
        inbound?: FirewallRule[];
        outbound?: FirewallRule[];
    };
    devices?: {
        linodes?: number[];
        nodebalancers?: number[];
    };
    tags?: string[];
}
export interface UpdateFirewallRequest {
    label?: string;
    tags?: string[];
    status?: 'enabled' | 'disabled';
}
export interface FirewallDevice {
    id: number;
    entity_id: number;
    type: 'linode' | 'nodebalancer';
    label: string;
    url: string;
    created: string;
    updated: string;
}
export interface CreateFirewallDeviceRequest {
    id: number;
    type: 'linode' | 'nodebalancer';
}
export interface UpdateFirewallRulesRequest {
    inbound_policy?: 'ACCEPT' | 'DROP';
    outbound_policy?: 'ACCEPT' | 'DROP';
    inbound?: FirewallRule[];
    outbound?: FirewallRule[];
}
export interface VLAN {
    id: string;
    description: string;
    region: string;
    linodes: number[];
    created: string;
}
export interface LinodeNetworkingClient {
    getIPAddresses: () => Promise<{
        ipv4: {
            public: IPAddress[];
            private: IPAddress[];
            shared: IPAddress[];
        };
        ipv6: {
            slaac: IPAddress;
            link_local: IPAddress;
            ranges: IPv6Range[];
        };
    }>;
    getIPAddress: (address: string) => Promise<IPAddress>;
    updateIPAddress: (address: string, data: UpdateIPRequest) => Promise<IPAddress>;
    allocateIPAddress: (data: AllocateIPRequest) => Promise<IPAddress>;
    shareIPAddresses: (data: ShareIPsRequest) => Promise<{}>;
    getIPv6Ranges: () => Promise<PaginatedResponse<IPv6Range>>;
    getIPv6Range: (range: string) => Promise<IPv6Range>;
    getIPv6Pools: () => Promise<PaginatedResponse<IPv6Pool>>;
    getFirewalls: (params?: PaginationParams) => Promise<PaginatedResponse<Firewall>>;
    getFirewall: (id: number) => Promise<Firewall>;
    createFirewall: (data: CreateFirewallRequest) => Promise<Firewall>;
    updateFirewall: (id: number, data: UpdateFirewallRequest) => Promise<Firewall>;
    deleteFirewall: (id: number) => Promise<{}>;
    getFirewallDevices: (firewallId: number) => Promise<PaginatedResponse<FirewallDevice>>;
    createFirewallDevice: (firewallId: number, data: CreateFirewallDeviceRequest) => Promise<FirewallDevice>;
    deleteFirewallDevice: (firewallId: number, deviceId: number) => Promise<{}>;
    getFirewallRules: (firewallId: number) => Promise<{
        inbound: FirewallRule[];
        outbound: FirewallRule[];
    }>;
    updateFirewallRules: (firewallId: number, data: UpdateFirewallRulesRequest) => Promise<{
        inbound: FirewallRule[];
        outbound: FirewallRule[];
    }>;
    getFirewallDevice: (firewallId: number, deviceId: number) => Promise<FirewallDevice>;
    getFirewallHistory: (firewallId: number, params?: PaginationParams) => Promise<PaginatedResponse<any>>;
    getFirewallRuleVersion: (firewallId: number, version: number) => Promise<any>;
    getFirewallSettings: () => Promise<any>;
    updateFirewallSettings: (data: any) => Promise<any>;
    getFirewallTemplates: () => Promise<any>;
    getFirewallTemplate: (slug: string) => Promise<any>;
    assignIPs: (data: {
        assignments: Array<{
            address: string;
            linode_id: number;
            region: string;
        }>;
    }) => Promise<{}>;
    assignIPv4Addresses: (data: {
        assignments: Array<{
            address: string;
            linode_id: number;
            region: string;
        }>;
    }) => Promise<{}>;
    shareIPv4Addresses: (data: {
        ips: string[];
        linode_id: number;
    }) => Promise<{}>;
    createIPv6Range: (data: {
        linode_id: number;
        prefix_length: number;
    }) => Promise<any>;
    deleteIPv6Range: (range: string) => Promise<{}>;
    getVLANs: (params?: PaginationParams) => Promise<PaginatedResponse<VLAN>>;
    getVLAN: (regionId: string, label: string) => Promise<VLAN>;
    deleteVLAN: (regionId: string, label: string) => Promise<{}>;
    getNetworkTransferPrices: () => Promise<any>;
    getLinodeInterfaces: (linodeId: number) => Promise<any>;
    getLinodeInterface: (linodeId: number, interfaceId: number) => Promise<any>;
    createLinodeInterface: (linodeId: number, data: any) => Promise<any>;
    updateLinodeInterface: (linodeId: number, interfaceId: number, data: any) => Promise<any>;
    deleteLinodeInterface: (linodeId: number, interfaceId: number) => Promise<{}>;
    getLinodeInterfaceHistory: (linodeId: number, params?: PaginationParams) => Promise<any>;
    getLinodeInterfaceSettings: (linodeId: number) => Promise<any>;
    updateLinodeInterfaceSettings: (linodeId: number, data: any) => Promise<any>;
    getLinodeInterfaceFirewalls: (linodeId: number, interfaceId: number) => Promise<any>;
    upgradeLinodeInterfaces: (linodeId: number) => Promise<any>;
}
export declare function createNetworkingClient(axios: AxiosInstance): LinodeNetworkingClient;