@llm-dev-ops/agentics-cli 1.4.27 → 1.4.29

package/dist/bundled-agents/analytics-hub-agents/dist/contracts/consensus-agent.d.ts

@@ -1,573 +0,0 @@
-/**
- * Consensus Agent Contract
- *
- * Defines inputs, outputs, validation rules, and boundaries for the Consensus Agent.
- * This agent performs ANALYTICAL SYNTHESIS and CONSENSUS FORMATION across signals.
- *
- * Classification: ANALYTICAL SYNTHESIS / CONSENSUS / CROSS-SIGNAL AGGREGATION
- *
- * @module contracts/consensus-agent
- */
-import { z } from 'zod';
-export declare const AGENT_ID = "consensus-agent";
-export declare const AGENT_VERSION = "1.0.0";
-export declare const DECISION_TYPE = "analytics_consensus_summary";
-/**
- * Individual signal input for consensus computation
- */
-export declare const SignalInputSchema: z.ZodObject<{
-    /** Unique signal identifier */
-    signalId: z.ZodString;
-    /** Source layer (e.g., "observatory", "costops", "governance") */
-    sourceLayer: z.ZodString;
-    /** Signal value (numeric or structured) */
-    value: z.ZodUnion<[z.ZodNumber, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>]>;
-    /** Confidence of the signal (0-1) */
-    confidence: z.ZodNumber;
-    /** Timestamp of signal generation */
-    timestamp: z.ZodString;
-    /** Optional metadata */
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, "strip", z.ZodTypeAny, {
-    timestamp: string;
-    value: number | z.objectOutputType<{}, z.ZodTypeAny, "passthrough">;
-    signalId: string;
-    confidence: number;
-    sourceLayer: string;
-    metadata?: Record<string, unknown> | undefined;
-}, {
-    timestamp: string;
-    value: number | z.objectInputType<{}, z.ZodTypeAny, "passthrough">;
-    signalId: string;
-    confidence: number;
-    sourceLayer: string;
-    metadata?: Record<string, unknown> | undefined;
-}>;
-/**
- * Consensus Agent input schema
- */
-export declare const ConsensusInputSchema: z.ZodObject<{
-    /** Signals to analyze for consensus */
-    signals: z.ZodArray<z.ZodObject<{
-        /** Unique signal identifier */
-        signalId: z.ZodString;
-        /** Source layer (e.g., "observatory", "costops", "governance") */
-        sourceLayer: z.ZodString;
-        /** Signal value (numeric or structured) */
-        value: z.ZodUnion<[z.ZodNumber, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>]>;
-        /** Confidence of the signal (0-1) */
-        confidence: z.ZodNumber;
-        /** Timestamp of signal generation */
-        timestamp: z.ZodString;
-        /** Optional metadata */
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, "strip", z.ZodTypeAny, {
-        timestamp: string;
-        value: number | z.objectOutputType<{}, z.ZodTypeAny, "passthrough">;
-        signalId: string;
-        confidence: number;
-        sourceLayer: string;
-        metadata?: Record<string, unknown> | undefined;
-    }, {
-        timestamp: string;
-        value: number | z.objectInputType<{}, z.ZodTypeAny, "passthrough">;
-        signalId: string;
-        confidence: number;
-        sourceLayer: string;
-        metadata?: Record<string, unknown> | undefined;
-    }>, "many">;
-    /** Time range for analysis */
-    timeRange: z.ZodObject<{
-        start: z.ZodString;
-        end: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        start: string;
-        end: string;
-    }, {
-        start: string;
-        end: string;
-    }>;
-    /** Consensus computation options */
-    options: z.ZodDefault<z.ZodObject<{
-        /** Minimum agreement threshold to establish consensus (0-1) */
-        minAgreementThreshold: z.ZodDefault<z.ZodNumber>;
-        /** Confidence weighting strategy */
-        confidenceWeighting: z.ZodDefault<z.ZodEnum<["uniform", "proportional", "exponential"]>>;
-        /** Aggregation method for numeric signals */
-        aggregationMethod: z.ZodDefault<z.ZodEnum<["mean", "median", "mode", "weighted_mean"]>>;
-        /** Include divergent signal analysis */
-        includeDivergentAnalysis: z.ZodDefault<z.ZodBoolean>;
-        /** Signal scope filter */
-        scopeFilter: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        minAgreementThreshold: number;
-        confidenceWeighting: "uniform" | "proportional" | "exponential";
-        aggregationMethod: "mean" | "median" | "mode" | "weighted_mean";
-        includeDivergentAnalysis: boolean;
-        scopeFilter?: string[] | undefined;
-    }, {
-        minAgreementThreshold?: number | undefined;
-        confidenceWeighting?: "uniform" | "proportional" | "exponential" | undefined;
-        aggregationMethod?: "mean" | "median" | "mode" | "weighted_mean" | undefined;
-        includeDivergentAnalysis?: boolean | undefined;
-        scopeFilter?: string[] | undefined;
-    }>>;
-    /** Execution reference for tracing */
-    executionRef: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    options: {
-        minAgreementThreshold: number;
-        confidenceWeighting: "uniform" | "proportional" | "exponential";
-        aggregationMethod: "mean" | "median" | "mode" | "weighted_mean";
-        includeDivergentAnalysis: boolean;
-        scopeFilter?: string[] | undefined;
-    };
-    signals: {
-        timestamp: string;
-        value: number | z.objectOutputType<{}, z.ZodTypeAny, "passthrough">;
-        signalId: string;
-        confidence: number;
-        sourceLayer: string;
-        metadata?: Record<string, unknown> | undefined;
-    }[];
-    timeRange: {
-        start: string;
-        end: string;
-    };
-    executionRef?: string | undefined;
-}, {
-    signals: {
-        timestamp: string;
-        value: number | z.objectInputType<{}, z.ZodTypeAny, "passthrough">;
-        signalId: string;
-        confidence: number;
-        sourceLayer: string;
-        metadata?: Record<string, unknown> | undefined;
-    }[];
-    timeRange: {
-        start: string;
-        end: string;
-    };
-    options?: {
-        minAgreementThreshold?: number | undefined;
-        confidenceWeighting?: "uniform" | "proportional" | "exponential" | undefined;
-        aggregationMethod?: "mean" | "median" | "mode" | "weighted_mean" | undefined;
-        includeDivergentAnalysis?: boolean | undefined;
-        scopeFilter?: string[] | undefined;
-    } | undefined;
-    executionRef?: string | undefined;
-}>;
-export type SignalInput = z.infer<typeof SignalInputSchema>;
-export type ConsensusInput = z.infer<typeof ConsensusInputSchema>;
-/**
- * Consensus Agent response schema
- */
-export declare const ConsensusResponseSchema: z.ZodObject<{
-    /** Whether consensus was achieved */
-    consensusAchieved: z.ZodBoolean;
-    /** The decision event emitted */
-    decisionEvent: z.ZodObject<{
-        agent_id: z.ZodLiteral<"consensus-agent">;
-        agent_version: z.ZodString;
-        decision_type: z.ZodLiteral<"analytics_consensus_summary">;
-        inputs_hash: z.ZodString;
-        outputs: z.ZodObject<{
-            consensusValue: z.ZodUnknown;
-            agreementLevel: z.ZodNumber;
-            agreementCount: z.ZodNumber;
-            totalSignals: z.ZodNumber;
-            divergentSignals: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                signalId: z.ZodString;
-                divergenceScore: z.ZodNumber;
-                value: z.ZodUnknown;
-            }, "strip", z.ZodTypeAny, {
-                signalId: string;
-                divergenceScore: number;
-                value?: unknown;
-            }, {
-                signalId: string;
-                divergenceScore: number;
-                value?: unknown;
-            }>, "many">>;
-            statistics: z.ZodOptional<z.ZodObject<{
-                mean: z.ZodOptional<z.ZodNumber>;
-                median: z.ZodOptional<z.ZodNumber>;
-                stdDev: z.ZodOptional<z.ZodNumber>;
-                variance: z.ZodOptional<z.ZodNumber>;
-            }, "strip", z.ZodTypeAny, {
-                mean?: number | undefined;
-                median?: number | undefined;
-                stdDev?: number | undefined;
-                variance?: number | undefined;
-            }, {
-                mean?: number | undefined;
-                median?: number | undefined;
-                stdDev?: number | undefined;
-                variance?: number | undefined;
-            }>>;
-        }, "strip", z.ZodTypeAny, {
-            agreementLevel: number;
-            agreementCount: number;
-            totalSignals: number;
-            consensusValue?: unknown;
-            divergentSignals?: {
-                signalId: string;
-                divergenceScore: number;
-                value?: unknown;
-            }[] | undefined;
-            statistics?: {
-                mean?: number | undefined;
-                median?: number | undefined;
-                stdDev?: number | undefined;
-                variance?: number | undefined;
-            } | undefined;
-        }, {
-            agreementLevel: number;
-            agreementCount: number;
-            totalSignals: number;
-            consensusValue?: unknown;
-            divergentSignals?: {
-                signalId: string;
-                divergenceScore: number;
-                value?: unknown;
-            }[] | undefined;
-            statistics?: {
-                mean?: number | undefined;
-                median?: number | undefined;
-                stdDev?: number | undefined;
-                variance?: number | undefined;
-            } | undefined;
-        }>;
-        confidence: z.ZodNumber;
-        constraints_applied: z.ZodArray<z.ZodObject<{
-            scope: z.ZodString;
-            dataBoundaries: z.ZodObject<{
-                startTime: z.ZodString;
-                endTime: z.ZodString;
-                layers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, "strip", z.ZodTypeAny, {
-                startTime: string;
-                endTime: string;
-                layers?: string[] | undefined;
-            }, {
-                startTime: string;
-                endTime: string;
-                layers?: string[] | undefined;
-            }>;
-            confidenceBands: z.ZodOptional<z.ZodObject<{
-                lower: z.ZodNumber;
-                upper: z.ZodNumber;
-            }, "strip", z.ZodTypeAny, {
-                lower: number;
-                upper: number;
-            }, {
-                lower: number;
-                upper: number;
-            }>>;
-            minAgreementThreshold: z.ZodOptional<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            scope: string;
-            dataBoundaries: {
-                startTime: string;
-                endTime: string;
-                layers?: string[] | undefined;
-            };
-            confidenceBands?: {
-                lower: number;
-                upper: number;
-            } | undefined;
-            minAgreementThreshold?: number | undefined;
-        }, {
-            scope: string;
-            dataBoundaries: {
-                startTime: string;
-                endTime: string;
-                layers?: string[] | undefined;
-            };
-            confidenceBands?: {
-                lower: number;
-                upper: number;
-            } | undefined;
-            minAgreementThreshold?: number | undefined;
-        }>, "many">;
-        execution_ref: z.ZodString;
-        timestamp: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        timestamp: string;
-        agent_id: "consensus-agent";
-        agent_version: string;
-        decision_type: "analytics_consensus_summary";
-        inputs_hash: string;
-        outputs: {
-            agreementLevel: number;
-            agreementCount: number;
-            totalSignals: number;
-            consensusValue?: unknown;
-            divergentSignals?: {
-                signalId: string;
-                divergenceScore: number;
-                value?: unknown;
-            }[] | undefined;
-            statistics?: {
-                mean?: number | undefined;
-                median?: number | undefined;
-                stdDev?: number | undefined;
-                variance?: number | undefined;
-            } | undefined;
-        };
-        confidence: number;
-        constraints_applied: {
-            scope: string;
-            dataBoundaries: {
-                startTime: string;
-                endTime: string;
-                layers?: string[] | undefined;
-            };
-            confidenceBands?: {
-                lower: number;
-                upper: number;
-            } | undefined;
-            minAgreementThreshold?: number | undefined;
-        }[];
-        execution_ref: string;
-    }, {
-        timestamp: string;
-        agent_id: "consensus-agent";
-        agent_version: string;
-        decision_type: "analytics_consensus_summary";
-        inputs_hash: string;
-        outputs: {
-            agreementLevel: number;
-            agreementCount: number;
-            totalSignals: number;
-            consensusValue?: unknown;
-            divergentSignals?: {
-                signalId: string;
-                divergenceScore: number;
-                value?: unknown;
-            }[] | undefined;
-            statistics?: {
-                mean?: number | undefined;
-                median?: number | undefined;
-                stdDev?: number | undefined;
-                variance?: number | undefined;
-            } | undefined;
-        };
-        confidence: number;
-        constraints_applied: {
-            scope: string;
-            dataBoundaries: {
-                startTime: string;
-                endTime: string;
-                layers?: string[] | undefined;
-            };
-            confidenceBands?: {
-                lower: number;
-                upper: number;
-            } | undefined;
-            minAgreementThreshold?: number | undefined;
-        }[];
-        execution_ref: string;
-    }>;
-    /** Human-readable summary */
-    summary: z.ZodString;
-    /** Processing metadata */
-    processingMetadata: z.ZodObject<{
-        signalsProcessed: z.ZodNumber;
-        computationTimeMs: z.ZodNumber;
-        method: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        method: string;
-        signalsProcessed: number;
-        computationTimeMs: number;
-    }, {
-        method: string;
-        signalsProcessed: number;
-        computationTimeMs: number;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    consensusAchieved: boolean;
-    decisionEvent: {
-        timestamp: string;
-        agent_id: "consensus-agent";
-        agent_version: string;
-        decision_type: "analytics_consensus_summary";
-        inputs_hash: string;
-        outputs: {
-            agreementLevel: number;
-            agreementCount: number;
-            totalSignals: number;
-            consensusValue?: unknown;
-            divergentSignals?: {
-                signalId: string;
-                divergenceScore: number;
-                value?: unknown;
-            }[] | undefined;
-            statistics?: {
-                mean?: number | undefined;
-                median?: number | undefined;
-                stdDev?: number | undefined;
-                variance?: number | undefined;
-            } | undefined;
-        };
-        confidence: number;
-        constraints_applied: {
-            scope: string;
-            dataBoundaries: {
-                startTime: string;
-                endTime: string;
-                layers?: string[] | undefined;
-            };
-            confidenceBands?: {
-                lower: number;
-                upper: number;
-            } | undefined;
-            minAgreementThreshold?: number | undefined;
-        }[];
-        execution_ref: string;
-    };
-    summary: string;
-    processingMetadata: {
-        method: string;
-        signalsProcessed: number;
-        computationTimeMs: number;
-    };
-}, {
-    consensusAchieved: boolean;
-    decisionEvent: {
-        timestamp: string;
-        agent_id: "consensus-agent";
-        agent_version: string;
-        decision_type: "analytics_consensus_summary";
-        inputs_hash: string;
-        outputs: {
-            agreementLevel: number;
-            agreementCount: number;
-            totalSignals: number;
-            consensusValue?: unknown;
-            divergentSignals?: {
-                signalId: string;
-                divergenceScore: number;
-                value?: unknown;
-            }[] | undefined;
-            statistics?: {
-                mean?: number | undefined;
-                median?: number | undefined;
-                stdDev?: number | undefined;
-                variance?: number | undefined;
-            } | undefined;
-        };
-        confidence: number;
-        constraints_applied: {
-            scope: string;
-            dataBoundaries: {
-                startTime: string;
-                endTime: string;
-                layers?: string[] | undefined;
-            };
-            confidenceBands?: {
-                lower: number;
-                upper: number;
-            } | undefined;
-            minAgreementThreshold?: number | undefined;
-        }[];
-        execution_ref: string;
-    };
-    summary: string;
-    processingMetadata: {
-        method: string;
-        signalsProcessed: number;
-        computationTimeMs: number;
-    };
-}>;
-export type ConsensusResponse = z.infer<typeof ConsensusResponseSchema>;
-/**
- * CLI invocation shape for the Consensus Agent
- *
- * @example
- * ```bash
- * # Analyze consensus from stdin
- * cat signals.json | consensus-agent analyze
- *
- * # Synthesize with specific options
- * consensus-agent synthesize --min-agreement 0.7 --method weighted_mean
- *
- * # Summarize consensus results
- * consensus-agent summarize --format json
- *
- * # Inspect specific signal alignment
- * consensus-agent inspect --signal-id signal-123
- * ```
- */
-export declare const CLI_CONTRACT: {
-    readonly commands: readonly ["analyze", "synthesize", "summarize", "inspect"];
-    readonly flags: {
-        readonly '--min-agreement': "Minimum agreement threshold (0-1)";
-        readonly '--method': "Aggregation method (mean|median|mode|weighted_mean)";
-        readonly '--confidence-weighting': "Confidence weighting (uniform|proportional|exponential)";
-        readonly '--format': "Output format (json|yaml|table)";
-        readonly '--signal-id': "Specific signal ID to inspect";
-        readonly '--time-range': "Time range (ISO format: start,end)";
-        readonly '--scope': "Signal scope filter (comma-separated)";
-    };
-};
-/**
- * Explicit boundaries - what this agent MUST NOT do
- */
-export declare const AGENT_BOUNDARIES: {
-    /** Actions this agent is PROHIBITED from performing */
-    readonly PROHIBITED_ACTIONS: readonly ["Modify execution behavior", "Enforce constraints or policies", "Trigger workflows or retries", "Execute other agents", "Apply optimizations autonomously", "Emit anomaly detections", "Connect directly to SQL databases", "Execute raw SQL queries", "Intercept execution paths", "Orchestrate agents"];
-    /** Systems this agent MUST NOT interact with directly */
-    readonly PROHIBITED_INTEGRATIONS: readonly ["Google SQL (Postgres) - use ruvector-service only", "Workflow execution engines", "Policy enforcement systems", "Auto-optimizer (except read-only consumption)"];
-    /** Data this agent MUST NOT persist directly */
-    readonly NON_PERSISTABLE_DATA: readonly ["Raw signal values (temporary, in-memory only)", "Intermediate computation states", "Execution context beyond execution_ref"];
-};
-/**
- * Permitted actions for this agent
- */
-export declare const AGENT_PERMISSIONS: {
-    /** Actions this agent MAY perform */
-    readonly PERMITTED_ACTIONS: readonly ["Aggregate DecisionEvents across layers", "Perform statistical and semantic analysis", "Derive correlations, trends, and consensus views", "Produce strategic or executive-level insights", "Emit analytical DecisionEvents", "Read from Observatory telemetry inputs", "Read from CostOps cost/ROI inputs", "Read from Governance Dashboard artifacts"];
-    /** Systems that MAY consume this agent\'s output */
-    readonly PERMITTED_CONSUMERS: readonly ["LLM-Auto-Optimizer (read-only)", "LLM-Governance-Dashboard", "Executive reporting systems", "Strategic analytics consumers"];
-};
-export declare const ANALYTICS_CLASSIFICATION: {
-    readonly type: "ANALYTICAL_SYNTHESIS";
-    readonly subtype: "CONSENSUS_FORMATION";
-    readonly scope: "CROSS_SIGNAL_AGGREGATION";
-    readonly readOnly: true;
-    readonly executionPath: "OUTSIDE_CRITICAL_PATH";
-};
-export declare const FAILURE_MODES: {
-    /** Input validation failures */
-    readonly VALIDATION_FAILURE: {
-        readonly code: "CONSENSUS_VALIDATION_FAILURE";
-        readonly recoverable: true;
-        readonly action: "Return validation error, do not emit DecisionEvent";
-    };
-    /** Insufficient signals for consensus */
-    readonly INSUFFICIENT_SIGNALS: {
-        readonly code: "CONSENSUS_INSUFFICIENT_SIGNALS";
-        readonly recoverable: true;
-        readonly action: "Return partial result with low confidence, emit DecisionEvent with confidence=0";
-    };
-    /** ruvector-service connection failure */
-    readonly PERSISTENCE_FAILURE: {
-        readonly code: "CONSENSUS_PERSISTENCE_FAILURE";
-        readonly recoverable: false;
-        readonly action: "Log error, return failure response, do not emit DecisionEvent";
-    };
-    /** Computation timeout */
-    readonly COMPUTATION_TIMEOUT: {
-        readonly code: "CONSENSUS_COMPUTATION_TIMEOUT";
-        readonly recoverable: false;
-        readonly action: "Abort computation, return timeout error, do not emit DecisionEvent";
-    };
-    /** Internal computation error */
-    readonly COMPUTATION_ERROR: {
-        readonly code: "CONSENSUS_COMPUTATION_ERROR";
-        readonly recoverable: false;
-        readonly action: "Log error, return failure response, do not emit DecisionEvent";
-    };
-};
-//# sourceMappingURL=consensus-agent.d.ts.map

package/dist/bundled-agents/analytics-hub-agents/dist/contracts/consensus-agent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"consensus-agent.d.ts","sourceRoot":"","sources":["../../src/contracts/consensus-agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,QAAQ,oBAAoB,CAAC;AAC1C,eAAO,MAAM,aAAa,UAAU,CAAC;AACrC,eAAO,MAAM,aAAa,gCAAgC,CAAC;AAM3D;;GAEG;AACH,eAAO,MAAM,iBAAiB;IAC5B,+BAA+B;;IAE/B,kEAAkE;;IAElE,2CAA2C;;IAE3C,qCAAqC;;IAErC,qCAAqC;;IAErC,wBAAwB;;;;;;;;;;;;;;;;EAExB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;IAC/B,uCAAuC;;QAlBvC,+BAA+B;;QAE/B,kEAAkE;;QAElE,2CAA2C;;QAE3C,qCAAqC;;QAErC,qCAAqC;;QAErC,wBAAwB;;;;;;;;;;;;;;;;;IAUxB,8BAA8B;;;;;;;;;;;IAK9B,oCAAoC;;QAElC,+DAA+D;;QAE/D,oCAAoC;;QAEpC,6CAA6C;;QAE7C,wCAAwC;;QAExC,0BAA0B;;;;;;;;;;;;;;;IAG5B,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEtC,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAMlE;;GAEG;AACH,eAAO,MAAM,uBAAuB;IAClC,qCAAqC;;IAErC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEjC,6BAA6B;;IAE7B,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM1B,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAMxE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;CAWf,CAAC;AAMX;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B,uDAAuD;;IAcvD,yDAAyD;;IAQzD,gDAAgD;;CAMxC,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,iBAAiB;IAC5B,qCAAqC;;IAYrC,oDAAoD;;CAO5C,CAAC;AAMX,eAAO,MAAM,wBAAwB;;;;;;CAM3B,CAAC;AAMX,eAAO,MAAM,aAAa;IACxB,gCAAgC;;;;;;IAOhC,yCAAyC;;;;;;IAOzC,0CAA0C;;;;;;IAO1C,0BAA0B;;;;;;IAO1B,iCAAiC;;;;;;CAMzB,CAAC"}