@rnsk/toolkits 0.0.9 → 0.0.10

package/dist/toolkits/hostinger/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/hostinger/manifest.js

@@ -0,0 +1,36 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { HOSTINGER_ICON } from './icon.js';
+import { hostingerTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'hostinger',
+    displayName: 'Hostinger',
+    shortDescription: 'Domains, DNS, WHOIS, VPS, hosting, websites, and billing.',
+    category: 'Developer Tools & DevOps',
+    icon: HOSTINGER_ICON,
+    auth: {
+        type: 'api_key',
+        tokenField: 'hostingerApiKey',
+        provider: {
+            in: 'header',
+            name: 'Authorization',
+            prefix: 'Bearer',
+            connectDescription: 'Connect Hostinger with an API token. Generate one from your Hostinger dashboard under the API section. All requests send it as Authorization: Bearer <token>.',
+        },
+    },
+    allowedHosts: ['developers.hostinger.com'],
+    tools: hostingerTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope ?? inferToolScope(entry.name),
+    })),
+    meta: {
+        since: '0.0.9',
+        homepage: 'https://www.hostinger.com',
+        docsUrl: 'https://developers.hostinger.com/',
+        apiDocsUrl: 'https://docs.hostinger.com/api-reference/overview',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/hostinger/tools/billing.d.ts

@@ -0,0 +1,12 @@
+export declare const hostingerListCatalogItems: import("ai").Tool<{
+    name?: string | undefined;
+    hostingerApiKey?: string | undefined;
+    category?: "DOMAIN" | "VPS" | undefined;
+}, any>;
+export declare const hostingerListPaymentMethods: import("ai").Tool<{
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerListSubscriptions: import("ai").Tool<{
+    hostingerApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=billing.d.ts.map

package/dist/toolkits/hostinger/tools/billing.js

@@ -0,0 +1,35 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { hostingerRequest } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const hostingerListCatalogItems = tool({
+    description: 'List catalog items available for order (domains, VPS plans) with pricing in cents. Use to check services and prices before ordering.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+        name: z.string().optional().describe('Filter by name, use * as wildcard, e.g. ".COM*"'),
+        category: z.enum(['DOMAIN', 'VPS']).optional().describe('Filter by category'),
+    }),
+    execute: async ({ hostingerApiKey, name, category }) => {
+        return hostingerRequest(hostingerApiKey, '/api/billing/v1/catalog', { query: { name, category } });
+    },
+});
+export const hostingerListPaymentMethods = tool({
+    description: 'List payment methods available for placing orders. Use to view payment options before creating an order.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+    }),
+    execute: async ({ hostingerApiKey }) => {
+        return hostingerRequest(hostingerApiKey, '/api/billing/v1/payment-methods');
+    },
+});
+export const hostingerListSubscriptions = tool({
+    description: 'List all subscriptions on the account. Use to monitor active services and billing status.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+    }),
+    execute: async ({ hostingerApiKey }) => {
+        return hostingerRequest(hostingerApiKey, '/api/billing/v1/subscriptions');
+    },
+});
+//# sourceMappingURL=billing.js.map

package/dist/toolkits/hostinger/tools/client.d.ts

@@ -0,0 +1,6 @@
+export declare function hostingerRequest(hostingerApiKey: string | undefined, path: string, options?: {
+    method?: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+}): Promise<any>;
+//# sourceMappingURL=client.d.ts.map

package/dist/toolkits/hostinger/tools/client.js

@@ -0,0 +1,57 @@
+// @ts-nocheck
+const HOSTINGER_API_BASE = 'https://developers.hostinger.com';
+export async function hostingerRequest(hostingerApiKey, path, options = {}) {
+    if (!hostingerApiKey) {
+        return { error: 'Hostinger API key is required. Connect Hostinger first.' };
+    }
+    const params = new URLSearchParams();
+    if (options.query) {
+        for (const [key, value] of Object.entries(options.query)) {
+            if (value !== undefined && value !== null && value !== '') {
+                if (Array.isArray(value)) {
+                    for (const item of value)
+                        params.append(key, String(item));
+                }
+                else {
+                    params.append(key, String(value));
+                }
+            }
+        }
+    }
+    const queryString = params.toString();
+    const url = `${HOSTINGER_API_BASE}${path}${queryString ? `?${queryString}` : ''}`;
+    try {
+        const response = await fetch(url, {
+            method: options.method ?? 'GET',
+            headers: {
+                Authorization: `Bearer ${hostingerApiKey}`,
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+            body: options.body !== undefined ? JSON.stringify(options.body) : undefined,
+        });
+        if (!response.ok) {
+            const details = await response.json().catch(() => ({}));
+            return { error: `Hostinger API request failed with status ${response.status}`, details };
+        }
+        if (response.status === 204) {
+            return { success: true };
+        }
+        const text = await response.text();
+        if (!text)
+            return { success: true };
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return { raw: text };
+        }
+    }
+    catch (error) {
+        return {
+            error: 'Error calling Hostinger API',
+            message: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/toolkits/hostinger/tools/dns.d.ts

@@ -0,0 +1,22 @@
+export declare const hostingerGetDnsRecords: import("ai").Tool<{
+    domain: string;
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerValidateDnsRecords: import("ai").Tool<{
+    domain: string;
+    zone: {
+        type: string;
+        name: string;
+        records: {
+            content: string;
+        }[];
+        ttl?: number | undefined;
+    }[];
+    overwrite?: boolean | undefined;
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerListDnsSnapshots: import("ai").Tool<{
+    domain: string;
+    hostingerApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=dns.d.ts.map

package/dist/toolkits/hostinger/tools/dns.js

@@ -0,0 +1,47 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { hostingerRequest } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const hostingerGetDnsRecords = tool({
+    description: 'Get DNS zone records for a domain. Use to review current DNS configuration, check propagation after updates, or audit DNS settings.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+        domain: z.string().describe('Domain name, e.g. "mydomain.tld"'),
+    }),
+    execute: async ({ hostingerApiKey, domain }) => {
+        return hostingerRequest(hostingerApiKey, `/api/dns/v1/zones/${encodeURIComponent(domain)}`);
+    },
+});
+const zoneEntry = z.object({
+    name: z.string().describe('Subdomain or hostname, e.g. "www"'),
+    type: z.string().describe('Record type, e.g. "A", "AAAA", "CNAME", "MX", "TXT", "NS"'),
+    ttl: z.number().int().min(0).optional().describe('Time to live in seconds'),
+    records: z.array(z.object({ content: z.string().describe('Record content, e.g. IP address or hostname') })).min(1).describe('DNS records for this entry'),
+});
+export const hostingerValidateDnsRecords = tool({
+    description: 'Validate DNS zone records for a domain before applying an update. Use to verify record validity; success returns 200, invalid records fail with 422.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+        domain: z.string().describe('Domain name, e.g. "example.com"'),
+        zone: z.array(zoneEntry).min(1).describe('DNS zone entries to validate'),
+        overwrite: z.boolean().optional().describe('When true, matching records are replaced; otherwise TTLs are updated and records appended'),
+    }),
+    execute: async ({ hostingerApiKey, domain, zone, overwrite }) => {
+        return hostingerRequest(hostingerApiKey, `/api/dns/v1/zones/${encodeURIComponent(domain)}/validate`, {
+            method: 'POST',
+            body: { zone, overwrite },
+        });
+    },
+});
+export const hostingerListDnsSnapshots = tool({
+    description: 'List DNS snapshots (backup points) for a domain. Use to find restore points for DNS recovery or audit history.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+        domain: z.string().describe('Domain name, e.g. "mydomain.tld"'),
+    }),
+    execute: async ({ hostingerApiKey, domain }) => {
+        return hostingerRequest(hostingerApiKey, `/api/dns/v1/snapshots/${encodeURIComponent(domain)}`);
+    },
+});
+//# sourceMappingURL=dns.js.map

package/dist/toolkits/hostinger/tools/domains.d.ts

@@ -0,0 +1,21 @@
+export declare const hostingerCheckDomainAvailability: import("ai").Tool<{
+    domain: string;
+    tlds: string[];
+    hostingerApiKey?: string | undefined;
+    withAlternatives?: boolean | undefined;
+}, any>;
+export declare const hostingerListDomains: import("ai").Tool<{
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerGetDomainForwarding: import("ai").Tool<{
+    domain: string;
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerGenerateFreeSubdomain: import("ai").Tool<{
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerVerifyDomainOwnership: import("ai").Tool<{
+    domain: string;
+    hostingerApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=domains.d.ts.map

package/dist/toolkits/hostinger/tools/domains.js

@@ -0,0 +1,62 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { hostingerRequest } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const hostingerCheckDomainAvailability = tool({
+    description: 'Check if domain names are available for registration across multiple TLDs. Use before purchasing a domain. Provide TLDs without a leading dot. Rate limited to 10 requests per minute.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+        domain: z.string().describe('Domain name without TLD, e.g. "mydomain"'),
+        tlds: z.array(z.string()).min(1).describe('TLDs to check without leading dot, e.g. ["com", "net"]'),
+        withAlternatives: z.boolean().optional().describe('Include alternative domain suggestions (provide only one TLD when true)'),
+    }),
+    execute: async ({ hostingerApiKey, domain, tlds, withAlternatives }) => {
+        return hostingerRequest(hostingerApiKey, '/api/domains/v1/availability', {
+            method: 'POST',
+            body: { domain, tlds, with_alternatives: withAlternatives },
+        });
+    },
+});
+export const hostingerListDomains = tool({
+    description: 'List all domains in the Hostinger account portfolio. Use when the user asks to see their domains or domain portfolio.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+    }),
+    execute: async ({ hostingerApiKey }) => {
+        return hostingerRequest(hostingerApiKey, '/api/domains/v1/portfolio');
+    },
+});
+export const hostingerGetDomainForwarding = tool({
+    description: 'Get the forwarding (redirect) configuration for a domain, including target URL and redirect type (301/302).',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+        domain: z.string().describe('Domain name, e.g. "mydomain.tld"'),
+    }),
+    execute: async ({ hostingerApiKey, domain }) => {
+        return hostingerRequest(hostingerApiKey, `/api/domains/v1/forwarding/${encodeURIComponent(domain)}`);
+    },
+});
+export const hostingerGenerateFreeSubdomain = tool({
+    description: 'Generate a free *.hostingersite.com subdomain for hosting without buying a custom domain. Use when the user wants a quick free subdomain.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+    }),
+    execute: async ({ hostingerApiKey }) => {
+        return hostingerRequest(hostingerApiKey, '/api/hosting/v1/domains/free-subdomains', { method: 'POST' });
+    },
+});
+export const hostingerVerifyDomainOwnership = tool({
+    description: 'Verify ownership of a domain and check if it is accessible for new websites. If not accessible, the response includes a TXT record to add to DNS. Skip for *.hostingersite.com subdomains.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+        domain: z.string().describe('Domain name to verify, e.g. "example.com"'),
+    }),
+    execute: async ({ hostingerApiKey, domain }) => {
+        return hostingerRequest(hostingerApiKey, '/api/hosting/v1/domains/verify-ownership', {
+            method: 'POST',
+            body: { domain },
+        });
+    },
+});
+//# sourceMappingURL=domains.js.map

