@runtypelabs/sdk 0.1.1

package/README.md

@@ -0,0 +1,398 @@
+# @runtypelabs/sdk
+
+TypeScript client SDK for the Runtype API with FlowBuilder for constructing and executing AI workflows.
+
+## Installation
+
+```bash
+npm install @runtypelabs/sdk
+# or
+yarn add @runtypelabs/sdk
+# or
+pnpm add @runtypelabs/sdk
+```
+
+## Quick Start
+
+```typescript
+import { RuntypeClient } from '@runtypelabs/sdk'
+
+// Initialize the client
+const runtype = new RuntypeClient({
+  apiKey: 'your-api-key',
+  baseUrl: 'https://api.runtype.com' // optional, defaults to production
+})
+
+// Use the FlowBuilder for intuitive flow construction
+const result = await runtype
+  .flow('My AI Workflow')
+  .withRecord({ name: 'Test', type: 'data', metadata: { url: 'https://example.com' } })
+  .fetchUrl({
+    name: 'Fetch Content',
+    url: '{{_record.metadata.url}}',
+    outputVariable: 'content'
+  })
+  .prompt({
+    name: 'Analyze',
+    model: 'gpt-4',
+    userPrompt: 'Analyze this content: {{content}}',
+    responseFormat: 'json'
+  })
+  .run({ streamResponse: true, flowMode: 'virtual' })
+
+// Get the analysis result
+const analysis = await result.getResult('Analyze')
+console.log(analysis)
+```
+
+## Features
+
+- **FlowBuilder API**: Fluent, chainable API for building AI workflows
+- **Streaming Support**: Process streaming responses with callbacks or async iteration
+- **Automatic Field Transformation**: All request/response data is automatically transformed between camelCase (client) and snake_case (API)
+- **Type Safety**: Full TypeScript support with comprehensive type definitions
+- **Error Handling**: Proper error handling with custom error types
+- **Zero Dependencies**: No external runtime dependencies
+
+## FlowBuilder API
+
+The FlowBuilder provides a fluent interface for constructing and executing flows.
+
+### Basic Usage
+
+```typescript
+import { RuntypeClient } from '@runtypelabs/sdk'
+
+const runtype = new RuntypeClient({ apiKey: 'sk-...' })
+
+// Build and execute a flow
+const result = await runtype
+  .flow('Theme Generator')
+  .withRecord({ name: 'Test', type: 'theme', metadata: { url: 'https://example.com' } })
+  .fetchUrl({
+    name: 'Capture Screenshot',
+    url: '{{_record.metadata.url}}',
+    fetchMethod: 'firecrawl',
+    outputVariable: 'screenshot'
+  })
+  .prompt({
+    name: 'Analyze',
+    model: 'gemini-2.5-flash',
+    userPrompt: 'Analyze the screenshot and extract color themes...',
+    responseFormat: 'json'
+  })
+  .run({ streamResponse: true, flowMode: 'virtual' })
+
+// Get specific step result
+const analysis = await result.getResult('Analyze')
+```
+
+### With Streaming Callbacks
+
+```typescript
+const summary = await runtype
+  .flow('My Flow')
+  .prompt({ name: 'Process', model: 'gpt-4', userPrompt: '...' })
+  .run({ streamResponse: true }, {
+    onStepStart: (event) => console.log('Starting:', event.name),
+    onStepChunk: (chunk) => process.stdout.write(chunk),
+    onStepComplete: (result, event) => console.log('Done:', event.name),
+    onFlowComplete: (event) => console.log('Complete!'),
+  })
+```
+
+### Using Existing Flows
+
+```typescript
+// Reference an existing flow by ID
+const result = await runtype
+  .flow('Existing Flow')
+  .useExistingFlow('flow_abc123')
+  .withRecord({ name: 'Test', type: 'data' })
+  .run({ streamResponse: true })
+```
+
+### Standalone FlowBuilder
+
+```typescript
+import { FlowBuilder } from '@runtypelabs/sdk'
+
+// Build flow definition without a client
+const flowBuilder = new FlowBuilder()
+  .createFlow({ name: 'My Flow' })
+  .withRecord({ name: 'Test', type: 'data' })
+  .prompt({ name: 'Step 1', model: 'gpt-4', userPrompt: '...' })
+
+// Execute with any client that implements DispatchClient interface
+const flowResult = await flowBuilder.run(apiClient, {
+  streamResponse: true,
+  flowMode: 'virtual',
+  storeResults: true
+})
+
+// Get specific step result
+const stepResult = await flowResult.getResult('Step 1')
+
+// Or get all results
+const allResults = await flowResult.getAllResults()
+```
+
+### Available Step Methods
+
+| Method | Step Type | Description |
+|--------|-----------|-------------|
+| `.prompt()` | `prompt` | AI prompt execution |
+| `.fetchUrl()` | `fetch-url` | HTTP/Firecrawl fetch |
+| `.transformData()` | `transform-data` | JavaScript transformation |
+| `.setVariable()` | `set-variable` | Set a variable |
+| `.conditional()` | `conditional` | If/else branching |
+| `.search()` | `search` | Web search (Exa, etc.) |
+| `.sendEmail()` | `send-email` | Send email |
+| `.sendStream()` | `send-stream` | Stream message to client |
+| `.retrieveRecord()` | `retrieve-record` | Load record data |
+| `.upsertRecord()` | `upsert-record` | Create/update record |
+| `.vectorSearch()` | `vector-search` | Semantic search |
+| `.generateEmbedding()` | `generate-embedding` | Create embedding |
+| `.waitUntil()` | `wait-until` | Delay or poll |
+| `.sendEvent()` | `send-event` | Analytics event |
+| `.sendText()` | `send-text` | SMS message |
+| `.fetchGitHub()` | `fetch-github` | GitHub API |
+
+### Configuration Methods
+
+- `.createFlow({ name, description })` - Initialize flow
+- `.useExistingFlow(flowId)` - Use an existing flow by ID
+- `.withRecord({ id?, name?, type?, metadata? })` - Set record config
+- `.withMessages([...])` - Set conversation messages
+- `.withOptions({ ... })` - Set default options
+
+### FlowResult Methods
+
+- `.getResult(stepName)` - Get a specific step's result
+- `.getAllResults()` - Get all step results as `Map<string, any>`
+- `.getSummary()` - Get `FlowSummary` with execution details
+- `.stream(callbacks?)` - Process stream with optional callbacks
+- `.raw` - Access raw `Response` for manual handling
+
+### Streaming Callbacks
+
+```typescript
+interface StreamCallbacks {
+  onFlowStart?: (event: FlowStartEvent) => void
+  onStepStart?: (event: StepStartEvent) => void
+  onStepChunk?: (chunk: string, event: StepChunkEvent) => void
+  onStepComplete?: (result: any, event: StepCompleteEvent) => void
+  onFlowComplete?: (event: FlowCompleteEvent) => void
+  onError?: (error: Error) => void
+}
+```
+
+## Traditional API Usage
+
+The client also provides traditional endpoint-based API access:
+
+### Flows
+
+```typescript
+// List flows with pagination
+const flows = await runtype.flows.list({ limit: 20, cursor: 'next-page-cursor' })
+
+// Get a specific flow
+const flow = await runtype.flows.get('flow_123')
+
+// Create a new flow
+const newFlow = await runtype.flows.create({
+  name: 'Analysis Flow',
+  description: 'Analyzes customer data',
+  prompts: [...]
+})
+
+// Update a flow
+const updatedFlow = await runtype.flows.update('flow_123', { name: 'Updated Name' })
+
+// Delete a flow
+await runtype.flows.delete('flow_123')
+```
+
+### Records
+
+```typescript
+// List records with filtering
+const records = await runtype.records.list({
+  metadataKeys: 'company,industry',
+  minFields: 5
+})
+
+// Create a record
+const record = await runtype.records.create({
+  type: 'customer',
+  name: 'Acme Corp',
+  metadata: {
+    industry: 'Technology',
+    revenue: 1000000
+  }
+})
+
+// Bulk edit records
+const result = await runtype.records.bulkEdit({
+  recordIds: ['rec_1', 'rec_2'],
+  updates: { status: 'processed' }
+})
+```
+
+### Model Configurations
+
+```typescript
+// Get available models
+const models = await runtype.modelConfigs.getAvailable()
+
+// Create a model configuration
+const config = await runtype.modelConfigs.create({
+  provider: 'openai',
+  modelId: 'gpt-4',
+  apiKey: 'your-openai-key'
+})
+
+// Set as default
+await runtype.modelConfigs.setDefault(config.id)
+```
+
+### Dispatch (Atomic Operations)
+
+```typescript
+// Create record and flow, then execute atomically
+const result = await runtype.dispatch.execute({
+  record: {
+    name: 'New Customer',
+    type: 'customer',
+    metadata: { industry: 'Tech' }
+  },
+  flow: {
+    name: 'Customer Analysis',
+    prompts: [
+      {
+        name: 'Analyze Industry',
+        text: 'Analyze this {{metadata.industry}} company',
+        model: 'gpt-4',
+        responseFormat: 'json'
+      }
+    ]
+  },
+  options: {
+    streamResponse: true
+  }
+})
+```
+
+## Field Name Transformation
+
+The SDK automatically handles field name transformation between camelCase (client) and snake_case (API):
+
+```typescript
+// You write (camelCase):
+const record = await runtype.records.create({
+  recordType: 'customer',
+  metadataSchema: { ... }
+})
+
+// API receives (snake_case):
+// { "record_type": "customer", "metadata_schema": { ... } }
+
+// API responds (snake_case):
+// { "created_at": "2024-01-01T00:00:00Z" }
+
+// You receive (camelCase):
+console.log(record.createdAt) // "2024-01-01T00:00:00Z"
+```
+
+## Error Handling
+
+```typescript
+import { RuntypeApiError } from '@runtypelabs/sdk'
+
+try {
+  const flow = await runtype.flows.get('invalid_id')
+} catch (error) {
+  if (error instanceof RuntypeApiError) {
+    console.log('API Error:', error.message)
+    console.log('Status Code:', error.statusCode)
+    console.log('Error Data:', error.data)
+  } else {
+    console.log('Network or other error:', error)
+  }
+}
+```
+
+## TypeScript Support
+
+The SDK is built with TypeScript and provides full type safety:
+
+```typescript
+import type {
+  Flow,
+  RuntypeRecord,
+  Prompt,
+  FlowBuilder,
+  FlowResult,
+  StreamCallbacks
+} from '@runtypelabs/sdk'
+
+// All types use camelCase field names
+const flow: Flow = await runtype.flows.get('flow_123')
+console.log(flow.createdAt) // TypeScript knows this is a string
+```
+
+## Configuration Options
+
+```typescript
+const runtype = new RuntypeClient({
+  apiKey: 'your-api-key',           // Required for authenticated endpoints
+  baseUrl: 'https://api.runtype.com', // Optional, defaults to production
+  apiVersion: 'v1',                  // Optional, API version (default: 'v1')
+  timeout: 30000,                    // Optional, request timeout in ms (default: 30000)
+  headers: {                         // Optional, additional headers
+    'X-Custom-Header': 'value'
+  }
+})
+```
+
+## Publishing
+
+### Prerequisites
+
+- npm account with publish access to `@runtypelabs/sdk`
+- Logged in via `npm login`
+
+### Steps
+
+```bash
+# 1. Ensure you're on main/staging with clean working tree
+git status
+
+# 2. Build the package
+cd packages/client
+pnpm build
+
+# 3. Bump version (edit package.json manually or use npm with --ignore-scripts)
+npm version patch --ignore-scripts   # 0.1.0 → 0.1.1
+# npm version minor --ignore-scripts # 0.1.0 → 0.2.0
+# npm version major --ignore-scripts # 0.1.0 → 1.0.0
+
+# 4. Publish to npm (pnpm handles workspace protocol correctly)
+pnpm publish --access public --no-git-checks
+
+# 5. Push version commit and tag to git
+git push && git push --tags
+```
+
+### Dry Run
+
+To preview what will be published without actually publishing:
+
+```bash
+pnpm publish --dry-run
+```
+
+## License
+
+MIT

