@astro-api/n8n-nodes-astrology 0.6.0 → 0.7.0

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

@@ -21,6 +21,7 @@ const resourceHandlers = {
     charts: handlers_1.handleChartsResource,
     humanDesign: handlers_1.handleHumanDesignResource,
     numerology: handlers_1.handleNumerologyResource,
+    tarot: handlers_1.handleTarotResource,
 };
 class Astrology {
     constructor() {
@@ -51,6 +52,7 @@ class Astrology {
                 ...operations_1.chartsOperations,
                 ...operations_1.humanDesignOperations,
                 ...operations_1.numerologyOperations,
+                ...operations_1.tarotOperations,
             ],
         };
     }

package/dist/nodes/Astrology/handlers/index.d.ts

@@ -3,3 +3,4 @@ export { handleHoroscopeResource } from "./horoscope.handler";
 export { handleChartsResource } from "./charts.handler";
 export { handleHumanDesignResource } from "./humanDesign.handler";
 export { handleNumerologyResource } from "./numerology.handler";
+export { handleTarotResource } from "./tarot.handler";

package/dist/nodes/Astrology/handlers/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleNumerologyResource = exports.handleHumanDesignResource = exports.handleChartsResource = exports.handleHoroscopeResource = exports.handleDataResource = void 0;
+exports.handleTarotResource = exports.handleNumerologyResource = exports.handleHumanDesignResource = exports.handleChartsResource = exports.handleHoroscopeResource = exports.handleDataResource = void 0;
 var data_handler_1 = require("./data.handler");
 Object.defineProperty(exports, "handleDataResource", { enumerable: true, get: function () { return data_handler_1.handleDataResource; } });
 var horoscope_handler_1 = require("./horoscope.handler");
@@ -11,3 +11,5 @@ var humanDesign_handler_1 = require("./humanDesign.handler");
 Object.defineProperty(exports, "handleHumanDesignResource", { enumerable: true, get: function () { return humanDesign_handler_1.handleHumanDesignResource; } });
 var numerology_handler_1 = require("./numerology.handler");
 Object.defineProperty(exports, "handleNumerologyResource", { enumerable: true, get: function () { return numerology_handler_1.handleNumerologyResource; } });
+var tarot_handler_1 = require("./tarot.handler");
+Object.defineProperty(exports, "handleTarotResource", { enumerable: true, get: function () { return tarot_handler_1.handleTarotResource; } });

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

@@ -0,0 +1,6 @@
+import type { IDataObject } from "n8n-workflow";
+import type { IHandlerContext } from "../interfaces/types";
+/**
+ * Handles all Tarot resource operations
+ */
+export declare function handleTarotResource(context: IHandlerContext, operation: string): Promise<IDataObject>;

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

