jtlt 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -1,3 +1,43 @@
+/**
+ * Create and run a JTLT instance with the appropriate engine typing.
+ *
+ * Overloads help TypeScript select the correct constructor signature.
+ * @overload
+ * @param {Omit<JSONPathJTLTOptions<"json">, "success">} cfg
+ * @returns {Promise<ResultType<"json">>}
+ */
+export function jtlt(cfg: Omit<JSONPathJTLTOptions<"json">, "success">): Promise<ResultType<"json">>;
+/**
+ * @overload
+ * @param {Omit<JSONPathJTLTOptions<"string">, "success">} cfg
+ * @returns {Promise<ResultType<"string">>}
+ */
+export function jtlt(cfg: Omit<JSONPathJTLTOptions<"string">, "success">): Promise<ResultType<"string">>;
+/**
+ * @overload
+ * @param {Omit<JSONPathJTLTOptions<"dom">, "success">} cfg
+ * @returns {Promise<ResultType<"dom">>}
+ */
+export function jtlt(cfg: Omit<JSONPathJTLTOptions<"dom">, "success">): Promise<ResultType<"dom">>;
+/**
+ * @overload
+ * @param {Omit<XPathJTLTOptions<"json">, "success">} cfg
+ * @returns {Promise<ResultType<"json">>}
+ */
+export function jtlt(cfg: Omit<XPathJTLTOptions<"json">, "success">): Promise<ResultType<"json">>;
+/**
+ * @overload
+ * @param {Omit<XPathJTLTOptions<"dom">, "success">} cfg
+ * @returns {Promise<ResultType<"dom">>}
+ */
+export function jtlt(cfg: Omit<XPathJTLTOptions<"dom">, "success">): Promise<ResultType<"dom">>;
+/**
+ * @overload
+ * @param {Omit<XPathJTLTOptions<"string">, "success">} cfg
+ * @returns {Promise<ResultType<"string">>}
+ */
+export function jtlt(cfg: Omit<XPathJTLTOptions<"string">, "success">): Promise<ResultType<"string">>;
+export function setWindow(win: import("jsdom").DOMWindow | typeof globalThis): void;
 export { default as AbstractJoiningTransformer } from "./AbstractJoiningTransformer.js";
 export { default as StringJoiningTransformer } from "./StringJoiningTransformer.js";
 export { default as DOMJoiningTransformer } from "./DOMJoiningTransformer.js";
@@ -8,35 +48,70 @@ export { default as JSONPathTransformer } from "./JSONPathTransformer.js";
 export { default as XPathTransformerContext } from "./XPathTransformerContext.js";
 export { default as XPathTransformer } from "./XPathTransformer.js";
 export default JTLT;
