mixpeek 0.81.1

package/dist/models/stage-params-sample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-params-sample.d.ts","sourceRoot":"","sources":["../../models/stage-params-sample.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAIH;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAC9B;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,UAAU,CAAC,EAAE,6BAA6B,CAAC;IAC3C;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,eAAO,MAAM,6BAA6B;;;;CAIhC,CAAC;AAEX,MAAM,MAAM,6BAA6B,GAAG,OAAO,6BAA6B,CAAC,MAAM,OAAO,6BAA6B,CAAC,CAAC"}

package/dist/models/stage-params-sort-attribute.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Mixpeek API
+ * This is the Mixpeek API, providing access to various endpoints for data processing and retrieval.
+ *
+ * The version of the OpenAPI document: 0.81.1
+ * Contact: info@mixpeek.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { StageDefsSortDirection } from './stage-defs-sort-direction';
+/**
+ * Configuration for sorting documents by an attribute field.  **Stage Category**: SORT  **Transformation**: N documents → N documents (same docs, different order, same schema)  **Purpose**: Reorders documents in the pipeline based on any document attribute (not just relevance scores). Use this for sorting by metadata fields like dates, popularity, priority, or custom attributes.  **When to Use**:     - Sort by timestamps (created_at, updated_at, published_date)     - Sort by numeric metadata (popularity, view_count, rating, price)     - Sort by string attributes (title, category) with optional case-insensitive comparison     - Apply business logic ordering (priority, status)     - Secondary sorting after relevance-based retrieval  **When NOT to Use**:     - For sorting by relevance/similarity scores (use sort_relevance instead)     - For initial document retrieval (use FILTER stages)     - For removing documents (use FILTER stages)     - For enriching documents (use APPLY stages)  **Operational Behavior**:     - Operates on in-memory document results (no database queries)     - Maintains all documents, just changes their order     - Fast operation (simple in-memory sort)     - Does not change document count or schema     - Handles null values gracefully (configurable placement)  **Common Pipeline Position**: FILTER → SORT (this stage) → APPLY  Requirements:     - field: REQUIRED, document field path to sort on     - direction: OPTIONAL, defaults to descending     - nulls_last: OPTIONAL, defaults to true (nulls at end)  Use Cases:     - Recent content first: Sort by published_date desc     - Popular content: Sort by view_count or popularity score     - Alphabetical: Sort by title or name     - Priority-based: Sort by urgency or importance ratings     - Temporal ordering: Sort by event timestamps
+ * @export
+ * @interface StageParamsSortAttribute
+ */
+export interface StageParamsSortAttribute {
+    /**
+     * Document field path to sort on. Use dot notation for nested fields (e.g., \'metadata.release_date\'). Supports template expressions for dynamic field selection. Can sort by strings, numbers, dates, or booleans. Examples: \'metadata.created_at\', \'metadata.popularity\', \'title\'.
+     * @type {string}
+     * @memberof StageParamsSortAttribute
+     */
+    'field'?: string;
+    /**
+     * OPTIONAL. Sort direction. \'desc\' (default): Highest/latest values first (Z-A, 100-0, newest-oldest). \'asc\': Lowest/earliest values first (A-Z, 0-100, oldest-newest).
+     * @type {StageDefsSortDirection}
+     * @memberof StageParamsSortAttribute
+     */
+    'direction'?: StageDefsSortDirection;
+    /**
+     * OPTIONAL. Whether documents with null/missing field values should be placed at the end of results regardless of sort direction. true (default): Nulls always at the end. false: Nulls follow natural sort order (beginning for asc, end for desc).
+     * @type {boolean}
+     * @memberof StageParamsSortAttribute
+     */
+    'nulls_last'?: boolean;
+}
+//# sourceMappingURL=stage-params-sort-attribute.d.ts.map

package/dist/models/stage-params-sort-attribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-params-sort-attribute.d.ts","sourceRoot":"","sources":["../../models/stage-params-sort-attribute.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAE1E;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACrC;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,WAAW,CAAC,EAAE,sBAAsB,CAAC;IACrC;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CAC1B"}