@@ -0,0 +1,387 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleTarotResource = handleTarotResource;
+const shared_1 = require("../shared");
+/**
+ * Endpoint mapping for Tarot operations
+ */
+const TAROT_ENDPOINTS = {
+    // Glossary (GET)
+    glossaryCards: "/api/v3/tarot/glossary/cards",
+    glossarySpreads: "/api/v3/tarot/glossary/spreads",
+    glossaryCardDetail: "/api/v3/tarot/glossary/cards/{card_id}",
+    searchCards: "/api/v3/tarot/cards/search",
+    dailyCard: "/api/v3/tarot/cards/daily",
+    // Draw (POST)
+    drawCards: "/api/v3/tarot/cards/draw",
+    // Reports (POST)
+    reportSingle: "/api/v3/tarot/reports/single",
+    reportThreeCard: "/api/v3/tarot/reports/three-card",
+    reportCelticCross: "/api/v3/tarot/reports/celtic-cross",
+    reportSynastry: "/api/v3/tarot/reports/synastry",
+    reportHouses: "/api/v3/tarot/reports/houses",
+    reportTreeOfLife: "/api/v3/tarot/reports/tree-of-life",
+    // Analysis (POST)
+    analysisQuintessence: "/api/v3/tarot/analysis/quintessence",
+    analysisBirthCards: "/api/v3/tarot/analysis/birth-cards",
+    analysisDignities: "/api/v3/tarot/analysis/dignities",
+    analysisTiming: "/api/v3/tarot/analysis/timing",
+    analysisOptimalTimes: "/api/v3/tarot/analysis/optimal-times",
+    analysisTransitReport: "/api/v3/tarot/analysis/transit-report",
+    analysisNatalReport: "/api/v3/tarot/analysis/natal-report",
+};
+/**
+ * Handles all Tarot resource operations
+ */
+async function handleTarotResource(context, operation) {
+    const op = operation;
+    switch (op) {
+        // Glossary operations (GET)
+        case "glossaryCards":
+            return handleGlossaryCards(context);
+        case "glossarySpreads":
+            return handleGlossarySpreads(context);
+        case "glossaryCardDetail":
+            return handleGlossaryCardDetail(context);
+        case "searchCards":
+            return handleSearchCards(context);
+        case "dailyCard":
+            return handleDailyCard(context);
+        // Draw operation (POST)
+        case "drawCards":
+            return handleDrawCards(context);
+        // Report operations (POST)
+        case "reportSingle":
+        case "reportThreeCard":
+        case "reportCelticCross":
+        case "reportHouses":
+        case "reportTreeOfLife":
+            return handleReport(context, op);
+        case "reportSynastry":
+            return handleReportSynastry(context);
+        // Analysis operations (POST)
+        case "analysisQuintessence":
+        case "analysisDignities":
+        case "analysisTiming":
+            return handleAnalysisWithCards(context, op);
+        case "analysisBirthCards":
+            return handleAnalysisBirthCards(context);
+        case "analysisOptimalTimes":
+            return handleAnalysisOptimalTimes(context);
+        case "analysisTransitReport":
+            return handleAnalysisTransitReport(context);
+        case "analysisNatalReport":
+            return handleAnalysisNatalReport(context);
+        default:
+            throw new Error(`The operation '${operation}' is not supported for the tarot resource`);
+    }
+}
+/**
+ * Builds common tarot options from node parameters
+ */
+function buildTarotOptions(executeFunctions, itemIndex) {
+    return {
+        use_reversals: executeFunctions.getNodeParameter("useReversals", itemIndex, true),
+        tradition: executeFunctions.getNodeParameter("tradition", itemIndex, "universal"),
+        include_dignities: executeFunctions.getNodeParameter("includeDignities", itemIndex, false),
+        include_timing: executeFunctions.getNodeParameter("includeTiming", itemIndex, false),
+        include_astro_context: executeFunctions.getNodeParameter("includeAstroContext", itemIndex, false),
+        include_birth_cards: executeFunctions.getNodeParameter("includeBirthCards", itemIndex, false),
+        interpretation_depth: executeFunctions.getNodeParameter("interpretationDepth", itemIndex, "detailed"),
+        language: executeFunctions.getNodeParameter("language", itemIndex, "en"),
+    };
+}
+/**
+ * Builds second subject birth data from subject2* prefixed fields
+ */
+function buildSecondSubjectBirthData(executeFunctions, itemIndex) {
+    const locationType = executeFunctions.getNodeParameter("subject2LocationType", itemIndex);
+    const birthData = {
+        year: executeFunctions.getNodeParameter("subject2Year", itemIndex),
+        month: executeFunctions.getNodeParameter("subject2Month", itemIndex),
+        day: executeFunctions.getNodeParameter("subject2Day", itemIndex),
+        hour: executeFunctions.getNodeParameter("subject2Hour", itemIndex),
+        minute: executeFunctions.getNodeParameter("subject2Minute", itemIndex),
+    };
+    if (locationType === "city") {
+        birthData.city = executeFunctions.getNodeParameter("subject2City", itemIndex);
+        birthData.country_code = executeFunctions.getNodeParameter("subject2CountryCode", itemIndex);
+    }
+    else {
+        birthData.latitude = executeFunctions.getNodeParameter("subject2Latitude", itemIndex);
+        birthData.longitude = executeFunctions.getNodeParameter("subject2Longitude", itemIndex);
+    }
+    return birthData;
+}
+/**
+ * Handles glossary cards request (GET with filters)
+ */
+async function handleGlossaryCards(context) {
+    const { executeFunctions, itemIndex, baseUrl, apiKey } = context;
+    // Build query parameters from filters
+    const params = [];
+    const arcana = executeFunctions.getNodeParameter("arcana", itemIndex, "");
+    if (arcana)
+        params.push(`arcana=${arcana}`);
+    const suit = executeFunctions.getNodeParameter("suit", itemIndex, "");
+    if (suit)
+        params.push(`suit=${suit}`);
+    const element = executeFunctions.getNodeParameter("element", itemIndex, "");
+    if (element)
+        params.push(`element=${element}`);
+    const planet = executeFunctions.getNodeParameter("planet", itemIndex, "");
+    if (planet)
+        params.push(`planet=${planet}`);
+    const sign = executeFunctions.getNodeParameter("sign", itemIndex, "");
+    if (sign)
+        params.push(`sign=${sign}`);
+    const house = executeFunctions.getNodeParameter("house", itemIndex, 0);
+    if (house > 0)
+        params.push(`house=${house}`);
+    const queryString = params.length > 0 ? `?${params.join("&")}` : "";
+    const endpoint = `${TAROT_ENDPOINTS.glossaryCards}${queryString}`;
+    return await (0, shared_1.makeApiRequest)(executeFunctions, "GET", baseUrl, endpoint, apiKey);
+}
+/**
+ * Handles glossary spreads request (GET)
+ */
+async function handleGlossarySpreads(context) {
+    const { executeFunctions, baseUrl, apiKey } = context;
+    return await (0, shared_1.makeApiRequest)(executeFunctions, "GET", baseUrl, TAROT_ENDPOINTS.glossarySpreads, apiKey);
+}
+/**
+ * Handles glossary card detail request (GET with path parameter)
+ */
+async function handleGlossaryCardDetail(context) {
+    const { executeFunctions, itemIndex, baseUrl, apiKey } = context;
+    const cardId = executeFunctions.getNodeParameter("cardId", itemIndex);
+    // Replace path parameter
+    const endpoint = TAROT_ENDPOINTS.glossaryCardDetail.replace("{card_id}", encodeURIComponent(cardId));
+    return await (0, shared_1.makeApiRequest)(executeFunctions, "GET", baseUrl, endpoint, apiKey);
+}
+/**
+ * Handles search cards request (GET with pagination and filters)
+ */
+async function handleSearchCards(context) {
+    const { executeFunctions, itemIndex, baseUrl, apiKey } = context;
+    // Build query parameters
+    const params = [];
+    const keyword = executeFunctions.getNodeParameter("keyword", itemIndex, "");
+    if (keyword)
+        params.push(`keyword=${encodeURIComponent(keyword)}`);
+    const lifeArea = executeFunctions.getNodeParameter("lifeArea", itemIndex, "");
+    if (lifeArea)
+        params.push(`life_area=${encodeURIComponent(lifeArea)}`);
+    const arcana = executeFunctions.getNodeParameter("arcana", itemIndex, "");
+    if (arcana)
+        params.push(`arcana=${arcana}`);
+    const suit = executeFunctions.getNodeParameter("suit", itemIndex, "");
+    if (suit)
+        params.push(`suit=${suit}`);
+    const element = executeFunctions.getNodeParameter("element", itemIndex, "");
+    if (element)
+        params.push(`element=${element}`);
+    const planet = executeFunctions.getNodeParameter("planet", itemIndex, "");
+    if (planet)
+        params.push(`planet=${planet}`);
+    const sign = executeFunctions.getNodeParameter("sign", itemIndex, "");
+    if (sign)
+        params.push(`sign=${sign}`);
+    const page = executeFunctions.getNodeParameter("page", itemIndex, 1);
+    params.push(`page=${page}`);
+    const pageSize = executeFunctions.getNodeParameter("pageSize", itemIndex, 20);
+    params.push(`page_size=${pageSize}`);
+    const queryString = params.length > 0 ? `?${params.join("&")}` : "";
+    const endpoint = `${TAROT_ENDPOINTS.searchCards}${queryString}`;
+    return await (0, shared_1.makeApiRequest)(executeFunctions, "GET", baseUrl, endpoint, apiKey);
+}
+/**
+ * Handles daily card request (GET with user_id)
+ */
+async function handleDailyCard(context) {
+    const { executeFunctions, itemIndex, baseUrl, apiKey } = context;
+    const userId = executeFunctions.getNodeParameter("userId", itemIndex);
+    const params = [`user_id=${encodeURIComponent(userId)}`];
+    const lifeArea = executeFunctions.getNodeParameter("lifeArea", itemIndex, "");
+    if (lifeArea)
+        params.push(`life_area=${encodeURIComponent(lifeArea)}`);
+    // Optional birth data for personalization
+    try {
+        const year = executeFunctions.getNodeParameter("year", itemIndex, 0);
+        if (year > 0) {
+            params.push(`birth_year=${year}`);
+            const month = executeFunctions.getNodeParameter("month", itemIndex, 0);
+            if (month > 0)
+                params.push(`birth_month=${month}`);
+            const day = executeFunctions.getNodeParameter("day", itemIndex, 0);
+            if (day > 0)
+                params.push(`birth_day=${day}`);
+            const hour = executeFunctions.getNodeParameter("hour", itemIndex, 0);
+            if (hour > 0)
+                params.push(`birth_hour=${hour}`);
+            const minute = executeFunctions.getNodeParameter("minute", itemIndex, 0);
+            if (minute > 0)
+                params.push(`birth_minute=${minute}`);
+        }
+    }
+    catch {
+        // Birth data fields are optional, ignore if not provided
+    }
+    const queryString = `?${params.join("&")}`;
+    const endpoint = `${TAROT_ENDPOINTS.dailyCard}${queryString}`;
+    return await (0, shared_1.makeApiRequest)(executeFunctions, "GET", baseUrl, endpoint, apiKey);
+}
+/**
+ * Handles draw cards request (POST)
+ */
+async function handleDrawCards(context) {
+    const { executeFunctions, itemIndex, baseUrl, apiKey } = context;
+    const count = executeFunctions.getNodeParameter("drawCount", itemIndex, 1);
+    const excludeReversed = executeFunctions.getNodeParameter("excludeReversed", itemIndex, false);
+    const excludeMajors = executeFunctions.getNodeParameter("excludeMajors", itemIndex, false);
+    const excludeMinors = executeFunctions.getNodeParameter("excludeMinors", itemIndex, false);
+    const lifeArea = executeFunctions.getNodeParameter("lifeArea", itemIndex, "");
+    const body = {
+        count,
+        exclude_reversed: excludeReversed,
+        exclude_majors: excludeMajors,
+        exclude_minors: excludeMinors,
+    };
+    if (lifeArea) {
+        body.life_area = lifeArea;
+    }
+    const responseData = await (0, shared_1.makeApiRequest)(executeFunctions, "POST", baseUrl, TAROT_ENDPOINTS.drawCards, apiKey, body);
+    const simplify = executeFunctions.getNodeParameter("simplify", itemIndex, true);
+    return simplify ? (0, shared_1.simplifyResponse)(responseData) : responseData;
+}
+/**
+ * Handles generic report requests (POST)
+ */
+async function handleReport(context, op) {
+    const { executeFunctions, itemIndex, baseUrl, apiKey } = context;
+    // Build birth data
+    const birthData = (0, shared_1.buildBirthData)(executeFunctions, itemIndex);
+    // Get options
+    const lifeArea = executeFunctions.getNodeParameter("lifeArea", itemIndex, "");
+    const options = buildTarotOptions(executeFunctions, itemIndex);
+    const body = {
+        birth_data: birthData,
+        ...options,
+    };
+    if (lifeArea) {
+        body.life_area = lifeArea;
+    }
+    const responseData = await (0, shared_1.makeApiRequest)(executeFunctions, "POST", baseUrl, TAROT_ENDPOINTS[op], apiKey, body);
+    const simplify = executeFunctions.getNodeParameter("simplify", itemIndex, true);
+    return simplify ? (0, shared_1.simplifyResponse)(responseData) : responseData;
+}
+/**
+ * Handles synastry report (POST with two subjects)
+ */
+async function handleReportSynastry(context) {
+    const { executeFunctions, itemIndex, baseUrl, apiKey } = context;
+    // Build subject 1 birth data
+    const birthData1 = (0, shared_1.buildBirthData)(executeFunctions, itemIndex);
+    // Build subject 2 birth data
+    const birthData2 = buildSecondSubjectBirthData(executeFunctions, itemIndex);
+    // Get options
+    const lifeArea = executeFunctions.getNodeParameter("lifeArea", itemIndex, "");
+    const options = buildTarotOptions(executeFunctions, itemIndex);
+    const body = {
+        birth_data: birthData1,
+        partner_birth_data: birthData2,
+        ...options,
+    };
+    if (lifeArea) {
+        body.life_area = lifeArea;
+    }
+    const responseData = await (0, shared_1.makeApiRequest)(executeFunctions, "POST", baseUrl, TAROT_ENDPOINTS.reportSynastry, apiKey, body);
+    const simplify = executeFunctions.getNodeParameter("simplify", itemIndex, true);
+    return simplify ? (0, shared_1.simplifyResponse)(responseData) : responseData;
+}
+/**
+ * Handles analysis operations that require card IDs input
+ */
+async function handleAnalysisWithCards(context, op) {
+    const { executeFunctions, itemIndex, baseUrl, apiKey } = context;
+    // Parse card IDs from comma-separated string
+    const cardIdsStr = executeFunctions.getNodeParameter("cardIds", itemIndex);
+    const cards = cardIdsStr
+        .split(",")
+        .map((id) => id.trim())
+        .filter((id) => id);
+    // Get options
+    const options = buildTarotOptions(executeFunctions, itemIndex);
+    const body = {
+        cards,
+        ...options,
+    };
+    const responseData = await (0, shared_1.makeApiRequest)(executeFunctions, "POST", baseUrl, TAROT_ENDPOINTS[op], apiKey, body);
+    const simplify = executeFunctions.getNodeParameter("simplify", itemIndex, true);
+    return simplify ? (0, shared_1.simplifyResponse)(responseData) : responseData;
+}
+/**
+ * Handles birth cards analysis (POST with birth data)
+ */
+async function handleAnalysisBirthCards(context) {
+    const { executeFunctions, itemIndex, baseUrl, apiKey } = context;
+    // Build birth data
+    const birthData = (0, shared_1.buildBirthData)(executeFunctions, itemIndex);
+    // Get options
+    const options = buildTarotOptions(executeFunctions, itemIndex);
+    const body = {
+        birth_data: birthData,
+        ...options,
+    };
+    const responseData = await (0, shared_1.makeApiRequest)(executeFunctions, "POST", baseUrl, TAROT_ENDPOINTS.analysisBirthCards, apiKey, body);
+    const simplify = executeFunctions.getNodeParameter("simplify", itemIndex, true);
+    return simplify ? (0, shared_1.simplifyResponse)(responseData) : responseData;
+}
+/**
+ * Handles optimal times analysis (POST with birth data)
+ */
+async function handleAnalysisOptimalTimes(context) {
+    const { executeFunctions, itemIndex, baseUrl, apiKey } = context;
+    // Get options
+    const options = buildTarotOptions(executeFunctions, itemIndex);
+    const body = {
+        ...options,
+    };
+    const responseData = await (0, shared_1.makeApiRequest)(executeFunctions, "POST", baseUrl, TAROT_ENDPOINTS.analysisOptimalTimes, apiKey, body);
+    const simplify = executeFunctions.getNodeParameter("simplify", itemIndex, true);
+    return simplify ? (0, shared_1.simplifyResponse)(responseData) : responseData;
+}
+/**
+ * Handles transit report analysis (POST with birth data)
+ */
+async function handleAnalysisTransitReport(context) {
+    const { executeFunctions, itemIndex, baseUrl, apiKey } = context;
+    // Build birth data
+    const birthData = (0, shared_1.buildBirthData)(executeFunctions, itemIndex);
+    // Get options
+    const options = buildTarotOptions(executeFunctions, itemIndex);
+    const body = {
+        birth_data: birthData,
+        ...options,
+    };
+    const responseData = await (0, shared_1.makeApiRequest)(executeFunctions, "POST", baseUrl, TAROT_ENDPOINTS.analysisTransitReport, apiKey, body);
+    const simplify = executeFunctions.getNodeParameter("simplify", itemIndex, true);
+    return simplify ? (0, shared_1.simplifyResponse)(responseData) : responseData;
+}
+/**
+ * Handles natal report analysis (POST with birth data)
+ */
+async function handleAnalysisNatalReport(context) {
+    const { executeFunctions, itemIndex, baseUrl, apiKey } = context;
+    // Build birth data
+    const birthData = (0, shared_1.buildBirthData)(executeFunctions, itemIndex);
+    // Get options
+    const options = buildTarotOptions(executeFunctions, itemIndex);
+    const body = {
+        birth_data: birthData,
+        ...options,
+    };
+    const responseData = await (0, shared_1.makeApiRequest)(executeFunctions, "POST", baseUrl, TAROT_ENDPOINTS.analysisNatalReport, apiKey, body);
+    const simplify = executeFunctions.getNodeParameter("simplify", itemIndex, true);
+    return simplify ? (0, shared_1.simplifyResponse)(responseData) : responseData;
+}