package/dist/toolkits/hostinger/tools/hosting.d.ts

@@ -0,0 +1,17 @@
+export declare const hostingerListOrders: import("ai").Tool<{
+    perPage?: number | undefined;
+    page?: number | undefined;
+    statuses?: string[] | undefined;
+    hostingerApiKey?: string | undefined;
+    orderIds?: number[] | undefined;
+}, any>;
+export declare const hostingerListWebsites: import("ai").Tool<{
+    perPage?: number | undefined;
+    page?: number | undefined;
+    username?: string | undefined;
+    domain?: string | undefined;
+    hostingerApiKey?: string | undefined;
+    orderId?: number | undefined;
+    isEnabled?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=hosting.d.ts.map

package/dist/toolkits/hostinger/tools/hosting.js

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { hostingerRequest } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const hostingerListOrders = tool({
+    description: 'List hosting orders (paginated), including shared-access accounts. Use to review orders; filter by status or order IDs.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+        page: z.number().int().min(1).optional().describe('Page number'),
+        perPage: z.number().int().min(1).max(100).optional().describe('Items per page (default 25)'),
+        statuses: z.array(z.string()).optional().describe('Filter by statuses, e.g. ["active", "suspended"]'),
+        orderIds: z.array(z.number().int()).optional().describe('Filter by specific order IDs'),
+    }),
+    execute: async ({ hostingerApiKey, page, perPage, statuses, orderIds }) => {
+        return hostingerRequest(hostingerApiKey, '/api/hosting/v1/orders', {
+            query: { page, per_page: perPage, statuses, order_ids: orderIds },
+        });
+    },
+});
+export const hostingerListWebsites = tool({
+    description: 'List websites (main and addon) accessible to the account, paginated. Use to review hosted sites; filter by domain, order, username, or enabled status.',
+    inputSchema: z.object({
+        hostingerApiKey: tokenField,
+        page: z.number().int().min(1).optional().describe('Page number'),
+        perPage: z.number().int().min(1).max(100).optional().describe('Items per page (1-100)'),
+        domain: z.string().optional().describe('Filter by exact domain name'),
+        orderId: z.number().int().optional().describe('Filter by order ID'),
+        username: z.string().optional().describe('Filter by hosting username'),
+        isEnabled: z.boolean().optional().describe('Filter by enabled status'),
+    }),
+    execute: async ({ hostingerApiKey, page, perPage, domain, orderId, username, isEnabled }) => {
+        return hostingerRequest(hostingerApiKey, '/api/hosting/v1/websites', {
+            query: { page, per_page: perPage, domain, order_id: orderId, username, is_enabled: isEnabled },
+        });
+    },
+});
+//# sourceMappingURL=hosting.js.map

