@objectstack/spec 0.6.1 → 0.7.2

package/dist/system/plugin-capability.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-capability.zod.d.ts","sourceRoot":"","sources":["../../src/system/plugin-capability.zod.ts"],"names":[],"mappings":"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"}

package/dist/system/plugin-capability.zod.js

@@ -0,0 +1,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginCapabilityManifestSchema = exports.ExtensionPointSchema = exports.PluginDependencySchema = exports.PluginInterfaceSchema = exports.PluginCapabilitySchema = exports.ProtocolFeatureSchema = exports.ProtocolReferenceSchema = exports.ProtocolVersionSchema = exports.CapabilityConformanceLevelSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * # Plugin Capability Protocol
+ *
+ * Defines the standard way plugins declare their capabilities, implementations,
+ * and conformance levels to ensure interoperability across vendors.
+ *
+ * Based on the Protocol-Oriented Architecture pattern similar to:
+ * - Kubernetes CRDs (Custom Resource Definitions)
+ * - OSGi Service Registry
+ * - Eclipse Extension Points
+ */
+/**
+ * Capability Conformance Level
+ * Indicates how completely a plugin implements a given protocol.
+ */
+exports.CapabilityConformanceLevelSchema = zod_1.z.enum([
+    'full', // Complete implementation of all protocol features
+    'partial', // Subset implementation with specific features listed
+    'experimental', // Unstable/preview implementation
+    'deprecated', // Still supported but scheduled for removal
+]).describe('Level of protocol conformance');
+/**
+ * Protocol Version Schema
+ * Uses semantic versioning to track protocol evolution.
+ */
+exports.ProtocolVersionSchema = zod_1.z.object({
+    major: zod_1.z.number().int().min(0),
+    minor: zod_1.z.number().int().min(0),
+    patch: zod_1.z.number().int().min(0),
+}).describe('Semantic version of the protocol');
+/**
+ * Protocol Reference
+ * Uniquely identifies a protocol/interface that a plugin can implement.
+ *
+ * Examples:
+ * - com.objectstack.protocol.storage.v1
+ * - com.objectstack.protocol.auth.oauth2.v2
+ * - com.acme.protocol.payment.stripe.v1
+ */
+exports.ProtocolReferenceSchema = zod_1.z.object({
+    /**
+     * Protocol identifier using reverse domain notation.
+     * Format: {domain}.protocol.{category}.{name}[.{subcategory}].v{major}
+     */
+    id: zod_1.z.string()
+        .regex(/^([a-z][a-z0-9]*\.)+protocol\.[a-z][a-z0-9._]*\.v\d+$/)
+        .describe('Unique protocol identifier (e.g., com.objectstack.protocol.storage.v1)'),
+    /**
+     * Human-readable protocol name
+     */
+    label: zod_1.z.string(),
+    /**
+     * Protocol version
+     */
+    version: exports.ProtocolVersionSchema,
+    /**
+     * Detailed protocol specification URL or file reference
+     */
+    specification: zod_1.z.string().optional().describe('URL or path to protocol specification'),
+    /**
+     * Brief description of what this protocol defines
+     */
+    description: zod_1.z.string().optional(),
+});
+/**
+ * Protocol Feature
+ * Represents a specific capability within a protocol.
+ */
+exports.ProtocolFeatureSchema = zod_1.z.object({
+    name: zod_1.z.string().describe('Feature identifier within the protocol'),
+    enabled: zod_1.z.boolean().default(true),
+    description: zod_1.z.string().optional(),
+    sinceVersion: zod_1.z.string().optional().describe('Version when this feature was added'),
+    deprecatedSince: zod_1.z.string().optional().describe('Version when deprecated'),
+});
+/**
+ * Plugin Capability Declaration
+ * Documents what protocols a plugin implements and to what extent.
+ */
+exports.PluginCapabilitySchema = zod_1.z.object({
+    /**
+     * The protocol being implemented
+     */
+    protocol: exports.ProtocolReferenceSchema,
+    /**
+     * Conformance level
+     */
+    conformance: exports.CapabilityConformanceLevelSchema.default('full'),
+    /**
+     * Specific features implemented (required if conformance is 'partial')
+     */
+    implementedFeatures: zod_1.z.array(zod_1.z.string()).optional().describe('List of implemented feature names'),
+    /**
+     * Optional feature flags indicating advanced capabilities
+     */
+    features: zod_1.z.array(exports.ProtocolFeatureSchema).optional(),
+    /**
+     * Custom metadata for vendor-specific information
+     */
+    metadata: zod_1.z.record(zod_1.z.any()).optional(),
+    /**
+     * Testing/Certification status
+     */
+    certified: zod_1.z.boolean().default(false).describe('Has passed official conformance tests'),
+    certificationDate: zod_1.z.string().datetime().optional(),
+});
+/**
+ * Plugin Interface Declaration
+ * Defines the contract for services this plugin provides to other plugins.
+ */
+exports.PluginInterfaceSchema = zod_1.z.object({
+    /**
+     * Unique interface identifier
+     * Format: {plugin-id}.interface.{name}
+     */
+    id: zod_1.z.string()
+        .regex(/^([a-z][a-z0-9]*\.)+interface\.[a-z][a-z0-9._]+$/)
+        .describe('Unique interface identifier'),
+    /**
+     * Interface name
+     */
+    name: zod_1.z.string(),
+    /**
+     * Description of what this interface provides
+     */
+    description: zod_1.z.string().optional(),
+    /**
+     * Interface version
+     */
+    version: exports.ProtocolVersionSchema,
+    /**
+     * Methods exposed by this interface
+     */
+    methods: zod_1.z.array(zod_1.z.object({
+        name: zod_1.z.string().describe('Method name'),
+        description: zod_1.z.string().optional(),
+        parameters: zod_1.z.array(zod_1.z.object({
+            name: zod_1.z.string(),
+            type: zod_1.z.string().describe('Type notation (e.g., string, number, User)'),
+            required: zod_1.z.boolean().default(true),
+            description: zod_1.z.string().optional(),
+        })).optional(),
+        returnType: zod_1.z.string().optional().describe('Return value type'),
+        async: zod_1.z.boolean().default(false).describe('Whether method returns a Promise'),
+    })),
+    /**
+     * Events emitted by this interface
+     */
+    events: zod_1.z.array(zod_1.z.object({
+        name: zod_1.z.string().describe('Event name'),
+        description: zod_1.z.string().optional(),
+        payload: zod_1.z.string().optional().describe('Event payload type'),
+    })).optional(),
+    /**
+     * Stability level
+     */
+    stability: zod_1.z.enum(['stable', 'beta', 'alpha', 'experimental']).default('stable'),
+});
+/**
+ * Plugin Dependency Declaration
+ * Specifies what other plugins or capabilities this plugin requires.
+ */
+exports.PluginDependencySchema = zod_1.z.object({
+    /**
+     * Plugin ID using reverse domain notation
+     */
+    pluginId: zod_1.z.string()
+        .regex(/^([a-z][a-z0-9]*\.)+[a-z][a-z0-9-]+$/)
+        .describe('Required plugin identifier'),
+    /**
+     * Version constraint (supports semver ranges)
+     * Examples: "1.0.0", "^1.2.3", ">=2.0.0 <3.0.0"
+     */
+    version: zod_1.z.string().describe('Semantic version constraint'),
+    /**
+     * Whether this dependency is optional
+     */
+    optional: zod_1.z.boolean().default(false),
+    /**
+     * Reason for the dependency
+     */
+    reason: zod_1.z.string().optional(),
+    /**
+     * Minimum required capabilities from the dependency
+     */
+    requiredCapabilities: zod_1.z.array(zod_1.z.string()).optional().describe('Protocol IDs the dependency must support'),
+});
+/**
+ * Extension Point Declaration
+ * Defines hooks where other plugins can extend this plugin's functionality.
+ */
+exports.ExtensionPointSchema = zod_1.z.object({
+    /**
+     * Extension point identifier
+     */
+    id: zod_1.z.string()
+        .regex(/^([a-z][a-z0-9]*\.)+extension\.[a-z][a-z0-9._]+$/)
+        .describe('Unique extension point identifier'),
+    /**
+     * Extension point name
+     */
+    name: zod_1.z.string(),
+    /**
+     * Description
+     */
+    description: zod_1.z.string().optional(),
+    /**
+     * Type of extension point
+     */
+    type: zod_1.z.enum([
+        'action', // Plugins can register executable actions
+        'hook', // Plugins can listen to lifecycle events
+        'widget', // Plugins can contribute UI widgets
+        'provider', // Plugins can provide data/services
+        'transformer', // Plugins can transform data
+        'validator', // Plugins can validate data
+        'decorator', // Plugins can enhance/wrap functionality
+    ]),
+    /**
+     * Expected interface contract for extensions
+     */
+    contract: zod_1.z.object({
+        input: zod_1.z.string().optional().describe('Input type/schema'),
+        output: zod_1.z.string().optional().describe('Output type/schema'),
+        signature: zod_1.z.string().optional().describe('Function signature if applicable'),
+    }).optional(),
+    /**
+     * Cardinality
+     */
+    cardinality: zod_1.z.enum(['single', 'multiple']).default('multiple')
+        .describe('Whether multiple extensions can register to this point'),
+});
+/**
+ * Complete Plugin Capability Manifest
+ * This is included in the main plugin manifest to declare all capabilities.
+ */
+exports.PluginCapabilityManifestSchema = zod_1.z.object({
+    /**
+     * Protocols this plugin implements
+     */
+    implements: zod_1.z.array(exports.PluginCapabilitySchema).optional()
+        .describe('List of protocols this plugin conforms to'),
+    /**
+     * Interfaces this plugin exposes to other plugins
+     */
+    provides: zod_1.z.array(exports.PluginInterfaceSchema).optional()
+        .describe('Services/APIs this plugin offers to others'),
+    /**
+     * Dependencies on other plugins
+     */
+    requires: zod_1.z.array(exports.PluginDependencySchema).optional()
+        .describe('Required plugins and their capabilities'),
+    /**
+     * Extension points this plugin defines
+     */
+    extensionPoints: zod_1.z.array(exports.ExtensionPointSchema).optional()
+        .describe('Points where other plugins can extend this plugin'),
+    /**
+     * Extensions this plugin contributes to other plugins
+     */
+    extensions: zod_1.z.array(zod_1.z.object({
+        targetPluginId: zod_1.z.string().describe('Plugin ID being extended'),
+        extensionPointId: zod_1.z.string().describe('Extension point identifier'),
+        implementation: zod_1.z.string().describe('Path to implementation module'),
+        priority: zod_1.z.number().int().default(100).describe('Registration priority (lower = higher priority)'),
+    })).optional().describe('Extensions contributed to other plugins'),
+});