package/dist/nodes/Astrology/interfaces/index.d.ts

@@ -1 +1 @@
-export type { IBirthData, ISubjectRequest, ResourceType, DataOperation, HoroscopeOperation, ChartsOperation, IHandlerContext, ResourceHandler, ZodiacSign, LocationType, Tradition, TextFormat, } from "./types";
+export type { IBirthData, ISubjectRequest, ResourceType, DataOperation, HoroscopeOperation, ChartsOperation, TarotOperation, TarotTradition, TarotInterpretationDepth, TarotArcana, TarotSuit, IHandlerContext, ResourceHandler, ZodiacSign, LocationType, Tradition, TextFormat, } from "./types";

package/dist/nodes/Astrology/interfaces/types.d.ts

@@ -25,7 +25,7 @@ export interface ISubjectRequest {
 /**
  * Resource types available in the node
  */
-export type ResourceType = "data" | "horoscope" | "charts" | "humanDesign" | "numerology";
+export type ResourceType = "data" | "horoscope" | "charts" | "humanDesign" | "numerology" | "tarot";
 /**
  * Data resource operations
  */
@@ -46,6 +46,26 @@ export type HumanDesignOperation = "glossaryChannels" | "glossaryGates" | "gloss
  * Numerology resource operations
  */
 export type NumerologyOperation = "coreNumbers" | "comprehensive" | "compatibility";
+/**
+ * Tarot resource operations
+ */
+export type TarotOperation = "glossaryCards" | "glossarySpreads" | "glossaryCardDetail" | "searchCards" | "dailyCard" | "drawCards" | "reportSingle" | "reportThreeCard" | "reportCelticCross" | "reportSynastry" | "reportHouses" | "reportTreeOfLife" | "analysisQuintessence" | "analysisBirthCards" | "analysisDignities" | "analysisTiming" | "analysisOptimalTimes" | "analysisTransitReport" | "analysisNatalReport";
+/**
+ * Tarot tradition/interpretation style
+ */
+export type TarotTradition = "universal" | "psychological" | "classical" | "hermetic";
+/**
+ * Tarot interpretation depth levels
+ */
+export type TarotInterpretationDepth = "keywords" | "basic" | "detailed" | "professional";
+/**
+ * Tarot arcana types for filtering
+ */
+export type TarotArcana = "major" | "minor";
+/**
+ * Tarot suits for filtering
+ */
+export type TarotSuit = "wands" | "cups" | "swords" | "pentacles";
 /**
  * Human Design circuit types
  */

package/dist/nodes/Astrology/operations/index.d.ts

@@ -4,3 +4,4 @@ export { horoscopeOperations } from "./horoscope.operation";
 export { chartsOperations } from "./charts.operation";
 export { humanDesignOperations } from "./humanDesign.operation";
 export { numerologyOperations } from "./numerology.operation";
+export { tarotOperations } from "./tarot.operation";

package/dist/nodes/Astrology/operations/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.numerologyOperations = exports.humanDesignOperations = exports.chartsOperations = exports.horoscopeOperations = exports.dataOperations = exports.resourceField = void 0;
+exports.tarotOperations = exports.numerologyOperations = exports.humanDesignOperations = exports.chartsOperations = exports.horoscopeOperations = exports.dataOperations = exports.resourceField = void 0;
 var resource_options_1 = require("./resource.options");
 Object.defineProperty(exports, "resourceField", { enumerable: true, get: function () { return resource_options_1.resourceField; } });
 var data_operation_1 = require("./data.operation");
@@ -13,3 +13,5 @@ var humanDesign_operation_1 = require("./humanDesign.operation");
 Object.defineProperty(exports, "humanDesignOperations", { enumerable: true, get: function () { return humanDesign_operation_1.humanDesignOperations; } });
 var numerology_operation_1 = require("./numerology.operation");
 Object.defineProperty(exports, "numerologyOperations", { enumerable: true, get: function () { return numerology_operation_1.numerologyOperations; } });
+var tarot_operation_1 = require("./tarot.operation");
+Object.defineProperty(exports, "tarotOperations", { enumerable: true, get: function () { return tarot_operation_1.tarotOperations; } });

package/dist/nodes/Astrology/operations/resource.options.js

@@ -36,6 +36,11 @@ exports.resourceField = {
             value: "numerology",
             description: "Numerology calculations: Life Path, Expression, Soul Urge numbers, comprehensive readings, and compatibility analysis",
         },
+        {
+            name: "Tarot",
+            value: "tarot",
+            description: "Tarot card readings and analysis: daily cards, spreads (single, three-card, Celtic Cross), birth cards, and astrological integration",
+        },
     ],
     default: "data",
 };