package/dist/toolkits/hostinger/tools/index.d.ts

@@ -0,0 +1,179 @@
+import { hostingerCheckDomainAvailability, hostingerListDomains, hostingerGetDomainForwarding, hostingerGenerateFreeSubdomain, hostingerVerifyDomainOwnership } from './domains.js';
+import { hostingerCreateWhoisProfile, hostingerGetWhoisProfile, hostingerGetWhoisProfileUsage, hostingerListWhoisProfiles } from './whois.js';
+import { hostingerGetDnsRecords, hostingerValidateDnsRecords, hostingerListDnsSnapshots } from './dns.js';
+import { hostingerListVirtualMachines, hostingerListTemplates, hostingerGetTemplateDetails, hostingerListDataCenters, hostingerCreatePublicKey, hostingerListPublicKeys, hostingerDeletePublicKey } from './vps.js';
+import { hostingerListCatalogItems, hostingerListPaymentMethods, hostingerListSubscriptions } from './billing.js';
+import { hostingerListOrders, hostingerListWebsites } from './hosting.js';
+export { hostingerCheckDomainAvailability, hostingerListDomains, hostingerGetDomainForwarding, hostingerGenerateFreeSubdomain, hostingerVerifyDomainOwnership, hostingerCreateWhoisProfile, hostingerGetWhoisProfile, hostingerGetWhoisProfileUsage, hostingerListWhoisProfiles, hostingerGetDnsRecords, hostingerValidateDnsRecords, hostingerListDnsSnapshots, hostingerListVirtualMachines, hostingerListTemplates, hostingerGetTemplateDetails, hostingerListDataCenters, hostingerCreatePublicKey, hostingerListPublicKeys, hostingerDeletePublicKey, hostingerListCatalogItems, hostingerListPaymentMethods, hostingerListSubscriptions, hostingerListOrders, hostingerListWebsites, };
+export declare const hostingerTools: ({
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        domain: string;
+        tlds: string[];
+        hostingerApiKey?: string | undefined;
+        withAlternatives?: boolean | undefined;
+    }, any>;
+    requiredAuth: "hostingerApiKey";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        hostingerApiKey?: string | undefined;
+    }, any>;
+    requiredAuth: "hostingerApiKey";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        domain: string;
+        hostingerApiKey?: string | undefined;
+    }, any>;
+    requiredAuth: "hostingerApiKey";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        hostingerApiKey?: string | undefined;
+    }, any>;
+    requiredAuth: "hostingerApiKey";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        country: string;
+        tld: string;
+        entityType: "organization" | "individual";
+        whoisDetails: {
+            email: string;
+            address: string;
+            firstName: string;
+            lastName: string;
+            city: string;
+            country?: string | undefined;
+            state?: string | undefined;
+            countryCode?: string | undefined;
+            postalCode?: string | undefined;
+            companyName?: string | undefined;
+            phoneCc?: string | undefined;
+            phoneNumber?: string | undefined;
+        };
+        hostingerApiKey?: string | undefined;
+    }, any>;
+    requiredAuth: "hostingerApiKey";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        whoisId: number;
+        hostingerApiKey?: string | undefined;
+    }, any>;
+    requiredAuth: "hostingerApiKey";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        hostingerApiKey?: string | undefined;
+        tld?: string | undefined;
+    }, any>;
+    requiredAuth: "hostingerApiKey";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        domain: string;
+        zone: {
+            type: string;
+            name: string;
+            records: {
+                content: string;
+            }[];
+            ttl?: number | undefined;
+        }[];
+        overwrite?: boolean | undefined;
+        hostingerApiKey?: string | undefined;
+    }, any>;
+    requiredAuth: "hostingerApiKey";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        templateId: number;
+        hostingerApiKey?: string | undefined;
+    }, any>;
+    requiredAuth: "hostingerApiKey";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        name: string;
+        key: string;
+        hostingerApiKey?: string | undefined;
+    }, any>;
+    requiredAuth: "hostingerApiKey";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        page?: number | undefined;
+        hostingerApiKey?: string | undefined;
+    }, any>;
+    requiredAuth: "hostingerApiKey";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        publicKeyId: number;
+        hostingerApiKey?: string | undefined;
+    }, any>;
+    requiredAuth: "hostingerApiKey";
+    scope: "delete";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        name?: string | undefined;
+        hostingerApiKey?: string | undefined;
+        category?: "DOMAIN" | "VPS" | undefined;
+    }, any>;
+    requiredAuth: "hostingerApiKey";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        perPage?: number | undefined;
+        page?: number | undefined;
+        statuses?: string[] | undefined;
+        hostingerApiKey?: string | undefined;
+        orderIds?: number[] | undefined;
+    }, any>;
+    requiredAuth: "hostingerApiKey";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        perPage?: number | undefined;
+        page?: number | undefined;
+        username?: string | undefined;
+        domain?: string | undefined;
+        hostingerApiKey?: string | undefined;
+        orderId?: number | undefined;
+        isEnabled?: boolean | undefined;
+    }, any>;
+    requiredAuth: "hostingerApiKey";
+    scope: "read";
+})[];
+//# sourceMappingURL=index.d.ts.map

