@defai.digital/ax-cli 4.0.4 → 4.0.6

package/packages/schemas/dist/src/public/agent/chat-types.d.ts

@@ -0,0 +1,164 @@
+/**
+ * @ax-cli/schemas - Agent Chat Types
+ *
+ * Single Source of Truth (SSOT) for agent chat-related types.
+ * These types are used across the agent, UI, checkpoint, and SDK modules.
+ *
+ * @packageDocumentation
+ */
+/**
+ * LLM Tool Call representation
+ *
+ * Represents a tool call made by the LLM during a conversation.
+ * This is a simplified version that doesn't depend on OpenAI types.
+ */
+export interface LLMToolCallRef {
+    /** Unique identifier for this tool call */
+    id: string;
+    /** Type of tool call (always "function" for now) */
+    type: "function";
+    /** Function details */
+    function: {
+        /** Name of the function to call */
+        name: string;
+        /** JSON-encoded arguments string */
+        arguments: string;
+    };
+}
+/**
+ * Tool execution result
+ *
+ * Represents the result of executing a tool.
+ */
+export interface ToolResultRef {
+    /** Whether the tool execution succeeded */
+    success: boolean;
+    /** Output from successful execution */
+    output?: string;
+    /** Error message if execution failed */
+    error?: string;
+    /** Additional structured data from the tool */
+    data?: Record<string, unknown>;
+}
+/**
+ * Chat Entry
+ *
+ * Represents a single entry in the chat history between user and assistant.
+ * This is the canonical definition - DO NOT duplicate this type elsewhere.
+ *
+ * @example
+ * ```typescript
+ * const userMessage: ChatEntry = {
+ *   type: "user",
+ *   content: "Hello, how are you?",
+ *   timestamp: new Date(),
+ * };
+ *
+ * const assistantMessage: ChatEntry = {
+ *   type: "assistant",
+ *   content: "I'm doing well, thank you!",
+ *   timestamp: new Date(),
+ *   durationMs: 1500,
+ * };
+ * ```
+ */
+export interface ChatEntry {
+    /** Type of chat entry */
+    type: "user" | "assistant" | "tool_result" | "tool_call";
+    /** Text content of the entry */
+    content: string;
+    /** When this entry was created */
+    timestamp: Date;
+    /** Tool calls made by assistant (for type="assistant") */
+    toolCalls?: LLMToolCallRef[];
+    /** Single tool call (for type="tool_call") */
+    toolCall?: LLMToolCallRef;
+    /** Result of tool execution (for type="tool_result") */
+    toolResult?: {
+        success: boolean;
+        output?: string;
+        error?: string;
+    };
+    /** Whether content is currently streaming */
+    isStreaming?: boolean;
+    /** GLM-4.6 reasoning content (thinking mode) */
+    reasoningContent?: string;
+    /** Whether reasoning is currently streaming */
+    isReasoningStreaming?: boolean;
+    /** Response duration in milliseconds */
+    durationMs?: number;
+    /** Tool execution start time (for elapsed time display while running) */
+    executionStartTime?: Date;
+    /** Tool execution duration in milliseconds (shown after completion) */
+    executionDurationMs?: number;
+}
+/**
+ * Streaming Chunk Types
+ *
+ * Represents different types of streaming chunks that can be received
+ * during a streaming response from the LLM.
+ */
+export type StreamingChunkType = "content" | "reasoning" | "tool_calls" | "tool_result" | "done" | "token_count";
+/**
+ * Streaming Chunk
+ *
+ * Represents a chunk of data received during streaming response.
+ * Used by UI components to render incremental updates.
+ *
+ * @example
+ * ```typescript
+ * // Content chunk
+ * const contentChunk: StreamingChunk = {
+ *   type: "content",
+ *   content: "Hello",
+ * };
+ *
+ * // Tool result chunk
+ * const toolResultChunk: StreamingChunk = {
+ *   type: "tool_result",
+ *   toolResult: { success: true, output: "File created" },
+ *   executionDurationMs: 150,
+ * };
+ * ```
+ */
+export interface StreamingChunk {
+    /** Type of streaming chunk */
+    type: StreamingChunkType;
+    /** Text content (for type="content") */
+    content?: string;
+    /** GLM-4.6 reasoning content chunk (for type="reasoning") */
+    reasoningContent?: string;
+    /** Tool calls from LLM (for type="tool_calls") */
+    toolCalls?: LLMToolCallRef[];
+    /** Single tool call */
+    toolCall?: LLMToolCallRef;
+    /** Tool execution result (for type="tool_result") */
+    toolResult?: ToolResultRef;
+    /** Token count (for type="token_count") */
+    tokenCount?: number;
+    /** Tool execution duration in milliseconds (for type="tool_result") */
+    executionDurationMs?: number;
+}
+/**
+ * Accumulated Message
+ *
+ * Contains the full message content accumulated from streaming response.
+ * Used internally by the agent to build complete messages from chunks.
+ */
+export interface AccumulatedMessage {
+    /** Message role (e.g., "assistant") */
+    role?: string;
+    /** Full accumulated content */
+    content?: string;
+    /** Tool calls accumulated from the response */
+    tool_calls?: LLMToolCallRef[];
+    /** Allow additional properties for flexibility */
+    [key: string]: unknown;
+}
+/**
+ * Chat History
+ *
+ * Type alias for an array of chat entries.
+ */
+export type ChatHistory = ChatEntry[];
+//# sourceMappingURL=chat-types.d.ts.map