package/dist/nodes/Astrology/operations/tarot.operation.d.ts

@@ -0,0 +1,5 @@
+import type { INodeProperties } from "n8n-workflow";
+/**
+ * All properties for the Tarot resource
+ */
+export declare const tarotOperations: INodeProperties[];

package/dist/nodes/Astrology/operations/tarot.operation.js

@@ -0,0 +1,573 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tarotOperations = void 0;
+const shared_1 = require("../shared");
+/**
+ * Operation groups for displayOptions
+ */
+const glossaryOperations = [
+    "glossaryCards",
+    "glossarySpreads",
+    "glossaryCardDetail",
+    "searchCards",
+    "dailyCard",
+];
+const birthDataOperations = [
+    "dailyCard",
+    "reportSingle",
+    "reportThreeCard",
+    "reportCelticCross",
+    "reportSynastry",
+    "reportHouses",
+    "reportTreeOfLife",
+    "analysisBirthCards",
+    "analysisTransitReport",
+    "analysisNatalReport",
+];
+const locationOperations = [
+    "dailyCard",
+    "reportSingle",
+    "reportThreeCard",
+    "reportCelticCross",
+    "reportSynastry",
+    "reportHouses",
+    "reportTreeOfLife",
+    "analysisBirthCards",
+    "analysisTransitReport",
+    "analysisNatalReport",
+];
+const synastryOperations = ["reportSynastry"];
+const reportOperations = [
+    "reportSingle",
+    "reportThreeCard",
+    "reportCelticCross",
+    "reportSynastry",
+    "reportHouses",
+    "reportTreeOfLife",
+];
+const analysisOperations = [
+    "analysisQuintessence",
+    "analysisBirthCards",
+    "analysisDignities",
+    "analysisTiming",
+    "analysisOptimalTimes",
+    "analysisTransitReport",
+    "analysisNatalReport",
+];
+const cardsInputOperations = [
+    "analysisQuintessence",
+    "analysisDignities",
+    "analysisTiming",
+];
+const filterOperations = ["glossaryCards", "searchCards"];
+const postOperations = [
+    "drawCards",
+    ...reportOperations,
+    ...analysisOperations,
+];
+/**
+ * Operation selector for Tarot resource
+ */
+const tarotOperationField = {
+    displayName: "Operation",
+    name: "operation",
+    type: "options",
+    noDataExpression: true,
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+        },
+    },
+    options: [
+        // Analysis operations
+        {
+            name: "Analysis - Birth Cards",
+            value: "analysisBirthCards",
+            description: "Calculate personal birth cards based on date of birth",
+            action: "Calculate birth cards",
+        },
+        {
+            name: "Analysis - Dignities",
+            value: "analysisDignities",
+            description: "Analyze elemental dignities between cards in a spread",
+            action: "Analyze elemental dignities",
+        },
+        {
+            name: "Analysis - Natal Report",
+            value: "analysisNatalReport",
+            description: "Tarot reading integrated with natal chart for deep personal insights",
+            action: "Get natal integration report",
+        },
+        {
+            name: "Analysis - Optimal Times",
+            value: "analysisOptimalTimes",
+            description: "Find optimal timing for specific activities based on tarot and astrology",
+            action: "Find optimal times",
+        },
+        {
+            name: "Analysis - Quintessence",
+            value: "analysisQuintessence",
+            description: "Calculate the quintessence (essence card) from a spread",
+            action: "Calculate quintessence",
+        },
+        {
+            name: "Analysis - Timing",
+            value: "analysisTiming",
+            description: "Timing analysis and predictions based on card positions",
+            action: "Analyze timing",
+        },
+        {
+            name: "Analysis - Transit Report",
+            value: "analysisTransitReport",
+            description: "Tarot reading aligned with current planetary transits for timely guidance",
+            action: "Get transit report",
+        },
+        // Daily Card
+        {
+            name: "Daily Card",
+            value: "dailyCard",
+            description: "Get a personalized daily tarot card for guidance (consistent per user/day)",
+            action: "Get daily card",
+        },
+        // Draw Cards
+        {
+            name: "Draw Cards",
+            value: "drawCards",
+            description: "Draw random tarot cards for a reading (1-78 cards)",
+            action: "Draw random cards",
+        },
+        // Glossary operations
+        {
+            name: "Glossary - Card Detail",
+            value: "glossaryCardDetail",
+            description: "Get detailed information about a specific tarot card by ID",
+            action: "Get card detail",
+        },
+        {
+            name: "Glossary - Cards",
+            value: "glossaryCards",
+            description: "Get tarot cards glossary with optional filters (arcana, suit, element, planet, sign)",
+            action: "Get cards glossary",
+        },
+        {
+            name: "Glossary - Spreads",
+            value: "glossarySpreads",
+            description: "Get available tarot spread types and their position descriptions",
+            action: "Get spreads glossary",
+        },
+        // Report operations
+        {
+            name: "Report - Celtic Cross",
+            value: "reportCelticCross",
+            description: "Full Celtic Cross spread (10 cards) for comprehensive life situation analysis",
+            action: "Get celtic cross report",
+        },
+        {
+            name: "Report - Houses",
+            value: "reportHouses",
+            description: "12-house astrological spread covering all life areas",
+            action: "Get houses report",
+        },
+        {
+            name: "Report - Single Card",
+            value: "reportSingle",
+            description: "Single card tarot reading for focused guidance",
+            action: "Get single card report",
+        },
+        {
+            name: "Report - Synastry",
+            value: "reportSynastry",
+            description: "Two-person relationship tarot reading for compatibility insights",
+            action: "Get synastry report",
+        },
+        {
+            name: "Report - Three Card",
+            value: "reportThreeCard",
+            description: "Classic three card spread (past/present/future or situation/action/outcome)",
+            action: "Get three card report",
+        },
+        {
+            name: "Report - Tree of Life",
+            value: "reportTreeOfLife",
+            description: "Kabbalah Tree of Life spread for spiritual insight",
+            action: "Get tree of life report",
+        },
+        // Search Cards
+        {
+            name: "Search Cards",
+            value: "searchCards",
+            description: "Search tarot cards by keyword, life area, element, or astrological correspondence",
+            action: "Search cards",
+        },
+    ],
+    default: "reportSingle",
+};
+/**
+ * Card ID field for glossaryCardDetail
+ */
+const cardIdField = {
+    displayName: "Card ID",
+    name: "cardId",
+    type: "string",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+            operation: ["glossaryCardDetail"],
+        },
+    },
+    default: "",
+    placeholder: "e.g. the_fool, ace_of_wands, major_04",
+    description: "The card identifier to get details for",
+    required: true,
+};
+/**
+ * User ID field for daily card
+ */
+const userIdField = {
+    displayName: "User ID",
+    name: "userId",
+    type: "string",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+            operation: ["dailyCard"],
+        },
+    },
+    default: "",
+    placeholder: "e.g. user-123, email@example.com",
+    description: "Unique user identifier for consistent daily card (same user gets same card per day)",
+    required: true,
+};
+/**
+ * Draw count field
+ */
+const drawCountField = {
+    displayName: "Number of Cards",
+    name: "drawCount",
+    type: "number",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+            operation: ["drawCards"],
+        },
+    },
+    default: 1,
+    typeOptions: {
+        minValue: 1,
+        maxValue: 78,
+    },
+    description: "Number of cards to draw (1-78)",
+    required: true,
+};
+/**
+ * Exclude reversed cards toggle
+ */
+const excludeReversedField = {
+    displayName: "Exclude Reversed",
+    name: "excludeReversed",
+    type: "boolean",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+            operation: ["drawCards"],
+        },
+    },
+    default: false,
+    description: "Whether to exclude reversed card orientations from draw",
+};
+/**
+ * Exclude Major Arcana toggle
+ */
+const excludeMajorsField = {
+    displayName: "Exclude Major Arcana",
+    name: "excludeMajors",
+    type: "boolean",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+            operation: ["drawCards"],
+        },
+    },
+    default: false,
+    description: "Whether to exclude Major Arcana cards from draw",
+};
+/**
+ * Exclude Minor Arcana toggle
+ */
+const excludeMinorsField = {
+    displayName: "Exclude Minor Arcana",
+    name: "excludeMinors",
+    type: "boolean",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+            operation: ["drawCards"],
+        },
+    },
+    default: false,
+    description: "Whether to exclude Minor Arcana cards from draw",
+};
+/**
+ * Arcana filter field
+ */
+const arcanaFilterField = {
+    displayName: "Filter by Arcana",
+    name: "arcana",
+    type: "options",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+            operation: filterOperations,
+        },
+    },
+    options: shared_1.tarotArcanaOptions,
+    default: "",
+    description: "Filter cards by arcana type",
+};
+/**
+ * Suit filter field
+ */
+const suitFilterField = {
+    displayName: "Filter by Suit",
+    name: "suit",
+    type: "options",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+            operation: filterOperations,
+        },
+    },
+    options: shared_1.tarotSuitOptions,
+    default: "",
+    description: "Filter Minor Arcana cards by suit",
+};
+/**
+ * Element filter field
+ */
+const elementFilterField = {
+    displayName: "Filter by Element",
+    name: "element",
+    type: "options",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+            operation: filterOperations,
+        },
+    },
+    options: shared_1.tarotElementOptions,
+    default: "",
+    description: "Filter cards by elemental correspondence",
+};
+/**
+ * Planet filter field
+ */
+const planetFilterField = {
+    displayName: "Filter by Planet",
+    name: "planet",
+    type: "string",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+            operation: filterOperations,
+        },
+    },
+    default: "",
+    placeholder: "e.g. mars, venus, moon",
+    description: "Filter cards by planetary correspondence (lowercase)",
+};
+/**
+ * Sign filter field
+ */
+const signFilterField = {
+    displayName: "Filter by Zodiac Sign",
+    name: "sign",
+    type: "string",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+            operation: filterOperations,
+        },
+    },
+    default: "",
+    placeholder: "e.g. ari, tau, gem (3-letter code)",
+    description: "Filter cards by zodiac sign correspondence (3-letter code)",
+};
+/**
+ * House filter field
+ */
+const houseFilterField = {
+    displayName: "Filter by House",
+    name: "house",
+    type: "number",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+            operation: filterOperations,
+        },
+    },
+    default: 0,
+    typeOptions: {
+        minValue: 0,
+        maxValue: 12,
+    },
+    description: "Filter cards by astrological house correspondence (1-12, 0 for all)",
+};
+/**
+ * Search keyword field
+ */
+const keywordField = {
+    displayName: "Keyword",
+    name: "keyword",
+    type: "string",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+            operation: ["searchCards"],
+        },
+    },
+    default: "",
+    placeholder: "e.g. love, success, transformation",
+    description: "Search keyword for card names (case-insensitive)",
+};
+/**
+ * Life area field
+ */
+const lifeAreaField = {
+    displayName: "Life Area",
+    name: "lifeArea",
+    type: "string",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+            operation: ["searchCards", "dailyCard", "drawCards", ...reportOperations],
+        },
+    },
+    default: "",
+    placeholder: "e.g. career, love, health, finances",
+    description: "Optional life area focus for the reading or search",
+};
+/**
+ * Page number field for search
+ */
+const pageField = {
+    displayName: "Page",
+    name: "page",
+    type: "number",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+            operation: ["searchCards"],
+        },
+    },
+    default: 1,
+    typeOptions: {
+        minValue: 1,
+    },
+    description: "Page number for pagination (1-based)",
+};
+/**
+ * Page size field for search
+ */
+const pageSizeField = {
+    displayName: "Page Size",
+    name: "pageSize",
+    type: "number",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+            operation: ["searchCards"],
+        },
+    },
+    default: 20,
+    typeOptions: {
+        minValue: 1,
+        maxValue: 78,
+    },
+    description: "Number of results per page (max 78)",
+};
+/**
+ * Cards input field for analysis operations
+ */
+const cardsInputField = {
+    displayName: "Card IDs",
+    name: "cardIds",
+    type: "string",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+            operation: cardsInputOperations,
+        },
+    },
+    default: "",
+    placeholder: "the_fool,the_magician,the_high_priestess",
+    description: "Comma-separated list of card IDs for analysis",
+    required: true,
+};
+/**
+ * Simplify output toggle
+ */
+const simplifyField = {
+    displayName: "Simplify",
+    name: "simplify",
+    type: "boolean",
+    displayOptions: {
+        show: {
+            resource: ["tarot"],
+        },
+        hide: {
+            operation: glossaryOperations,
+        },
+    },
+    default: true,
+    description: "Whether to return simplified response with key data only. Disable for full API response.",
+};
+/**
+ * All properties for the Tarot resource
+ */
+exports.tarotOperations = [
+    // Operation selector
+    tarotOperationField,
+    // Card ID for glossaryCardDetail
+    cardIdField,
+    // User ID for dailyCard
+    userIdField,
+    // Draw options
+    drawCountField,
+    excludeReversedField,
+    excludeMajorsField,
+    excludeMinorsField,
+    // Filter fields for glossary/search
+    arcanaFilterField,
+    suitFilterField,
+    elementFilterField,
+    planetFilterField,
+    signFilterField,
+    houseFilterField,
+    // Search fields
+    keywordField,
+    pageField,
+    pageSizeField,
+    // Life area
+    lifeAreaField,
+    // Cards input for analysis
+    cardsInputField,
+    // Birth data fields (for operations that need it)
+    ...(0, shared_1.createBirthDataFields)("tarot", birthDataOperations),
+    // Location fields
+    ...(0, shared_1.createLocationFields)("tarot", locationOperations),
+    // Second subject fields for synastry
+    ...(0, shared_1.createSecondSubjectFields)("tarot", synastryOperations),
+    // Tarot-specific options
+    (0, shared_1.createLanguageField)("tarot", postOperations),
+    (0, shared_1.createTarotTraditionField)("tarot", [
+        ...reportOperations,
+        ...analysisOperations,
+    ]),
+    (0, shared_1.createInterpretationDepthField)("tarot", reportOperations),
+    ...(0, shared_1.createTarotOptionsFields)("tarot", [
+        ...reportOperations,
+        ...analysisOperations,
+    ]),
+    // Simplify output
+    simplifyField,
+];

