mixpeek 0.81.1

package/dist/models/stage-defs-feature-search-config.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 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 { OnEmptyBehavior } from './on-empty-behavior';
+import type { Query } from './query';
+import type { QueryPreprocessing } from './query-preprocessing';
+/**
+ * Configuration for a single feature search within the feature_filter stage.  Each feature search specifies: - Which feature URI to search (embedding index) - What input to search with (text, URL, or base64) - Search parameters (top_k, score threshold) - Optional weight for fusion  Multiple feature searches are combined using the stage\'s fusion strategy.  Examples:     Text semantic search:         ```json         {             \"feature_uri\": \"mixpeek://text_extractor@v1/multilingual_e5_large_instruct_v1\",             \"query\": {\"input_mode\": \"text\", \"value\": \"Hello world!\"},             \"top_k\": 100         }         ```      Image visual search with URL (auto-detected):         ```json         {             \"feature_uri\": \"mixpeek://clip_extractor@v1/image_embedding\",             \"query\": {\"input_mode\": \"content\", \"value\": \"{{INPUT.image_url}}\"},             \"top_k\": 50         }         ```      Video search with query preprocessing:         ```json         {             \"feature_uri\": \"mixpeek://multimodal_extractor@v1/vertex_multimodal_embedding\",             \"query\": {\"input_mode\": \"content\", \"value\": \"{{INPUT.video}}\"},             \"query_preprocessing\": {                 \"params\": {\"split_method\": \"time\", \"time_split_interval\": 10},                 \"max_chunks\": 20,                 \"aggregation\": \"rrf\"             },             \"top_k\": 100         }         ```
+ * @export
+ * @interface StageDefsFeatureSearchConfig
+ */
+export interface StageDefsFeatureSearchConfig {
+    /**
+     * REQUIRED. Feature URI specifying which embedding index to search. Format: \'mixpeek://extractor@version/output\' or \'namespace://collection/feature\'. Must reference a valid dense vector index in the collection. The feature must exist and be indexed for all documents in the collection.
+     * @type {string}
+     * @memberof StageDefsFeatureSearchConfig
+     */
+    'feature_uri': string;
+    /**
+     *
+     * @type {Query}
+     * @memberof StageDefsFeatureSearchConfig
+     */
+    'query': Query;
+    /**
+     * OPTIONAL. Number of results to fetch for this specific feature search. Defaults to 100. This is the per-feature top_k, independent of the final_top_k parameter. Higher values: More comprehensive but slower. Lower values: Faster but may miss relevant results. Qdrant will fetch this many results before fusion.
+     * @type {number}
+     * @memberof StageDefsFeatureSearchConfig
+     */
+    'top_k'?: number;
+    /**
+     * OPTIONAL. Minimum similarity score threshold for this feature search. NOT REQUIRED - if not specified, no score filtering is applied. Filters out results below this threshold BEFORE fusion. Typical values: 0.5-0.8 depending on model and use case. Lower threshold: More recall, less precision. Higher threshold: More precision, less recall.
+     * @type {number}
+     * @memberof StageDefsFeatureSearchConfig
+     */
+    'min_score'?: number;
+    /**
+     * OPTIONAL. Weight for this feature search when using \'weighted\' fusion. Defaults to 1.0 (equal weight). Ignored for \'rrf\' and \'max\' fusion strategies. Sum of all feature weights should typically equal 1.0 for normalized scores. Higher weight: More influence on final ranking. Example: Text=0.7, Image=0.3 for text-heavy search.
+     * @type {number}
+     * @memberof StageDefsFeatureSearchConfig
+     */
+    'weight'?: number;
+    /**
+     * OPTIONAL. Behavior when input is empty after template resolution. Defaults to \'error\' (fail if input missing).   ┌─────────┬────────────────────────────────────────────────────────────┐ │ Value   │ Behavior                                                   │ ├─────────┼────────────────────────────────────────────────────────────┤ │ error   │ Fail with error (input is required) - DEFAULT              │ │ skip    │ Exclude from fusion (let other searches drive results)     │ │ random  │ Use random vector (always return results)                  │ └─────────┴────────────────────────────────────────────────────────────┘   \'error\' (default): Strict mode - fail fast if input is missing. Use when input is required and missing input indicates a bug.   \'skip\': Graceful degradation - exclude this search from fusion. Use for multi-modal search where user may provide text OR image OR both. If all searches skip (all inputs empty), returns error.   \'random\': Always return results - use random vector as fallback. Use for single-feature optional search where you always want results.
+     * @type {OnEmptyBehavior}
+     * @memberof StageDefsFeatureSearchConfig
+     */
+    'on_empty'?: OnEmptyBehavior;
+    /**
+     * OPTIONAL. Enable query preprocessing for large file inputs. When set, the query input (video, PDF, long text) is decomposed into chunks using the same extractor pipeline that indexed the data, N parallel searches are run, and results are fused. Only applicable for content-mode queries (URLs or base64).
+     * @type {QueryPreprocessing}
+     * @memberof StageDefsFeatureSearchConfig
+     */
+    'query_preprocessing'?: QueryPreprocessing;
+    /**
+     * OPTIONAL. Collection identifiers to search for this specific feature search. Can be collection IDs or names. Enables per-search collection targeting for hybrid/multi-feature searches.   Fallback Priority (most specific wins): 1. This field (per-search targeting) - most specific 2. Stage-level collection_identifiers 3. Retriever-level collection_identifiers   Use Cases: - Hybrid search where different features exist in different collections - Text embeddings in col_products, image embeddings in col_media - Fine-grained collection targeting per feature URI   Note: All collections (across all searches) must be declared in the retriever\'s collection_identifiers at creation time for validation.
+     * @type {Array<string>}
+     * @memberof StageDefsFeatureSearchConfig
+     */
+    'collection_identifiers'?: Array<string>;
+}
+//# sourceMappingURL=stage-defs-feature-search-config.d.ts.map