package/dist/models/stage-params-sort-relevance.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Mixpeek API
+ * This is the Mixpeek API, providing access to various endpoints for data processing and retrieval.
+ *
+ * The version of the OpenAPI document: 0.81.1
+ * Contact: info@mixpeek.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { StageDefsSortDirection } from './stage-defs-sort-direction';
+/**
+ * Configuration for re-sorting documents by relevance score.  **Stage Category**: SORT  **Transformation**: N documents → N documents (same docs, different order, same schema)  **Purpose**: Reorders documents in the pipeline based on their relevance scores. This stage does NOT add/remove documents - it only changes their order.  **When to Use**:     - After SEARCH stages to reorder results by their similarity scores     - After multiple SEARCH stages are merged to apply final relevance ordering     - When you need to sort by a custom score field (not just top-level score)     - To apply consistent ordering after filtering operations  **When NOT to Use**:     - For initial document retrieval (use FILTER stages: hybrid_search)     - For removing documents (use FILTER stages: attribute_filter, llm_filter)     - For sorting by non-score attributes (use sort_attribute instead)     - For enriching documents (use APPLY stages)  **Operational Behavior**:     - Operates on in-memory document results (no database queries)     - Maintains all documents, just changes their order     - Fast operation (simple in-memory sort)     - Does not change document count or schema  **Common Pipeline Position**: FILTER → SORT (this stage) → APPLY  Requirements:     - score_field: OPTIONAL, defaults to \"score\"     - direction: OPTIONAL, defaults to descending (highest scores first)     - feature_address: OPTIONAL, for computing similarity when scores missing     - missing_score: OPTIONAL, controls placement of documents without scores  Use Cases:     - Standard relevance ranking: Sort search results by similarity scores     - Custom scoring: Sort by model-specific scores (metadata.rerank_score)     - Multi-stage pipelines: Final ordering after complex filtering     - Hybrid search: Order fused results by combined scores
+ * @export
+ * @interface StageParamsSortRelevance
+ */
+export interface StageParamsSortRelevance {
+    /**
+     * OPTIONAL. Document field path to use for sorting. Defaults to top-level \'score\' field populated by SEARCH stages. Use dot notation for nested fields (e.g., \'metadata.rerank_score\'). Supports template expressions for dynamic field selection.
+     * @type {string}
+     * @memberof StageParamsSortRelevance
+     */
+    'score_field'?: string;
+    /**
+     * OPTIONAL. Sort direction for relevance scores. \'desc\' (default): Highest scores first (most relevant). \'asc\': Lowest scores first (least relevant, rarely used).
+     * @type {StageDefsSortDirection}
+     * @memberof StageParamsSortRelevance
+     */
+    'direction'?: StageDefsSortDirection;
+    /**
+     * OPTIONAL. Feature address to compute similarity when scores are missing. If a document lacks the score_field, the system can compute similarity using this feature and the query embedding from earlier SEARCH stages. Format: \'mixpeek://extractor@version/output\'. NOT REQUIRED - only use when expecting missing scores and want to compute them.
+     * @type {string}
+     * @memberof StageParamsSortRelevance
+     */
+    'feature_address'?: string;
+    /**
+     * OPTIONAL. How to handle documents without a score_field value. \'bottom\' (default): Place at end of results (lowest priority). \'top\': Place at start of results (highest priority, rarely used). \'preserve\': Keep in original position (maintain insertion order).
+     * @type {string}
+     * @memberof StageParamsSortRelevance
+     */
+    'missing_score'?: StageParamsSortRelevanceMissingScoreEnum;
+}
+export declare const StageParamsSortRelevanceMissingScoreEnum: {
+    readonly Bottom: "bottom";
+    readonly Top: "top";
+    readonly Preserve: "preserve";
+};
+export type StageParamsSortRelevanceMissingScoreEnum = typeof StageParamsSortRelevanceMissingScoreEnum[keyof typeof StageParamsSortRelevanceMissingScoreEnum];
+//# sourceMappingURL=stage-params-sort-relevance.d.ts.map

package/dist/models/stage-params-sort-relevance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-params-sort-relevance.d.ts","sourceRoot":"","sources":["../../models/stage-params-sort-relevance.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAE1E;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACrC;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,WAAW,CAAC,EAAE,sBAAsB,CAAC;IACrC;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,eAAe,CAAC,EAAE,wCAAwC,CAAC;CAC9D;AAED,eAAO,MAAM,wCAAwC;;;;CAI3C,CAAC;AAEX,MAAM,MAAM,wCAAwC,GAAG,OAAO,wCAAwC,CAAC,MAAM,OAAO,wCAAwC,CAAC,CAAC"}