package/dist/nodes/Astrology/shared/index.d.ts

@@ -6,4 +6,5 @@ export { createTransitTimeFields } from "./transitTime.fields";
 export { createDateRangeFields } from "./dateRange.fields";
 export { createNameField, createSecondSubjectNameField } from "./name.fields";
 export { languageOptions, createLanguageField, createIncludeInterpretationsField, } from "./language.fields";
+export { tarotTraditionOptions, tarotInterpretationDepthOptions, tarotArcanaOptions, tarotSuitOptions, tarotElementOptions, createTarotTraditionField, createInterpretationDepthField, createTarotOptionsFields, } from "./tarot.fields";
 export { buildBirthData, makeApiRequest, createSubjectRequest, simplifyResponse, } from "./helpers";

package/dist/nodes/Astrology/shared/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.simplifyResponse = exports.createSubjectRequest = exports.makeApiRequest = exports.buildBirthData = exports.createIncludeInterpretationsField = exports.createLanguageField = exports.languageOptions = exports.createSecondSubjectNameField = exports.createNameField = exports.createDateRangeFields = exports.createTransitTimeFields = exports.createSecondSubjectFields = exports.createTraditionField = exports.traditionOptions = exports.createZodiacSignField = exports.zodiacSignOptions = exports.createLocationFields = exports.createBirthDataFields = void 0;
+exports.simplifyResponse = exports.createSubjectRequest = exports.makeApiRequest = exports.buildBirthData = exports.createTarotOptionsFields = exports.createInterpretationDepthField = exports.createTarotTraditionField = exports.tarotElementOptions = exports.tarotSuitOptions = exports.tarotArcanaOptions = exports.tarotInterpretationDepthOptions = exports.tarotTraditionOptions = exports.createIncludeInterpretationsField = exports.createLanguageField = exports.languageOptions = exports.createSecondSubjectNameField = exports.createNameField = exports.createDateRangeFields = exports.createTransitTimeFields = exports.createSecondSubjectFields = exports.createTraditionField = exports.traditionOptions = exports.createZodiacSignField = exports.zodiacSignOptions = exports.createLocationFields = exports.createBirthDataFields = void 0;
 // Shared field creators
 var birthData_fields_1 = require("./birthData.fields");
 Object.defineProperty(exports, "createBirthDataFields", { enumerable: true, get: function () { return birthData_fields_1.createBirthDataFields; } });