package/dist/models/stage-defs-feature-search-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-defs-feature-search-config.d.ts","sourceRoot":"","sources":["../../models/stage-defs-feature-search-config.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGrC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE;;;;GAIG;AACH,MAAM,WAAW,4BAA4B;IACzC;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,OAAO,EAAE,KAAK,CAAC;IACf;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,kBAAkB,CAAC;IAC3C;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CAC5C"}

package/dist/models/stage-defs-feature-search-group-by.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+/**
+ * Database-level grouping for feature search (uses Qdrant query_points_groups).  Enables efficient grouping at the database level rather than in-memory post-processing. Perfect for decompose/recompose patterns where you search chunks but want to return parent documents.  This mirrors the output_mode behavior of the group_by REDUCE stage for API consistency, but executes at the database level for better performance on large result sets.  Stage Category: FILTER (grouping is part of the Qdrant query)  Performance: Database-level grouping is significantly faster than fetching all results and grouping in memory. Qdrant handles the grouping natively.  Use Cases:     - Decompose/recompose: Search 500 text chunks, return top 25 unique documents     - Deduplication: One best result per product_id     - Scene → Video grouping: Search video frames, return parent videos  Examples:     Deduplication (one result per video):         ```json         {\"field\": \"video_id\", \"max_per_group\": 1, \"output_mode\": \"first\"}         ```      Top 3 chunks per document:         ```json         {\"field\": \"source_object_id\", \"max_per_group\": 3, \"output_mode\": \"all\"}         ```      Flatten grouped results:         ```json         {\"field\": \"category\", \"max_per_group\": 5, \"output_mode\": \"flatten\"}         ```
+ * @export
+ * @interface StageDefsFeatureSearchGroupBy
+ */
+export interface StageDefsFeatureSearchGroupBy {
+    /**
+     * REQUIRED. Field path to group documents by using dot notation. Documents with the same field value are grouped together. Common fields: \'source_object_id\' (parent object from decomposition), \'video_id\' (media grouping), \'product_id\' (e-commerce), \'metadata.category\' (nested categorical field). The field must exist in the document payload. IMPORTANT: This field MUST have a keyword payload index configured on the namespace. Without an index, grouping will fail with \'Index required but not found\'. Create indexes via PATCH /v1/namespaces/{id} with payload_indexes.
+     * @type {string}
+     * @memberof StageDefsFeatureSearchGroupBy
+     */
+    'field': string;
+    /**
+     * OPTIONAL. Maximum number of documents to keep per group (Qdrant\'s group_size). Documents are sorted by score (highest first) before limiting. Default: 1 (deduplication - keeps only highest scoring doc per group). Use 1 for deduplication, 3-5 for preview results, 10+ for comprehensive results. Note: This is a best-effort parameter in Qdrant.
+     * @type {number}
+     * @memberof StageDefsFeatureSearchGroupBy
+     */
+    'max_per_group'?: number;
+    /**
+     * OPTIONAL. Maximum number of groups to return. This overrides final_top_k when grouping is enabled. Default: 25 groups.
+     * @type {number}
+     * @memberof StageDefsFeatureSearchGroupBy
+     */
+    'limit'?: number;
+    /**
+     * OPTIONAL. Controls what documents are returned per group. Mirrors the group_by REDUCE stage for API consistency. \'first\': Return only the top document per group (deduplication, fastest).          Use for: unique results per group (e.g., one video per brand). \'all\': Return all documents grouped by field (default, shows full context).        Use for: showing chunks within each parent object. \'flatten\': Return all documents as flat list (loses group structure).            Use for: need all docs but don\'t care about grouping metadata. Default: \'all\'.
+     * @type {string}
+     * @memberof StageDefsFeatureSearchGroupBy
+     */
+    'output_mode'?: StageDefsFeatureSearchGroupByOutputModeEnum;
+}
+export declare const StageDefsFeatureSearchGroupByOutputModeEnum: {
+    readonly First: "first";
+    readonly All: "all";
+    readonly Flatten: "flatten";
+};
+export type StageDefsFeatureSearchGroupByOutputModeEnum = typeof StageDefsFeatureSearchGroupByOutputModeEnum[keyof typeof StageDefsFeatureSearchGroupByOutputModeEnum];
+//# sourceMappingURL=stage-defs-feature-search-group-by.d.ts.map