-export type JTLTOptions = {
+/**
+ * Internal options extension adding private runtime state flags.
+ * Not part of the public API surface but used for narrowing casts.
+ */
+export type InternalJTLTOptions = JTLTOptions & {
+    _customJoiningTransformer?: boolean;
+};
+/**
+ * A template declaration whose `template` executes with `this` bound
+ * to the engine-specific context type `TCtx`.
+ * Either `path` must be provided (for pattern matching), or `name` must be
+ * provided (for named templates callable via callTemplate), or both.
+ */
+export type TemplateObject<T, U, TCtx> = {
     /**
-     * A callback supplied with a single
-     * argument that is the result of this instance's transform() method.
+     * - JSONPath or XPath selector for matching nodes
      */
-    success: Function;
+    path?: string | undefined;
     /**
-     * An array of template objects
+     * - Optional name for calling via callTemplate
      */
-    templates?: any[] | undefined;
+    name?: string | undefined;
     /**
-     * A function assumed to be a
-     * root template or a single, complete template object
+     * - Optional mode for template matching
      */
-    template?: object | Function | undefined;
+    mode?: string | undefined;
     /**
-     * A function assumed to be a root template
+     * - Priority for template selection
      */
-    query?: Function | undefined;
+    priority?: number | undefined;
     /**
-     * An array with arguments to be supplied
-     * to a single call to `forEach` (and which will serve as the root
-     * template)
+     * - Template function
      */
-    forQuery?: any[] | undefined;
+    template: TemplateFunction<T, U, TCtx>;
+};
+/**
+ * A callable template function with an engine-specific `this`.
+ */
+export type TemplateFunction<T, U, TCtx> = (this: TCtx, value: ResultType<U>, cfg?: {
+    mode?: string;
+}) => ResultType<T> | void;
+export type JSONPathTemplateObject<T> = TemplateObject<T, "json", import("./JSONPathTransformerContext.js").default<T>>;
+export type XPathTemplateObject<T> = TemplateObject<T, "dom", import("./XPathTransformerContext.js").default>;
+export type XPathTemplateArray<T> = (XPathTemplateObject<T> | [string, TemplateFunction<T, "dom", import("./XPathTransformerContext.js").default>])[];
+export type JSONPathTemplateArray<T> = JSONPathTemplateObject<T> | [string, TemplateFunction<T, "json", import("./JSONPathTransformerContext.js").default>];
+export type JoiningTransformer = (StringJoiningTransformer | DOMJoiningTransformer | JSONJoiningTransformer);
+export type joiningTypes = "json" | "string" | "dom";
+export type ResultType<T> = T extends "json" ? unknown : T extends "string" ? string : DocumentFragment | Element;
+/**
+ * Options common to both engines.
+ */
+export type BaseJTLTOptions<T> = {
+    /**
+     * A callback supplied
+     * with a single argument that is the result of this instance's
+     * transform() method. When used in TypeScript, this can be made
+     * generic as `success<T>(result: T): void`.
+     */
+    success: (result: ResultType<T>) => void;
     /**
-     * A JSON object
+     * A JSON
+     * object or DOM document (XPath)
      */
-    data?: any;
+    data?: string | number | boolean | object | null | undefined;
     /**
      * URL of a JSON file to retrieve for
      * evaluation
@@ -64,60 +139,233 @@ export type JTLTOptions = {
      */
     unwrapSingleResult?: boolean | undefined;
     /**
-     * The mode in which to begin the transform.
+     * When true, joiners return an array
+     * of complete documents: XMLDocument[] for DOM, document wrapper objects[]
+     * for JSON, and string[] for string joiners. Each array element corresponds
+     * to a root element built during transformation.
      */
-    mode?: string | undefined;
+    exposeDocuments?: boolean | undefined;
     /**
-     * Output type: 'string', 'dom', or 'json'
+     * The mode in which to begin the transform.
      */
-    outputType?: string | undefined;
+    mode?: string | undefined;
     /**
-     * Will be based the
+     * Will be based on the
      * same config as passed to this instance. Defaults to a transforming
      * function based on JSONPath and with its own set of priorities for
      * processing templates.
      */
-    engine?: Function | undefined;
-    /**
-     * Choose built-in engine.
-     * Defaults to 'jsonpath'. When 'xpath', `xpathVersion` may be used.
-     */
-    engineType?: "jsonpath" | "xpath" | undefined;
-    /**
-     * XPath engine version: 1 (native) or 2
-     * (xpath2.js) when `engineType` is 'xpath'.
-     */
-    xpathVersion?: 1 | 2 | undefined;
+    engine?: ((opts: JTLTOptions & Required<Pick<JTLTOptions, "joiningTransformer">>) => ResultType<T>) | undefined;
     /**
      * Callback for getting the priority by specificity
      */
-    specificityPriorityResolver?: Function | undefined;
+    specificityPriorityResolver?: ((path: string) => 0 | 0.5 | -0.5) | undefined;
     /**
-     * Can
-     * be a singleton or class instance. Defaults to string joining for output
-     * transformation.
+     * A concrete joining transformer instance (or custom subclass) responsible
+     * for accumulating output. When omitted, one is created automatically based
+     * on `outputType`.
      */
-    joiningTransformer?: {
-        get: Function;
-        append: Function;
-        string?: Function;
-        object?: Function;
-        array?: Function;
-    } | undefined;
+    joiningTransformer?: JoiningTransformer | undefined;
     /**
-     * Config to pass on to the joining
-     * transformer
+     * Config for the joining
+     * transformer.
      */
-    joiningConfig?: object | undefined;
+    joiningConfig?: import("./AbstractJoiningTransformer.js").JoiningTransformerConfig<T> | undefined;
     /**
      * Parent object for context
      */
-    parent?: any;
+    parent?: object | undefined;
     /**
      * Parent property name for context
      */
     parentProperty?: string | undefined;
 };
+/**
+ * JSONPath engine options with context-aware template typing.
+ */
+export type JSONPathJTLTOptions<T = "json"> = BaseJTLTOptions<T> & {
+    templates?: JSONPathTemplateArray<T>[];
+    template?: JSONPathTemplateObject<T> | TemplateFunction<T, "json", import("./JSONPathTransformerContext.js").default>;
+    query?: TemplateFunction<T, "json", import("./JSONPathTransformerContext.js").default>;
+    forQuery?: [string, TemplateFunction<T, "json", import("./XPathTransformerContext.js").default>];
+    engineType?: "jsonpath";
+    outputType?: T;
+};
+/**
+ * XPath engine options with context-aware template typing.
+ */
+export type XPathJTLTOptions<T> = BaseJTLTOptions<T> & {
+    templates?: XPathTemplateArray<T>;
+    template?: XPathTemplateObject<T> | TemplateFunction<T, "dom", import("./XPathTransformerContext.js").default>;
+    query?: TemplateFunction<T, "dom", import("./XPathTransformerContext.js").default>;
+    forQuery?: [string, TemplateFunction<T, "dom", import("./JSONPathTransformerContext.js").default>];
+    engineType: "xpath";
+    xpathVersion?: 1 | 2;
+    outputType?: "string" | "dom" | "json";
+};
+export type JTLTOptions = JSONPathJTLTOptions | JSONPathJTLTOptions<"string"> | JSONPathJTLTOptions<"dom"> | XPathJTLTOptions<"json"> | XPathJTLTOptions<"string"> | XPathJTLTOptions<"dom">;
+/**
+ * Internal options extension adding private runtime state flags.
+ * Not part of the public API surface but used for narrowing casts.
+ * @typedef {JTLTOptions & {
+ *   _customJoiningTransformer?: boolean
+ * }} InternalJTLTOptions
+ */
+/**
+ * A template declaration whose `template` executes with `this` bound
+ * to the engine-specific context type `TCtx`.
+ * Either `path` must be provided (for pattern matching), or `name` must be
+ * provided (for named templates callable via callTemplate), or both.
+ * @template T
+ * @template U
+ * @template TCtx
+ * @typedef {object} TemplateObject
+ * @property {string} [path] - JSONPath or XPath selector for matching nodes
+ * @property {string} [name] - Optional name for calling via callTemplate
+ * @property {string} [mode] - Optional mode for template matching
+ * @property {number} [priority] - Priority for template selection
+ * @property {TemplateFunction<T, U, TCtx>} template - Template function
+ */
+/**
+ * A callable template function with an engine-specific `this`.
+ * @template T
+ * @template U
+ * @template TCtx
+ * @typedef {(this: TCtx,
+ *   value: ResultType<U>,
+ *   cfg?: {mode?: string}
+ * ) => ResultType<T>|void} TemplateFunction
+ */
+/**
+ * @template T
+ * @typedef {TemplateObject<T, "json",
+ *   import('./JSONPathTransformerContext.js').default<T>
+ * >} JSONPathTemplateObject
+ */
+/**
+ * @template T
+ * @typedef {TemplateObject<T, "dom",
+ *   import('./XPathTransformerContext.js').default
+ * >} XPathTemplateObject
+ */
+/**
+ * @template T
+ * @typedef {(XPathTemplateObject<T> | [string, TemplateFunction<T, "dom",
+ *   import('./XPathTransformerContext.js').default
+ * >])[]} XPathTemplateArray
+ */
+/**
+ * @template T
+ * @typedef {JSONPathTemplateObject<T> | [string, TemplateFunction<T, "json",
+ *   import('./JSONPathTransformerContext.js').default
+ * >]} JSONPathTemplateArray
+ */
+/**
+ * @typedef {(
+ *   StringJoiningTransformer|
+ *   DOMJoiningTransformer|
+ *   JSONJoiningTransformer
+ * )} JoiningTransformer
+ */
+/**
+ * @typedef {"json"|"string"|"dom"} joiningTypes
+ */
+/**
+ * @template T
+ * @typedef {T extends "json" ? unknown : T extends "string" ? string :
+ *   DocumentFragment|Element} ResultType
+ */
+/**
+ * Options common to both engines.
+ * @template T
+ * @typedef {object} BaseJTLTOptions
+ * @property {(
+ *   result: ResultType<T>
+ * ) => void} success A callback supplied
+ *   with a single argument that is the result of this instance's
+ *   transform() method. When used in TypeScript, this can be made
+ *   generic as `success<T>(result: T): void`.
+ * @property {null|boolean|number|string|object} [data] A JSON
+ *   object or DOM document (XPath)
+ * @property {string} [ajaxData] URL of a JSON file to retrieve for
+ * evaluation
+ * @property {boolean} [errorOnEqualPriority] Whether or not to
+ * report an error when equal priority templates are found
+ * @property {boolean} [autostart] Whether to begin transform()
+ * immediately.
+ * @property {boolean} [preventEval] Whether to prevent
+ * parenthetical evaluations in JSONPath. Safer if relying on user
+ * input, but reduces capabilities of JSONPath.
+ * @property {boolean} [unwrapSingleResult] For JSON output, whether to
+ * unwrap single-element root arrays to return just the element
+ * @property {boolean} [exposeDocuments] When true, joiners return an array
+ * of complete documents: XMLDocument[] for DOM, document wrapper objects[]
+ * for JSON, and string[] for string joiners. Each array element corresponds
+ * to a root element built during transformation.
+ * @property {string} [mode] The mode in which to begin the transform.
+ * @property {(opts: JTLTOptions &
+ *   Required<Pick<JTLTOptions, "joiningTransformer">>
+ * ) => ResultType<T>} [engine] Will be based on the
+ * same config as passed to this instance. Defaults to a transforming
+ * function based on JSONPath and with its own set of priorities for
+ * processing templates.
+ * @property {(path: string) => 0 | 0.5 | -0.5} [specificityPriorityResolver]
+ * Callback for getting the priority by specificity
+ * @property {JoiningTransformer} [joiningTransformer]
+ * A concrete joining transformer instance (or custom subclass) responsible
+ * for accumulating output. When omitted, one is created automatically based
+ * on `outputType`.
+ * @property {import('./AbstractJoiningTransformer.js').
+ *   JoiningTransformerConfig<T>} [joiningConfig] Config for the joining
+ *   transformer.
+ * @property {object} [parent] Parent object for context
+ * @property {string} [parentProperty] Parent property name for context
+ */
+/**
+ * JSONPath engine options with context-aware template typing.
+ * @template [T = "json"]
+ * @typedef {BaseJTLTOptions<T> & {
+ *   templates?: JSONPathTemplateArray<T>[],
+ *   template?: JSONPathTemplateObject<T> | TemplateFunction<T, "json",
+ *     import('./JSONPathTransformerContext.js').default
+ *   >,
+ *   query?: TemplateFunction<T, "json",
+ *     import('./JSONPathTransformerContext.js').default
+ *   >,
+ *   forQuery?: [string, TemplateFunction<T, "json",
+ *     import('./XPathTransformerContext.js').default
+ *   >],
+ *   engineType?: 'jsonpath',
+ *   outputType?: T
+ * }} JSONPathJTLTOptions
+ */
+/**
+ * XPath engine options with context-aware template typing.
+ * @template T
+ * @typedef {BaseJTLTOptions<T> & {
+ *   templates?: XPathTemplateArray<T>,
+ *   template?: XPathTemplateObject<T> | TemplateFunction<T, "dom",
+ *     import('./XPathTransformerContext.js').default
+ *   >,
+ *   query?: TemplateFunction<T, "dom",
+ *     import('./XPathTransformerContext.js').default
+ *   >,
+ *   forQuery?: [string, TemplateFunction<T, "dom",
+ *     import('./JSONPathTransformerContext.js').default
+ *   >],
+ *   engineType: 'xpath',
+ *   xpathVersion?: 1|2,
+ *   outputType?: 'string'|'dom'|'json'
+ * }} XPathJTLTOptions
+ */
+/**
+ * @typedef {JSONPathJTLTOptions |
+ *   JSONPathJTLTOptions<"string"> |
+ *   JSONPathJTLTOptions<"dom"> |
+ *   XPathJTLTOptions<"json">|
+ *   XPathJTLTOptions<"string">|
+ *   XPathJTLTOptions<"dom">} JTLTOptions
+ */
 /**
  * High-level façade for running a JTLT transform.
  *
@@ -132,10 +380,35 @@ declare class JTLT {
      * config.template, or config.templates, but one must be
      * present and of valid type. For the source json, one must use
      * either a valid config.ajaxData or config.data parameter.
-     * @param {JTLTOptions} config Options
-     * @todo Remove JSONPath dependency in query use of '$'?
+     * @overload
+     * @param {JSONPathJTLTOptions} config Options for JSONPath engine
+     */
+    constructor(config: JSONPathJTLTOptions);
+    /**
+     * @overload
+     * @param {JSONPathJTLTOptions<"string">} config Options for JSONPath engine
+     */
+    constructor(config: JSONPathJTLTOptions<"string">);
+    /**
+     * @overload
+     * @param {JSONPathJTLTOptions<"dom">} config Options for JSONPath engine
+     */
+    constructor(config: JSONPathJTLTOptions<"dom">);
+    /**
+     * @overload
+     * @param {XPathJTLTOptions<"json">} config Options for XPath engine
+     */
+    constructor(config: XPathJTLTOptions<"json">);
+    /**
+     * @overload
+     * @param {XPathJTLTOptions<"string">} config Options for XPath engine
      */
-    constructor(config: JTLTOptions);
+    constructor(config: XPathJTLTOptions<"string">);
+    /**
+     * @overload
+     * @param {XPathJTLTOptions<"dom">} config Options for XPath engine
+     */
+    constructor(config: XPathJTLTOptions<"dom">);
     /** @type {JTLTOptions} */
     config: JTLTOptions;
     /**
@@ -144,25 +417,25 @@ declare class JTLT {
      */
     _createJoiningTransformer(): DOMJoiningTransformer | JSONJoiningTransformer | StringJoiningTransformer;
     /**
-     * @param {string} mode
+     * @param {string|undefined} mode
      * @returns {void}
      */
-    _autoStart(mode: string): void;
+    _autoStart(mode: string | undefined): void;
     /**
      * @param {JTLTOptions} config
      * @returns {JTLT}
      */
     setDefaults(config: JTLTOptions): JTLT;
     /**
-     * @param {string} mode The mode of the transformation
-     * @returns {any} Result of transformation
+     * @param {string} [mode] The mode of the transformation
+     * @returns {void}
      * @todo Allow for a success callback in case the jsonpath code is modified
      *     to work asynchronously (as with queries to access remote JSON
      *     stores)
      */
-    transform(mode: string): any;
+    transform(mode?: string): void;
 }