package/dist/toolkits/hostinger/tools/index.js

@@ -0,0 +1,35 @@
+// @ts-nocheck
+import { hostingerCheckDomainAvailability, hostingerListDomains, hostingerGetDomainForwarding, hostingerGenerateFreeSubdomain, hostingerVerifyDomainOwnership, } from './domains.js';
+import { hostingerCreateWhoisProfile, hostingerGetWhoisProfile, hostingerGetWhoisProfileUsage, hostingerListWhoisProfiles, } from './whois.js';
+import { hostingerGetDnsRecords, hostingerValidateDnsRecords, hostingerListDnsSnapshots } from './dns.js';
+import { hostingerListVirtualMachines, hostingerListTemplates, hostingerGetTemplateDetails, hostingerListDataCenters, hostingerCreatePublicKey, hostingerListPublicKeys, hostingerDeletePublicKey, } from './vps.js';
+import { hostingerListCatalogItems, hostingerListPaymentMethods, hostingerListSubscriptions } from './billing.js';
+import { hostingerListOrders, hostingerListWebsites } from './hosting.js';
+export { hostingerCheckDomainAvailability, hostingerListDomains, hostingerGetDomainForwarding, hostingerGenerateFreeSubdomain, hostingerVerifyDomainOwnership, hostingerCreateWhoisProfile, hostingerGetWhoisProfile, hostingerGetWhoisProfileUsage, hostingerListWhoisProfiles, hostingerGetDnsRecords, hostingerValidateDnsRecords, hostingerListDnsSnapshots, hostingerListVirtualMachines, hostingerListTemplates, hostingerGetTemplateDetails, hostingerListDataCenters, hostingerCreatePublicKey, hostingerListPublicKeys, hostingerDeletePublicKey, hostingerListCatalogItems, hostingerListPaymentMethods, hostingerListSubscriptions, hostingerListOrders, hostingerListWebsites, };
+export const hostingerTools = [
+    { name: 'HostingerCheckDomainAvailability', description: hostingerCheckDomainAvailability.description, tool: hostingerCheckDomainAvailability, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerListDomains', description: hostingerListDomains.description, tool: hostingerListDomains, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerGetDomainForwarding', description: hostingerGetDomainForwarding.description, tool: hostingerGetDomainForwarding, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerGenerateFreeSubdomain', description: hostingerGenerateFreeSubdomain.description, tool: hostingerGenerateFreeSubdomain, requiredAuth: 'hostingerApiKey', scope: 'write' },
+    { name: 'HostingerVerifyDomainOwnership', description: hostingerVerifyDomainOwnership.description, tool: hostingerVerifyDomainOwnership, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerCreateWhoisProfile', description: hostingerCreateWhoisProfile.description, tool: hostingerCreateWhoisProfile, requiredAuth: 'hostingerApiKey', scope: 'write' },
+    { name: 'HostingerGetWhoisProfile', description: hostingerGetWhoisProfile.description, tool: hostingerGetWhoisProfile, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerGetWhoisProfileUsage', description: hostingerGetWhoisProfileUsage.description, tool: hostingerGetWhoisProfileUsage, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerListWhoisProfiles', description: hostingerListWhoisProfiles.description, tool: hostingerListWhoisProfiles, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerGetDnsRecords', description: hostingerGetDnsRecords.description, tool: hostingerGetDnsRecords, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerValidateDnsRecords', description: hostingerValidateDnsRecords.description, tool: hostingerValidateDnsRecords, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerListDnsSnapshots', description: hostingerListDnsSnapshots.description, tool: hostingerListDnsSnapshots, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerListVirtualMachines', description: hostingerListVirtualMachines.description, tool: hostingerListVirtualMachines, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerListTemplates', description: hostingerListTemplates.description, tool: hostingerListTemplates, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerGetTemplateDetails', description: hostingerGetTemplateDetails.description, tool: hostingerGetTemplateDetails, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerListDataCenters', description: hostingerListDataCenters.description, tool: hostingerListDataCenters, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerCreatePublicKey', description: hostingerCreatePublicKey.description, tool: hostingerCreatePublicKey, requiredAuth: 'hostingerApiKey', scope: 'write' },
+    { name: 'HostingerListPublicKeys', description: hostingerListPublicKeys.description, tool: hostingerListPublicKeys, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerDeletePublicKey', description: hostingerDeletePublicKey.description, tool: hostingerDeletePublicKey, requiredAuth: 'hostingerApiKey', scope: 'delete' },
+    { name: 'HostingerListCatalogItems', description: hostingerListCatalogItems.description, tool: hostingerListCatalogItems, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerListPaymentMethods', description: hostingerListPaymentMethods.description, tool: hostingerListPaymentMethods, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerListSubscriptions', description: hostingerListSubscriptions.description, tool: hostingerListSubscriptions, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerListOrders', description: hostingerListOrders.description, tool: hostingerListOrders, requiredAuth: 'hostingerApiKey', scope: 'read' },
+    { name: 'HostingerListWebsites', description: hostingerListWebsites.description, tool: hostingerListWebsites, requiredAuth: 'hostingerApiKey', scope: 'read' },
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/hostinger/tools/vps.d.ts

@@ -0,0 +1,27 @@
+export declare const hostingerListVirtualMachines: import("ai").Tool<{
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerListTemplates: import("ai").Tool<{
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerGetTemplateDetails: import("ai").Tool<{
+    templateId: number;
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerListDataCenters: import("ai").Tool<{
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerCreatePublicKey: import("ai").Tool<{
+    name: string;
+    key: string;
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerListPublicKeys: import("ai").Tool<{
+    page?: number | undefined;
+    hostingerApiKey?: string | undefined;
+}, any>;
+export declare const hostingerDeletePublicKey: import("ai").Tool<{
+    publicKeyId: number;
+    hostingerApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=vps.d.ts.map