package/dist/models/stage-defs-feature-search-group-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-defs-feature-search-group-by.d.ts","sourceRoot":"","sources":["../../models/stage-defs-feature-search-group-by.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAIH;;;;GAIG;AACH,MAAM,WAAW,6BAA6B;IAC1C;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,aAAa,CAAC,EAAE,2CAA2C,CAAC;CAC/D;AAED,eAAO,MAAM,2CAA2C;;;;CAI9C,CAAC;AAEX,MAAM,MAAM,2CAA2C,GAAG,OAAO,2CAA2C,CAAC,MAAM,OAAO,2CAA2C,CAAC,CAAC"}

package/dist/models/stage-defs-filter-condition.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 { DynamicValue } from './dynamic-value';
+import type { FilterOperator } from './filter-operator';
+/**
+ * Represents a single filter condition.  Attributes:     field: The field to filter on     operator: The comparison operator     value: The value to compare against
+ * @export
+ * @interface StageDefsFilterCondition
+ */
+export interface StageDefsFilterCondition {
+    /**
+     * Field name to filter on
+     * @type {string}
+     * @memberof StageDefsFilterCondition
+     */
+    'field': string;
+    /**
+     * Comparison operator
+     * @type {FilterOperator}
+     * @memberof StageDefsFilterCondition
+     */
+    'operator'?: FilterOperator;
+    /**
+     *
+     * @type {DynamicValue}
+     * @memberof StageDefsFilterCondition
+     */
+    'value': DynamicValue | null;
+}
+//# sourceMappingURL=stage-defs-filter-condition.d.ts.map

package/dist/models/stage-defs-filter-condition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-defs-filter-condition.d.ts","sourceRoot":"","sources":["../../models/stage-defs-filter-condition.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACrC;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B;;;;OAIG;IACH,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;CAChC"}

package/dist/models/stage-defs-filter-operator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+/**
+ * Supported filter operators across database implementations.
+ * @export
+ * @enum {string}
+ */
+export declare const StageDefsFilterOperator: {
+    readonly Eq: "eq";
+    readonly Ne: "ne";
+    readonly Gt: "gt";
+    readonly Lt: "lt";
+    readonly Gte: "gte";
+    readonly Lte: "lte";
+    readonly In: "in";
+    readonly Nin: "nin";
+    readonly Contains: "contains";
+    readonly StartsWith: "starts_with";
+    readonly EndsWith: "ends_with";
+    readonly Regex: "regex";
+    readonly Exists: "exists";
+    readonly IsNull: "is_null";
+    readonly Text: "text";
+};
+export type StageDefsFilterOperator = typeof StageDefsFilterOperator[keyof typeof StageDefsFilterOperator];
+//# sourceMappingURL=stage-defs-filter-operator.d.ts.map