@@ -24,6 +24,15 @@ var language_fields_1 = require("./language.fields");
 Object.defineProperty(exports, "languageOptions", { enumerable: true, get: function () { return language_fields_1.languageOptions; } });
 Object.defineProperty(exports, "createLanguageField", { enumerable: true, get: function () { return language_fields_1.createLanguageField; } });
 Object.defineProperty(exports, "createIncludeInterpretationsField", { enumerable: true, get: function () { return language_fields_1.createIncludeInterpretationsField; } });
+var tarot_fields_1 = require("./tarot.fields");
+Object.defineProperty(exports, "tarotTraditionOptions", { enumerable: true, get: function () { return tarot_fields_1.tarotTraditionOptions; } });
+Object.defineProperty(exports, "tarotInterpretationDepthOptions", { enumerable: true, get: function () { return tarot_fields_1.tarotInterpretationDepthOptions; } });
+Object.defineProperty(exports, "tarotArcanaOptions", { enumerable: true, get: function () { return tarot_fields_1.tarotArcanaOptions; } });
+Object.defineProperty(exports, "tarotSuitOptions", { enumerable: true, get: function () { return tarot_fields_1.tarotSuitOptions; } });
+Object.defineProperty(exports, "tarotElementOptions", { enumerable: true, get: function () { return tarot_fields_1.tarotElementOptions; } });
+Object.defineProperty(exports, "createTarotTraditionField", { enumerable: true, get: function () { return tarot_fields_1.createTarotTraditionField; } });
+Object.defineProperty(exports, "createInterpretationDepthField", { enumerable: true, get: function () { return tarot_fields_1.createInterpretationDepthField; } });
+Object.defineProperty(exports, "createTarotOptionsFields", { enumerable: true, get: function () { return tarot_fields_1.createTarotOptionsFields; } });
 // Helper functions
 var helpers_1 = require("./helpers");
 Object.defineProperty(exports, "buildBirthData", { enumerable: true, get: function () { return helpers_1.buildBirthData; } });