package/dist/batch-builder.d.ts

@@ -0,0 +1,106 @@
+/**
+ * BatchBuilder - Fluent builder for batch operations
+ *
+ * Provides a chainable API for building batch dispatch configurations
+ * that execute a flow across multiple records of the same type.
+ *
+ * @example
+ * ```typescript
+ * import { BatchBuilder } from '@runtypelabs/sdk'
+ *
+ * const batch = await new BatchBuilder()
+ *   .useFlow('flow_abc123')
+ *   .forRecordType('customer')
+ *   .withOptions({ async: true })
+ *   .run(apiClient)
+ * ```
+ */
+export interface BatchOptions {
+    /** Run batch asynchronously (default: true) */
+    async?: boolean;
+    /** Maximum concurrent executions */
+    concurrency?: number;
+    /** Continue on individual record failures */
+    continueOnError?: boolean;
+    /** Store results for each record */
+    storeResults?: boolean;
+    /** Model override for batch execution */
+    modelOverride?: string;
+}
+export interface BatchRequest {
+    flowId: string;
+    recordType: string;
+    options?: BatchOptions;
+    /** Optional filter for records */
+    filter?: Record<string, any>;
+    /** Optional limit on number of records */
+    limit?: number;
+}
+export interface BatchResult {
+    batchId: string;
+    status: 'queued' | 'running' | 'completed' | 'failed';
+    totalRecords: number;
+    processedRecords: number;
+    failedRecords: number;
+}
+export declare class BatchBuilder {
+    private flowId;
+    private recordType;
+    private batchOptions;
+    private filterConfig;
+    private limitConfig;
+    /**
+     * Specify the flow to execute for each record
+     */
+    useFlow(flowId: string): this;
+    /**
+     * Specify the record type to batch process
+     */
+    forRecordType(recordType: string): this;
+    /**
+     * Set batch execution options
+     */
+    withOptions(options: BatchOptions): this;
+    /**
+     * Filter records to process
+     *
+     * @example
+     * ```typescript
+     * .withFilter({ status: 'pending', createdAt: { $gt: '2024-01-01' } })
+     * ```
+     */
+    withFilter(filter: Record<string, any>): this;
+    /**
+     * Limit the number of records to process
+     */
+    withLimit(limit: number): this;
+    /**
+     * Build the batch request configuration
+     */
+    build(): BatchRequest;
+    /**
+     * Execute the batch operation
+     *
+     * @param client - Client with batch dispatch capability
+     * @returns BatchResult with batch status
+     */
+    run(client: BatchClient): Promise<BatchResult>;
+}
+/**
+ * Interface for clients that can execute batch operations
+ */
+export interface BatchClient {
+    batch(config: BatchRequest): Promise<BatchResult>;
+}
+/**
+ * BatchBuilder that is bound to a client for direct execution
+ */
+export declare class ClientBatchBuilder extends BatchBuilder {
+    private boundClient;
+    constructor(client: BatchClient);
+    /**
+     * Execute the batch using the bound client
+     */
+    run(): Promise<BatchResult>;
+}
+//# sourceMappingURL=batch-builder.d.ts.map