package/dist/models/stage-defs-filter-operator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-defs-filter-operator.d.ts","sourceRoot":"","sources":["../../models/stage-defs-filter-operator.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAIH;;;;GAIG;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;CAgB1B,CAAC;AAEX,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAC,MAAM,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/models/stage-defs-fusion-strategy.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ */
+/**
+ * Score fusion strategies for combining multiple feature searches.  ┌──────────┬──────────────┬─────────────────────────────────────────────────────┐ │ Strategy │ Qdrant Native│ Description                                         │ ├──────────┼──────────────┼─────────────────────────────────────────────────────┤ │ rrf      │ ✅ Yes       │ Rank-based fusion, robust default (recommended)     │ │ dbsf     │ ✅ Yes       │ Score-based with statistical normalization          │ │ weighted │ ❌ No        │ Manual score-weighted fusion with custom weights    │ │ max      │ ❌ No        │ Take maximum score across features                  │ │ learned  │ ❌ No        │ Bandit-learned weights, enables personalization     │ └──────────┴──────────────┴─────────────────────────────────────────────────────┘  Performance Note:     - rrf/dbsf: Single Qdrant call (fastest)     - weighted/max/learned: Separate queries per feature, merged client-side  ═══════════════════════════════════════════════════════════════════════════════ RRF (Reciprocal Rank Fusion) - RECOMMENDED DEFAULT ═══════════════════════════════════════════════════════════════════════════════     Formula: score = Σ(1 / (k + rank_i))     - Rank-based: ignores raw scores, uses position only     - Robust to score scale differences between embedding models     - No tuning required, works well out-of-the-box     - Qdrant default k=2 (configurable)     - Best for: General-purpose multi-vector search  ═══════════════════════════════════════════════════════════════════════════════ DBSF (Distribution-Based Score Fusion) ═══════════════════════════════════════════════════════════════════════════════     Formula: Normalizes scores using mean ± 3σ, then sums     - Score-based with statistical normalization     - Handles different score distributions across features     - Available since Qdrant v1.11     - Best for: When score magnitudes matter but scales differ  ═══════════════════════════════════════════════════════════════════════════════ WEIGHTED (Manual Weight Fusion) ═══════════════════════════════════════════════════════════════════════════════     Formula: score = Σ(weight_i * score_i)     - User specifies weight per feature search     - Weights defined in each FeatureSearchConfig.weight field     - Runs N separate queries, merges results client-side     - Best for: When you know relative feature importance upfront  ═══════════════════════════════════════════════════════════════════════════════ MAX (Maximum Score Fusion) ═══════════════════════════════════════════════════════════════════════════════     Formula: score = max(score_1, score_2, ..., score_n)     - Takes best match from any single feature     - Good when any modality match is sufficient     - Runs N separate queries, merges results client-side     - Best for: \"OR\" semantics (match text OR image OR audio)  ═══════════════════════════════════════════════════════════════════════════════ LEARNED (Bandit-Learned Fusion) ═══════════════════════════════════════════════════════════════════════════════     Formula: score = Σ(learned_weight_i * score_i)     - Learns optimal weights from user feedback (clicks, purchases, etc.)     - Uses Thompson Sampling (Beta-Bernoulli bandit) by default     - Supports personalization via context (user_id, segment, etc.)     - Cold start handling with hierarchical fallback     - REQUIRES learning_config to be specified     - Runs N separate queries to get per-feature scores for learning     - Best for: Personalized search, learning feature importance over time  Example Usage:     ```python     # Fast, no tuning needed (recommended)     fusion = FusionStrategy.RRF      # Score-aware with normalization     fusion = FusionStrategy.DBSF      # Manual weights (0.7 text, 0.3 image)     fusion = FusionStrategy.WEIGHTED     searches = [         {\"feature_uri\": \"...\", \"weight\": 0.7, ...},         {\"feature_uri\": \"...\", \"weight\": 0.3, ...},     ]      # Best match from any feature     fusion = FusionStrategy.MAX      # Personalized, learns from feedback     fusion = FusionStrategy.LEARNED     learning_config = LearnedFusionConfig(         context_features=[\"INPUT.user_id\"],         reward_signal=\"click\"     )     ```
+ * @export
+ * @enum {string}
+ */
+export declare const StageDefsFusionStrategy: {
+    readonly Rrf: "rrf";
+    readonly Dbsf: "dbsf";
+    readonly Weighted: "weighted";
+    readonly Max: "max";
+    readonly Learned: "learned";
+};
+export type StageDefsFusionStrategy = typeof StageDefsFusionStrategy[keyof typeof StageDefsFusionStrategy];
+//# sourceMappingURL=stage-defs-fusion-strategy.d.ts.map

package/dist/models/stage-defs-fusion-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-defs-fusion-strategy.d.ts","sourceRoot":"","sources":["../../models/stage-defs-fusion-strategy.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAIH;;;;GAIG;AAEH,eAAO,MAAM,uBAAuB;;;;;;CAM1B,CAAC;AAEX,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAC,MAAM,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/models/stage-defs-group-by-field-config.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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.
+ */
+/**
+ * Configuration for grouping documents before aggregation.  When specified, aggregations are computed per-group rather than across all documents.  Example:     Group by category and count:         ```json         {\"field\": \"metadata.category\", \"alias\": \"category\"}         ```
+ * @export
+ * @interface StageDefsGroupByFieldConfig
+ */
+export interface StageDefsGroupByFieldConfig {
+    /**
+     * REQUIRED. Field path to group by (dot notation supported). Documents with the same value for this field are grouped together. Examples: \'metadata.category\', \'collection_id\', \'metadata.file_type\'.
+     * @type {string}
+     * @memberof StageDefsGroupByFieldConfig
+     */
+    'field': string;
+    /**
+     * OPTIONAL. Alias for this group-by field in the output. Defaults to the field name (last segment after dot). Example: \'category\' for field \'metadata.category\'.
+     * @type {string}
+     * @memberof StageDefsGroupByFieldConfig
+     */
+    'alias'?: string;
+}
+//# sourceMappingURL=stage-defs-group-by-field-config.d.ts.map

