@prisma-next/sql-relational-core 0.3.0-dev.16 → 0.3.0-dev.162

package/src/types.ts

@@ -1,179 +1,83 @@
 import type {
+  Contract,
   ResultType as CoreResultType,
   ExecutionPlan,
   PlanRefs,
 } from '@prisma-next/contract/types';
-import type { ArgSpec, ReturnSpec } from '@prisma-next/operations';
-import type { SqlContract, SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';
-import type { SqlLoweringSpec } from '@prisma-next/sql-operations';
+import type { ParamSpec } from '@prisma-next/operations';
 import type {
-  BinaryOp,
-  ColumnRef,
-  Direction,
-  OperationExpr,
-  ParamRef,
-  QueryAst,
-} from './ast/types';
+  ExtractFieldOutputTypes,
+  SqlStorage,
+  StorageColumn,
+} from '@prisma-next/sql-contract/types';
+import type { SqlLoweringSpec } from '@prisma-next/sql-operations';
+import type { AnyQueryAst, ColumnRef, ParamRef } from './ast/types';
 import type { SqlQueryPlan } from './plan';
-import type { QueryLaneContext } from './query-lane-context';
-
-export interface ParamPlaceholder {
-  readonly kind: 'param-placeholder';
-  readonly name: string;
-}
-
-export interface OrderBuilder<
-  ColumnName extends string = string,
-  ColumnMeta extends StorageColumn = StorageColumn,
-  JsType = unknown,
-> {
-  readonly kind: 'order';
-  readonly expr: ColumnBuilder<ColumnName, ColumnMeta, JsType> | OperationExpr;
-  readonly dir: Direction;
-}
+import type { ExecutionContext } from './query-lane-context';
 
-/**
- * Creates an OrderBuilder for use in orderBy clauses.
- */
-export function createOrderBuilder(
-  expr: AnyColumnBuilder | OperationExpr,
-  dir: Direction,
-): AnyOrderBuilder {
-  return { kind: 'order', expr, dir } as AnyOrderBuilder;
-}
+export type Expr = ColumnRef | ParamRef;
 
 /**
- * ColumnBuilder with optional operation methods based on the column's typeId.
- * When Operations is provided and the column's typeId matches, operation methods are included.
+ * Extracts the model name for a given table by iterating models to find the one
+ * whose `storage.table` matches.
  */