package/dist/models/stage-params-sql-lookup.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Mixpeek API
+ * This is the Mixpeek API, providing access to various endpoints for data processing and retrieval.
+ *
+ * The version of the OpenAPI document: 0.81.1
+ * Contact: info@mixpeek.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { StageDefsErrorHandling } from './stage-defs-error-handling';
+import type { StageDefsLogicalOperator } from './stage-defs-logical-operator';
+import type { StageDefsOnNoResults } from './stage-defs-on-no-results';
+import type { StageDefsResultHandling } from './stage-defs-result-handling';
+/**
+ * Configuration for SQL Lookup enrichment stage.  **Stage Category**: APPLY (1-1 Enrichment or 0-M Document Creation)  **Transformation**: - With documents: N documents -> N documents (expanded schema) - Without documents: 0 documents -> M documents (from SQL results)  **Purpose**: Enriches documents by running SQL queries against organization connections (PostgreSQL, Snowflake). Enables joining structured database data with document pipelines.  **Security**: - Only SELECT queries allowed (no INSERT/UPDATE/DELETE/DROP) - Uses parameterized queries to prevent SQL injection - Connection credentials managed via organization connections - Query timeout enforced  **Supported Providers**: - PostgreSQL: Full SQL support with $1, $2 placeholders - Snowflake: Full SQL support (coming soon)  **When to Use**: - Lookup customer data from database by ID - Enrich products with inventory information - Join document metadata with relational data - Create documents from SQL query results  **When NOT to Use**: - Complex analytics queries (use dedicated analytics tools) - High-volume batch operations (use ETL pipelines) - Real-time streaming (use event systems)  Requirements:     - connection_id: REQUIRED, organization connection ID or name     - query: REQUIRED, SQL SELECT query     - parameters: OPTIONAL, named parameters for query     - output_field: OPTIONAL, where to store results     - result_handling: OPTIONAL, how to handle multiple rows     - timeout: OPTIONAL, query timeout (default: 30s)     - when: OPTIONAL, conditional enrichment filter     - on_error: OPTIONAL, error handling strategy
+ * @export
+ * @interface StageParamsSqlLookup
+ */
+export interface StageParamsSqlLookup {
+    /**
+     * REQUIRED. Organization connection ID (conn_...) or name. Connection must be SQL-capable (PostgreSQL or Snowflake). Use POST /v1/organizations/connections to create connections. Example: \'conn_abc123\' or \'my_postgres_db\'
+     * @type {string}
+     * @memberof StageParamsSqlLookup
+     */
+    'connection_id': string;
+    /**
+     * REQUIRED. SQL SELECT query to execute. Only SELECT queries allowed - mutations are blocked. Use $1, $2, etc. for PostgreSQL parameter placeholders. Supports template variables in \'parameters\' field values. Example: \'SELECT * FROM products WHERE sku = $1\'
+     * @type {string}
+     * @memberof StageParamsSqlLookup
+     */
+    'query': string;
+    /**
+     * OPTIONAL. Named parameters for SQL query. Keys are parameter names, values support template syntax. Parameters are converted to positional args ($1, $2) in order. Template variables: {{DOC.field}}, {{INPUT.field}}, {{SECRET.name}}. Example: {\'sku\': \'{{DOC.metadata.sku}}\'}
+     * @type {{ [key: string]: any; }}
+     * @memberof StageParamsSqlLookup
+     */
+    'parameters'?: {
+        [key: string]: any;
+    };
+    /**
+     * OPTIONAL. Dot-path where SQL results should be stored. Creates nested structure if needed. For FIRST mode: single object. For ALL mode: array of objects. Default: \'sql_result\'. Note: Avoid using \'metadata.*\' paths as the metadata field is excluded from API responses.
+     * @type {string}
+     * @memberof StageParamsSqlLookup
+     */
+    'output_field'?: string;
+    /**
+     * OPTIONAL. How to handle multiple result rows. \'first\': Return only first row (default). \'all\': Return all rows as array. \'error_if_empty\': Error if no results. \'error_if_multiple\': Error if more than one result.
+     * @type {StageDefsResultHandling}
+     * @memberof StageParamsSqlLookup
+     */
+    'result_handling'?: StageDefsResultHandling;
+    /**
+     * OPTIONAL. Behavior when query returns no rows. \'skip\': Keep document unchanged. \'null\': Set output_field to null (default). \'error\': Raise error.
+     * @type {StageDefsOnNoResults}
+     * @memberof StageParamsSqlLookup
+     */
+    'on_no_results'?: StageDefsOnNoResults;
+    /**
+     * OPTIONAL. Query timeout in seconds. Range: 1-300. Default: 30. Increase for complex queries.
+     * @type {number}
+     * @memberof StageParamsSqlLookup
+     */
+    'timeout'?: number;
+    /**
+     * OPTIONAL. Conditional filter for selective enrichment. Only documents matching condition will execute SQL lookup. RECOMMENDED for performance optimization.
+     * @type {StageDefsLogicalOperator}
+     * @memberof StageParamsSqlLookup
+     */
+    'when'?: StageDefsLogicalOperator;
+    /**
+     * OPTIONAL. Error handling strategy. \'skip\': Pass document through unchanged (default). \'remove\': Remove failed documents. \'raise\': Halt pipeline on error.
+     * @type {StageDefsErrorHandling}
+     * @memberof StageParamsSqlLookup
+     */
+    'on_error'?: StageDefsErrorHandling;
+}
+//# sourceMappingURL=stage-params-sql-lookup.d.ts.map

package/dist/models/stage-params-sql-lookup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-params-sql-lookup.d.ts","sourceRoot":"","sources":["../../models/stage-params-sql-lookup.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAG1E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAG9E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAGvE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAE5E;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACjC;;;;OAIG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,YAAY,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KAAE,CAAC;IACvC;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,uBAAuB,CAAC;IAC5C;;;;OAIG;IACH,eAAe,CAAC,EAAE,oBAAoB,CAAC;IACvC;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,MAAM,CAAC,EAAE,wBAAwB,CAAC;IAClC;;;;OAIG;IACH,UAAU,CAAC,EAAE,sBAAsB,CAAC;CACvC"}