package/dist/models/stage-defs-group-by-field-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-defs-group-by-field-config.d.ts","sourceRoot":"","sources":["../../models/stage-defs-group-by-field-config.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAIH;;;;GAIG;AACH,MAAM,WAAW,2BAA2B;IACxC;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB"}

package/dist/models/stage-defs-learned-fusion-config.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 { LearningAlgorithm } from './learning-algorithm';
+/**
+ * Configuration for learned fusion with bandit-based weight optimization.  Enables personalized feature weighting by learning from user interactions. The system learns which features (text, image, audio, etc.) matter most for different users or contexts.  ┌─────────────────────────────────────────────────────────────────────────────┐ │ HOW LEARNED FUSION WORKS                                                     │ ├─────────────────────────────────────────────────────────────────────────────┤ │ 1. Query arrives with context (user_id, segment, etc.)                      │ │ 2. Look up bandit state for this context                                    │ │ 3. Sample feature weights from Beta distributions                           │ │ 4. Execute separate queries per feature with learned weights                │ │ 5. Fuse results using sampled weights                                       │ │ 6. On feedback (click), update bandit for relevant features                 │ └─────────────────────────────────────────────────────────────────────────────┘  Cold Start Handling:     - NEW users: Uses demographic context (user_segment, device_type)     - Returning users: Uses personal context after min_interactions     - Fallback: Global context as ultimate fallback  Requirements:     - Interactions API must be called with feedback (clicks, etc.)     - Context features should be passed in query inputs  Example:     ```python     LearnedFusionConfig(         algorithm=LearningAlgorithm.THOMPSON_SAMPLING,         context_features=[\"INPUT.user_id\"],         demographic_features=[\"INPUT.user_segment\", \"INPUT.device_type\"],         reward_signal=\"click\",         min_interactions=5,     )     ```
+ * @export
+ * @interface StageDefsLearnedFusionConfig
+ */
+export interface StageDefsLearnedFusionConfig {
+    /**
+     * Learning algorithm for weight optimization. THOMPSON_SAMPLING (default): Beta-Bernoulli bandit with natural exploration. Works immediately, no tuning needed, best for most use cases.
+     * @type {LearningAlgorithm}
+     * @memberof StageDefsLearnedFusionConfig
+     */
+    'algorithm'?: LearningAlgorithm;
+    /**
+     * Template variables for personal context (e.g., [\'INPUT.user_id\']). Empty list = global learning (same weights for all users). Personal context is used after user has min_interactions. Supports: INPUT.*, CONTEXT.*, etc.
+     * @type {Array<string>}
+     * @memberof StageDefsLearnedFusionConfig
+     */
+    'context_features'?: Array<string>;
+    /**
+     * Template variables for demographic fallback context. Used for NEW users with < min_interactions. Enables cold start by learning from similar user segments. Examples: INPUT.user_segment, INPUT.device_type, INPUT.country.
+     * @type {Array<string>}
+     * @memberof StageDefsLearnedFusionConfig
+     */
+    'demographic_features'?: Array<string>;
+    /**
+     * Strategy when user lacks sufficient history. \'hierarchical\': Try personal → demographic → global (recommended). \'global\': Skip demographic, fall back directly to global.
+     * @type {string}
+     * @memberof StageDefsLearnedFusionConfig
+     */
+    'fallback_strategy'?: StageDefsLearnedFusionConfigFallbackStrategyEnum;
+    /**
+     * Minimum interactions before using personal context. Below this threshold, uses demographic or global context. Prevents overfitting to small samples. Typical range: 3-10.
+     * @type {number}
+     * @memberof StageDefsLearnedFusionConfig
+     */
+    'min_interactions'?: number;
+    /**
+     * Interaction type(s) that count as positive reward. Single: \'click\', \'purchase\', \'positive_feedback\'. Multiple: \'click,purchase\' (comma-separated). Determines when to strengthen feature weights.
+     * @type {string}
+     * @memberof StageDefsLearnedFusionConfig
+     */
+    'reward_signal'?: string;
+    /**
+     * Controls exploration vs exploitation balance. 1.0 = balanced (default). Higher = more exploration (try diverse weights). Lower = more exploitation (use known winners). Typical range: 0.5-2.0.
+     * @type {number}
+     * @memberof StageDefsLearnedFusionConfig
+     */
+    'exploration_bonus'?: number;
+    /**
+     * Beta distribution prior for positive feedback (α). 1.0 = uniform prior (no initial bias). Higher = initial belief that features are effective.
+     * @type {number}
+     * @memberof StageDefsLearnedFusionConfig
+     */
+    'prior_alpha'?: number;
+    /**
+     * Beta distribution prior for negative feedback (β). 1.0 = uniform prior (no initial bias). Higher = initial belief that features are ineffective.
+     * @type {number}
+     * @memberof StageDefsLearnedFusionConfig
+     */
+    'prior_beta'?: number;
+}
+export declare const StageDefsLearnedFusionConfigFallbackStrategyEnum: {
+    readonly Hierarchical: "hierarchical";
+    readonly Global: "global";
+};
+export type StageDefsLearnedFusionConfigFallbackStrategyEnum = typeof StageDefsLearnedFusionConfigFallbackStrategyEnum[keyof typeof StageDefsLearnedFusionConfigFallbackStrategyEnum];
+//# sourceMappingURL=stage-defs-learned-fusion-config.d.ts.map