package/dist/system/plugin-lifecycle-events.zod.d.ts

@@ -0,0 +1,382 @@
+import { z } from 'zod';
+/**
+ * Plugin Lifecycle Events Protocol
+ *
+ * Zod schemas for plugin lifecycle event data structures.
+ * These schemas align with the IPluginLifecycleEvents contract interface.
+ *
+ * Following ObjectStack "Zod First" principle - all data structures
+ * must have Zod schemas for runtime validation and JSON Schema generation.
+ */
+/**
+ * Event Phase Enum
+ * Lifecycle phase where an error occurred
+ */
+export declare const EventPhaseSchema: z.ZodEnum<["init", "start", "destroy"]>;
+export type EventPhase = z.infer<typeof EventPhaseSchema>;
+/**
+ * Plugin Event Base Schema
+ * Common fields for all plugin events
+ */
+export declare const PluginEventBaseSchema: z.ZodObject<{
+    /**
+     * Plugin name
+     */
+    pluginName: z.ZodString;
+    /**
+     * Event timestamp (Unix milliseconds)
+     */
+    timestamp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    timestamp: number;
+    pluginName: string;
+}, {
+    timestamp: number;
+    pluginName: string;
+}>;
+/**
+ * Plugin Registered Event Schema
+ *
+ * @example
+ * {
+ *   "pluginName": "crm-plugin",
+ *   "timestamp": 1706659200000,
+ *   "version": "1.0.0"
+ * }
+ */
+export declare const PluginRegisteredEventSchema: z.ZodObject<{
+    /**
+     * Plugin name
+     */
+    pluginName: z.ZodString;
+    /**
+     * Event timestamp (Unix milliseconds)
+     */
+    timestamp: z.ZodNumber;
+} & {
+    /**
+     * Plugin version (optional)
+     */
+    version: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: number;
+    pluginName: string;
+    version?: string | undefined;
+}, {
+    timestamp: number;
+    pluginName: string;
+    version?: string | undefined;
+}>;
+export type PluginRegisteredEvent = z.infer<typeof PluginRegisteredEventSchema>;
+/**
+ * Plugin Lifecycle Phase Event Schema
+ * For init, start, destroy phases
+ *
+ * @example
+ * {
+ *   "pluginName": "crm-plugin",
+ *   "timestamp": 1706659200000,
+ *   "duration": 1250,
+ *   "phase": "init"
+ * }
+ */
+export declare const PluginLifecyclePhaseEventSchema: z.ZodObject<{
+    /**
+     * Plugin name
+     */
+    pluginName: z.ZodString;
+    /**
+     * Event timestamp (Unix milliseconds)
+     */
+    timestamp: z.ZodNumber;
+} & {
+    /**
+     * Duration of the phase (milliseconds)
+     */
+    duration: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Lifecycle phase
+     */
+    phase: z.ZodOptional<z.ZodEnum<["init", "start", "destroy"]>>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: number;
+    pluginName: string;
+    duration?: number | undefined;
+    phase?: "start" | "init" | "destroy" | undefined;
+}, {
+    timestamp: number;
+    pluginName: string;
+    duration?: number | undefined;
+    phase?: "start" | "init" | "destroy" | undefined;
+}>;
+export type PluginLifecyclePhaseEvent = z.infer<typeof PluginLifecyclePhaseEventSchema>;
+/**
+ * Plugin Error Event Schema
+ * When a plugin encounters an error
+ *
+ * @example
+ * {
+ *   "pluginName": "crm-plugin",
+ *   "timestamp": 1706659200000,
+ *   "error": Error("Connection failed"),
+ *   "phase": "start",
+ *   "errorMessage": "Connection failed",
+ *   "errorStack": "Error: Connection failed\n  at ..."
+ * }
+ */
+export declare const PluginErrorEventSchema: z.ZodObject<{
+    /**
+     * Plugin name
+     */
+    pluginName: z.ZodString;
+    /**
+     * Event timestamp (Unix milliseconds)
+     */
+    timestamp: z.ZodNumber;
+} & {
+    /**
+     * Error object
+     */
+    error: z.ZodType<Error, z.ZodTypeDef, Error>;
+    /**
+     * Lifecycle phase where error occurred
+     */
+    phase: z.ZodEnum<["init", "start", "destroy"]>;
+    /**
+     * Error message (for serialization)
+     */
+    errorMessage: z.ZodOptional<z.ZodString>;
+    /**
+     * Error stack trace (for debugging)
+     */
+    errorStack: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    error: Error;
+    timestamp: number;
+    pluginName: string;
+    phase: "start" | "init" | "destroy";
+    errorMessage?: string | undefined;
+    errorStack?: string | undefined;
+}, {
+    error: Error;
+    timestamp: number;
+    pluginName: string;
+    phase: "start" | "init" | "destroy";
+    errorMessage?: string | undefined;
+    errorStack?: string | undefined;
+}>;
+export type PluginErrorEvent = z.infer<typeof PluginErrorEventSchema>;
+/**
+ * Service Registered Event Schema
+ *
+ * @example
+ * {
+ *   "serviceName": "database",
+ *   "timestamp": 1706659200000,
+ *   "serviceType": "IDataEngine"
+ * }
+ */
+export declare const ServiceRegisteredEventSchema: z.ZodObject<{
+    /**
+     * Service name
+     */
+    serviceName: z.ZodString;
+    /**
+     * Event timestamp (Unix milliseconds)
+     */
+    timestamp: z.ZodNumber;
+    /**
+     * Service type (optional)
+     */
+    serviceType: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: number;
+    serviceName: string;
+    serviceType?: string | undefined;
+}, {
+    timestamp: number;
+    serviceName: string;
+    serviceType?: string | undefined;
+}>;
+export type ServiceRegisteredEvent = z.infer<typeof ServiceRegisteredEventSchema>;
+/**
+ * Service Unregistered Event Schema
+ *
+ * @example
+ * {
+ *   "serviceName": "database",
+ *   "timestamp": 1706659200000
+ * }
+ */
+export declare const ServiceUnregisteredEventSchema: z.ZodObject<{
+    /**
+     * Service name
+     */
+    serviceName: z.ZodString;
+    /**
+     * Event timestamp (Unix milliseconds)
+     */
+    timestamp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    timestamp: number;
+    serviceName: string;
+}, {
+    timestamp: number;
+    serviceName: string;
+}>;
+export type ServiceUnregisteredEvent = z.infer<typeof ServiceUnregisteredEventSchema>;
+/**
+ * Hook Registered Event Schema
+ *
+ * @example
+ * {
+ *   "hookName": "data.beforeInsert",
+ *   "timestamp": 1706659200000,
+ *   "handlerCount": 3
+ * }
+ */
+export declare const HookRegisteredEventSchema: z.ZodObject<{
+    /**
+     * Hook name
+     */
+    hookName: z.ZodString;
+    /**
+     * Event timestamp (Unix milliseconds)
+     */
+    timestamp: z.ZodNumber;
+    /**
+     * Number of handlers registered for this hook
+     */
+    handlerCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    timestamp: number;
+    hookName: string;
+    handlerCount: number;
+}, {
+    timestamp: number;
+    hookName: string;
+    handlerCount: number;
+}>;
+export type HookRegisteredEvent = z.infer<typeof HookRegisteredEventSchema>;
+/**
+ * Hook Triggered Event Schema
+ *
+ * @example
+ * {
+ *   "hookName": "data.beforeInsert",
+ *   "timestamp": 1706659200000,
+ *   "args": [{ "object": "customer", "data": {...} }],
+ *   "handlerCount": 3
+ * }
+ */
+export declare const HookTriggeredEventSchema: z.ZodObject<{
+    /**
+     * Hook name
+     */
+    hookName: z.ZodString;
+    /**
+     * Event timestamp (Unix milliseconds)
+     */
+    timestamp: z.ZodNumber;
+    /**
+     * Arguments passed to the hook
+     */
+    args: z.ZodArray<z.ZodAny, "many">;
+    /**
+     * Number of handlers that will handle this event
+     */
+    handlerCount: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: number;
+    args: any[];
+    hookName: string;
+    handlerCount?: number | undefined;
+}, {
+    timestamp: number;
+    args: any[];
+    hookName: string;
+    handlerCount?: number | undefined;
+}>;
+export type HookTriggeredEvent = z.infer<typeof HookTriggeredEventSchema>;
+/**
+ * Kernel Event Base Schema
+ * Common fields for kernel events
+ */
+export declare const KernelEventBaseSchema: z.ZodObject<{
+    /**
+     * Event timestamp (Unix milliseconds)
+     */
+    timestamp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    timestamp: number;
+}, {
+    timestamp: number;
+}>;
+/**
+ * Kernel Ready Event Schema
+ *
+ * @example
+ * {
+ *   "timestamp": 1706659200000,
+ *   "duration": 5400,
+ *   "pluginCount": 12
+ * }
+ */
+export declare const KernelReadyEventSchema: z.ZodObject<{
+    /**
+     * Event timestamp (Unix milliseconds)
+     */
+    timestamp: z.ZodNumber;
+} & {
+    /**
+     * Total initialization duration (milliseconds)
+     */
+    duration: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Number of plugins initialized
+     */
+    pluginCount: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: number;
+    duration?: number | undefined;
+    pluginCount?: number | undefined;
+}, {
+    timestamp: number;
+    duration?: number | undefined;
+    pluginCount?: number | undefined;
+}>;
+export type KernelReadyEvent = z.infer<typeof KernelReadyEventSchema>;
+/**
+ * Kernel Shutdown Event Schema
+ *
+ * @example
+ * {
+ *   "timestamp": 1706659200000,
+ *   "reason": "SIGTERM received"
+ * }
+ */
+export declare const KernelShutdownEventSchema: z.ZodObject<{
+    /**
+     * Event timestamp (Unix milliseconds)
+     */
+    timestamp: z.ZodNumber;
+} & {
+    /**
+     * Shutdown reason (optional)
+     */
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: number;
+    reason?: string | undefined;
+}, {
+    timestamp: number;
+    reason?: string | undefined;
+}>;
+export type KernelShutdownEvent = z.infer<typeof KernelShutdownEventSchema>;
+/**
+ * Plugin Lifecycle Event Type Enum
+ * All possible plugin lifecycle event types
+ */
+export declare const PluginLifecycleEventType: z.ZodEnum<["kernel:ready", "kernel:shutdown", "kernel:before-init", "kernel:after-init", "plugin:registered", "plugin:before-init", "plugin:init", "plugin:after-init", "plugin:before-start", "plugin:started", "plugin:after-start", "plugin:before-destroy", "plugin:destroyed", "plugin:after-destroy", "plugin:error", "service:registered", "service:unregistered", "hook:registered", "hook:triggered"]>;
+export type PluginLifecycleEventType = z.infer<typeof PluginLifecycleEventType>;
+//# sourceMappingURL=plugin-lifecycle-events.zod.d.ts.map