package/dist/nodes/Astrology/shared/tarot.fields.d.ts

@@ -0,0 +1,33 @@
+import type { INodeProperties } from "n8n-workflow";
+/**
+ * Tarot tradition options
+ */
+export declare const tarotTraditionOptions: INodeProperties["options"];
+/**
+ * Tarot interpretation depth options
+ */
+export declare const tarotInterpretationDepthOptions: INodeProperties["options"];
+/**
+ * Tarot arcana filter options
+ */
+export declare const tarotArcanaOptions: INodeProperties["options"];
+/**
+ * Tarot suit filter options
+ */
+export declare const tarotSuitOptions: INodeProperties["options"];
+/**
+ * Tarot element filter options
+ */
+export declare const tarotElementOptions: INodeProperties["options"];
+/**
+ * Creates a tarot tradition selection field
+ */
+export declare function createTarotTraditionField(resourceName: string, showForOperations?: string[]): INodeProperties;
+/**
+ * Creates an interpretation depth field
+ */
+export declare function createInterpretationDepthField(resourceName: string, showForOperations?: string[]): INodeProperties;
+/**
+ * Creates tarot-specific boolean option fields
+ */
+export declare function createTarotOptionsFields(resourceName: string, showForOperations: string[]): INodeProperties[];

package/dist/nodes/Astrology/shared/tarot.fields.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tarotElementOptions = exports.tarotSuitOptions = exports.tarotArcanaOptions = exports.tarotInterpretationDepthOptions = exports.tarotTraditionOptions = void 0;
+exports.createTarotTraditionField = createTarotTraditionField;
+exports.createInterpretationDepthField = createInterpretationDepthField;
+exports.createTarotOptionsFields = createTarotOptionsFields;
+/**
+ * Tarot tradition options
+ */
+exports.tarotTraditionOptions = [
+    { name: "Classical", value: "classical" },
+    { name: "Hermetic", value: "hermetic" },
+    { name: "Psychological", value: "psychological" },
+    { name: "Universal", value: "universal" },
+];
+/**
+ * Tarot interpretation depth options
+ */
+exports.tarotInterpretationDepthOptions = [
+    { name: "Keywords Only", value: "keywords" },
+    { name: "Basic", value: "basic" },
+    { name: "Detailed", value: "detailed" },
+    { name: "Professional", value: "professional" },
+];
+/**
+ * Tarot arcana filter options
+ */
+exports.tarotArcanaOptions = [
+    { name: "All", value: "" },
+    { name: "Major Arcana", value: "major" },
+    { name: "Minor Arcana", value: "minor" },
+];
+/**
+ * Tarot suit filter options
+ */
+exports.tarotSuitOptions = [
+    { name: "All", value: "" },
+    { name: "Cups", value: "cups" },
+    { name: "Pentacles", value: "pentacles" },
+    { name: "Swords", value: "swords" },
+    { name: "Wands", value: "wands" },
+];
+/**
+ * Tarot element filter options
+ */
+exports.tarotElementOptions = [
+    { name: "All", value: "" },
+    { name: "Air", value: "air" },
+    { name: "Earth", value: "earth" },
+    { name: "Fire", value: "fire" },
+    { name: "Water", value: "water" },
+];
+/**
+ * Creates a tarot tradition selection field
+ */
+function createTarotTraditionField(resourceName, showForOperations) {
+    const baseDisplayOptions = {
+        show: {
+            resource: [resourceName],
+        },
+    };
+    if (showForOperations && showForOperations.length > 0) {
+        baseDisplayOptions.show.operation = showForOperations;
+    }
+    return {
+        displayName: "Tradition",
+        name: "tradition",
+        type: "options",
+        displayOptions: baseDisplayOptions,
+        options: exports.tarotTraditionOptions,
+        default: "universal",
+        description: "Tarot interpretation tradition/style",
+    };
+}
+/**
+ * Creates an interpretation depth field
+ */
+function createInterpretationDepthField(resourceName, showForOperations) {
+    const baseDisplayOptions = {
+        show: {
+            resource: [resourceName],
+        },
+    };
+    if (showForOperations && showForOperations.length > 0) {
+        baseDisplayOptions.show.operation = showForOperations;
+    }
+    return {
+        displayName: "Interpretation Depth",
+        name: "interpretationDepth",
+        type: "options",
+        displayOptions: baseDisplayOptions,
+        options: exports.tarotInterpretationDepthOptions,
+        default: "detailed",
+        description: "Level of detail in card interpretations",
+    };
+}
+/**
+ * Creates tarot-specific boolean option fields
+ */
+function createTarotOptionsFields(resourceName, showForOperations) {
+    const baseDisplayOptions = {
+        show: {
+            resource: [resourceName],
+            operation: showForOperations,
+        },
+    };
+    return [
+        {
+            displayName: "Use Reversals",
+            name: "useReversals",
+            type: "boolean",
+            displayOptions: baseDisplayOptions,
+            default: true,
+            description: "Whether to include reversed card orientations",
+        },
+        {
+            displayName: "Include Dignities",
+            name: "includeDignities",
+            type: "boolean",
+            displayOptions: baseDisplayOptions,
+            default: false,
+            description: "Whether to include elemental dignity analysis",
+        },
+        {
+            displayName: "Include Timing",
+            name: "includeTiming",
+            type: "boolean",
+            displayOptions: baseDisplayOptions,
+            default: false,
+            description: "Whether to include timing predictions",
+        },
+        {
+            displayName: "Include Astrological Context",
+            name: "includeAstroContext",
+            type: "boolean",
+            displayOptions: baseDisplayOptions,
+            default: false,
+            description: "Whether to include current astrological influences",
+        },
+        {
+            displayName: "Include Birth Cards",
+            name: "includeBirthCards",
+            type: "boolean",
+            displayOptions: baseDisplayOptions,
+            default: false,
+            description: "Whether to include personal birth cards in analysis",
+        },
+    ];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astro-api/n8n-nodes-astrology",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "n8n community node for Astrology API - professional astrological calculations, charts, horoscopes, and interpretations",
   "main": "dist/index.js",
   "scripts": {