package/dist/models/stage-defs-learned-fusion-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-defs-learned-fusion-config.d.ts","sourceRoot":"","sources":["../../models/stage-defs-learned-fusion-config.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D;;;;GAIG;AACH,MAAM,WAAW,4BAA4B;IACzC;;;;OAIG;IACH,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACnC;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACvC;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,gDAAgD,CAAC;IACvE;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,eAAO,MAAM,gDAAgD;;;CAGnD,CAAC;AAEX,MAAM,MAAM,gDAAgD,GAAG,OAAO,gDAAgD,CAAC,MAAM,OAAO,gDAAgD,CAAC,CAAC"}

package/dist/models/stage-defs-learning-algorithm.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+/**
+ * Algorithms for learning feature fusion weights from feedback.  ┌─────────────────────────────────────────────────────────────────────────────┐ │ ALGORITHM COMPARISON                                                         │ ├───────────────────┬─────────────────────────────────────────────────────────┤ │ Algorithm         │ Description                                             │ ├───────────────────┼─────────────────────────────────────────────────────────┤ │ thompson_sampling │ Beta-Bernoulli bandit, natural exploration, no tuning  │ │ epsilon_greedy    │ (Future) Simple ε-greedy exploration                   │ │ ucb               │ (Future) Upper Confidence Bound with guarantees        │ └───────────────────┴─────────────────────────────────────────────────────────┘  THOMPSON_SAMPLING (Recommended):     - Beta-Bernoulli bandit with probabilistic exploration     - Works immediately with uniform priors (α=1, β=1)     - No hyperparameter tuning required     - Natural exploration/exploitation balance via sampling     - Converges to optimal weights as feedback accumulates     - Best for: Binary feedback (click/no-click), most use cases  How it works:     1. Each feature has Beta(α, β) distribution     2. Sample weight from each distribution before search     3. Apply sampled weights to fusion     4. On positive feedback (click): increment α for strong features     5. On no feedback: increment β for features in shown docs     6. Distribution shifts toward effective features over time
+ * @export
+ * @enum {string}
+ */
+export declare const StageDefsLearningAlgorithm: {
+    readonly ThompsonSampling: "thompson_sampling";
+    readonly EpsilonGreedy: "epsilon_greedy";
+    readonly Ucb: "ucb";
+};
+export type StageDefsLearningAlgorithm = typeof StageDefsLearningAlgorithm[keyof typeof StageDefsLearningAlgorithm];
+//# sourceMappingURL=stage-defs-learning-algorithm.d.ts.map

package/dist/models/stage-defs-learning-algorithm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-defs-learning-algorithm.d.ts","sourceRoot":"","sources":["../../models/stage-defs-learning-algorithm.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAIH;;;;GAIG;AAEH,eAAO,MAAM,0BAA0B;;;;CAI7B,CAAC;AAEX,MAAM,MAAM,0BAA0B,GAAG,OAAO,0BAA0B,CAAC,MAAM,OAAO,0BAA0B,CAAC,CAAC"}

package/dist/models/stage-defs-llmprovider.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+/**
+ * Supported LLM providers for content generation.  Each provider has different strengths, pricing, and multimodal capabilities. Choose based on your use case, performance requirements, and budget.  Values:     OPENAI: OpenAI GPT models (GPT-4o, GPT-4.1, O3-mini)         - Best for: General purpose, vision tasks, structured outputs         - Multimodal: Text, images         - Performance: Fast (100-500ms), reliable         - Cost: Moderate to high ($0.15-$10 per 1M tokens)         - Use when: Need high-quality generation with vision support      GOOGLE: Google Gemini models (Gemini 1.5 Flash, Gemini 2.5 Flash)         - Best for: Fast generation, video understanding, cost-efficiency         - Multimodal: Text, images, video, audio, PDFs         - Performance: Very fast (50-200ms)         - Cost: Low to moderate ($0.075-$0.40 per 1M tokens)         - Use when: Need video/audio/PDF support or cost-efficiency      ANTHROPIC: Anthropic Claude models (Claude 3.5 Sonnet, Claude 3.5 Haiku)         - Best for: Long context, complex reasoning, safety         - Multimodal: Text, images         - Performance: Moderate (200-800ms)         - Cost: Moderate to high ($0.25-$15 per 1M tokens)         - Use when: Need long context or complex reasoning  Examples:     - Use OPENAI for production with structured JSON outputs     - Use GOOGLE for video summarization and cost-sensitive workloads     - Use ANTHROPIC for complex reasoning with long documents
+ * @export
+ * @enum {string}
+ */
+export declare const StageDefsLLMProvider: {
+    readonly Openai: "openai";
+    readonly Google: "google";
+    readonly Anthropic: "anthropic";
+};
+export type StageDefsLLMProvider = typeof StageDefsLLMProvider[keyof typeof StageDefsLLMProvider];
+//# sourceMappingURL=stage-defs-llmprovider.d.ts.map