package/dist/models/stage-params-summarize.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Mixpeek API
+ * This is the Mixpeek API, providing access to various endpoints for data processing and retrieval.
+ *
+ * The version of the OpenAPI document: 0.81.1
+ * Contact: info@mixpeek.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { StageDefsLLMProvider } from './stage-defs-llmprovider';
+/**
+ * Configuration for multi-document summarization.  **Stage Category**: REDUCE  **Transformation**: N documents → 1 document (or N → M with group_by)  **Purpose**: Condense multiple documents into a single summary using an LLM. Unlike llm_enrich which processes each document independently, Summarize provides all documents to the LLM in a single call, enabling cross-document synthesis and comparison.  **When to Use**:     - Generate a single answer from search results (RAG output)     - Create executive summaries from multiple sources     - Synthesize information that spans multiple documents     - Reduce result set to key findings  **When NOT to Use**:     - Adding fields to each document (use llm_enrich instead)     - Simple filtering based on content (use llm_filter instead)     - When you need to preserve individual documents  **Common Pipeline Position**: feature_search → rerank → summarize  **Template Variables**:     - `{{DOCUMENTS}}`: Formatted list of all documents (required in prompt)     - `{{DOC_COUNT}}`: Number of documents being summarized     - `{{INPUT.*}}`: Access query inputs     - `{{CONTEXT.*}}`: Access execution context  Examples:     Basic summarization:         ```json         {             \"prompt\": \"Summarize these {{DOC_COUNT}} search results:\\n\\n{{DOCUMENTS}}\",             \"provider\": \"google\",             \"model_name\": \"gemini-2.0-flash\"         }         ```      Question-answering from search results:         ```json         {             \"prompt\": \"Answer this question: {{INPUT.question}}\\n\\nBased on these documents:\\n{{DOCUMENTS}}\",             \"provider\": \"openai\",             \"model_name\": \"gpt-4o\",             \"include_sources\": true         }         ```      Per-category summarization:         ```json         {             \"prompt\": \"Summarize documents about {{GROUP_VALUE}}:\\n\\n{{DOCUMENTS}}\",             \"provider\": \"openai\",             \"model_name\": \"gpt-4o-mini\",             \"group_by\": \"metadata.category\"         }         ```
+ * @export
+ * @interface StageParamsSummarize
+ */
+export interface StageParamsSummarize {
+    /**
+     * REQUIRED. Prompt template for the LLM. Must include {{DOCUMENTS}} placeholder.   Available placeholders: - {{DOCUMENTS}}: Formatted list of all documents - {{DOC_COUNT}}: Number of documents - {{GROUP_VALUE}}: Current group value (when using group_by) - {{INPUT.*}}: Query input values - {{CONTEXT.*}}: Execution context
+     * @type {string}
+     * @memberof StageParamsSummarize
+     */
+    'prompt'?: string;
+    /**
+     * LLM provider to use. Supported providers: - openai: GPT models (GPT-4o, GPT-4o-mini) - google: Gemini models (Gemini 2.0 Flash) - anthropic: Claude models (Claude 3.5 Sonnet/Haiku)  If not specified, defaults to \'google\'. Can be auto-inferred from model_name.
+     * @type {StageDefsLLMProvider}
+     * @memberof StageParamsSummarize
+     */
+    'provider'?: StageDefsLLMProvider;
+    /**
+     * Specific LLM model to use. If not specified, uses provider default. Examples: gemini-2.0-flash, gpt-4o-mini, gpt-4o
+     * @type {string}
+     * @memberof StageParamsSummarize
+     */
+    'model_name'?: string;
+    /**
+     * DEPRECATED: Use \'provider\' and \'model_name\' instead. Legacy format: \'provider:model\' (e.g., \'gemini:gemini-2.0-flash\'). Kept for backward compatibility only.
+     * @type {string}
+     * @memberof StageParamsSummarize
+     * @deprecated
+     */
+    'inference_name'?: string;
+    /**
+     * OPTIONAL. Template for formatting each document in {{DOCUMENTS}}. Default: \'[{{INDEX}}] {{DOC.content}}\\n\'.   Available placeholders: - {{INDEX}}: 1-based document index - {{DOC.*}}: Any document field (e.g., {{DOC.content}}, {{DOC.metadata.title}})
+     * @type {string}
+     * @memberof StageParamsSummarize
+     */
+    'document_template'?: string;
+    /**
+     * OPTIONAL. Primary field to extract content from each document. Used when {{DOC.content}} is referenced in document_template. Supports dot notation for nested fields.
+     * @type {string}
+     * @memberof StageParamsSummarize
+     */
+    'content_field'?: string;
+    /**
+     * OPTIONAL. Field to group documents by before summarization. When set, creates one summary per unique group value (N→M transformation). When not set, creates one summary for all documents (N→1 transformation).   Use cases: - \'metadata.category\': One summary per category - \'metadata.source\': One summary per source - \'metadata.date\': One summary per date
+     * @type {string}
+     * @memberof StageParamsSummarize
+     */
+    'group_by'?: string;
+    /**
+     * OPTIONAL. Field name for the summary in the output document. Default: \'summary\'.
+     * @type {string}
+     * @memberof StageParamsSummarize
+     */
+    'output_field'?: string;
+    /**
+     * OPTIONAL. Include source document IDs in output. When true, adds \'source_document_ids\' field to output. Useful for citation and attribution.
+     * @type {boolean}
+     * @memberof StageParamsSummarize
+     */
+    'include_sources'?: boolean;
+    /**
+     * OPTIONAL. Include metadata about summarization in output. Adds \'document_count\', \'tokens_used\', etc.
+     * @type {boolean}
+     * @memberof StageParamsSummarize
+     */
+    'include_metadata'?: boolean;
+    /**
+     * OPTIONAL. Maximum tokens to use for input documents. Documents exceeding this limit are truncated using truncation_strategy. Default: 8000 (safe for most models).
+     * @type {number}
+     * @memberof StageParamsSummarize
+     */
+    'max_input_tokens'?: number;
+    /**
+     * OPTIONAL. How to handle documents exceeding max_input_tokens.   Strategies: - \'drop_last\': Include documents in order until limit, drop remaining - \'truncate_each\': Give each document equal token budget, truncate individually - \'smart\': Prioritize by relevance score, truncate lower-scored documents first
+     * @type {string}
+     * @memberof StageParamsSummarize
+     */
+    'truncation_strategy'?: StageParamsSummarizeTruncationStrategyEnum;
+    /**
+     * OPTIONAL. LLM temperature for summary generation. Lower values (0.1-0.3) produce more focused, deterministic summaries. Higher values (0.7-1.0) produce more creative, varied summaries. Default: 0.3 (factual summarization).
+     * @type {number}
+     * @memberof StageParamsSummarize
+     */
+    'temperature'?: number;
+    /**
+     * OPTIONAL. Maximum tokens for the summary output. Default: 1024.
+     * @type {number}
+     * @memberof StageParamsSummarize
+     */
+    'max_output_tokens'?: number;
+    /**
+     * OPTIONAL. JSON schema for structured output. When provided, LLM output is parsed as JSON matching this schema.
+     * @type {{ [key: string]: any; }}
+     * @memberof StageParamsSummarize
+     */
+    'output_schema'?: {
+        [key: string]: any;
+    };
+}
+export declare const StageParamsSummarizeTruncationStrategyEnum: {
+    readonly DropLast: "drop_last";
+    readonly TruncateEach: "truncate_each";
+    readonly Smart: "smart";
+};
+export type StageParamsSummarizeTruncationStrategyEnum = typeof StageParamsSummarizeTruncationStrategyEnum[keyof typeof StageParamsSummarizeTruncationStrategyEnum];
+//# sourceMappingURL=stage-params-summarize.d.ts.map

