@prisma-next/cli 0.3.0-dev.6 → 0.3.0-dev.64

package/dist/exports/control-api.d.mts

@@ -0,0 +1,621 @@
+import { Result } from "@prisma-next/utils/result";
+import { ContractSourceDiagnostics, ContractSourceProvider } from "@prisma-next/config/config-types";
+import { ControlAdapterDescriptor, ControlDriverDescriptor, ControlExtensionDescriptor, ControlFamilyDescriptor, ControlPlaneStack, ControlTargetDescriptor, MigrationPlannerConflict, SignDatabaseResult, SignDatabaseResult as SignDatabaseResult$1, VerifyDatabaseResult, VerifyDatabaseResult as VerifyDatabaseResult$1, VerifyDatabaseSchemaResult, VerifyDatabaseSchemaResult as VerifyDatabaseSchemaResult$1 } from "@prisma-next/core-control-plane/types";
+import { ContractMarkerRecord } from "@prisma-next/contract/types";
+import { CoreSchemaView } from "@prisma-next/core-control-plane/schema-view";
+
+//#region src/control-api/types.d.ts
+
+/**
+ * Options for creating a control client.
+ *
+ * Note: This is NOT the same as CLI config. There's no `contract` field,
+ * no file paths. The client is config-agnostic.
+ *
+ * The descriptor types use permissive `any` because family-specific descriptors
+ * (e.g., SqlFamilyDescriptor) have more specific `create` method signatures that
+ * are not compatible with the base ControlFamilyDescriptor type due to TypeScript
+ * variance rules. The client implementation casts these internally.
+ */
+interface ControlClientOptions {
+  readonly family: ControlFamilyDescriptor<any, any>;
+  readonly target: ControlTargetDescriptor<any, any, any, any>;
+  readonly adapter: ControlAdapterDescriptor<any, any, any>;
+  /** Optional - control client can be created without driver for offline operations */
+  readonly driver?: ControlDriverDescriptor<any, any, any, any>;
+  readonly extensionPacks?: ReadonlyArray<ControlExtensionDescriptor<any, any, any>>;
+  /**
+   * Optional default connection for auto-connect.
+   * When provided, operations will auto-connect if not already connected.
+   * The type is driver-specific (e.g., string URL for Postgres).
+   */
+  readonly connection?: unknown;
+}
+/**
+ * Action names for control-api operations that can emit progress events.
+ */
+type ControlActionName = 'dbInit' | 'dbUpdate' | 'migrationApply' | 'verify' | 'schemaVerify' | 'sign' | 'introspect' | 'emit';
+/**
+ * Progress event emitted during control-api operation execution.
+ *
+ * Events model operation progress using a span-based model:
+ * - `spanStart`: Begin a timed segment (supports nesting via parentSpanId)
+ * - `spanEnd`: Complete a timed segment
+ *
+ * All operation-specific progress (e.g., per-migration-operation) is modeled
+ * as nested spans rather than special event types.
+ *
+ * Events are delivered via an optional `onProgress` callback to avoid polluting
+ * return types. If the callback is absent, operations emit no events (zero overhead).
+ */
+type ControlProgressEvent = {
+  readonly action: ControlActionName;
+  readonly kind: 'spanStart';
+  readonly spanId: string;
+  readonly parentSpanId?: string;
+  readonly label: string;
+} | {
+  readonly action: ControlActionName;
+  readonly kind: 'spanEnd';
+  readonly spanId: string;
+  readonly outcome: 'ok' | 'skipped' | 'error';
+};
+/**
+ * Callback function for receiving progress events during control-api operations.
+ *
+ * @param event - The progress event emitted by the operation
+ */
+type OnControlProgress = (event: ControlProgressEvent) => void;
+/**
+ * Options for the verify operation.
+ */
+interface VerifyOptions {
+  /** Contract IR or unvalidated JSON - validated at runtime via familyInstance.validateContractIR() */
+  readonly contractIR: unknown;
+  /**
+   * Database connection. If provided, verify will connect before executing.
+   * If omitted, the client must already be connected.
+   * The type is driver-specific (e.g., string URL for Postgres).
+   */
+  readonly connection?: unknown;
+  /** Optional progress callback for observing operation progress */
+  readonly onProgress?: OnControlProgress;
+}
+/**
+ * Options for the schemaVerify operation.
+ */
+interface SchemaVerifyOptions {
+  /** Contract IR or unvalidated JSON - validated at runtime via familyInstance.validateContractIR() */
+  readonly contractIR: unknown;
+  /**
+   * Whether to use strict mode for schema verification.
+   * In strict mode, extra tables/columns are reported as issues.
+   * Default: false (tolerant mode - allows superset)
+   */
+  readonly strict?: boolean;
+  /**
+   * Database connection. If provided, schemaVerify will connect before executing.
+   * If omitted, the client must already be connected.
+   * The type is driver-specific (e.g., string URL for Postgres).
+   */
+  readonly connection?: unknown;
+  /** Optional progress callback for observing operation progress */
+  readonly onProgress?: OnControlProgress;
+}
+/**
+ * Options for the sign operation.
+ */
+interface SignOptions {
+  /** Contract IR or unvalidated JSON - validated at runtime via familyInstance.validateContractIR() */
+  readonly contractIR: unknown;
+  /**
+   * Path to the contract file (for metadata in the result).
+   */
+  readonly contractPath?: string;
+  /**
+   * Path to the config file (for metadata in the result).
+   */
+  readonly configPath?: string;
+  /**
+   * Database connection. If provided, sign will connect before executing.
+   * If omitted, the client must already be connected.
+   * The type is driver-specific (e.g., string URL for Postgres).
+   */
+  readonly connection?: unknown;
+  /** Optional progress callback for observing operation progress */
+  readonly onProgress?: OnControlProgress;
+}
+/**
+ * Options for the dbInit operation.
+ */
+interface DbInitOptions {
+  /** Contract IR or unvalidated JSON - validated at runtime via familyInstance.validateContractIR() */
+  readonly contractIR: unknown;
+  /**
+   * Mode for the dbInit operation.
+   * - 'plan': Returns planned operations without applying
+   * - 'apply': Applies operations and writes marker
+   */
+  readonly mode: 'plan' | 'apply';
+  /**
+   * Database connection. If provided, dbInit will connect before executing.
+   * If omitted, the client must already be connected.
+   * The type is driver-specific (e.g., string URL for Postgres).
+   */
+  readonly connection?: unknown;
+  /** Optional progress callback for observing operation progress */
+  readonly onProgress?: OnControlProgress;
+}
+/**
+ * Options for the dbUpdate operation.
+ */
+interface DbUpdateOptions {
+  /** Contract IR or unvalidated JSON - validated at runtime via familyInstance.validateContractIR() */
+  readonly contractIR: unknown;
+  /**
+   * Mode for the dbUpdate operation.
+   * - 'plan': Returns planned operations without applying
+   * - 'apply': Applies operations and writes marker/ledger
+   */
+  readonly mode: 'plan' | 'apply';
+  /**
+   * Database connection. If provided, dbUpdate will connect before executing.
+   * If omitted, the client must already be connected.
+   * The type is driver-specific (e.g., string URL for Postgres).
+   */
+  readonly connection?: unknown;
+  /**
+   * When true, allows applying plans that contain destructive operations
+   * (e.g., DROP TABLE, DROP COLUMN, ALTER TYPE).
+   * When false (default), the operation returns a failure if the plan
+   * includes destructive operations, prompting the user to use --plan
+   * to preview and then re-run with --accept-data-loss.
+   */
+  readonly acceptDataLoss?: boolean;
+  /** Optional progress callback for observing operation progress */
+  readonly onProgress?: OnControlProgress;
+}
+/**
+ * Options for the introspect operation.
+ */
+interface IntrospectOptions {
+  /**
+   * Optional schema name to introspect.
+   */
+  readonly schema?: string;
+  /**
+   * Database connection. If provided, introspect will connect before executing.
+   * If omitted, the client must already be connected.
+   * The type is driver-specific (e.g., string URL for Postgres).
+   */
+  readonly connection?: unknown;
+  /** Optional progress callback for observing operation progress */
+  readonly onProgress?: OnControlProgress;
+}
+/**
+ * Contract configuration for emit operation.
+ */
+interface EmitContractConfig {
+  /**
+   * Contract source provider.
+   */
+  readonly sourceProvider: ContractSourceProvider;
+  /**
+   * Output path for contract.json.
+   * The .d.ts types file will be colocated (e.g., contract.json → contract.d.ts).
+   */
+  readonly output: string;
+}
+/**
+ * Options for the emit operation.
+ */
+interface EmitOptions {
+  /**
+   * Contract configuration containing source, output, and types paths.
+   */
+  readonly contractConfig: EmitContractConfig;
+  /** Optional progress callback for observing operation progress */
+  readonly onProgress?: OnControlProgress;
+}
+/**
+ * Successful dbInit result.
+ */
+interface DbInitSuccess {
+  readonly mode: 'plan' | 'apply';
+  readonly plan: {
+    readonly operations: ReadonlyArray<{
+      readonly id: string;
+      readonly label: string;
+      readonly operationClass: string;
+    }>;
+    readonly sql?: ReadonlyArray<string>;
+  };
+  readonly destination: {
+    readonly storageHash: string;
+    readonly profileHash?: string;
+  };
+  readonly execution?: {
+    readonly operationsPlanned: number;
+    readonly operationsExecuted: number;
+  };
+  readonly marker?: {
+    readonly storageHash: string;
+    readonly profileHash?: string;
+  };
+  readonly summary: string;
+}
+/**
+ * Failure codes for dbInit operation.
+ */
+type DbInitFailureCode = 'PLANNING_FAILED' | 'MARKER_ORIGIN_MISMATCH' | 'RUNNER_FAILED';
+/**
+ * Failure details for dbInit operation.
+ */
+interface DbInitFailure {
+  readonly code: DbInitFailureCode;
+  readonly summary: string;
+  readonly why: string | undefined;
+  readonly conflicts: ReadonlyArray<MigrationPlannerConflict> | undefined;
+  readonly meta: Record<string, unknown> | undefined;
+  readonly marker?: {
+    readonly storageHash?: string;
+    readonly profileHash?: string;
+  };
+  readonly destination?: {
+    readonly storageHash: string;
+    readonly profileHash?: string | undefined;
+  };
+}
+/**
+ * Result type for dbInit operation.
+ * Uses Result pattern: success returns DbInitSuccess, failure returns DbInitFailure.
+ */
+type DbInitResult = Result<DbInitSuccess, DbInitFailure>;
+/**
+ * Successful dbUpdate result.
+ */
+interface DbUpdateSuccess {
+  readonly mode: 'plan' | 'apply';
+  readonly plan: {
+    readonly operations: ReadonlyArray<{
+      readonly id: string;
+      readonly label: string;
+      readonly operationClass: string;
+    }>;
+    readonly sql?: ReadonlyArray<string>;
+  };
+  readonly destination: {
+    readonly storageHash: string;
+    readonly profileHash?: string;
+  };
+  readonly execution?: {
+    readonly operationsPlanned: number;
+    readonly operationsExecuted: number;
+  };
+  readonly marker?: {
+    readonly storageHash: string;
+    readonly profileHash?: string;
+  };
+  readonly summary: string;
+}
+/**
+ * Failure codes for dbUpdate operation.
+ */
+type DbUpdateFailureCode = 'PLANNING_FAILED' | 'RUNNER_FAILED' | 'DESTRUCTIVE_CHANGES';
+/**
+ * Failure details for dbUpdate operation.
+ */
+interface DbUpdateFailure {
+  readonly code: DbUpdateFailureCode;
+  readonly summary: string;
+  readonly why: string | undefined;
+  readonly conflicts: ReadonlyArray<MigrationPlannerConflict> | undefined;
+  readonly meta: Record<string, unknown> | undefined;
+}
+/**
+ * Result type for dbUpdate operation.
+ * Uses Result pattern: success returns DbUpdateSuccess, failure returns DbUpdateFailure.
+ */
+type DbUpdateResult = Result<DbUpdateSuccess, DbUpdateFailure>;
+/**
+ * Successful emit result.
+ * Contains the hashes and paths of emitted files.
+ */
+interface EmitSuccess {
+  /** Storage hash of the emitted contract */
+  readonly storageHash: string;
+  /** Execution hash of the emitted contract (if execution section exists) */
+  readonly executionHash?: string;
+  /** Profile hash of the emitted contract (target-specific) */
+  readonly profileHash: string;
+  /** The emitted contract as JSON string */
+  readonly contractJson: string;
+  /** The emitted contract TypeScript declarations */
+  readonly contractDts: string;
+}
+/**
+ * Failure codes for emit operation.
+ */
+type EmitFailureCode = 'CONTRACT_SOURCE_INVALID' | 'CONTRACT_VALIDATION_FAILED' | 'EMIT_FAILED';
+/**
+ * Failure details for emit operation.
+ */
+interface EmitFailure {
+  readonly code: EmitFailureCode;
+  readonly summary: string;
+  readonly why: string | undefined;
+  readonly meta: Record<string, unknown> | undefined;
+  readonly diagnostics?: ContractSourceDiagnostics;
+}
+/**
+ * Result type for emit operation.
+ * Uses Result pattern: success returns EmitSuccess, failure returns EmitFailure.
+ */
+type EmitResult = Result<EmitSuccess, EmitFailure>;
+/**
+ * A pre-planned migration step ready for execution.
+ * Contains the manifest metadata and the serialized operations from ops.json.
+ */
+interface MigrationApplyStep {
+  readonly dirName: string;
+  readonly from: string;
+  readonly to: string;
+  readonly toContract: unknown;
+  readonly operations: ReadonlyArray<{
+    readonly id: string;
+    readonly label: string;
+    readonly operationClass: string;
+    readonly [key: string]: unknown;
+  }>;
+}
+/**
+ * Options for the migrationApply operation.
+ */
+interface MigrationApplyOptions {
+  /**
+   * Hash of the database state this apply path starts from.
+   * This is resolved by the caller (typically the CLI orchestration layer).
+   */
+  readonly originHash: string;
+  /**
+   * Hash of the target contract this apply path must reach.
+   * This is resolved by the caller (typically the CLI orchestration layer).
+   */
+  readonly destinationHash: string;
+  /**
+   * Ordered list of migrations to execute from originHash to destinationHash.
+   * The execution layer does not choose defaults; it only executes this explicit path.
+   */
+  readonly pendingMigrations: readonly MigrationApplyStep[];
+  /**
+   * Database connection. If provided, migrationApply will connect before executing.
+   * If omitted, the client must already be connected.
+   */
+  readonly connection?: unknown;
+  /** Optional progress callback for observing operation progress */
+  readonly onProgress?: OnControlProgress;
+}
+/**
+ * Record of a successfully applied migration.
+ */
+interface MigrationApplyAppliedEntry {
+  readonly dirName: string;
+  readonly from: string;
+  readonly to: string;
+  readonly operationsExecuted: number;
+}
+/**
+ * Successful migrationApply result.
+ */
+interface MigrationApplySuccess {
+  readonly migrationsApplied: number;
+  readonly markerHash: string;
+  readonly applied: readonly MigrationApplyAppliedEntry[];
+  readonly summary: string;
+}
+/**
+ * Failure codes for migrationApply operation.
+ */
+type MigrationApplyFailureCode = 'RUNNER_FAILED' | 'MIGRATION_PATH_NOT_FOUND';
+/**
+ * Failure details for migrationApply operation.
+ */
+interface MigrationApplyFailure {
+  readonly code: MigrationApplyFailureCode;
+  readonly summary: string;
+  readonly why: string | undefined;
+  readonly meta: Record<string, unknown> | undefined;
+}
+/**
+ * Result type for migrationApply operation.
+ */
+type MigrationApplyResult = Result<MigrationApplySuccess, MigrationApplyFailure>;
+/**
+ * Options for the standalone executeContractEmit function.
+ * Used by tooling (e.g., Vite plugin) that needs to emit contracts
+ * without the full ControlClient infrastructure.
+ */
+interface ContractEmitOptions {
+  /** Path to the prisma-next.config.ts file */
+  readonly configPath: string;
+  /** Optional AbortSignal for cancellation support */
+  readonly signal?: AbortSignal;
+}
+/**
+ * Result from the standalone executeContractEmit function.
+ */
+interface ContractEmitResult {
+  /** Hash of the storage contract (schema-level) */
+  readonly storageHash: string;
+  /** Hash of the execution contract (if execution section exists) */
+  readonly executionHash?: string;
+  /** Hash of the profile (target+extensions) */
+  readonly profileHash: string;
+  /** Paths to the emitted files */
+  readonly files: {
+    /** Path to the emitted contract.json file */
+    readonly json: string;
+    /** Path to the emitted contract.d.ts file */
+    readonly dts: string;
+  };
+}
+/**
+ * Programmatic control client for Prisma Next operations.
+ *
+ * Lifecycle: `connect(connection)` before operations, `close()` when done.
+ * Both `init()` and `connect()` are auto-called by operations if needed,
+ * but `connect()` requires a connection so must be called explicitly first
+ * unless a default connection was provided in options.
+ *
+ * @see README.md "Programmatic Control API" section for usage examples
+ */
+interface ControlClient {
+  /**
+   * Initializes the client by creating the control plane stack,
+   * family instance, and validating framework components.
+   *
+   * Idempotent (safe to call multiple times).
+   * Called automatically by `connect()` if not already initialized.
+   */
+  init(): void;
+  /**
+   * Establishes a database connection.
+   * Auto-calls `init()` if not already initialized.
+   * Must be called before any database operations unless a default connection
+   * was provided in options.
+   *
+   * @param connection - Driver-specific connection input (e.g., URL string for Postgres).
+   *   If omitted, uses the default connection from options (if provided).
+   * @throws If connection fails, already connected, driver is not configured,
+   *   or no connection provided and no default connection in options.
+   */
+  connect(connection?: unknown): Promise<void>;
+  /**
+   * Closes the database connection.
+   * Idempotent (safe to call multiple times).
+   * After close(), can call `connect()` again with same or different URL.
+   */
+  close(): Promise<void>;
+  /**
+   * Verifies database marker matches the contract.
+   * Compares storageHash and profileHash.
+   *
+   * @returns Structured result (ok: false for mismatch, not throwing)
+   * @throws If not connected or infrastructure failure
+   */
+  verify(options: VerifyOptions): Promise<VerifyDatabaseResult$1>;
+  /**
+   * Verifies database schema satisfies the contract requirements.
+   *
+   * @param options.strict - If true, extra tables/columns are issues. Default: false
+   * @returns Structured result with schema issues
+   * @throws If not connected or infrastructure failure
+   */
+  schemaVerify(options: SchemaVerifyOptions): Promise<VerifyDatabaseSchemaResult$1>;
+  /**
+   * Signs the database with a contract signature.
+   * Writes or updates the signature if schema verification passes.
+   * Idempotent (no-op if signature already matches).
+   *
+   * @returns Structured result
+   * @throws If not connected or infrastructure failure
+   */
+  sign(options: SignOptions): Promise<SignDatabaseResult$1>;
+  /**
+   * Initializes database schema from contract.
+   * Uses additive-only policy (no destructive changes).
+   *
+   * @param options.mode - 'plan' to preview, 'apply' to execute
+   * @returns Result pattern: Ok with planned/executed operations, NotOk with failure details
+   * @throws If not connected, target doesn't support migrations, or infrastructure failure
+   */
+  dbInit(options: DbInitOptions): Promise<DbInitResult>;
+  /**
+   * Updates a database schema to match the current contract.
+   * Creates the signature table if it does not exist. No preconditions required.
+   * Allows additive, widening, and destructive operation classes.
+   *
+   * @param options.mode - 'plan' to preview, 'apply' to execute
+   * @returns Result pattern: Ok with planned/executed operations, NotOk with failure details
+   * @throws If not connected, target doesn't support migrations, or infrastructure failure
+   */
+  dbUpdate(options: DbUpdateOptions): Promise<DbUpdateResult>;
+  /**
+   * Reads the contract marker from the database.
+   * Returns null if no marker exists (fresh database).
+   *
+   * @throws If not connected or infrastructure failure
+   */
+  readMarker(): Promise<ContractMarkerRecord | null>;
+  /**
+   * Applies pre-planned on-disk migrations to the database.
+   * Each migration runs in its own transaction with full execution checks.
+   * Resume-safe: re-running after failure picks up from the last applied migration.
+   *
+   * @param options.originHash - Explicit source hash for the apply path
+   * @param options.destinationHash - Explicit destination hash for the apply path
+   * @param options.pendingMigrations - Ordered migrations to execute
+   * @returns Result pattern: Ok with applied details, NotOk with failure details
+   * @throws If not connected, target doesn't support migrations, or infrastructure failure
+   */
+  migrationApply(options: MigrationApplyOptions): Promise<MigrationApplyResult>;
+  /**
+   * Introspects the database schema.
+   *
+   * @returns Raw schema IR
+   * @throws If not connected or infrastructure failure
+   */
+  introspect(options?: IntrospectOptions): Promise<unknown>;
+  /**
+   * Converts a schema IR to a schema view for CLI tree rendering.
+   * Delegates to the family instance's toSchemaView method.
+   *
+   * @param schemaIR - The schema IR from introspect()
+   * @returns CoreSchemaView if the family supports it, undefined otherwise
+   */
+  toSchemaView(schemaIR: unknown): CoreSchemaView | undefined;
+  /**
+   * Emits the contract to JSON and TypeScript declarations.
+   * This is an offline operation that does NOT require a database connection.
+   * Uses `init()` to create the stack but does NOT call `connect()`.
+   *
+   * @returns Result pattern: Ok with emit details, NotOk with failure details
+   */
+  emit(options: EmitOptions): Promise<EmitResult>;
+}
+//#endregion
+//#region src/control-api/client.d.ts
+/**
+ * Creates a programmatic control client for Prisma Next operations.
+ *
+ * The client accepts framework component descriptors at creation time,
+ * manages driver lifecycle via connect()/close(), and exposes domain
+ * operations that delegate to the existing family instance methods.
+ *
+ * @see {@link ControlClient} for the client interface
+ * @see README.md "Programmatic Control API" section for usage examples
+ */
+declare function createControlClient(options: ControlClientOptions): ControlClient;
+//#endregion
+//#region src/control-api/operations/contract-emit.d.ts
+/**
+ * Executes the contract emit operation.
+ *
+ * This is an offline operation that:
+ * 1. Loads the Prisma Next config from the specified path
+ * 2. Resolves the contract source from config
+ * 3. Creates a control plane stack and family instance
+ * 4. Emits contract artifacts (JSON and DTS)
+ * 5. Writes files to the paths specified in config
+ *
+ * Supports AbortSignal for cancellation, enabling "last change wins" behavior.
+ *
+ * @param options - Options including configPath and optional signal
+ * @returns File paths and hashes of emitted artifacts
+ * @throws If config loading fails, contract is invalid, or file I/O fails
+ * @throws signal.reason if cancelled via AbortSignal (typically DOMException with name 'AbortError')
+ */
+declare function executeContractEmit(options: ContractEmitOptions): Promise<ContractEmitResult>;
+//#endregion
+export { type ContractEmitOptions, type ContractEmitResult, type ControlActionName, type ControlClient, type ControlClientOptions, type ControlPlaneStack, type ControlProgressEvent, type DbInitFailure, type DbInitFailureCode, type DbInitOptions, type DbInitResult, type DbInitSuccess, type DbUpdateFailure, type DbUpdateFailureCode, type DbUpdateOptions, type DbUpdateResult, type DbUpdateSuccess, type EmitContractConfig, type EmitFailure, type EmitFailureCode, type EmitOptions, type EmitResult, type EmitSuccess, type IntrospectOptions, type OnControlProgress, type SchemaVerifyOptions, type SignDatabaseResult, type SignOptions, type VerifyDatabaseResult, type VerifyDatabaseSchemaResult, type VerifyOptions, createControlClient, executeContractEmit };
+//# sourceMappingURL=control-api.d.mts.map