package/dist/system/plugin-lifecycle-events.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-lifecycle-events.zod.d.ts","sourceRoot":"","sources":["../../src/system/plugin-lifecycle-events.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;GAQG;AAMH;;;GAGG;AACH,eAAO,MAAM,gBAAgB,yCACQ,CAAC;AAEtC,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,qBAAqB;IAChC;;OAEG;;IAGH;;OAEG;;;;;;;;EAEH,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B;IArBtC;;OAEG;;IAGH;;OAEG;;;IAeH;;OAEG;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,+BAA+B;IA1C1C;;OAEG;;IAGH;;OAEG;;;IAoCH;;OAEG;;IAGH;;OAEG;;;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB;IAtEjC;;OAEG;;IAGH;;OAEG;;;IAgEH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;;;;;;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAMtE;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B;IACvC;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B;IACzC;;OAEG;;IAGH;;OAEG;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAMtF;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB;IACpC;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB;IACnC;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAM1E;;;GAGG;AACH,eAAO,MAAM,qBAAqB;IAChC;;OAEG;;;;;;EAEH,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;IAhBjC;;OAEG;;;IAeH;;OAEG;;IAGH;;OAEG;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB;IAvCpC;;OAEG;;;IAsCH;;OAEG;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAM5E;;;GAGG;AACH,eAAO,MAAM,wBAAwB,iZAoBK,CAAC;AAE3C,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}