package/dist/models/stage-params-summarize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-params-summarize.d.ts","sourceRoot":"","sources":["../../models/stage-params-summarize.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACjC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,UAAU,CAAC,EAAE,oBAAoB,CAAC;IAClC;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,0CAA0C,CAAC;IACnE;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,eAAe,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KAAE,CAAC;CAC7C;AAED,eAAO,MAAM,0CAA0C;;;;CAI7C,CAAC;AAEX,MAAM,MAAM,0CAA0C,GAAG,OAAO,0CAA0C,CAAC,MAAM,OAAO,0CAA0C,CAAC,CAAC"}

package/dist/models/stage-params-taxonomy-enrich.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Mixpeek API
+ * This is the Mixpeek API, providing access to various endpoints for data processing and retrieval.
+ *
+ * The version of the OpenAPI document: 0.81.1
+ * Contact: info@mixpeek.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { StageDefsEnrichmentField } from './stage-defs-enrichment-field';
+import type { StageDefsLogicalOperator } from './stage-defs-logical-operator';
+/**
+ * Configuration for enriching documents with taxonomy assignments.  **Stage Category**: APPLY (1-1 or 1-N depending on configuration)  **Transformation**:     - 1-1 mode (top_k=1): N documents → N documents (same count, expanded schema)     - 1-N mode (top_k>1): N documents → N*M documents (outer join/tagging)  **Purpose**: Applies each document to a taxonomy search, matching against predefined taxonomy nodes using vector similarity. Can operate as 1-1 enrichment (single best match) or 1-N expansion (multiple matching tags).  **When to Use**:     - After FILTER/SORT to classify and tag retrieved documents     - For automatic content categorization (topics, genres, entities)     - When you have labeled reference data (people, products, categories)     - For face recognition (matching faces against enrolled identities)     - To apply hierarchical categorization (parent/child relationships)     - For entity linking (matching content to knowledge base entities)     - **1-1 mode** (top_k=1): Single best match enrichment     - **1-N mode** (top_k>1): Multi-tag expansion (document multiplication)  **When NOT to Use**:     - For initial document retrieval from collections (use FILTER: hybrid_search)     - For removing documents (use FILTER stages)     - For reordering results (use SORT stages)     - For general field-based JOINs (use document_enrich instead)     - When you don\'t have a predefined taxonomy collection  **Operational Behavior**:     - Applies each input document to taxonomy vector search     - Performs vector similarity search against taxonomy collection (Qdrant)     - Document count: N in → N out (top_k=1) or N*M out (top_k>1)     - Expands or maintains schema depending on mode     - Moderate performance (vector similarity searches per document)     - Supports conditional enrichment (via `when` parameter for cost savings)  **Common Pipeline Position**: FILTER → SORT → APPLY (this stage)  **Conditional Enrichment**: Supports `when` parameter to only enrich documents matching specific criteria. Critical for:     - Cost savings (vector searches are compute-intensive)     - Selective enrichment based on document properties     - Applying different taxonomies to different document types  Requirements:     - taxonomy_id: REQUIRED - ID of the taxonomy to use for enrichment     - fields: OPTIONAL, which taxonomy fields to merge into documents     - top_k: OPTIONAL, max taxonomy matches per document (default 3)     - min_score: OPTIONAL, minimum similarity threshold (default 0.0)     - when: OPTIONAL, condition for selective enrichment  Use Cases:     - Face recognition: Match detected faces to employee directory     - Content classification: Tag articles with topic categories     - Product categorization: Assign products to taxonomy of categories     - Entity linking: Link mentions to knowledge base entities     - Brand detection: Identify brand logos in images  Examples:     Basic taxonomy enrichment:         ```json         {             \"taxonomy_id\": \"tax_abc123\",             \"top_k\": 3         }         ```      Conditional enrichment (only enrich if category=product):         ```json         {             \"taxonomy_id\": \"tax_product_classifier\",             \"top_k\": 3,             \"when\": {                 \"AND\": [                     {\"field\": \"metadata.category\", \"operator\": \"eq\", \"value\": \"product\"},                     {\"field\": \"metadata.has_image\", \"operator\": \"eq\", \"value\": true}                 ]             }         }         ```
+ * @export
+ * @interface StageParamsTaxonomyEnrich
+ */
+export interface StageParamsTaxonomyEnrich {
+    /**
+     * ID of the taxonomy to use for enrichment. The taxonomy\'s configured input_mappings determine which vector field from source documents to use for similarity matching. NOTE: You must replace the default placeholder with your actual taxonomy ID.
+     * @type {string}
+     * @memberof StageParamsTaxonomyEnrich
+     */
+    'taxonomy_id'?: string;
+    /**
+     * Fields from the taxonomy node to merge into the document.
+     * @type {Array<StageDefsEnrichmentField>}
+     * @memberof StageParamsTaxonomyEnrich
+     */
+    'fields'?: Array<StageDefsEnrichmentField>;
+    /**
+     * Maximum taxonomy assignments to attach per document.
+     * @type {number}
+     * @memberof StageParamsTaxonomyEnrich
+     */
+    'top_k'?: number;
+    /**
+     * Minimum similarity score required to keep an assignment.
+     * @type {number}
+     * @memberof StageParamsTaxonomyEnrich
+     */
+    'min_score'?: number;
+    /**
+     * OPTIONAL. Conditional filter that documents must satisfy to be enriched. Uses LogicalOperator (AND/OR/NOT) for complex boolean logic, or simple field/operator/value for single conditions. Documents NOT matching this condition will SKIP enrichment (pass-through unchanged). Useful for cost savings (only enrich relevant documents) and conditional processing. When NOT specified, ALL documents are enriched unconditionally.   Simple condition example: {\"field\": \"metadata.category\", \"operator\": \"eq\", \"value\": \"product\"} Boolean AND example: {\"AND\": [{\"field\": \"x\", \"operator\": \"eq\", \"value\": \"y\"}, ...]} Boolean OR example: {\"OR\": [{\"field\": \"x\", \"operator\": \"eq\", \"value\": \"y\"}, ...]}
+     * @type {StageDefsLogicalOperator}
+     * @memberof StageParamsTaxonomyEnrich
+     */
+    'when'?: StageDefsLogicalOperator;
+}
+//# sourceMappingURL=stage-params-taxonomy-enrich.d.ts.map