package/dist/exports/control-api.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-api.d.mts","names":[],"sources":["../../src/control-api/types.ts","../../src/control-api/client.ts","../../src/control-api/operations/contract-emit.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AAkCA;;;;;;;;AA2BA;AAuBY,UAlDK,oBAAA,CAkDe;EAoBpB,SAAA,MAAA,EApEO,uBAoEqB,CAAA,GAAA,EAAA,GAAA,CAAA;EASvB,SAAA,MAAA,EA3EE,uBAqFK,CAAA,GAAA,EAAiB,GAAA,EAAA,GAAA,EAAA,GAAA,CAAA;EAMxB,SAAA,OAAA,EAzFG,wBAyGI,CAAA,GAAA,EAAA,GAAA,EAAiB,GAAA,CAAA;EAMxB;EAwBA,SAAA,MAAA,CAAa,EApIV,uBAoJI,CAAA,GAAA,EAAiB,GAAA,EAAA,GAAA,EAAA,GAAA,CAAA;EAMxB,SAAA,cAAe,CAAA,EAxJJ,aAgLJ,CAhLkB,0BAgLD,CAAA,GAAA,EAAA,GAAA,EAAA,GAAA,CAAA,CAAA;EAMxB;AAkBjB;AAeA;AAgBA;AA4BA;EAKiB,SAAA,UAAa,CAAA,EAAA,OAAA;;;;;AAKP,KA7PX,iBAAA,GA6PW,QAAA,GAAA,UAAA,GAAA,gBAAA,GAAA,QAAA,GAAA,cAAA,GAAA,MAAA,GAAA,YAAA,GAAA,MAAA;AAevB;;;;;AAKA;AA4BA;AAKA;;;;;;AAYY,KAvSA,oBAAA,GAuSc;EAAU,SAAA,MAAA,EArSb,iBAqSa;EAAiB,SAAA,IAAA,EAAA,WAAA;EAAxB,SAAA,MAAA,EAAA,MAAA;EAAM,SAAA,YAAA,CAAA,EAAA,MAAA;EAMlB,SAAA,KAAW,EAAA,MAAA;AAgB5B,CAAA,GAAY;EAQK,SAAA,MAAW,EA5TL,iBA4TK;EACX,SAAA,IAAA,EAAA,SAAA;EAGA,SAAA,MAAA,EAAA,MAAA;EACQ,SAAA,OAAA,EAAA,IAAA,GAAA,SAAA,GAAA,OAAA;CAAyB;AAOlD;;;;;AAUiB,KAvUL,iBAAA,GAuUuB,CAAA,KAKZ,EA5UiB,oBA4UJ,EAAA,GAAA,IAAA;AAWpC;AA4BA;AAUA;AAUY,UA9XK,aAAA,CA8XL;EAKK;EAUL,SAAA,UAAA,EAAA,OAAoB;EAAU;;;;AAW1C;EAUiB,SAAA,UAAA,CAAA,EAAkB,OAAA;EA8BlB;EAqBgB,SAAA,UAAA,CAAA,EA3cT,iBA2cS;;;;;AAyBT,UA9dP,mBAAA,CA8dO;EAA8B;EAAR,SAAA,UAAA,EAAA,OAAA;EAU9B;;;;;EAUkB,SAAA,MAAA,CAAA,EAAA,OAAA;EAWd;;;;;EAqBM,SAAA,UAAA,CAAA,EAAA,OAAA;EAAgC;EAAR,SAAA,UAAA,CAAA,EAlgB1B,iBAkgB0B;;;;;AA0BZ,UAthBrB,WAAA,CAshBqB;EAAR;EAAO,SAAA,UAAA,EAAA,OAAA;;;;EC5nBrB,SAAA,YAAA,CAAmB,EAAA,MAAA;;;;ECHb,SAAA,UAAA,CAAA,EAAmB,MAAA;EAC9B;;;;;;;wBF0Ha;;;;;UAMP,aAAA;;;;;;;;;;;;;;;;wBAgBO;;;;;UAMP,eAAA;;;;;;;;;;;;;;;;;;;;;;;;wBAwBO;;;;;UAMP,iBAAA;;;;;;;;;;;;wBAYO;;;;;UAMP,kBAAA;;;;2BAIU;;;;;;;;;;UAWV,WAAA;;;;2BAIU;;wBAEH;;;;;UAUP,aAAA;;;yBAGQ;;;;;mBAKN;;;;;;;;;;;;;;;;;;;KAoBP,iBAAA;;;;UAKK,aAAA;iBACA;;;sBAGK,cAAc;iBACnB;;;;;;;;;;;;;;KAeL,YAAA,GAAe,OAAO,eAAe;;;;UAKhC,eAAA;;;yBAGQ;;;;;mBAKN;;;;;;;;;;;;;;;;;;;KAoBP,mBAAA;;;;UAKK,eAAA;iBACA;;;sBAGK,cAAc;iBACnB;;;;;;KAOL,cAAA,GAAiB,OAAO,iBAAiB;;;;;UAMpC,WAAA;;;;;;;;;;;;;;;KAgBL,eAAA;;;;UAQK,WAAA;iBACA;;;iBAGA;yBACQ;;;;;;KAOb,UAAA,GAAa,OAAO,aAAa;;;;;UAU5B,kBAAA;;;;;uBAKM;;;;;;;;;;UAWN,qBAAA;;;;;;;;;;;;;;;uCAesB;;;;;;;wBAOf;;;;;UAMP,0BAAA;;;;;;;;;UAUA,qBAAA;;;6BAGY;;;;;;KAOjB,yBAAA;;;;UAKK,qBAAA;iBACA;;;iBAGA;;;;;KAML,oBAAA,GAAuB,OAAO,uBAAuB;;;;;;UAWhD,mBAAA;;;;oBAIG;;;;;UAMH,kBAAA;;;;;;;;;;;;;;;;;;;;;;;;;UA8BA,aAAA;;;;;;;;;;;;;;;;;;;;iCAqBgB;;;;;;WAOtB;;;;;;;;kBASO,gBAAgB,QAAQ;;;;;;;;wBASlB,sBAAsB,QAAQ;;;;;;;;;gBAUtC,cAAc,QAAQ;;;;;;;;;kBAUpB,gBAAgB,QAAQ;;;;;;;;;;oBAWtB,kBAAkB,QAAQ;;;;;;;gBAQ9B,QAAQ;;;;;;;;;;;;0BAaE,wBAAwB,QAAQ;;;;;;;uBAQnC,oBAAoB;;;;;;;;mCASR;;;;;;;;gBASnB,cAAc,QAAQ;;;;;;;;;;AA3oBtC;;;;AASoB,iBCMJ,mBAAA,CDNI,OAAA,ECMyB,oBDNzB,CAAA,ECMgD,aDNhD;;;;;;;;;AATpB;;;;;;;;AA2BA;AAuBA;AAoBA;AASiB,iBEnEK,mBAAA,CF6EE,OAAiB,EE5E9B,mBF4E8B,CAAA,EE3EtC,OF2EsC,CE3E9B,kBF2E8B,CAAA"}