-export type ColumnBuilder<
-  ColumnName extends string = string,
-  ColumnMeta extends StorageColumn = StorageColumn,
-  JsType = unknown,
-  Operations extends OperationTypes = Record<string, never>,
-> = {
-  readonly kind: 'column';
-  readonly table: string;
-  readonly column: ColumnName;
-  readonly columnMeta: ColumnMeta;
-  eq(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-  neq(
-    value: ParamPlaceholder | AnyColumnBuilderBase,
-  ): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-  gt(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-  lt(value: ParamPlaceholder | AnyColumnBuilderBase): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-  gte(
-    value: ParamPlaceholder | AnyColumnBuilderBase,
-  ): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-  lte(
-    value: ParamPlaceholder | AnyColumnBuilderBase,
-  ): BinaryBuilder<ColumnName, ColumnMeta, JsType>;
-  asc(): OrderBuilder<ColumnName, ColumnMeta, JsType>;
-  desc(): OrderBuilder<ColumnName, ColumnMeta, JsType>;
-  // Helper property for type extraction (not used at runtime)
-  readonly __jsType: JsType;
-} & (ColumnMeta['codecId'] extends string
-  ? ColumnMeta['codecId'] extends keyof Operations
-    ? OperationMethods<
-        OperationsForTypeId<ColumnMeta['codecId'] & string, Operations>,
-        ColumnName,
-        StorageColumn,
-        JsType
-      >
-    : Record<string, never>
-  : Record<string, never>);
-
-export interface BinaryBuilder<
-  ColumnName extends string = string,
-  ColumnMeta extends StorageColumn = StorageColumn,
-  JsType = unknown,
-> {
-  readonly kind: 'binary';
-  readonly op: BinaryOp;
-  readonly left: ColumnBuilder<ColumnName, ColumnMeta, JsType> | OperationExpr;
-  readonly right: ParamPlaceholder | AnyColumnBuilderBase;
-}
-
-// Helper aliases for usage sites where the specific column parameters are irrelevant
-// Accepts any ColumnBuilder regardless of its Operations parameter
-// Note: We use `any` here because TypeScript's variance rules don't allow us to express
-// "any type that extends OperationTypes" in a way that works for assignment.
-// Contract-specific OperationTypes (e.g., PgVectorOperationTypes) are not assignable
-// to the base OperationTypes in generic parameter position, even though they extend it structurally.
-// Helper type that accepts any ColumnBuilder regardless of its generic parameters
-// This is needed because conditional types in ColumnBuilder create incompatible intersection types
-// when Operations differs, even though structurally they're compatible
-export type AnyColumnBuilderBase = {
-  readonly kind: 'column';
-  readonly table: string;
-  readonly column: string;
-  readonly columnMeta: StorageColumn;
-  eq(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
-  neq(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
-  gt(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
-  lt(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
-  gte(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
-  lte(value: ParamPlaceholder | AnyColumnBuilderBase): AnyBinaryBuilder;
-  asc(): AnyOrderBuilder;
-  desc(): AnyOrderBuilder;
-  readonly __jsType: unknown;
-  // Allow any operation methods (from conditional type)
-  readonly [key: string]: unknown;
-};
-
-export type AnyColumnBuilder =
-  | ColumnBuilder<
-      string,
-      StorageColumn,
-      unknown,
-      // biome-ignore lint/suspicious/noExplicitAny: AnyColumnBuilder must accept column builders with any operation types
-      any
-    >
-  | AnyColumnBuilderBase;
-export type AnyBinaryBuilder = BinaryBuilder<string, StorageColumn, unknown>;
-export type AnyOrderBuilder = OrderBuilder<string, StorageColumn, unknown>;
-
-export function isColumnBuilder(value: unknown): value is AnyColumnBuilder {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'kind' in value &&
-    (value as { kind: unknown }).kind === 'column'
-  );
-}
-
-export interface JoinOnBuilder {
-  eqCol(left: AnyColumnBuilder, right: AnyColumnBuilder): JoinOnPredicate;
-}
-
-export interface JoinOnPredicate {
-  readonly kind: 'join-on';
-  readonly left: AnyColumnBuilder;
-  readonly right: AnyColumnBuilder;
-}
-
-export type Expr = ColumnRef | ParamRef;
+type ExtractTableToModel<
+  TContract extends Contract<SqlStorage>,
+  TableName extends string,
+> = TContract['models'] extends infer Models extends Record<string, unknown>
+  ? {
+      [M in keyof Models & string]: Models[M] extends {
+        readonly storage: { readonly table: TableName };
+      }
+        ? M
+        : never;
+    }[keyof Models & string]
+  : never;
 
 /**
- * Helper type to extract codec output type from CodecTypes.
- * Returns never if the codecId is not found in CodecTypes.
+ * Extracts the field name for a given column by finding the field in
+ * `model.storage.fields` whose `column` matches.
  */
-type ExtractCodecOutputType<
-  CodecId extends string,
-  CodecTypes extends Record<string, { readonly output: unknown }>,
-> = CodecId extends keyof CodecTypes
-  ? CodecTypes[CodecId] extends { readonly output: infer Output }
-    ? Output
+type ExtractColumnToField<
+  TContract extends Contract<SqlStorage>,
+  TableName extends string,
+  ColumnName extends string,
+> = ExtractTableToModel<TContract, TableName> extends infer ModelName extends string
+  ? TContract['models'] extends infer Models extends Record<string, unknown>
+    ? ModelName & keyof Models extends infer MKey extends string
+      ? Models[MKey] extends {
+          readonly storage: { readonly fields: infer Fields extends Record<string, unknown> };
+        }
+        ? {
+            [F in keyof Fields & string]: Fields[F] extends { readonly column: ColumnName }
+              ? F
+              : never;
+          }[keyof Fields & string]
+        : never
+      : never
     : never
   : never;
 
+type FallbackCodecLookup<
+  ColumnMeta extends StorageColumn,
+  CodecTypes extends Record<string, { readonly output: unknown }>,
+> = ColumnMeta extends { codecId: infer CodecId extends string }
+  ? CodecId extends keyof CodecTypes
+    ? CodecTypes[CodecId] extends { readonly output: infer O }
+      ? ColumnMeta extends { nullable: true }
+        ? O | null
+        : O
+      : unknown
+    : unknown
+  : unknown;
+
 /**
  * Type-level operation signature.
- * Represents an operation at the type level, similar to OperationSignature at runtime.
+ * Represents an operation at the type level for use in contract type maps.
  */
 export type OperationTypeSignature = {
-  readonly args: ReadonlyArray<ArgSpec>;
-  readonly returns: ReturnSpec;
+  readonly args: ReadonlyArray<ParamSpec>;
+  readonly returns: ParamSpec;
   readonly lowering: SqlLoweringSpec;
   readonly capabilities?: ReadonlyArray<string>;
 };
@@ -187,8 +91,8 @@ export type OperationTypeSignature = {
  * type MyOperations: OperationTypes = {
  *   'pg/vector@1': {
  *     cosineDistance: {
- *       args: [{ kind: 'typeId'; type: 'pg/vector@1' }];
- *       returns: { kind: 'builtin'; type: 'number' };
+ *       args: [{ codecId: 'pg/vector@1'; nullable: false }];
+ *       returns: { codecId: 'core/float8'; nullable: false };
  *       lowering: { targetFamily: 'sql'; strategy: 'function'; template: '...' };
  *     };
  *   };
@@ -230,216 +134,55 @@ export type OperationsForTypeId<
     ? Operations[TypeId]
     : Record<string, never>;
 
-/**
- * Maps operation signatures to method signatures on ColumnBuilder.
- * Each operation becomes a method that returns a ColumnBuilder or BinaryBuilder
- * based on the return type.
- */
-type OperationMethods<
-  Ops extends Record<string, OperationTypeSignature>,
-  ColumnName extends string,
-  ColumnMeta extends StorageColumn,
-  JsType,
-> = {
-  [K in keyof Ops]: Ops[K] extends OperationTypeSignature
-    ? (
-        ...args: OperationArgs<Ops[K]['args']>
-      ) => OperationReturn<Ops[K]['returns'], ColumnName, ColumnMeta, JsType>
-    : never;
-};
-
-/**
- * Maps operation argument specs to TypeScript argument types.
- * - typeId args: ColumnBuilder (accepts base columns or operation results)
- * - param args: ParamPlaceholder
- * - literal args: unknown (could be more specific in future)
- */
-type OperationArgs<Args extends ReadonlyArray<ArgSpec>> = Args extends readonly [
-  infer First,
-  ...infer Rest,
-]
-  ? First extends ArgSpec
-    ? [ArgToType<First>, ...(Rest extends ReadonlyArray<ArgSpec> ? OperationArgs<Rest> : [])]
-    : []
-  : [];
-
-type ArgToType<Arg extends ArgSpec> = Arg extends { kind: 'typeId' }
-  ? AnyColumnBuilder
-  : Arg extends { kind: 'param' }
-    ? ParamPlaceholder
-    : Arg extends { kind: 'literal' }
-      ? unknown
-      : never;
-
-/**
- * Maps operation return spec to return type.
- * - builtin types: ColumnBuilder with appropriate JsType (matches runtime behavior)
- * - typeId types: ColumnBuilder (for now, could be more specific in future)
- */
-type OperationReturn<
-  Returns extends ReturnSpec,
-  ColumnName extends string,
-  ColumnMeta extends StorageColumn,
-  _JsType,
-> = Returns extends { kind: 'builtin'; type: infer T }
-  ? T extends 'number'
-    ? ColumnBuilder<ColumnName, ColumnMeta, number>
-    : T extends 'boolean'
-      ? ColumnBuilder<ColumnName, ColumnMeta, boolean>
-      : T extends 'string'
-        ? ColumnBuilder<ColumnName, ColumnMeta, string>
-        : ColumnBuilder<ColumnName, ColumnMeta, unknown>
-  : Returns extends { kind: 'typeId' }
-    ? AnyColumnBuilder
-    : ColumnBuilder<ColumnName, ColumnMeta, unknown>;
-
-/**
- * Computes JavaScript type for a column at column creation time.
- *
- * Type inference:
- * - Read columnMeta.codecId as typeId string literal
- * - Look up CodecTypes[typeId].output
- * - Apply nullability: nullable ? Output | null : Output
- */
-type ColumnMetaTypeId<ColumnMeta> = ColumnMeta extends { codecId: infer CodecId extends string }
-  ? CodecId
-  : ColumnMeta extends { type: infer TypeId extends string }
-    ? TypeId
-    : never;
-
 export type ComputeColumnJsType<
-  _Contract extends SqlContract<SqlStorage>,
-  _TableName extends string,
-  _ColumnName extends string,
+  TContract extends Contract<SqlStorage>,
+  TableName extends string,
+  ColumnName extends string,
   ColumnMeta extends StorageColumn,
   CodecTypes extends Record<string, { readonly output: unknown }>,
-> = ColumnMeta extends { nullable: infer Nullable }
-  ? ColumnMetaTypeId<ColumnMeta> extends infer TypeId
-    ? TypeId extends string
-      ? ExtractCodecOutputType<TypeId, CodecTypes> extends infer CodecOutput
-        ? [CodecOutput] extends [never]
-          ? unknown // Codec not found in CodecTypes
-          : Nullable extends true
-            ? CodecOutput | null
-            : CodecOutput
-        : unknown
-      : unknown
-    : unknown
-  : unknown;
-
-/**
- * Infers Row type from a projection object.
- * Maps Record<string, ColumnBuilder> to Record<string, JSType>
- *
- * Extracts the pre-computed JsType from each ColumnBuilder in the projection.
- */
-/**
- * Extracts the inferred JsType carried by a ColumnBuilder.
- */
-type ExtractJsTypeFromColumnBuilder<CB extends AnyColumnBuilder> =
-  CB extends ColumnBuilder<
-    infer _ColumnName extends string,
-    infer _ColumnMeta extends StorageColumn,
-    infer JsType,
-    infer _Ops
-  >
-    ? JsType
-    : never;
-
-export type InferProjectionRow<P extends Record<string, AnyColumnBuilder>> = {
-  [K in keyof P]: ExtractJsTypeFromColumnBuilder<P[K]>;
-};
-
-/**
- * Nested projection type - allows recursive nesting of ColumnBuilder or nested objects.
- */
-export type NestedProjection = Record<
-  string,
-  | AnyColumnBuilder
-  | Record<
-      string,
-      | AnyColumnBuilder
-      | Record<
-          string,
-          AnyColumnBuilder | Record<string, AnyColumnBuilder | Record<string, AnyColumnBuilder>>
-        >
-    >
->;
-
-/**
- * Helper type to extract include type from Includes map.
- * Returns the value type if K is a key of Includes, otherwise returns unknown.
- */
-type ExtractIncludeType<
-  K extends string,
-  Includes extends Record<string, unknown>,
-> = K extends keyof Includes ? Includes[K] : unknown;
-
-/**
- * Infers Row type from a nested projection object.
- * Recursively maps Record<string, ColumnBuilder | boolean | NestedProjection> to nested object types.
- *
- * Extracts the pre-computed JsType from each ColumnBuilder at leaves.
- * When a value is `true`, it represents an include reference and infers `Array<ChildShape>`
- * by looking up the include alias in the Includes type map.
- */
-export type InferNestedProjectionRow<
-  P extends Record<string, AnyColumnBuilder | boolean | NestedProjection>,
-  CodecTypes extends Record<string, { readonly output: unknown }> = Record<string, never>,
-  Includes extends Record<string, unknown> = Record<string, never>,
-> = {
-  [K in keyof P]: P[K] extends AnyColumnBuilder
-    ? ExtractJsTypeFromColumnBuilder<P[K]>
-    : P[K] extends true
-      ? Array<ExtractIncludeType<K & string, Includes>> // Include reference - infers Array<ChildShape> from Includes map
-      : P[K] extends NestedProjection
-        ? InferNestedProjectionRow<P[K], CodecTypes, Includes>
-        : never;
-};
-
-/**
- * Infers Row type from a tuple of ColumnBuilders used in returning() clause.
- * Extracts column name and JsType from each ColumnBuilder and creates a Record.
- */
-export type InferReturningRow<Columns extends readonly AnyColumnBuilder[]> =
-  Columns extends readonly [infer First, ...infer Rest]
-    ? First extends ColumnBuilder<
-        infer Name,
-        infer _Meta,
-        infer JsType,
-        infer _Ops extends OperationTypes
-      >
-      ? Name extends string
-        ? Rest extends readonly AnyColumnBuilder[]
-          ? { [K in Name]: JsType } & InferReturningRow<Rest>
-          : { [K in Name]: JsType }
+> = ExtractTableToModel<TContract, TableName> extends infer ModelName
+  ? [ModelName] extends [never]
+    ? FallbackCodecLookup<ColumnMeta, CodecTypes>
+    : ModelName extends string
+      ? ExtractColumnToField<TContract, TableName, ColumnName> extends infer FieldName
+        ? [FieldName] extends [never]
+          ? FallbackCodecLookup<ColumnMeta, CodecTypes>
+          : FieldName extends string
+            ? ModelName extends keyof ExtractFieldOutputTypes<TContract>
+              ? FieldName extends keyof ExtractFieldOutputTypes<TContract>[ModelName]
+                ? ExtractFieldOutputTypes<TContract>[ModelName][FieldName]
+                : never
+              : never
+            : never
         : never
       : never
-    : Record<string, never>;
+  : never;
 
 /**
  * Utility type to check if a contract has the required capabilities for includeMany.
  * Requires both `lateral` and `jsonAgg` to be `true` in the contract's capabilities for the target.
  * Capabilities are nested by target: `{ [target]: { lateral: true, jsonAgg: true } }`
  */
-export type HasIncludeManyCapabilities<TContract extends SqlContract<SqlStorage>> =
-  TContract extends { capabilities: infer C; target: infer T }
-    ? T extends string
-      ? C extends Record<string, Record<string, boolean>>
-        ? C extends { [K in T]: infer TargetCaps }
-          ? TargetCaps extends { lateral: true; jsonAgg: true }
-            ? true
-            : false
+export type HasIncludeManyCapabilities<TContract extends Contract<SqlStorage>> = TContract extends {
+  capabilities: infer C;
+  target: infer T;
+}
+  ? T extends string
+    ? C extends Record<string, Record<string, boolean>>
+      ? C extends { [K in T]: infer TargetCaps }
+        ? TargetCaps extends { lateral: true; jsonAgg: true }
+          ? true
           : false
         : false
       : false
-    : false;
+    : false
+  : false;
 
 /**
- * SQL-specific Plan type that refines the ast field to use QueryAst.
+ * SQL-specific Plan type that refines the ast field to use AnyQueryAst.
  * This is the type used by SQL query builders.
  */
-export type SqlPlan<Row = unknown> = ExecutionPlan<Row, QueryAst>;
+export type SqlPlan<Row = unknown> = ExecutionPlan<Row, AnyQueryAst>;
 
 /**
  * Helper types for extracting contract structure.
@@ -524,7 +267,14 @@ export interface RawFactory extends RawTemplateFactory {
   with(options: RawTemplateOptions): RawTemplateFactory;
 }
 
-export type { RuntimeError } from '@prisma-next/plan';
+export interface RuntimeError extends Error {
+  readonly code: string;
+  readonly category: 'PLAN';
+  readonly severity: 'error';
+  readonly details?: Record<string, unknown>;
+  readonly hints?: readonly string[];
+  readonly docs?: readonly string[];
+}
 
 export interface BuildParamsMap {
   readonly [name: string]: unknown;
@@ -534,10 +284,8 @@ export interface BuildOptions {
   readonly params?: BuildParamsMap;
 }
 
-export interface SqlBuilderOptions<
-  TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>,
-> {
-  readonly context: QueryLaneContext<TContract>;
+export interface SqlBuilderOptions<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> {
+  readonly context: ExecutionContext<TContract>;
 }
 
 /**

package/dist/ast/adapter-types.d.ts

@@ -1,28 +0,0 @@
-import type { CodecRegistry } from './codec-types';
-export type AdapterTarget = string;
-export interface AdapterProfile<TTarget extends AdapterTarget = AdapterTarget> {
-    readonly id: string;
-    readonly target: TTarget;
-    readonly capabilities: Record<string, unknown>;
-    /**
-     * Returns the adapter's default codec registry.
-     * The registry contains codecs provided by the adapter for converting
-     * between wire types and JavaScript types.
-     */
-    codecs(): CodecRegistry;
-}
-export interface LoweredPayload<TBody = unknown> {
-    readonly profileId?: string;
-    readonly body: TBody;
-    readonly annotations?: Record<string, unknown>;
-}
-export interface LowererContext<TContract = unknown> {
-    readonly contract: TContract;
-    readonly params?: readonly unknown[];
-}
-export type Lowerer<Ast = unknown, TContract = unknown, TBody = unknown> = (ast: Ast, context: LowererContext<TContract>) => LoweredPayload<TBody>;
-export interface Adapter<Ast = unknown, TContract = unknown, TBody = unknown> {
-    readonly profile: AdapterProfile;
-    lower(ast: Ast, context: LowererContext<TContract>): LoweredPayload<TBody>;
-}
-//# sourceMappingURL=adapter-types.d.ts.map

package/dist/ast/adapter-types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter-types.d.ts","sourceRoot":"","sources":["../../src/ast/adapter-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC;AAEnC,MAAM,WAAW,cAAc,CAAC,OAAO,SAAS,aAAa,GAAG,aAAa;IAC3E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/C;;;;OAIG;IACH,MAAM,IAAI,aAAa,CAAC;CACzB;AAED,MAAM,WAAW,cAAc,CAAC,KAAK,GAAG,OAAO;IAC7C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,cAAc,CAAC,SAAS,GAAG,OAAO;IACjD,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CACtC;AAED,MAAM,MAAM,OAAO,CAAC,GAAG,GAAG,OAAO,EAAE,SAAS,GAAG,OAAO,EAAE,KAAK,GAAG,OAAO,IAAI,CACzE,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,cAAc,CAAC,SAAS,CAAC,KAC/B,cAAc,CAAC,KAAK,CAAC,CAAC;AAE3B,MAAM,WAAW,OAAO,CAAC,GAAG,GAAG,OAAO,EAAE,SAAS,GAAG,OAAO,EAAE,KAAK,GAAG,OAAO;IAC1E,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,cAAc,CAAC,SAAS,CAAC,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;CAC5E"}