package/dist/batch-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-builder.d.ts","sourceRoot":"","sources":["../src/batch-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH,MAAM,WAAW,YAAY;IAC3B,+CAA+C;IAC/C,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,oCAAoC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,6CAA6C;IAC7C,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,oCAAoC;IACpC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,yCAAyC;IACzC,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,YAAY,CAAA;IACtB,kCAAkC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC5B,0CAA0C;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAA;IACrD,YAAY,EAAE,MAAM,CAAA;IACpB,gBAAgB,EAAE,MAAM,CAAA;IACxB,aAAa,EAAE,MAAM,CAAA;CACtB;AAMD,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,YAAY,CAAmB;IACvC,OAAO,CAAC,YAAY,CAAiC;IACrD,OAAO,CAAC,WAAW,CAAoB;IAEvC;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAK7B;;OAEG;IACH,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAKvC;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAKxC;;;;;;;OAOG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IAK7C;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAK9B;;OAEG;IACH,KAAK,IAAI,YAAY;IA4BrB;;;;;OAKG;IACG,GAAG,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;CAIrD;AAMD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAAA;CAClD;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;IAClD,OAAO,CAAC,WAAW,CAAa;gBAEpB,MAAM,EAAE,WAAW;IAK/B;;OAEG;IACG,GAAG,IAAI,OAAO,CAAC,WAAW,CAAC;CAIlC"}