package/packages/schemas/dist/src/public/agent/chat-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-types.d.ts","sourceRoot":"","sources":["../../../../src/public/agent/chat-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,2CAA2C;IAC3C,EAAE,EAAE,MAAM,CAAC;IACX,oDAAoD;IACpD,IAAI,EAAE,UAAU,CAAC;IACjB,uBAAuB;IACvB,QAAQ,EAAE;QACR,mCAAmC;QACnC,IAAI,EAAE,MAAM,CAAC;QACb,oCAAoC;QACpC,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,2CAA2C;IAC3C,OAAO,EAAE,OAAO,CAAC;IACjB,uCAAuC;IACvC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,SAAS;IACxB,yBAAyB;IACzB,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,aAAa,GAAG,WAAW,CAAC;IAEzD,gCAAgC;IAChC,OAAO,EAAE,MAAM,CAAC;IAEhB,kCAAkC;IAClC,SAAS,EAAE,IAAI,CAAC;IAEhB,0DAA0D;IAC1D,SAAS,CAAC,EAAE,cAAc,EAAE,CAAC;IAE7B,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,cAAc,CAAC;IAE1B,wDAAwD;IACxD,UAAU,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAEnE,6CAA6C;IAC7C,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB,gDAAgD;IAChD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,+CAA+C;IAC/C,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAE/B,wCAAwC;IACxC,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,yEAAyE;IACzE,kBAAkB,CAAC,EAAE,IAAI,CAAC;IAE1B,uEAAuE;IACvE,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAC1B,SAAS,GACT,WAAW,GACX,YAAY,GACZ,aAAa,GACb,MAAM,GACN,aAAa,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,cAAc;IAC7B,8BAA8B;IAC9B,IAAI,EAAE,kBAAkB,CAAC;IAEzB,wCAAwC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,6DAA6D;IAC7D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,kDAAkD;IAClD,SAAS,CAAC,EAAE,cAAc,EAAE,CAAC;IAE7B,uBAAuB;IACvB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAE1B,qDAAqD;IACrD,UAAU,CAAC,EAAE,aAAa,CAAC;IAE3B,2CAA2C;IAC3C,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,uEAAuE;IACvE,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,+BAA+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,+CAA+C;IAC/C,UAAU,CAAC,EAAE,cAAc,EAAE,CAAC;IAE9B,kDAAkD;IAClD,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,SAAS,EAAE,CAAC"}

package/packages/schemas/dist/src/public/agent/chat-types.js

@@ -0,0 +1,10 @@
+/**
+ * @ax-cli/schemas - Agent Chat Types
+ *
+ * Single Source of Truth (SSOT) for agent chat-related types.
+ * These types are used across the agent, UI, checkpoint, and SDK modules.
+ *
+ * @packageDocumentation
+ */
+export {};
+//# sourceMappingURL=chat-types.js.map