package/dist/models/stage-defs-llmprovider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-defs-llmprovider.d.ts","sourceRoot":"","sources":["../../models/stage-defs-llmprovider.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAIH;;;;GAIG;AAEH,eAAO,MAAM,oBAAoB;;;;CAIvB,CAAC;AAEX,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,MAAM,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/models/stage-defs-logical-operator.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 { AndInner } from './and-inner';
+/**
+ * Represents a logical operation (AND, OR, NOT) on filter conditions.  Allows nesting with a defined depth limit.  Also supports shorthand syntax where field names can be passed directly as key-value pairs for equality filtering (e.g., {\"metadata.title\": \"value\"}).
+ * @export
+ * @interface StageDefsLogicalOperator
+ */
+export interface StageDefsLogicalOperator {
+    [key: string]: any;
+    /**
+     * Logical AND operation - all conditions must be true
+     * @type {Array<AndInner>}
+     * @memberof StageDefsLogicalOperator
+     */
+    'AND'?: Array<AndInner>;
+    /**
+     * Logical OR operation - at least one condition must be true
+     * @type {Array<AndInner>}
+     * @memberof StageDefsLogicalOperator
+     */
+    'OR'?: Array<AndInner>;
+    /**
+     * Logical NOT operation - all conditions must be false
+     * @type {Array<AndInner>}
+     * @memberof StageDefsLogicalOperator
+     */
+    'NOT'?: Array<AndInner>;
+    /**
+     * Whether to perform case-sensitive matching
+     * @type {boolean}
+     * @memberof StageDefsLogicalOperator
+     */
+    'case_sensitive'?: boolean;
+}
+//# sourceMappingURL=stage-defs-logical-operator.d.ts.map

package/dist/models/stage-defs-logical-operator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-defs-logical-operator.d.ts","sourceRoot":"","sources":["../../models/stage-defs-logical-operator.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACrC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;IAEnB;;;;OAIG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;IACxB;;;;OAIG;IACH,IAAI,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;IACvB;;;;OAIG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;IACxB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC9B"}

package/dist/models/stage-defs-multi-content-query-input.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+/**
+ * Multi-file query input for feature indexes that support multi-content embedding.  Accepts a list of URLs and/or text strings and embeds them together in a single API call to produce ONE query vector. Only valid when the feature URI\'s vector index has ``supports_multi_query=True`` (e.g., gemini_multifile_extractor).  At execution time the system validates that the target feature URI supports multi-content queries and raises an error if it does not.  Use Cases:     - Object-level search: query with multiple files that describe the same item       (e.g., product image + spec sheet + description)     - Cross-modal similarity: find objects similar to a combination of inputs     - Reverse lookup: find objects like \"this image AND this text together\"  Examples:     URLs and text together:         ```json         {             \"input_mode\": \"multi_content\",             \"values\": [                 \"https://example.com/product.jpg\",                 \"s3://bucket/spec.pdf\",                 \"Lightweight carbon-fiber trail running shoe\"             ]         }         ```      Template-based (values resolved from retriever inputs):         ```json         {             \"input_mode\": \"multi_content\",             \"values\": [\"{{INPUT.image_url}}\", \"{{INPUT.description}}\"]         }         ```
+ * @export
+ * @interface StageDefsMultiContentQueryInput
+ */
+export interface StageDefsMultiContentQueryInput {
+    /**
+     * Discriminator field. Always \'multi_content\' for multi-file queries.
+     * @type {string}
+     * @memberof StageDefsMultiContentQueryInput
+     */
+    'input_mode'?: StageDefsMultiContentQueryInputInputModeEnum;
+    /**
+     * List of content items to embed together. Each item is either: (1) a URL (http://, https://, s3://) — fetched and embedded as a file, or (2) a plain text string — embedded as text. Supports template variables: \'{{INPUT.field_name}}\'. All items are passed to the underlying model in one API call, producing a single query embedding. Only valid for feature URIs whose vector index has supports_multi_query=True.
+     * @type {Array<string>}
+     * @memberof StageDefsMultiContentQueryInput
+     */
+    'values': Array<string>;
+}
+export declare const StageDefsMultiContentQueryInputInputModeEnum: {
+    readonly MultiContent: "multi_content";
+};
+export type StageDefsMultiContentQueryInputInputModeEnum = typeof StageDefsMultiContentQueryInputInputModeEnum[keyof typeof StageDefsMultiContentQueryInputInputModeEnum];
+//# sourceMappingURL=stage-defs-multi-content-query-input.d.ts.map