package/dist/models/stage-params-taxonomy-enrich.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-params-taxonomy-enrich.d.ts","sourceRoot":"","sources":["../../models/stage-params-taxonomy-enrich.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAG9E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAE9E;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACtC;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,KAAK,CAAC,wBAAwB,CAAC,CAAC;IAC3C;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,MAAM,CAAC,EAAE,wBAAwB,CAAC;CACrC"}

package/dist/models/stage-params-web-scrape.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Mixpeek API
+ * This is the Mixpeek API, providing access to various endpoints for data processing and retrieval.
+ *
+ * The version of the OpenAPI document: 0.81.1
+ * Contact: info@mixpeek.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { StageDefsErrorHandling } from './stage-defs-error-handling';
+import type { StageDefsLogicalOperator } from './stage-defs-logical-operator';
+import type { StageDefsURLPatterns } from './stage-defs-urlpatterns';
+/**
+ * Configuration for web scrape (content fetching) stage.  **Stage Category**: ENRICH (1-1 Enrichment)  **Transformation**: N documents → N documents (same count, expanded schema)  **Purpose**: Fetches full web page content from URLs found in document fields. Uses the Engine\'s Playwright service to extract clean text, metadata, and HTML from web pages. Enriches documents with complete content beyond the snippets provided by search APIs like Exa.  **When to Use**:     - After web_search stage to fetch full content from search results     - When documents contain URLs that need content extraction     - For article/blog content aggregation     - To get full page text beyond API snippets     - For content analysis requiring complete text     - Web scraping as part of retrieval pipeline  **When NOT to Use**:     - When URL snippets/titles are sufficient (web_search provides these)     - For very large numbers of URLs (slow, browser-intensive)     - When content is behind authentication (Playwright can\'t authenticate)     - For dynamic content requiring complex interactions     - When speed is critical (browser rendering is slow: 2-5s per page)  **Operational Behavior**:     - Enriches each input document (1-1 operation)     - Maintains document count: N in → N out (or fewer with REMOVE error handling)     - Expands schema: adds web content fields to each document     - Makes HTTP requests to Engine Playwright service     - Slow operation: 100ms-5s per document depending on strategy     - Supports concurrent requests with configurable batch size     - Browser-intensive for JavaScript strategy  **Common Pipeline Position**:     - web_search → web_scrape (get snippets then full content)     - semantic_search → web_scrape (if docs have URLs)     - filter → web_scrape → llm_enrich (fetch then analyze)  **Cost & Performance**:     - Expensive: Browser rendering is resource-intensive     - Slow: 2-5s per page for JavaScript, 100-500ms for static     - Use STATIC strategy when possible for speed     - Use conditional enrichment (when parameter) to reduce load     - Consider batch_size for balancing speed vs resource usage  **Conditional Enrichment**: Supports `when` parameter to only fetch content for specific documents. CRITICAL FOR PERFORMANCE - web scraping is slow!     - Only fetch for high-scoring results     - Only fetch specific content types     - Only fetch when URL field is present  Requirements:     - url_field: REQUIRED, document field containing URL to fetch     - output_field: REQUIRED, where to store fetched content     - strategy: OPTIONAL, scraping strategy (static/javascript/auto, default: auto)     - timeout: OPTIONAL, request timeout in seconds (default: 10)     - include_html: OPTIONAL, include raw HTML in response (default: False)     - min_content_length: OPTIONAL, minimum content length for auto fallback (default: 500)     - when: OPTIONAL but RECOMMENDED for performance     - on_error: OPTIONAL, error handling strategy (skip/remove/raise, default: skip)     - batch_size: OPTIONAL, concurrent requests (default: 5)  Use Cases:     - Content aggregation: Fetch full articles after web search     - Research pipelines: Get complete documents for analysis     - Content monitoring: Scrape pages for change detection     - Data enrichment: Add full page text to search results     - Competitive analysis: Fetch competitor content     - News aggregation: Get full articles from headlines  Examples:     Basic web scrape after search:         ```json         {             \"url_field\": \"metadata.url\",             \"output_field\": \"metadata.full_content\",             \"strategy\": \"auto\"         }         ```      Fast static scraping:         ```json         {             \"url_field\": \"metadata.url\",             \"output_field\": \"metadata.content\",             \"strategy\": \"static\",             \"timeout\": 5,             \"on_error\": \"skip\"         }         ```      JavaScript SPA scraping:         ```json         {             \"url_field\": \"metadata.url\",             \"output_field\": \"metadata.rendered_content\",             \"strategy\": \"javascript\",             \"timeout\": 30,             \"include_html\": true         }         ```      Conditional scrape (only high scores):         ```json         {             \"url_field\": \"metadata.url\",             \"output_field\": \"metadata.full_text\",             \"strategy\": \"auto\",             \"when\": {                 \"field\": \"score\",                 \"operator\": \"gte\",                 \"value\": 0.8             },             \"batch_size\": 3         }         ```
+ * @export
+ * @interface StageParamsWebScrape
+ */
+export interface StageParamsWebScrape {
+    /**
+     * Direct URL to fetch (supports templates like \'{{inputs.url}}\'). Use this when you want to scrape a URL from inputs without needing existing documents. Creates a new document with the scraped content. Either \'url\' or \'url_field\' must be provided, but not both.
+     * @type {string}
+     * @memberof StageParamsWebScrape
+     */
+    'url'?: string;
+    /**
+     * Dot-path to document field containing URL to fetch. Use this when enriching existing documents that have URL fields. Supports nested paths like \'metadata.url\' or \'data.source.link\'. The field must contain a valid HTTP/HTTPS URL. If field is missing or URL is invalid, behavior depends on on_error setting. Either \'url\' or \'url_field\' must be provided, but not both.
+     * @type {string}
+     * @memberof StageParamsWebScrape
+     */
+    'url_field'?: string;
+    /**
+     * Dot-path where fetched content should be stored. Creates nested structure if path doesn\'t exist. Stores object with: text, title, url, final_url, content_length, metadata, strategy_used. Example: \'metadata.web_content\' creates doc.metadata.web_content.text, doc.metadata.web_content.title, etc.
+     * @type {string}
+     * @memberof StageParamsWebScrape
+     */
+    'output_field'?: string;
+    /**
+     * OPTIONAL. Scraping strategy to use. \'static\': Fast HTML parsing, no JavaScript (best for articles/blogs). \'javascript\': Full browser rendering (slow, required for SPAs). \'auto\': Try static first, fallback to JavaScript if needed. Default is \'auto\' for best balance of speed and completeness.
+     * @type {string}
+     * @memberof StageParamsWebScrape
+     */
+    'strategy'?: string;
+    /**
+     * OPTIONAL. Request timeout in seconds. Range: 1-60 seconds. Default is 10. JavaScript rendering may need higher timeouts (20-30s). Shorter timeouts fail faster but may miss slow-loading pages.
+     * @type {number}
+     * @memberof StageParamsWebScrape
+     */
+    'timeout'?: number;
+    /**
+     * OPTIONAL. Include raw HTML in output. Default is False. Set to True if you need HTML for custom parsing. Warning: Significantly increases response size and memory usage.
+     * @type {boolean}
+     * @memberof StageParamsWebScrape
+     */
+    'include_html'?: boolean;
+    /**
+     * OPTIONAL. Minimum content length (characters) for auto strategy. If static parsing yields less than this, fallback to JavaScript. Default is 500 characters. Higher values = more likely to use JavaScript. Range: 100+.
+     * @type {number}
+     * @memberof StageParamsWebScrape
+     */
+    'min_content_length'?: number;
+    /**
+     * OPTIONAL. Conditional filter that documents must satisfy to be enriched with web content. Uses LogicalOperator (AND/OR/NOT) for complex boolean logic, or simple field/operator/value for single conditions. Documents NOT matching this condition will SKIP enrichment (pass-through unchanged). CRITICAL FOR PERFORMANCE - web scraping is slow! Only fetch content for documents that need it. When NOT specified, ALL documents are enriched unconditionally (may be very slow).   Use cases: - Only fetch for high-scoring results (score >= 0.8) - Only fetch specific content types (category = \'article\') - Only fetch when URL field is present   Simple condition example: {\"field\": \"score\", \"operator\": \"gte\", \"value\": 0.8} Boolean AND example: {\"AND\": [{\"field\": \"metadata.category\", \"operator\": \"eq\", \"value\": \"article\"}, ...]}
+     * @type {StageDefsLogicalOperator}
+     * @memberof StageParamsWebScrape
+     */
+    'when'?: StageDefsLogicalOperator;
+    /**
+     * OPTIONAL. How to handle fetch errors. \'skip\': Skip failed documents, pass them through unchanged (default). \'remove\': Remove failed documents from results entirely. \'raise\': Raise exception on first failure, halt pipeline. Default is \'skip\' for fault tolerance.
+     * @type {StageDefsErrorHandling}
+     * @memberof StageParamsWebScrape
+     */
+    'on_error'?: StageDefsErrorHandling;
+    /**
+     * OPTIONAL. Number of concurrent fetch requests. Range: 1-20. Default is 5. Higher values = faster but more resource intensive. Lower values = slower but safer for rate limits. Consider Engine resource capacity when setting.
+     * @type {number}
+     * @memberof StageParamsWebScrape
+     */
+    'batch_size'?: number;
+    /**
+     * OPTIONAL. Maximum link depth to follow from seed URL. None = single URL mode (default behavior). 0 = only seed page. 1 = seed + direct links from seed. 2 = seed + links + links from those pages. Higher values exponentially increase crawl time. Recommended: 1-2 for most use cases.
+     * @type {number}
+     * @memberof StageParamsWebScrape
+     */
+    'max_depth'?: number;
+    /**
+     * OPTIONAL. Maximum total pages to crawl. None = single URL mode (default behavior). Crawling stops when this limit is reached regardless of depth. Acts as a safety limit to prevent runaway crawls. Range: 1-100.
+     * @type {number}
+     * @memberof StageParamsWebScrape
+     */
+    'max_pages'?: number;
+    /**
+     * OPTIONAL. Only follow links to the same domain as seed URL. Default is True (strongly recommended). Set to False only for intentional cross-domain crawling. Prevents crawl explosion to external sites.
+     * @type {boolean}
+     * @memberof StageParamsWebScrape
+     */
+    'same_domain_only'?: boolean;
+    /**
+     * OPTIONAL. Include/exclude regex patterns for filtering discovered URLs. Include patterns: URLs must match at least one (if provided). Exclude patterns: URLs matching any are skipped. Applied after same_domain_only filter. Example: {\'include\': [\'/docs/.*\'], \'exclude\': [\'/login\', \'/admin/.*\']}
+     * @type {StageDefsURLPatterns}
+     * @memberof StageParamsWebScrape
+     */
+    'url_patterns'?: StageDefsURLPatterns;
+    /**
+     * OPTIONAL. Delay in seconds between starting new requests (politeness). Helps avoid overwhelming target servers. 0 = no delay (use with caution). Default is 0.5 seconds. Recommended: 0.5-1.0 for most sites.
+     * @type {number}
+     * @memberof StageParamsWebScrape
+     */
+    'delay_between_requests'?: number;
+}
+//# sourceMappingURL=stage-params-web-scrape.d.ts.map

