@astro-api/n8n-nodes-astrology 0.7.1 → 0.8.1

package/dist/nodes/Astrology/Astrology.node.js

@@ -22,6 +22,23 @@ const resourceHandlers = {
     humanDesign: handlers_1.handleHumanDesignResource,
     numerology: handlers_1.handleNumerologyResource,
     tarot: handlers_1.handleTarotResource,
+    lunar: handlers_1.handleLunarResource,
+    vedic: handlers_1.handleVedicResource,
+    analysis: handlers_1.handleAnalysisResource,
+    render: handlers_1.handleRenderResource,
+    insights: handlers_1.handleInsightsResource,
+    traditional: handlers_1.handleTraditionalResource,
+    astrocartography: handlers_1.handleAstrocartographyResource,
+    chinese: handlers_1.handleChineseResource,
+    kabbalah: handlers_1.handleKabbalahResource,
+    glossary: handlers_1.handleGlossaryResource,
+    horary: handlers_1.handleHoraryResource,
+    fengshui: handlers_1.handleFengshuiResource,
+    fixedStars: handlers_1.handleFixedStarsResource,
+    enhanced: handlers_1.handleEnhancedResource,
+    pdf: handlers_1.handlePdfResource,
+    eclipses: handlers_1.handleEclipsesResource,
+    ziwei: handlers_1.handleZiweiResource,
 };
 class Astrology {
     constructor() {
@@ -53,6 +70,23 @@ class Astrology {
                 ...operations_1.humanDesignOperations,
                 ...operations_1.numerologyOperations,
                 ...operations_1.tarotOperations,
+                ...operations_1.lunarOperations,
+                ...operations_1.vedicOperations,
+                ...operations_1.analysisOperations,
+                ...operations_1.renderOperations,
+                ...operations_1.insightsOperations,
+                ...operations_1.traditionalOperations,
+                ...operations_1.astrocartographyOperations,
+                ...operations_1.chineseOperations,
+                ...operations_1.kabbalahOperations,
+                ...operations_1.glossaryOperations,
+                ...operations_1.horaryOperations,
+                ...operations_1.fengshuiOperations,
+                ...operations_1.fixedStarsOperations,
+                ...operations_1.enhancedOperations,
+                ...operations_1.pdfOperations,
+                ...operations_1.eclipsesOperations,
+                ...operations_1.ziweiOperations,
             ],
         };
     }