+import StringJoiningTransformer from './StringJoiningTransformer.js';
 import DOMJoiningTransformer from './DOMJoiningTransformer.js';
 import JSONJoiningTransformer from './JSONJoiningTransformer.js';
-import StringJoiningTransformer from './StringJoiningTransformer.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA0Bc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA8BH,GAAG;;;;;;AAOjB;;;;;;;GAOG;AACH;IACE;;;;;;;OAOG;IACH,oBAHW,WAAW,EA4BrB;IAxBC,0BAA0B;IAC1B,QADW,WAAW,CACI;IAyB5B;;;OAGG;IACH,6BAHa,qBAAqB,GAAC,sBAAsB,GACpD,wBAAwB,CAuD5B;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,IAAI,CAYhB;IAED;;;OAGG;IACH,oBAHW,WAAW,GACT,IAAI,CAoDhB;IAED;;;;;;OAMG;IACH,gBANW,MAAM,GACJ,GAAG,CA2Bf;CACF;kCApQiC,4BAA4B;mCAC3B,6BAA6B;qCAG3B,+BAA+B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Public JSDoc typedef aggregates for jtlt. Migrated from `typings/jtlt.d.ts`
+ * into a runtime JS module so declaration emit will produce `dist/types.d.ts`.
+ * Consumers can import these types in TS projects; the runtime exports are
+ * re-exported for convenience.
+ */
+/**
+ * @typedef {import('./JSONPathTransformerContext.js').default}
+ *   JSONPathTransformerContext
+ */
+/**
+ * @typedef {import('./XPathTransformerContext.js').default}
+ *   XPathTransformerContext
+ */
+/**
+ * @typedef {import('./AbstractJoiningTransformer.js').default<"string">|
+ *   import('./AbstractJoiningTransformer.js').default<"json">|
+ *   import('./AbstractJoiningTransformer.js').default<"dom">}
+ *   AbstractJoiningTransformer
+ */
+/**
+ * @typedef {import('./DOMJoiningTransformer.js').default}
+ *   DOMJoiningTransformer
+ */
+/**
+ * @typedef {import('./JSONJoiningTransformer.js').default}
+ *   JSONJoiningTransformer
+ */
+/**
+ * @typedef {import('./StringJoiningTransformer.js').default}
+ *   StringJoiningTransformer
+ */
+/**
+ * Generic template callable bound to a context type.
+ * @template TCtx
+ * @typedef {(this: TCtx, value?: unknown,
+ *   cfg?: {mode?: string}
+ * ) => unknown} TemplateFunction
+ */
+/**
+ * Template object with metadata and bound template function.
+ * @template TCtx
+ * @typedef {object} TemplateObject
+ * @property {string} path
+ * @property {(
+ *   'root' |
+ *   'transformRoot' |
+ *   'transformElements' |
+ *   'transformTextNodes' |
+ *   'transformScalars' |
+ *   'transformPropertyNames' |
+ *   'transformArrays' |
+ *   'transformObjects' |
+ *   'transformFunctions' |
+ *   string
+ * )} [name]
+ * @property {string} [mode]
+ * @property {number} [priority]
+ * @property {TemplateFunction<TCtx>} template
+ */
+/**
+ * @typedef {TemplateObject<JSONPathTransformerContext>}
+ *   JSONPathTemplateObject
+ */
+/**
+ * @typedef {TemplateObject<XPathTransformerContext>}
+ *   XPathTemplateObject
+ */
+/**
+ * Options common to both engines.
+ * @typedef {object} BaseJTLTOptions
+ * @property {(result: unknown) => void} success Callback receiving transform
+ *   result
+ * @property {unknown} [data] JSON object or DOM Document/Element
+ * @property {string} [ajaxData] URL for JSON retrieval
+ * @property {boolean} [errorOnEqualPriority]
+ * @property {boolean} [autostart]
+ * @property {boolean} [preventEval]
+ * @property {boolean} [unwrapSingleResult]
+ * @property {string} [mode]
+ * @property {'string'|'dom'|'json'} [outputType]
+ * @property {(opts: JTLTOptions) => unknown} [engine]
+ * @property {(path: string) => 0|0.5|-0.5} [specificityPriorityResolver]
+ * @property {AbstractJoiningTransformer} [joiningTransformer]
+ * @property {Record<string, unknown>} [joiningConfig]
+ * @property {unknown} [parent]
+ * @property {string} [parentProperty]
+ * @property {unknown[]} [forQuery]
+ */
+/**
+ * JSONPath engine options.
+ * @typedef {BaseJTLTOptions & {
+ *   templates?: JSONPathTemplateObject[] |
+ *     TemplateFunction<JSONPathTransformerContext>,
+ *   template?: JSONPathTemplateObject |
+ *     TemplateFunction<JSONPathTransformerContext>,
+ *   query?: TemplateFunction<JSONPathTransformerContext>,
+ *   engineType?: 'jsonpath'
+ * }} JSONPathJTLTOptions
+ */
+/**
+ * XPath engine options.
+ * @typedef {BaseJTLTOptions & {
+ *   templates?: XPathTemplateObject[] |
+ *     TemplateFunction<XPathTransformerContext>,
+ *   template?: XPathTemplateObject |
+ *     TemplateFunction<XPathTransformerContext>,
+ *   query?: TemplateFunction<XPathTransformerContext>,
+ *   engineType: 'xpath',
+ *   xpathVersion?: 1|2
+ * }} XPathJTLTOptions
+ */
+/** @typedef {JSONPathJTLTOptions | XPathJTLTOptions} JTLTOptions */
+/**
+ * Internal options extension adding private runtime state flags.
+ * Not part of the public API surface but used for narrowing casts.
+ * @typedef {JTLTOptions & {
+ *   _customJoiningTransformer?: boolean
+ * }} InternalJTLTOptions
+ */
+export const typesModuleMarker: true;
+export type JSONPathTransformerContext = import("./JSONPathTransformerContext.js").default;
+export type XPathTransformerContext = import("./XPathTransformerContext.js").default;
+export type AbstractJoiningTransformer = import("./AbstractJoiningTransformer.js").default<"string"> | import("./AbstractJoiningTransformer.js").default<"json"> | import("./AbstractJoiningTransformer.js").default<"dom">;
+export type DOMJoiningTransformer = import("./DOMJoiningTransformer.js").default;
+export type JSONJoiningTransformer = import("./JSONJoiningTransformer.js").default;
+export type StringJoiningTransformer = import("./StringJoiningTransformer.js").default;
+/**
+ * Generic template callable bound to a context type.
+ */
+export type TemplateFunction<TCtx> = (this: TCtx, value?: unknown, cfg?: {
+    mode?: string;
+}) => unknown;
+/**
+ * Template object with metadata and bound template function.
+ */
+export type TemplateObject<TCtx> = {
+    path: string;
+    name?: string | undefined;
+    mode?: string | undefined;
+    priority?: number | undefined;
+    template: TemplateFunction<TCtx>;
+};
+export type JSONPathTemplateObject = TemplateObject<JSONPathTransformerContext>;
+export type XPathTemplateObject = TemplateObject<XPathTransformerContext>;
+/**
+ * Options common to both engines.
+ */
+export type BaseJTLTOptions = {
+    /**
+     * Callback receiving transform
+     * result
+     */
+    success: (result: unknown) => void;
+    /**
+     * JSON object or DOM Document/Element
+     */
+    data?: unknown;
+    /**
+     * URL for JSON retrieval
+     */
+    ajaxData?: string | undefined;
+    errorOnEqualPriority?: boolean | undefined;
+    autostart?: boolean | undefined;
+    preventEval?: boolean | undefined;
+    unwrapSingleResult?: boolean | undefined;
+    mode?: string | undefined;
+    outputType?: "string" | "dom" | "json" | undefined;
+    engine?: ((opts: JTLTOptions) => unknown) | undefined;
+    specificityPriorityResolver?: ((path: string) => 0 | 0.5 | -0.5) | undefined;
+    joiningTransformer?: AbstractJoiningTransformer | undefined;
+    joiningConfig?: Record<string, unknown> | undefined;
+    parent?: unknown;
+    parentProperty?: string | undefined;
+    forQuery?: unknown[] | undefined;
+};
+/**
+ * JSONPath engine options.
+ */
+export type JSONPathJTLTOptions = BaseJTLTOptions & {
+    templates?: JSONPathTemplateObject[] | TemplateFunction<JSONPathTransformerContext>;
+    template?: JSONPathTemplateObject | TemplateFunction<JSONPathTransformerContext>;
+    query?: TemplateFunction<JSONPathTransformerContext>;
+    engineType?: "jsonpath";
+};
+/**
+ * XPath engine options.
+ */
+export type XPathJTLTOptions = BaseJTLTOptions & {
+    templates?: XPathTemplateObject[] | TemplateFunction<XPathTransformerContext>;
+    template?: XPathTemplateObject | TemplateFunction<XPathTransformerContext>;
+    query?: TemplateFunction<XPathTransformerContext>;
+    engineType: "xpath";
+    xpathVersion?: 1 | 2;
+};
+export type JTLTOptions = JSONPathJTLTOptions | XPathJTLTOptions;
+/**
+ * Internal options extension adding private runtime state flags.
+ * Not part of the public API surface but used for narrowing casts.
+ */
+export type InternalJTLTOptions = JTLTOptions & {
+    _customJoiningTransformer?: boolean;
+};
+//# sourceMappingURL=types.d.ts.map