package/dist/models/stage-params-web-scrape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-params-web-scrape.d.ts","sourceRoot":"","sources":["../../models/stage-params-web-scrape.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAG1E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAG9E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACjC;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,MAAM,CAAC,EAAE,wBAAwB,CAAC;IAClC;;;;OAIG;IACH,UAAU,CAAC,EAAE,sBAAsB,CAAC;IACpC;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;OAIG;IACH,cAAc,CAAC,EAAE,oBAAoB,CAAC;IACtC;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAC;CACrC"}

package/dist/models/stage-performance-input.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Mixpeek API
+ * This is the Mixpeek API, providing access to various endpoints for data processing and retrieval.
+ *
+ * The version of the OpenAPI document: 0.81.1
+ * Contact: info@mixpeek.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * Performance statistics for a retriever stage.
+ * @export
+ * @interface StagePerformanceInput
+ */
+export interface StagePerformanceInput {
+    /**
+     * Average execution time in milliseconds
+     * @type {number}
+     * @memberof StagePerformanceInput
+     */
+    'avg_execution_ms'?: number;
+    /**
+     * Number of times executed
+     * @type {number}
+     * @memberof StagePerformanceInput
+     */
+    'execution_count'?: number;
+    /**
+     * Number of errors encountered
+     * @type {number}
+     * @memberof StagePerformanceInput
+     */
+    'error_count'?: number;
+    /**
+     * Last time this stage was executed
+     * @type {string}
+     * @memberof StagePerformanceInput
+     */
+    'last_executed_at'?: string;
+}
+//# sourceMappingURL=stage-performance-input.d.ts.map