package/dist/models/stage-defs-multi-content-query-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-defs-multi-content-query-input.d.ts","sourceRoot":"","sources":["../../models/stage-defs-multi-content-query-input.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAIH;;;;GAIG;AACH,MAAM,WAAW,+BAA+B;IAC5C;;;;OAIG;IACH,YAAY,CAAC,EAAE,4CAA4C,CAAC;IAC5D;;;;OAIG;IACH,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CAC3B;AAED,eAAO,MAAM,4CAA4C;;CAE/C,CAAC;AAEX,MAAM,MAAM,4CAA4C,GAAG,OAAO,4CAA4C,CAAC,MAAM,OAAO,4CAA4C,CAAC,CAAC"}

package/dist/models/stage-defs-on-empty-behavior.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+/**
+ * Behavior when a feature search input is empty or missing.  Controls what happens when the resolved input (text, URL, or base64) is empty, None, or evaluates to an empty string after template resolution.  ┌─────────┬────────────────────────────────────────────────────────────────────┐ │ Value   │ Behavior                                                           │ ├─────────┼────────────────────────────────────────────────────────────────────┤ │ error   │ Fail with validation error (input is required)                     │ │ skip    │ Exclude this search from fusion (let other searches drive results) │ │ random  │ Use random vector to return results (for optional single-search)   │ └─────────┴────────────────────────────────────────────────────────────────────┘  Use Cases:     - error (default): Strict mode - fail fast if required input is missing.       Best for: Production pipelines where missing input indicates a bug.      - skip: Graceful degradation - exclude from fusion if input missing.       Best for: Multi-modal search where user may provide text OR image OR both.       If text is empty but image is provided, only image search runs.      - random: Always return results - use random vector as fallback.       Best for: Single-feature search where you always want results returned,       even if the input is empty (e.g., \"show me anything\" behavior).  Examples:     Multi-modal with optional inputs (skip empty):         ```json         {             \"searches\": [                 {\"feature_uri\": \"text-embed\", \"on_empty\": \"skip\", ...},                 {\"feature_uri\": \"image-embed\", \"on_empty\": \"skip\", ...}             ]         }         ```         - Text only provided → text search runs         - Image only provided → image search runs         - Both provided → fusion of both         - Neither provided → error (no searches to run)      Single search, always return results:         ```json         {             \"searches\": [                 {\"feature_uri\": \"text-embed\", \"on_empty\": \"random\", ...}             ]         }         ```         - Input provided → normal search         - Input empty → random results from collection
+ * @export
+ * @enum {string}
+ */
+export declare const StageDefsOnEmptyBehavior: {
+    readonly Error: "error";
+    readonly Skip: "skip";
+    readonly Random: "random";
+};
+export type StageDefsOnEmptyBehavior = typeof StageDefsOnEmptyBehavior[keyof typeof StageDefsOnEmptyBehavior];
+//# sourceMappingURL=stage-defs-on-empty-behavior.d.ts.map

package/dist/models/stage-defs-on-empty-behavior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-defs-on-empty-behavior.d.ts","sourceRoot":"","sources":["../../models/stage-defs-on-empty-behavior.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAIH;;;;GAIG;AAEH,eAAO,MAAM,wBAAwB;;;;CAI3B,CAAC;AAEX,MAAM,MAAM,wBAAwB,GAAG,OAAO,wBAAwB,CAAC,MAAM,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/models/stage-defs-on-no-results.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+/**
+ * Behavior when SQL query returns no rows.  Values:     SKIP: Keep document unchanged, do not set output_field         - Document passes through without enrichment         - Best for optional lookups      NULL: Set output_field to null         - Explicitly marks no result found         - Useful for downstream conditional logic      ERROR: Raise error and fail enrichment         - Strict mode for mandatory data         - Use with on_error to control pipeline behavior
+ * @export
+ * @enum {string}
+ */
+export declare const StageDefsOnNoResults: {
+    readonly Skip: "skip";
+    readonly Null: "null";
+    readonly Error: "error";
+};
+export type StageDefsOnNoResults = typeof StageDefsOnNoResults[keyof typeof StageDefsOnNoResults];
+//# sourceMappingURL=stage-defs-on-no-results.d.ts.map

package/dist/models/stage-defs-on-no-results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage-defs-on-no-results.d.ts","sourceRoot":"","sources":["../../models/stage-defs-on-no-results.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAIH;;;;GAIG;AAEH,eAAO,MAAM,oBAAoB;;;;CAIvB,CAAC;AAEX,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,MAAM,OAAO,oBAAoB,CAAC,CAAC"}