@@ -79,20 +113,23 @@ class Astrology {
                     throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The resource '${resource}' is not supported`, { itemIndex });
                 }
                 const responseData = await handler(context, operation);
-                returnData.push(responseData);
+                returnData.push({
+                    json: responseData,
+                    pairedItem: { item: itemIndex },
+                });
             }
             catch (error) {
                 if (this.continueOnFail()) {
                     returnData.push({
-                        error: error.message,
-                        itemIndex,
+                        json: { error: error.message },
+                        pairedItem: { item: itemIndex },
                     });
                     continue;
                 }
                 throw error;
             }
         }
-        return [this.helpers.returnJsonArray(returnData)];
+        return [returnData];
     }
 }
 exports.Astrology = Astrology;

package/dist/nodes/Astrology/handlers/analysis.handler.d.ts

@@ -0,0 +1,10 @@
+import type { IDataObject } from "n8n-workflow";
+import type { IHandlerContext } from "../interfaces/types";
+/**
+ * Handles all analysis resource operations
+ *
+ * @param context - Handler context with execution functions and credentials
+ * @param operation - The operation to execute
+ * @returns API response data
+ */
+export declare function handleAnalysisResource(context: IHandlerContext, operation: string): Promise<IDataObject>;

package/dist/nodes/Astrology/handlers/analysis.handler.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAnalysisResource = handleAnalysisResource;
+const helpers_1 = require("../shared/helpers");
+/**
+ * Endpoint mapping for analysis operations
+ */
+const ANALYSIS_ENDPOINTS = {
+    natalReport: "/api/v3/analysis/natal-report",
+    synastryReport: "/api/v3/analysis/synastry-report",
+    transitReport: "/api/v3/analysis/transit-report",
+    compositeReport: "/api/v3/analysis/composite-report",
+    solarReturnReport: "/api/v3/analysis/solar-return-report",
+    lunarReturnReport: "/api/v3/analysis/lunar-return-report",
+    progressionReport: "/api/v3/analysis/progression-report",
+    directionReport: "/api/v3/analysis/direction-report",
+    natalTransitReport: "/api/v3/analysis/natal-transit-report",
+    solarReturnTransitReport: "/api/v3/analysis/solar-return-transit-report",
+    lunarReturnTransitReport: "/api/v3/analysis/lunar-return-transit-report",
+    lunarAnalysis: "/api/v3/analysis/lunar-analysis",
+    compatibility: "/api/v3/analysis/compatibility",
+    compatibilityScore: "/api/v3/analysis/compatibility-score",
+    relationship: "/api/v3/analysis/relationship",
+    relationshipScore: "/api/v3/analysis/relationship-score",
+    career: "/api/v3/analysis/career",
+    vocational: "/api/v3/analysis/vocational",
+    health: "/api/v3/analysis/health",
+    psychological: "/api/v3/analysis/psychological",
+    spiritual: "/api/v3/analysis/spiritual",
+    karmic: "/api/v3/analysis/karmic",
+    predictive: "/api/v3/analysis/predictive",
+    relocation: "/api/v3/analysis/relocation",
+};
+/**
+ * Operations that require two subjects
+ */
+const TWO_SUBJECT_OPERATIONS = [
+    "synastryReport",
+    "compositeReport",
+    "compatibility",
+    "compatibilityScore",
+    "relationship",
+    "relationshipScore",
+];
+/**
+ * Operations that require transit time
+ */
+const TRANSIT_OPERATIONS = [
+    "transitReport",
+    "natalTransitReport",
+    "solarReturnTransitReport",
+    "lunarReturnTransitReport",
+];
+/**
+ * Builds report options from node parameters
+ */
+function buildReportOptions(context) {
+    const { executeFunctions, itemIndex } = context;
+    const reportOptions = {};
+    // Tradition (Western/Vedic)
+    const tradition = executeFunctions.getNodeParameter("tradition", itemIndex, "western");
+    if (tradition) {
+        reportOptions.tradition = tradition;
+    }
+    // Language
+    const language = executeFunctions.getNodeParameter("language", itemIndex, "en");
+    if (language) {
+        reportOptions.language = language;
+    }
+    return reportOptions;
+}
+/**
+ * Handles all analysis resource operations
+ *
+ * @param context - Handler context with execution functions and credentials
+ * @param operation - The operation to execute
+ * @returns API response data
+ */
+async function handleAnalysisResource(context, operation) {
+    const { executeFunctions, itemIndex, baseUrl, apiKey } = context;
+    const op = operation;
+    const birthData = (0, helpers_1.buildBirthData)(executeFunctions, itemIndex);
+    const reportOptions = buildReportOptions(context);
+    const includeAspectPatterns = executeFunctions.getNodeParameter("includeAspectPatterns", itemIndex, false);
+    const endpoint = ANALYSIS_ENDPOINTS[op] || ANALYSIS_ENDPOINTS.natalReport;
+    let body;
+    // Two-subject operations
+    if (TWO_SUBJECT_OPERATIONS.includes(op)) {
+        const secondBirthData = (0, helpers_1.buildSecondSubjectBirthData)(executeFunctions, itemIndex);
+        body = {
+            subject1: {
+                birth_data: birthData,
+            },
+            subject2: {
+                birth_data: secondBirthData,
+            },
+            report_options: reportOptions,
+            include_aspect_patterns: includeAspectPatterns,
+        };
+    }
+    // Transit operations
+    else if (TRANSIT_OPERATIONS.includes(op)) {
+        const transitTime = (0, helpers_1.buildTransitTime)(executeFunctions, itemIndex);
+        // Check if date range is provided
+        let startDate;
+        let endDate;
+        try {
+            startDate = executeFunctions.getNodeParameter("startDate", itemIndex, "");
+            endDate = executeFunctions.getNodeParameter("endDate", itemIndex, "");
+        }
+        catch {
+            // Date range fields may not be available for all transit operations
+        }
+        body = {
+            ...(0, helpers_1.createSubjectRequest)(birthData),
+            transit_time: {
+                datetime: transitTime,
+            },
+            report_options: reportOptions,
+            include_aspect_patterns: includeAspectPatterns,
+        };
+        if (startDate && endDate) {
+            body.start_date = startDate;
+            body.end_date = endDate;
+        }
+    }
+    // Single subject operations
+    else {
+        body = {
+            ...(0, helpers_1.createSubjectRequest)(birthData),
+            report_options: reportOptions,
+            include_aspect_patterns: includeAspectPatterns,
+        };
+    }
+    const responseData = await (0, helpers_1.makeApiRequest)(executeFunctions, "POST", baseUrl, endpoint, apiKey, body);
+    return (0, helpers_1.applySimplifyIfEnabled)(executeFunctions, itemIndex, responseData);
+}

package/dist/nodes/Astrology/handlers/astrocartography.handler.d.ts

@@ -0,0 +1,10 @@
+import type { IDataObject } from "n8n-workflow";
+import type { IHandlerContext } from "../interfaces/types";
+/**
+ * Handles all astrocartography resource operations
+ *
+ * @param context - Handler context with execution functions and credentials
+ * @param operation - The operation to execute
+ * @returns API response data
+ */
+export declare function handleAstrocartographyResource(context: IHandlerContext, operation: string): Promise<IDataObject>;

package/dist/nodes/Astrology/handlers/astrocartography.handler.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAstrocartographyResource = handleAstrocartographyResource;
+const helpers_1 = require("../shared/helpers");
+/**
+ * Endpoint mapping for astrocartography operations
+ */
+const ASTROCARTOGRAPHY_ENDPOINTS = {
+    supportedFeatures: "/api/v3/astrocartography/supported-features",
+    lineMeanings: "/api/v3/astrocartography/line-meanings",
+    map: "/api/v3/astrocartography/map",
+    render: "/api/v3/astrocartography/render",
+    lines: "/api/v3/astrocartography/lines",
+    locationAnalysis: "/api/v3/astrocartography/location-analysis",
+    searchLocations: "/api/v3/astrocartography/search-locations",
+    compareLocations: "/api/v3/astrocartography/compare-locations",
+    relocationChart: "/api/v3/astrocartography/relocation-chart",
+    powerZones: "/api/v3/astrocartography/power-zones",
+    paranMap: "/api/v3/astrocartography/paran-map",
+    astrodynes: "/api/v3/astrocartography/astrodynes",
+    astrodynesCompare: "/api/v3/astrocartography/astrodynes/compare",
+};
+/**
+ * GET operations (no body required)
+ */
+const GET_OPERATIONS = [
+    "supportedFeatures",
+    "lineMeanings",
+];
+/**
+ * Operations that use planets selection
+ */
+const PLANETS_OPERATIONS = [
+    "map",
+    "render",
+    "lines",
+    "paranMap",
+];
+/**
+ * Operations that use line types
+ */
+const LINE_TYPES_OPERATIONS = [
+    "map",
+    "render",
+    "lines",
+];
+/**
+ * Operations that use target location
+ */
+const TARGET_LOCATION_OPERATIONS = [
+    "locationAnalysis",
+    "relocationChart",
+    "astrodynes",
+];
+/**
+ * Operations that use map visual options
+ */
+const MAP_VISUAL_OPERATIONS = [
+    "map",
+    "render",
+    "paranMap",
+];
+/**
+ * Builds map options from node parameters
+ */
+function buildMapOptions(context, op) {
+    const { executeFunctions, itemIndex } = context;
+    const mapOptions = {};
+    if (PLANETS_OPERATIONS.includes(op)) {
+        const planets = executeFunctions.getNodeParameter("acPlanets", itemIndex, [
+            "Sun",
+            "Moon",
+            "Venus",
+            "Mars",
+            "Jupiter",
+        ]);
+        mapOptions.planets = planets;
+    }
+    if (LINE_TYPES_OPERATIONS.includes(op)) {
+        const lineTypes = executeFunctions.getNodeParameter("lineTypes", itemIndex, ["AC", "MC"]);
+        mapOptions.line_types = lineTypes;
+    }
+    if (op === "lines") {
+        const coordinatePrecision = executeFunctions.getNodeParameter("coordinatePrecision", itemIndex, 4);
+        mapOptions.coordinate_precision = coordinatePrecision;
+    }
+    return mapOptions;
+}
+/**
+ * Builds visual options from node parameters
+ */
+function buildVisualOptions(context) {
+    const { executeFunctions, itemIndex } = context;
+    const theme = executeFunctions.getNodeParameter("mapTheme", itemIndex, "light");
+    const width = executeFunctions.getNodeParameter("mapWidth", itemIndex, 1200);
+    const height = executeFunctions.getNodeParameter("mapHeight", itemIndex, 800);
+    return {
+        theme,
+        width,
+        height,
+    };
+}
+/**
+ * Builds target location from node parameters
+ */
+function buildTargetLocation(context) {
+    const { executeFunctions, itemIndex } = context;
+    const city = executeFunctions.getNodeParameter("targetCity", itemIndex, "");
+    const countryCode = executeFunctions.getNodeParameter("targetCountryCode", itemIndex, "");
+    const latitude = executeFunctions.getNodeParameter("targetLatitude", itemIndex, 0);
+    const longitude = executeFunctions.getNodeParameter("targetLongitude", itemIndex, 0);
+    const location = {};
+    if (city)
+        location.city = city;
+    if (countryCode)
+        location.country_code = countryCode;
+    if (latitude !== 0)
+        location.latitude = latitude;
+    if (longitude !== 0)
+        location.longitude = longitude;
+    return location;
+}
+/**
+ * Handles all astrocartography resource operations
+ *
+ * @param context - Handler context with execution functions and credentials
+ * @param operation - The operation to execute
+ * @returns API response data
+ */
+async function handleAstrocartographyResource(context, operation) {
+    const { executeFunctions, itemIndex, baseUrl, apiKey } = context;
+    const op = operation;
+    const endpoint = ASTROCARTOGRAPHY_ENDPOINTS[op] || ASTROCARTOGRAPHY_ENDPOINTS.map;
+    // GET operations - no body
+    if (GET_OPERATIONS.includes(op)) {
+        const responseData = await (0, helpers_1.makeApiRequest)(executeFunctions, "GET", baseUrl, endpoint, apiKey);
+        return (0, helpers_1.applySimplifyIfEnabled)(executeFunctions, itemIndex, responseData);
+    }
+    // POST operations with birth data
+    const birthData = (0, helpers_1.buildBirthData)(executeFunctions, itemIndex);
+    const body = {
+        ...(0, helpers_1.createSubjectRequest)(birthData),
+    };
+    // Add map options
+    const mapOptions = buildMapOptions(context, op);
+    if (Object.keys(mapOptions).length > 0) {
+        body.map_options = mapOptions;
+    }
+    // Add coordinate density for lines operation
+    if (op === "lines") {
+        const coordinateDensity = executeFunctions.getNodeParameter("coordinateDensity", itemIndex, 100);
+        body.coordinate_density = coordinateDensity;
+    }
+    // Add visual options
+    if (MAP_VISUAL_OPERATIONS.includes(op)) {
+        body.visual_options = buildVisualOptions(context);
+    }
+    // Add target location
+    if (TARGET_LOCATION_OPERATIONS.includes(op)) {
+        const targetLocation = buildTargetLocation(context);
+        if (Object.keys(targetLocation).length > 0) {
+            body.target_location = targetLocation;
+        }
+    }
+    // Add power type for power zones and search
+    if (op === "powerZones" || op === "searchLocations") {
+        const powerType = executeFunctions.getNodeParameter("powerType", itemIndex, "overall");
+        body.power_type = powerType;
+    }
+    const responseData = await (0, helpers_1.makeApiRequest)(executeFunctions, "POST", baseUrl, endpoint, apiKey, body);
+    return (0, helpers_1.applySimplifyIfEnabled)(executeFunctions, itemIndex, responseData);
+}

package/dist/nodes/Astrology/handlers/chinese.handler.d.ts

@@ -0,0 +1,10 @@
+import type { IDataObject } from "n8n-workflow";
+import type { IHandlerContext } from "../interfaces/types";
+/**
+ * Handles all chinese resource operations
+ *
+ * @param context - Handler context with execution functions and credentials
+ * @param operation - The operation to execute
+ * @returns API response data
+ */
+export declare function handleChineseResource(context: IHandlerContext, operation: string): Promise<IDataObject>;

package/dist/nodes/Astrology/handlers/chinese.handler.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleChineseResource = handleChineseResource;
+const helpers_1 = require("../shared/helpers");
+/**
+ * Endpoint mapping for chinese operations
+ */
+const CHINESE_ENDPOINTS = {
+    zodiacAnimal: "/api/v3/chinese/zodiac", // + /{animal}
+    solarTerms: "/api/v3/chinese/calendar/solar-terms", // + /{year}
+    elementsBalance: "/api/v3/chinese/elements/balance", // + /{year}
+    bazi: "/api/v3/chinese/bazi",
+    compatibility: "/api/v3/chinese/compatibility",
+    luckPillars: "/api/v3/chinese/luck-pillars",
+    mingGua: "/api/v3/chinese/ming-gua",
+    yearlyForecast: "/api/v3/chinese/yearly-forecast",
+};
+/**
+ * GET operations with path parameters
+ */
+const GET_WITH_PATH_OPERATIONS = [
+    "zodiacAnimal",
+    "solarTerms",
+    "elementsBalance",
+];
+/**
+ * Operations that require birth data
+ */
+const BIRTH_DATA_OPERATIONS = [
+    "bazi",
+    "luckPillars",
+    "mingGua",
+    "yearlyForecast",
+];
+/**
+ * Handles all chinese resource operations
+ *
+ * @param context - Handler context with execution functions and credentials
+ * @param operation - The operation to execute
+ * @returns API response data
+ */
+async function handleChineseResource(context, operation) {
+    const { executeFunctions, itemIndex, baseUrl, apiKey } = context;
+    const op = operation;
+    // GET operations with path parameters
+    if (GET_WITH_PATH_OPERATIONS.includes(op)) {
+        let endpoint = CHINESE_ENDPOINTS[op];
+        if (op === "zodiacAnimal") {
+            const animal = executeFunctions.getNodeParameter("zodiacAnimal", itemIndex, "dragon");
+            endpoint = `${endpoint}/${animal}`;
+        }
+        else if (op === "solarTerms" || op === "elementsBalance") {
+            const year = executeFunctions.getNodeParameter("chineseYear", itemIndex, 2024);
+            endpoint = `${endpoint}/${year}`;
+        }
+        const responseData = await (0, helpers_1.makeApiRequest)(executeFunctions, "GET", baseUrl, endpoint, apiKey);
+        return (0, helpers_1.applySimplifyIfEnabled)(executeFunctions, itemIndex, responseData);
+    }
+    // Compatibility operation - two subjects
+    if (op === "compatibility") {
+        const birthData = (0, helpers_1.buildBirthData)(executeFunctions, itemIndex);
+        const secondBirthData = (0, helpers_1.buildSecondSubjectBirthData)(executeFunctions, itemIndex);
+        const language = executeFunctions.getNodeParameter("language", itemIndex, "en");
+        const body = {
+            subject1: {
+                birth_data: birthData,
+            },
+            subject2: {
+                birth_data: secondBirthData,
+            },
+            language,
+        };
+        const responseData = await (0, helpers_1.makeApiRequest)(executeFunctions, "POST", baseUrl, CHINESE_ENDPOINTS[op], apiKey, body);
+        return (0, helpers_1.applySimplifyIfEnabled)(executeFunctions, itemIndex, responseData);
+    }
+    // Birth data operations
+    if (BIRTH_DATA_OPERATIONS.includes(op)) {
+        const birthData = (0, helpers_1.buildBirthData)(executeFunctions, itemIndex);
+        const language = executeFunctions.getNodeParameter("language", itemIndex, "en");
+        const body = {
+            subject: {
+                birth_data: birthData,
+            },
+            language,
+        };
+        // BaZi specific options
+        if (op === "bazi") {
+            const gender = executeFunctions.getNodeParameter("gender", itemIndex, "male");
+            const includeLuckPillars = executeFunctions.getNodeParameter("includeLuckPillars", itemIndex, false);
+            const includeAnnualPillars = executeFunctions.getNodeParameter("includeAnnualPillars", itemIndex, false);
+            const tradition = executeFunctions.getNodeParameter("chineseTradition", itemIndex, "classical");
+            const analysisDepth = executeFunctions.getNodeParameter("analysisDepth", itemIndex, "standard");
+            body.subject.gender = gender;
+            body.include_luck_pillars = includeLuckPillars;
+            body.include_annual_pillars = includeAnnualPillars;
+            body.tradition = tradition;
+            body.analysis_depth = analysisDepth;
+        }
+        // Luck pillars specific options
+        if (op === "luckPillars") {
+            const gender = executeFunctions.getNodeParameter("gender", itemIndex, "male");
+            body.subject.gender = gender;
+        }
+        // Yearly forecast specific options
+        if (op === "yearlyForecast") {
+            const tradition = executeFunctions.getNodeParameter("chineseTradition", itemIndex, "classical");
+            const analysisDepth = executeFunctions.getNodeParameter("analysisDepth", itemIndex, "standard");
+            body.tradition = tradition;
+            body.analysis_depth = analysisDepth;
+        }
+        const responseData = await (0, helpers_1.makeApiRequest)(executeFunctions, "POST", baseUrl, CHINESE_ENDPOINTS[op], apiKey, body);
+        return (0, helpers_1.applySimplifyIfEnabled)(executeFunctions, itemIndex, responseData);
+    }
+    // Fallback
+    const responseData = await (0, helpers_1.makeApiRequest)(executeFunctions, "POST", baseUrl, CHINESE_ENDPOINTS[op] || CHINESE_ENDPOINTS.bazi, apiKey, {});
+    return (0, helpers_1.applySimplifyIfEnabled)(executeFunctions, itemIndex, responseData);
+}

package/dist/nodes/Astrology/handlers/eclipses.handler.d.ts

@@ -0,0 +1,10 @@
+import type { IDataObject } from "n8n-workflow";
+import type { IHandlerContext } from "../interfaces/types";
+/**
+ * Handles all eclipses resource operations
+ *
+ * @param context - Handler context with execution functions and credentials
+ * @param operation - The operation to execute
+ * @returns API response data
+ */
+export declare function handleEclipsesResource(context: IHandlerContext, operation: string): Promise<IDataObject>;

package/dist/nodes/Astrology/handlers/eclipses.handler.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleEclipsesResource = handleEclipsesResource;
+const helpers_1 = require("../shared/helpers");
+/**
+ * Endpoint mapping for eclipses operations
+ */
+const ECLIPSES_ENDPOINTS = {
+    upcoming: "/api/v3/eclipses/upcoming",
+    natalCheck: "/api/v3/eclipses/natal-check",
+    interpretation: "/api/v3/eclipses/interpretation",
+};
+/**
+ * Handles all eclipses resource operations
+ *
+ * @param context - Handler context with execution functions and credentials
+ * @param operation - The operation to execute
+ * @returns API response data
+ */
+async function handleEclipsesResource(context, operation) {
+    const { executeFunctions, itemIndex, baseUrl, apiKey } = context;
+    const op = operation;
+    const endpoint = ECLIPSES_ENDPOINTS[op] || ECLIPSES_ENDPOINTS.upcoming;
+    // Handle upcoming (GET)
+    if (op === "upcoming") {
+        const count = executeFunctions.getNodeParameter("count", itemIndex, 10);
+        const finalEndpoint = `${endpoint}?count=${count}`;
+        const responseData = await (0, helpers_1.makeApiRequest)(executeFunctions, "GET", baseUrl, finalEndpoint, apiKey);
+        return (0, helpers_1.applySimplifyIfEnabled)(executeFunctions, itemIndex, responseData);
+    }
+    // Handle natalCheck (POST)
+    if (op === "natalCheck") {
+        const birthData = (0, helpers_1.buildBirthData)(executeFunctions, itemIndex);
+        const startYear = executeFunctions.getNodeParameter("startYear", itemIndex);
+        const startMonth = executeFunctions.getNodeParameter("startMonth", itemIndex);
+        const startDay = executeFunctions.getNodeParameter("startDay", itemIndex);
+        const endYear = executeFunctions.getNodeParameter("endYear", itemIndex);
+        const endMonth = executeFunctions.getNodeParameter("endMonth", itemIndex);
+        const endDay = executeFunctions.getNodeParameter("endDay", itemIndex);
+        const maxOrb = executeFunctions.getNodeParameter("maxOrb", itemIndex, 5);
+        const body = {
+            subject: {
+                birth_data: birthData,
+            },
+            date_range: {
+                start_date: {
+                    year: startYear,
+                    month: startMonth,
+                    day: startDay,
+                },
+                end_date: {
+                    year: endYear,
+                    month: endMonth,
+                    day: endDay,
+                },
+            },
+            max_orb: maxOrb,
+        };
+        const responseData = await (0, helpers_1.makeApiRequest)(executeFunctions, "POST", baseUrl, endpoint, apiKey, body);
+        return (0, helpers_1.applySimplifyIfEnabled)(executeFunctions, itemIndex, responseData);
+    }
+    // Handle interpretation (POST)
+    if (op === "interpretation") {
+        const eclipseId = executeFunctions.getNodeParameter("eclipseId", itemIndex, "");
+        const language = executeFunctions.getNodeParameter("language", itemIndex, "en");
+        const includePersonal = executeFunctions.getNodeParameter("includePersonal", itemIndex, false);
+        const body = {
+            eclipse_id: eclipseId,
+            language,
+        };
+        // Add optional birth data for personal interpretation
+        if (includePersonal) {
+            const birthYear = executeFunctions.getNodeParameter("birthYear", itemIndex);
+            const birthMonth = executeFunctions.getNodeParameter("birthMonth", itemIndex);
+            const birthDay = executeFunctions.getNodeParameter("birthDay", itemIndex);
+            const birthHour = executeFunctions.getNodeParameter("birthHour", itemIndex);
+            const birthMinute = executeFunctions.getNodeParameter("birthMinute", itemIndex);
+            const birthCity = executeFunctions.getNodeParameter("birthCity", itemIndex);
+            const birthCountryCode = executeFunctions.getNodeParameter("birthCountryCode", itemIndex);
+            body.birth_data = {
+                year: birthYear,
+                month: birthMonth,
+                day: birthDay,
+                hour: birthHour,
+                minute: birthMinute,
+                city: birthCity,
+                country_code: birthCountryCode,
+            };
+        }
+        const responseData = await (0, helpers_1.makeApiRequest)(executeFunctions, "POST", baseUrl, endpoint, apiKey, body);
+        return (0, helpers_1.applySimplifyIfEnabled)(executeFunctions, itemIndex, responseData);
+    }
+    // Fallback
+    const responseData = await (0, helpers_1.makeApiRequest)(executeFunctions, "GET", baseUrl, endpoint, apiKey);
+    return (0, helpers_1.applySimplifyIfEnabled)(executeFunctions, itemIndex, responseData);
+}

package/dist/nodes/Astrology/handlers/enhanced.handler.d.ts

@@ -0,0 +1,10 @@
+import type { IDataObject } from "n8n-workflow";
+import type { IHandlerContext } from "../interfaces/types";
+/**
+ * Handles all enhanced resource operations
+ *
+ * @param context - Handler context with execution functions and credentials
+ * @param operation - The operation to execute
+ * @returns API response data
+ */
+export declare function handleEnhancedResource(context: IHandlerContext, operation: string): Promise<IDataObject>;