package/dist/models/stage-performance-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-performance-input.d.ts","sourceRoot":"","sources":["../../models/stage-performance-input.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAIH;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IAClC;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC/B"}

package/dist/models/stage-performance-metrics.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Mixpeek API
+ * This is the Mixpeek API, providing access to various endpoints for data processing and retrieval.
+ *
+ * The version of the OpenAPI document: 0.81.1
+ * Contact: info@mixpeek.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * Stage-level performance metrics.
+ * @export
+ * @interface StagePerformanceMetrics
+ */
+export interface StagePerformanceMetrics {
+    /**
+     * Name of the stage
+     * @type {string}
+     * @memberof StagePerformanceMetrics
+     */
+    'stage_name': string;
+    /**
+     * Type of the stage
+     * @type {string}
+     * @memberof StagePerformanceMetrics
+     */
+    'stage_type': string;
+    /**
+     * Number of executions
+     * @type {number}
+     * @memberof StagePerformanceMetrics
+     */
+    'execution_count': number;
+    /**
+     * Average latency
+     * @type {number}
+     * @memberof StagePerformanceMetrics
+     */
+    'avg_latency_ms': number;
+    /**
+     * P95 latency
+     * @type {number}
+     * @memberof StagePerformanceMetrics
+     */
+    'p95_latency_ms': number;
+    /**
+     * Average documents input
+     * @type {number}
+     * @memberof StagePerformanceMetrics
+     */
+    'avg_documents_in': number;
+    /**
+     * Average documents output
+     * @type {number}
+     * @memberof StagePerformanceMetrics
+     */
+    'avg_documents_out': number;
+}
+//# sourceMappingURL=stage-performance-metrics.d.ts.map

package/dist/models/stage-performance-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-performance-metrics.d.ts","sourceRoot":"","sources":["../../models/stage-performance-metrics.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAIH;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACpC;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,mBAAmB,EAAE,MAAM,CAAC;CAC/B"}