package/dist/batch-builder.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * BatchBuilder - Fluent builder for batch operations
+ *
+ * Provides a chainable API for building batch dispatch configurations
+ * that execute a flow across multiple records of the same type.
+ *
+ * @example
+ * ```typescript
+ * import { BatchBuilder } from '@runtypelabs/sdk'
+ *
+ * const batch = await new BatchBuilder()
+ *   .useFlow('flow_abc123')
+ *   .forRecordType('customer')
+ *   .withOptions({ async: true })
+ *   .run(apiClient)
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientBatchBuilder = exports.BatchBuilder = void 0;
+// ============================================================================
+// BatchBuilder Class
+// ============================================================================
+class BatchBuilder {
+    constructor() {
+        this.flowId = '';
+        this.recordType = '';
+        this.batchOptions = {};
+    }
+    /**
+     * Specify the flow to execute for each record
+     */
+    useFlow(flowId) {
+        this.flowId = flowId;
+        return this;
+    }
+    /**
+     * Specify the record type to batch process
+     */
+    forRecordType(recordType) {
+        this.recordType = recordType;
+        return this;
+    }
+    /**
+     * Set batch execution options
+     */
+    withOptions(options) {
+        this.batchOptions = { ...this.batchOptions, ...options };
+        return this;
+    }
+    /**
+     * Filter records to process
+     *
+     * @example
+     * ```typescript
+     * .withFilter({ status: 'pending', createdAt: { $gt: '2024-01-01' } })
+     * ```
+     */
+    withFilter(filter) {
+        this.filterConfig = filter;
+        return this;
+    }
+    /**
+     * Limit the number of records to process
+     */
+    withLimit(limit) {
+        this.limitConfig = limit;
+        return this;
+    }
+    /**
+     * Build the batch request configuration
+     */
+    build() {
+        if (!this.flowId) {
+            throw new Error('BatchBuilder: flowId is required. Call .useFlow(flowId) first.');
+        }
+        if (!this.recordType) {
+            throw new Error('BatchBuilder: recordType is required. Call .forRecordType(type) first.');
+        }
+        const request = {
+            flowId: this.flowId,
+            recordType: this.recordType,
+        };
+        if (Object.keys(this.batchOptions).length > 0) {
+            request.options = this.batchOptions;
+        }
+        if (this.filterConfig) {
+            request.filter = this.filterConfig;
+        }
+        if (this.limitConfig !== undefined) {
+            request.limit = this.limitConfig;
+        }
+        return request;
+    }
+    /**
+     * Execute the batch operation
+     *
+     * @param client - Client with batch dispatch capability
+     * @returns BatchResult with batch status
+     */
+    async run(client) {
+        const config = this.build();
+        return client.batch(config);
+    }
+}
+exports.BatchBuilder = BatchBuilder;
+/**
+ * BatchBuilder that is bound to a client for direct execution
+ */
+class ClientBatchBuilder extends BatchBuilder {
+    constructor(client) {
+        super();
+        this.boundClient = client;
+    }
+    /**
+     * Execute the batch using the bound client
+     */
+    async run() {
+        const config = this.build();
+        return this.boundClient.batch(config);
+    }
+}
+exports.ClientBatchBuilder = ClientBatchBuilder;
+//# sourceMappingURL=batch-builder.js.map

package/dist/batch-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-builder.js","sourceRoot":"","sources":["../src/batch-builder.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;;;AAuCH,+EAA+E;AAC/E,qBAAqB;AACrB,+EAA+E;AAE/E,MAAa,YAAY;IAAzB;QACU,WAAM,GAAW,EAAE,CAAA;QACnB,eAAU,GAAW,EAAE,CAAA;QACvB,iBAAY,GAAiB,EAAE,CAAA;IA0FzC,CAAC;IAtFC;;OAEG;IACH,OAAO,CAAC,MAAc;QACpB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACpB,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;OAEG;IACH,aAAa,CAAC,UAAkB;QAC9B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAC5B,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;OAEG;IACH,WAAW,CAAC,OAAqB;QAC/B,IAAI,CAAC,YAAY,GAAG,EAAE,GAAG,IAAI,CAAC,YAAY,EAAE,GAAG,OAAO,EAAE,CAAA;QACxD,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;;;;OAOG;IACH,UAAU,CAAC,MAA2B;QACpC,IAAI,CAAC,YAAY,GAAG,MAAM,CAAA;QAC1B,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,KAAa;QACrB,IAAI,CAAC,WAAW,GAAG,KAAK,CAAA;QACxB,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;OAEG;IACH,KAAK;QACH,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAA;QACnF,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,wEAAwE,CAAC,CAAA;QAC3F,CAAC;QAED,MAAM,OAAO,GAAiB;YAC5B,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,UAAU,EAAE,IAAI,CAAC,UAAU;SAC5B,CAAA;QAED,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC9C,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,YAAY,CAAA;QACrC,CAAC;QAED,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,YAAY,CAAA;QACpC,CAAC;QAED,IAAI,IAAI,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;YACnC,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,WAAW,CAAA;QAClC,CAAC;QAED,OAAO,OAAO,CAAA;IAChB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,GAAG,CAAC,MAAmB;QAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,CAAA;QAC3B,OAAO,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IAC7B,CAAC;CACF;AA7FD,oCA6FC;AAaD;;GAEG;AACH,MAAa,kBAAmB,SAAQ,YAAY;IAGlD,YAAY,MAAmB;QAC7B,KAAK,EAAE,CAAA;QACP,IAAI,CAAC,WAAW,GAAG,MAAM,CAAA;IAC3B,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,GAAG;QACP,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,CAAA;QAC3B,OAAO,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IACvC,CAAC;CACF;AAfD,gDAeC"}