package/packages/schemas/dist/src/public/agent/chat-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-types.js","sourceRoot":"","sources":["../../../../src/public/agent/chat-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/packages/schemas/dist/src/public/agent/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @ax-cli/schemas - Agent Types
+ *
+ * Exports all agent-related types for the ax-cli ecosystem.
+ *
+ * @packageDocumentation
+ */
+export { type LLMToolCallRef, type ToolResultRef, type ChatEntry, type StreamingChunkType, type StreamingChunk, type AccumulatedMessage, type ChatHistory, } from './chat-types.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/schemas/dist/src/public/agent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/public/agent/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,WAAW,GACjB,MAAM,iBAAiB,CAAC"}

package/packages/schemas/dist/src/public/agent/index.js

@@ -0,0 +1,9 @@
+/**
+ * @ax-cli/schemas - Agent Types
+ *
+ * Exports all agent-related types for the ax-cli ecosystem.
+ *
+ * @packageDocumentation
+ */
+export {};
+//# sourceMappingURL=index.js.map

package/packages/schemas/dist/src/public/agent/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/public/agent/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/packages/schemas/dist/src/public/core/brand-types.d.ts

@@ -0,0 +1,308 @@
+/**
+ * Brand Types Utilities for @ax-cli/schemas
+ *
+ * CRITICAL SECURITY WARNING:
+ * =========================
+ * Brand types are COMPILE-TIME ONLY markers. They provide ZERO runtime validation.
+ *
+ * **YOU MUST VALIDATE ALL INPUTS AT SYSTEM BOUNDARIES**
+ *
+ * Unsafe usage (WILL FAIL IN PRODUCTION):
+ * ```typescript
+ * const tenantId = userInput as TenantId; // ❌ NO RUNTIME VALIDATION!
+ * ```
+ *
+ * Safe usage (REQUIRED):
+ * ```typescript
+ * const result = TenantId.parse(userInput); // ✅ Validates with Zod
+ * if (result.success) {
+ *   const tenantId = result.data; // Type-safe AND runtime-safe
+ * }
+ * ```
+ *
+ * WHEN TO USE BRAND TYPES:
+ * - Preventing ID mixing at compile time (ApiKeyId vs TenantId)
+ * - Enforcing domain boundaries in function signatures
+ * - Type-level documentation of intent
+ *
+ * WHEN TO VALIDATE:
+ * - API boundaries (HTTP requests, MCP inputs)
+ * - File I/O (reading configs, user settings)
+ * - Database queries (WHERE clauses with user IDs)
+ * - Environment variables
+ * - Command-line arguments
+ *
+ * PERFORMANCE:
+ * Brand types have ZERO runtime cost. They are erased during compilation.
+ *
+ * @module brand-types
+ * @see {@link https://github.com/microsoft/TypeScript/issues/4895|TypeScript Nominal Types}
+ */
+/**
+ * Unique symbol used as a phantom type marker for branding.
+ * This symbol is exported for type compatibility but cannot be accessed at runtime,
+ * making it impossible to forge branded types without using the
+ * provided constructor functions.
+ *
+ * @internal
+ */
+export declare const __brand: unique symbol;
+/**
+ * Brand<T, B> creates a "nominal type" from a structural type.
+ *
+ * TypeScript uses structural typing by default:
+ * ```typescript
+ * type UserId = string;
+ * type TenantId = string;
+ *
+ * const user: UserId = "user-123";
+ * const tenant: TenantId = user; // ✅ No error! Strings are compatible.
+ * ```
+ *
+ * Brand types enforce nominal typing:
+ * ```typescript
+ * type UserId = Brand<string, 'UserId'>;
+ * type TenantId = Brand<string, 'TenantId'>;
+ *
+ * const user = brand<string, 'UserId'>("user-123");
+ * const tenant: TenantId = user; // ❌ Compile error! Incompatible brands.
+ * ```
+ *
+ * @template T - The base type (string, number, etc.)
+ * @template B - The brand identifier (unique string literal)
+ *
+ * @example
+ * ```typescript
+ * type ApiKeyId = Brand<string, 'ApiKeyId'>;
+ * type TenantId = Brand<string, 'TenantId'>;
+ *
+ * function updateUsage(apiKeyId: ApiKeyId, tenantId: TenantId) {
+ *   // This function signature makes it impossible to swap arguments
+ * }
+ *
+ * const apiKey = brand<string, 'ApiKeyId'>("ak_123");
+ * const tenant = brand<string, 'TenantId'>("tn_456");
+ *
+ * updateUsage(apiKey, tenant);        // ✅ Correct
+ * updateUsage(tenant, apiKey);        // ❌ Compile error!
+ * updateUsage("ak_123", "tn_456");    // ❌ Compile error!
+ * ```
+ */
+export type Brand<T, B extends string> = T & {
+    readonly [__brand]: B;
+};
+/**
+ * Creates a branded value.
+ *
+ * WARNING: This function performs NO VALIDATION. It is a type-level assertion only.
+ *
+ * Use this ONLY in trusted contexts after validation:
+ * - Inside schema .transform() after Zod validation
+ * - After database queries that return validated data
+ * - In test fixtures with known-good values
+ *
+ * DO NOT use with user input directly:
+ * ```typescript
+ * // ❌ UNSAFE - No validation!
+ * const userId = brand<string, 'UserId'>(req.body.userId);
+ *
+ * // ✅ SAFE - Validated first
+ * const result = UserIdSchema.safeParse(req.body.userId);
+ * if (result.success) {
+ *   const userId = result.data; // Already branded by schema
+ * }
+ * ```
+ *
+ * @template T - The base type
+ * @template B - The brand identifier
+ * @param value - The value to brand
+ * @returns The same value, but with a brand type
+ *
+ * @example
+ * ```typescript
+ * // Safe usage in tests
+ * const mockTenantId = brand<string, 'TenantId'>("test-tenant-123");
+ *
+ * // Safe usage after validation
+ * const schema = z.string().uuid().transform(v => brand<string, 'TenantId'>(v));
+ * const tenantId = schema.parse(userInput); // Validated AND branded
+ * ```
+ */
+export declare function brand<T, B extends string>(value: T): Brand<T, B>;
+/**
+ * Type guard to check if a value is already branded with a specific brand.
+ *
+ * NOTE: This only works if the value was created using the brand() function.
+ * It CANNOT detect fake brands created with `as` casts.
+ *
+ * @template T - The base type
+ * @template B - The brand identifier
+ * @param value - The value to check
+ * @returns true if the value has the correct brand (compile-time only)
+ *
+ * @example
+ * ```typescript
+ * const value: string | TenantId = getTenantId();
+ *
+ * if (isBranded<string, 'TenantId'>(value)) {
+ *   const tenantId: TenantId = value; // TypeScript knows it's branded
+ * }
+ * ```
+ */
+export declare function isBranded<T, B extends string>(_value: unknown): _value is Brand<T, B>;
+/**
+ * Removes the brand from a branded type, returning the base type.
+ *
+ * Use this when you need to pass a branded value to a function that
+ * expects the base type (e.g., logging, serialization).
+ *
+ * @template T - The base type
+ * @template B - The brand identifier
+ * @param value - The branded value
+ * @returns The same value, but with the brand removed
+ *
+ * @example
+ * ```typescript
+ * const tenantId: TenantId = getTenantId();
+ *
+ * // Pass to function expecting plain string
+ * console.log(unbrand(tenantId)); // string, not TenantId
+ *
+ * // Serialize to JSON
+ * const json = JSON.stringify({ id: unbrand(tenantId) });
+ * ```
+ */
+export declare function unbrand<T, B extends string>(value: Brand<T, B>): T;
+/**
+ * Utility type to extract the brand identifier from a branded type.
+ *
+ * @template T - The branded type
+ *
+ * @example
+ * ```typescript
+ * type TenantId = Brand<string, 'TenantId'>;
+ * type BrandName = ExtractBrand<TenantId>; // 'TenantId'
+ * ```
+ */
+export type ExtractBrand<T> = T extends Brand<unknown, infer B> ? B : never;
+/**
+ * Utility type to extract the base type from a branded type.
+ *
+ * @template T - The branded type
+ *
+ * @example
+ * ```typescript
+ * type TenantId = Brand<string, 'TenantId'>;
+ * type BaseType = ExtractBase<TenantId>; // string
+ * ```
+ */
+export type ExtractBase<T> = T extends Brand<infer U, string> ? U : T;
+/**
+ * Creates a type-safe brand factory with validation.
+ *
+ * This is the RECOMMENDED way to create brand types with runtime validation.
+ *
+ * @template T - The base type
+ * @template B - The brand identifier
+ * @param schema - Zod schema for validation
+ * @param brandName - The brand identifier
+ * @returns Object with parse, create, and is methods
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const TenantId = createBrandFactory(
+ *   z.string().uuid(),
+ *   'TenantId'
+ * );
+ *
+ * // Type-safe parsing with validation
+ * const result = TenantId.parse(userInput);
+ * if (result.success) {
+ *   const tenantId = result.data; // Brand<string, 'TenantId'>
+ * }
+ *
+ * // Create new ID
+ * const newId = TenantId.create(); // Generates UUID
+ *
+ * // Type guard
+ * if (TenantId.is(value)) {
+ *   // value is Brand<string, 'TenantId'>
+ * }
+ * ```
+ */
+export declare function createBrandFactory<T, B extends string>(schema: {
+    parse: (input: unknown) => T;
+    safeParse: (input: unknown) => {
+        success: boolean;
+        data?: T;
+        error?: unknown;
+    };
+}, brandName: B): {
+    /**
+     * The Zod schema with brand transformation.
+     */
+    schema: {
+        parse: (input: unknown) => Brand<T, B>;
+        safeParse: (input: unknown) => {
+            success: true;
+            data: Brand<T, B>;
+        } | {
+            success: false;
+            error: unknown;
+        };
+    };
+    /**
+     * Parse and validate input, returning branded value.
+     * Throws on validation failure.
+     */
+    parse: (input: unknown) => Brand<T, B>;
+    /**
+     * Type guard to check if a value is this brand.
+     */
+    is: (value: unknown) => value is Brand<T, B>;
+    /**
+     * Brand name identifier.
+     */
+    brandName: B;
+};
+/**
+ * BEST PRACTICES SUMMARY:
+ * =======================
+ *
+ * 1. ALWAYS validate at boundaries:
+ *    - API inputs: Use Zod schemas
+ *    - Database outputs: Use Zod schemas
+ *    - File I/O: Use Zod schemas
+ *    - CLI args: Use Zod schemas
+ *
+ * 2. NEVER cast to brand types:
+ *    ❌ const id = userInput as TenantId;
+ *    ✅ const id = TenantIdSchema.parse(userInput);
+ *
+ * 3. Use createBrandFactory for all brand types:
+ *    - Provides validation
+ *    - Provides type guards
+ *    - Centralizes brand creation
+ *
+ * 4. Document which functions validate:
+ *    ```typescript
+ *    // @validates TenantId - performs Zod validation
+ *    function parseTenantId(input: string): TenantId {
+ *      return TenantIdSchema.parse(input);
+ *    }
+ *
+ *    // @assumes TenantId - no validation, requires validated input
+ *    function formatTenantId(id: TenantId): string {
+ *      return `tenant:${unbrand(id)}`;
+ *    }
+ *    ```
+ *
+ * 5. Test brand type enforcement:
+ *    ```typescript
+ *    // Should fail to compile
+ *    const apiKey: ApiKeyId = getTenantId(); // ❌
+ *    ```
+ */
+//# sourceMappingURL=brand-types.d.ts.map

package/packages/schemas/dist/src/public/core/brand-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brand-types.d.ts","sourceRoot":"","sources":["../../../../src/public/core/brand-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,CAAC,MAAM,OAAO,EAAE,OAAO,MAAM,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,GAAG;IAAE,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;CAAE,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAEhE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAC3C,MAAM,EAAE,OAAO,GACd,MAAM,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAIvB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAElE;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAE5E;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EACpD,MAAM,EAAE;IAAE,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,CAAC,CAAC;IAAC,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;CAAE,EACxH,SAAS,EAAE,CAAC;IAGV;;OAEG;;uBAEc,OAAO,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;2BAIjB,OAAO,KAAG;YAAE,OAAO,EAAE,IAAI,CAAC;YAAC,IAAI,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;SAAE,GAAG;YAAE,OAAO,EAAE,KAAK,CAAC;YAAC,KAAK,EAAE,OAAO,CAAA;SAAE;;IASxG;;;OAGG;mBACY,OAAO,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;IAKpC;;OAEG;gBACS,OAAO,KAAG,KAAK,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;IAK1C;;OAEG;;EAGN;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG"}