@pylo/node 0.0.12 → 0.1.1

package/dist/cli.js

@@ -34,7 +34,6 @@ async function loadConfig(cwd) {
       }
       return {
         endpoint: DEFAULT_ENDPOINT,
-        unknownFieldBehavior: "error",
         ...config
       };
     }
@@ -124,18 +123,15 @@ query PyloSchemaFetch($pagination: PaginationInput) {
   }
 }
 `;
-async function fetchSchema(config) {
+async function fetchSchemaWith(request) {
   var _a, _b;
   const allEntities = [];
   let page = 1;
   let hasMore = true;
   while (hasMore) {
-    const response = await graphqlRequestWithApiKey(
-      config.endpoint,
-      ENTITY_LIST_QUERY,
-      { pagination: { page, per_page: 50 } },
-      config.apiKey
-    );
+    const response = await request(ENTITY_LIST_QUERY, {
+      pagination: { page, per_page: 50 }
+    });
     if (response.errors) {
       const errMsg = Array.isArray(response.errors) ? response.errors.map((e) => e.message).join(", ") : (_b = (_a = response.errors.generalError) == null ? void 0 : _a.message) != null ? _b : "Unknown error";
       throw new Error(`Failed to fetch schema: ${errMsg}`);
@@ -150,13 +146,18 @@ async function fetchSchema(config) {
   }
   return allEntities;
 }
+async function fetchSchema(config) {
+  return fetchSchemaWith(
+    (query, variables) => graphqlRequestWithApiKey(config.endpoint, query, variables, config.apiKey)
+  );
+}
 var DATA_TYPE_MAP = {
   TEXT: "string",
   LONGTEXT: "string",
   RICHTEXT: "string",
   INT: "number",
   FLOAT: "number",
-  JSON: "Record<string, unknown> | unknown[]",
+  JSON: "string",
   DATE: "string",
   DATETIME: "string",
   TIME: "string",
@@ -263,6 +264,7 @@ function analyzeEntities(rawEntities) {
   });
 }
 var VARIANT_TYPE = "{ variant: string; value: string }";
+var REGISTERABLE_SOURCES = /* @__PURE__ */ new Set(["@pylo/node", "@pylo/nextjs"]);
 function fieldTypeString(field) {
   if (field.nullable) {
     return `${field.tsType} | null`;
@@ -276,10 +278,21 @@ function indent(text, level) {
 function getVariantFieldNames(entity) {
   return entity.fields.filter((f) => f.variantFieldName !== null).map((f) => f.variantFieldName);
 }
+var NON_WRITABLE_FIELDS = /* @__PURE__ */ new Set(["integer_id", "created_at", "updated_at"]);
+function generateReplaceVariablesField(entity) {
+  const fieldNames = entity.fields.map((f) => f.name).filter((name) => !NON_WRITABLE_FIELDS.has(name));
+  if (fieldNames.length === 0) return null;
+  const union = fieldNames.map((name) => `'${name}'`).join(" | ");
+  return [
+    "/**",
+    " * Field names whose template variables (e.g. `${replace_uuid.myNewEntity}`) the server",
+    " * should resolve to their concrete values during this upsert.",
+    " */",
+    `replace_variables?: Array<${union}>;`
+  ].join("\n");
+}
 function generateEntityFieldsType(entity) {
-  const lines = entity.fields.map(
-    (f) => `${f.name}: ${fieldTypeString(f)};`
-  );
+  const lines = entity.fields.map((f) => `${f.name}: ${fieldTypeString(f)};`);
   for (const variantName of getVariantFieldNames(entity)) {
     lines.push(`${variantName}: ${VARIANT_TYPE}[] | null;`);
   }
@@ -305,9 +318,7 @@ function generateCreateInputType(entity) {
   for (const rel of entity.relations) {
     for (const suffix of rel.suffixes) {
       const valueType = rel.type === "hasMany" ? "Record<string, unknown>[]" : "Record<string, unknown>";
-      lines.push(
-        `${rel.fieldName}${suffix}?: ${valueType};`
-      );
+      lines.push(`${rel.fieldName}${suffix}?: ${valueType};`);
     }
   }
   return lines.join("\n");
@@ -318,6 +329,10 @@ function generateUpdateInputType(entity) {
   lines.push(
     "__search_value?: { field: string; value?: string; not_found_behavior?: 'create' | 'ignore' | 'error'; search_in_all_field_variants?: boolean; multiple_results_allowed?: boolean; multiple_results_use_latest?: boolean };"
   );
+  const replaceVariables = generateReplaceVariablesField(entity);
+  if (replaceVariables) {
+    lines.push(replaceVariables);
+  }
   for (const field of entity.fields) {
     if (field.name === "id" || field.name === "integer_id") continue;
     if (field.name === "created_at" || field.name === "updated_at") continue;
@@ -329,9 +344,7 @@ function generateUpdateInputType(entity) {
   for (const rel of entity.relations) {
     for (const suffix of rel.suffixes) {
       const valueType = rel.type === "hasMany" ? "Record<string, unknown>[]" : "Record<string, unknown>";
-      lines.push(
-        `${rel.fieldName}${suffix}?: ${valueType};`
-      );
+      lines.push(`${rel.fieldName}${suffix}?: ${valueType};`);
     }
   }
   return lines.join("\n");
@@ -362,8 +375,6 @@ function generateIndexFile(entities, importSource) {
     "  SortInput,",
     "  SortOrder,",
     "  SearchValueInput,",
-    "  SchemaMetadata,",
-    "  EntityMetadata,",
     `} from '${importSource}';`,
     ""
   );
@@ -400,6 +411,16 @@ function generateIndexFile(entities, importSource) {
     lines.push("  };");
   }
   lines.push("}", "");
+  if (REGISTERABLE_SOURCES.has(importSource)) {
+    lines.push(
+      `declare module '${importSource}' {`,
+      "  interface PyloRegister {",
+      "    schema: PyloSchema;",
+      "  }",
+      "}",
+      ""
+    );
+  }
   return lines.join("\n");
 }
 function generateEntitiesFile(entities, importSource) {
@@ -425,57 +446,19 @@ function generateEntitiesFile(entities, importSource) {
     }
     for (const rel of entity.relations) {
       if (rel.type === "hasOne") {
-        lines.push(`  ${rel.fieldName}?: { data: ${rel.targetEntityPascalName} } | null;`);
+        lines.push(
+          `  ${rel.fieldName}?: { data: ${rel.targetEntityPascalName} } | null;`
+        );
       } else {
-        lines.push(`  ${rel.fieldName}?: { data: ${rel.targetEntityPascalName}[]; pagination: PaginationData };`);
+        lines.push(
+          `  ${rel.fieldName}?: { data: ${rel.targetEntityPascalName}[]; pagination: PaginationData };`
+        );
       }
     }
     lines.push("}", "");
   }
   return lines.join("\n");
 }
-function generateSchemaMetadataFile(entities, unknownFieldBehavior, importSource) {
-  const lines = [];
-  lines.push(
-    "// Auto-generated by @pylo/core codegen \u2014 DO NOT EDIT",
-    "",
-    `import type { SchemaMetadata } from '${importSource}';`,
-    "",
-    "export const schemaMetadata: SchemaMetadata = {",
-    `  unknownFieldBehavior: '${unknownFieldBehavior}',`,
-    "  entities: {"
-  );
-  for (const entity of entities) {
-    lines.push(`    ${entity.key}: {`);
-    lines.push(`      pascalName: '${entity.pascalName}',`);
-    const scalarNames = entity.fields.map((f) => `'${f.name}'`).join(", ");
-    lines.push(`      scalarFieldNames: [${scalarNames}],`);
-    const variantNames = getVariantFieldNames(entity);
-    if (variantNames.length > 0) {
-      const variantNamesStr = variantNames.map((n) => `'${n}'`).join(", ");
-      lines.push(`      variantFieldNames: [${variantNamesStr}],`);
-    }
-    const enumFields = entity.fields.filter((f) => f.enum !== null);
-    if (enumFields.length > 0) {
-      lines.push("      enumFields: {");
-      for (const f of enumFields) {
-        const vals = f.enum.values.map((v) => `'${v}'`).join(", ");
-        lines.push(`        ${f.name}: [${vals}],`);
-      }
-      lines.push("      },");
-    }
-    lines.push("      relations: {");
-    for (const rel of entity.relations) {
-      lines.push(
-        `        ${rel.fieldName}: { type: '${rel.type}', entity: '${rel.targetEntityKey}', pascalName: '${rel.targetEntityPascalName}' },`
-      );
-    }
-    lines.push("      },");
-    lines.push("    },");
-  }
-  lines.push("  },", "};", "");
-  return lines.join("\n");
-}
 function writeGeneratedFiles(outputDir, files) {
   mkdirSync(outputDir, { recursive: true });
   for (const [filename, content] of Object.entries(files)) {
@@ -499,8 +482,7 @@ async function generate(options) {
   console.log("Generating types...");
   const files = {
     "index.ts": generateIndexFile(entities, importSource),
-    "entities.ts": generateEntitiesFile(entities, importSource),
-    "schema-metadata.ts": generateSchemaMetadataFile(entities, config.unknownFieldBehavior, importSource)
+    "entities.ts": generateEntitiesFile(entities, importSource)
   };
   console.log(`Writing files to ${outputDir}...`);
   writeGeneratedFiles(outputDir, files);

package/dist/codegen.d.ts

@@ -1 +1,2 @@
 export { PyloConfig, defineConfig } from '@pylo/core/codegen';
+import '@pylo/core/schema';

package/dist/index.d.ts

@@ -98,22 +98,6 @@ interface PyloEventFieldValuesOptions {
     startTime?: string;
     limit?: number;
 }
-interface EntityMetadata {
-    pascalName: string;
-    scalarFieldNames: string[];
-    variantFieldNames?: string[];
-    jsonFieldNames?: string[];
-    enumFields?: Record<string, string[]>;
-    relations: Record<string, {
-        type: "hasOne" | "hasMany";
-        entity: string;
-        pascalName: string;
-    }>;
-}
-interface SchemaMetadata {
-    entities: Record<string, EntityMetadata>;
-    unknownFieldBehavior?: "error" | "ignore";
-}
 
 type EntityName<S> = string & keyof S;
 type EntityFields<S, E extends EntityName<S>> = S[E] extends {
@@ -128,26 +112,26 @@ type UpsertInput<S, E extends EntityName<S>> = S[E] extends {
 type OmitNever<T> = {
     [K in keyof T as T[K] extends never ? never : K]: T[K];
 };
-type EntitySelect<S, E extends EntityName<S>, Depth extends number = 0> = Depth extends 5 ? Record<string, true> : OmitNever<{
+type EntitySelect<S, E extends EntityName<S>, Depth extends number = 0> = Depth extends 5 ? Record<string, never> : OmitNever<{
     [K in keyof EntityFields<S, E>]?: true;
 }> & {
     [K in keyof EntityRelations<S, E>]?: EntityRelations<S, E>[K] extends {
         type: "hasOne";
         entity: infer Target;
-    } ? Target extends EntityName<S> ? true | {
-        select?: EntitySelect<S, Target, Increment[Depth]>;
+    } ? Target extends EntityName<S> ? {
+        select: EntitySelect<S, Target, Increment[Depth]>;
         filter?: FilterInput;
-    } : true : EntityRelations<S, E>[K] extends {
+    } : never : EntityRelations<S, E>[K] extends {
         type: "hasMany";
         entity: infer Target;
-    } ? Target extends EntityName<S> ? true | {
-        select?: EntitySelect<S, Target, Increment[Depth]>;
+    } ? Target extends EntityName<S> ? {
+        select: EntitySelect<S, Target, Increment[Depth]>;
         filter?: FilterInput;
         pagination?: PaginationInput;
-    } : true : true;
+    } : never : never;
 };
 type Increment = [1, 2, 3, 4, 5, 5];
-type EntityResult<S, E extends EntityName<S>, Select extends EntitySelect<S, E> | undefined = undefined, Depth extends number = 0> = Depth extends 5 ? Record<string, unknown> : Select extends undefined ? EntityFields<S, E> : Select extends EntitySelect<S, E> ? OmitNever<ScalarResult<S, E, Select> & RelationResult<S, E, Select, Depth>> : EntityFields<S, E>;
+type EntityResult<S, E extends EntityName<S>, Select extends EntitySelect<S, E>, Depth extends number = 0> = Depth extends 5 ? Record<string, unknown> : Select extends EntitySelect<S, E> ? OmitNever<ScalarResult<S, E, Select> & RelationResult<S, E, Select, Depth>> : EntityFields<S, E>;
 type ScalarResult<S, E extends EntityName<S>, Select extends EntitySelect<S, E>> = {
     [K in keyof Select & keyof EntityFields<S, E>]: Select[K] extends true ? EntityFields<S, E>[K] : never;
 };
@@ -159,36 +143,29 @@ type RelationResult<S, E extends EntityName<S>, Select extends EntitySelect<S, E
         select: infer SubSelect;
     } ? SubSelect extends EntitySelect<S, Target> ? {
         data: EntityResult<S, Target, SubSelect, Increment[Depth]>;
-    } | null : {
-        data: EntityFields<S, Target>;
-    } | null : Select[K] extends true ? {
-        data: EntityFields<S, Target>;
-    } | null : never : never : EntityRelations<S, E>[K] extends {
+    } | null : never : never : never : EntityRelations<S, E>[K] extends {
         type: "hasMany";
         entity: infer Target;
     } ? Target extends EntityName<S> ? Select[K] extends {
         select: infer SubSelect;
     } ? SubSelect extends EntitySelect<S, Target> ? {
         data: Array<EntityResult<S, Target, SubSelect, Increment[Depth]>>;
+    } & (Select[K] extends {
+        pagination: unknown;
+    } ? {
         pagination: PaginationData;
-    } : {
-        data: Array<EntityFields<S, Target>>;
-        pagination: PaginationData;
-    } : Select[K] extends true ? {
-        data: Array<EntityFields<S, Target>>;
-        pagination: PaginationData;
-    } : never : never : never;
+    } : unknown) : never : never : never : never;
 };
 type StrictSelect<Sel, Valid> = Valid & {
     [K in keyof Sel]: K extends keyof Valid ? Sel[K] : never;
 };
-type ListOptions<S, E extends EntityName<S>, Sel extends EntitySelect<S, E> | undefined = undefined> = {
-    select?: Sel extends undefined ? EntitySelect<S, E> : StrictSelect<Sel, EntitySelect<S, E>>;
+type ListOptions<S, E extends EntityName<S>, Sel extends EntitySelect<S, E>> = {
+    select: StrictSelect<Sel, EntitySelect<S, E>>;
     filter?: FilterInput;
     pagination?: PaginationInput;
 };
-type ByIdOptions<S, E extends EntityName<S>, Sel extends EntitySelect<S, E> | undefined = undefined> = {
-    select?: Sel extends undefined ? EntitySelect<S, E> : StrictSelect<Sel, EntitySelect<S, E>>;
+type ByIdOptions<S, E extends EntityName<S>, Sel extends EntitySelect<S, E>> = {
+    select: StrictSelect<Sel, EntitySelect<S, E>>;
 };
 interface ListResult<T> {
     data: T[];
@@ -211,13 +188,12 @@ type AuthProvider = () => Promise<{
 }>;
 interface ClientOptions {
     endpoint?: string;
-    schemaMetadata: SchemaMetadata;
     auth: AuthProvider;
     headers?: Record<string, string>;
 }
 interface EntityClient<S, E extends EntityName<S>> {
-    list<Sel extends EntitySelect<S, E> | undefined = undefined>(options?: ListOptions<S, E, Sel> & RequestOptions): Promise<ListResult<EntityResult<S, E, Sel>>>;
-    byId<Sel extends EntitySelect<S, E> | undefined = undefined>(id: string, options?: ByIdOptions<S, E, Sel> & RequestOptions): Promise<EntityResult<S, E, Sel> | null>;
+    list<Sel extends EntitySelect<S, E>>(options: ListOptions<S, E, Sel> & RequestOptions): Promise<ListResult<EntityResult<S, E, Sel>>>;
+    byId<Sel extends EntitySelect<S, E>>(id: string, options: ByIdOptions<S, E, Sel> & RequestOptions): Promise<EntityResult<S, E, Sel> | null>;
     upsert(input: UpsertInput<S, E>, options?: MutationRequestOptions): Promise<{
         id: string;
     }>;
@@ -241,9 +217,61 @@ type PyloClient<S> = {
 interface NodeClientOptions {
     apiKey: string;
     endpoint?: string;
-    schemaMetadata: SchemaMetadata;
     headers?: Record<string, string>;
 }
 declare function createPyloNode<S>(options: NodeClientOptions): PyloClient<S>;
+/**
+ * Augmentable registry that lets a host pin the schema type for the injected
+ * `pylo` client. Generated code augments it, e.g.:
+ *
+ *   declare module "@pylo/node" {
+ *     interface PyloRegister { schema: PyloSchema }
+ *   }
+ *
+ * With no augmentation the client falls back to an untyped (`any`) schema.
+ */
+interface PyloRegister {
+}
+type RegisteredSchema = PyloRegister extends {
+    schema: infer S;
+} ? S : any;
+/**
+ * Entity keys available on the registered schema — e.g. `"contact"`. Use as the
+ * type parameter for {@link PyloSelect} / {@link PyloResult}.
+ */
+type PyloEntity = EntityName<RegisteredSchema>;
+/**
+ * A reusable, type-safe selection for one entity on the registered schema.
+ * Lets you define what to fetch once and reuse it across calls.
+ *
+ * Declare the selection with `satisfies` (not a plain `: PyloSelect<…>`
+ * annotation) so the exact set of selected fields is preserved — that's what
+ * keeps {@link PyloResult} precise:
+ *
+ * ```ts
+ * const contactSelect = {
+ *   name: true,
+ *   email: true,
+ *   company: { select: { name: true } },
+ * } satisfies PyloSelect<"contact">;
+ *
+ * const { data } = await pylo.contact.list({ select: contactSelect });
+ * type Contact = PyloResult<"contact", typeof contactSelect>;
+ * ```
+ */
+type PyloSelect<E extends PyloEntity> = EntitySelect<RegisteredSchema, E>;
+/**
+ * The row type returned for a given entity and selection. Pair with
+ * `typeof <yourSelect>` (see {@link PyloSelect}) for an exact result type.
+ */
+type PyloResult<E extends PyloEntity, Sel extends PyloSelect<E>> = EntityResult<RegisteredSchema, E, Sel>;
+/**
+ * Zero-config client for environments that inject a ready-made client onto
+ * `globalThis.__PYLO_FLOW_CLIENT__` — e.g. the Pylo flow worker, which builds
+ * the client from the flow's API key and the customer's schema before running
+ * an action. Property access is forwarded to the current global client at
+ * access time, so a worker reused across customers always sees the live one.
+ */
+declare const pylo: PyloClient<RegisteredSchema>;
 
-export { type AggregateFunction, type AggregateInput, type AuthProvider, type ByIdOptions, type ClientOptions, type DimensionInput, type EntityClient, type EntityFields, type EntityMetadata, type EntityName, type EntityRelations, type EntityResult, type EntitySelect, type EventListFilterInput, type EventListOptions, type EventsClient, type FilterInput, type IngestEvents, type ListOptions, type ListResult, type MutationRequestOptions, type PaginationData, type PaginationInput, type PyloClient, PyloError, type PyloEvent, type PyloEventFieldValue, type PyloEventFieldValuesOptions, type PyloEventInput, type PyloEventListResult, type PyloEventProperty, type PyloEventPropertyKeysOptions, type QueryInput, type QueryInputCondition, type QueryOperator, type RequestOptions, type SchemaMetadata, type SearchValueInput, type SortInput, type SortOrder, type StrictSelect, type TimeBucketInput, type UpsertInput, createPyloNode };
+export { type AggregateFunction, type AggregateInput, type AuthProvider, type ByIdOptions, type ClientOptions, type DimensionInput, type EntityClient, type EntityFields, type EntityName, type EntityRelations, type EntityResult, type EntitySelect, type EventListFilterInput, type EventListOptions, type EventsClient, type FilterInput, type IngestEvents, type ListOptions, type ListResult, type MutationRequestOptions, type PaginationData, type PaginationInput, type PyloClient, type PyloEntity, PyloError, type PyloEvent, type PyloEventFieldValue, type PyloEventFieldValuesOptions, type PyloEventInput, type PyloEventListResult, type PyloEventProperty, type PyloEventPropertyKeysOptions, type PyloRegister, type PyloResult, type PyloSelect, type QueryInput, type QueryInputCondition, type QueryOperator, type RegisteredSchema, type RequestOptions, type SearchValueInput, type SortInput, type SortOrder, type StrictSelect, type TimeBucketInput, type UpsertInput, createPyloNode, pylo };

package/dist/index.js

@@ -48,6 +48,7 @@ async function graphqlRequest(endpoint, query, variables, options) {
 }
 
 // ../core/dist/index.js
+var VARIANT_SUFFIX = "_variants";
 var PAGINATION_FIELDS = `pagination {
     total
     current_page
@@ -55,92 +56,59 @@ var PAGINATION_FIELDS = `pagination {
     last_page
     has_more_pages
   }`;
-function buildSelectionSet(select, entityMeta, schemaMetadata, variables, variableTypes, prefix) {
-  var _a, _b;
+function buildSelectionSet(select, variables, variableTypes, prefix) {
   const fields = [];
-  const variantFieldNames = (_a = entityMeta.variantFieldNames) != null ? _a : [];
-  if (!select) {
-    fields.push(...entityMeta.scalarFieldNames);
-    for (const vf of variantFieldNames) {
-      fields.push(`${vf} { data { value variant } }`);
-    }
-    return fields.join("\n    ");
-  }
   for (const [key, value] of Object.entries(select)) {
-    if (entityMeta.scalarFieldNames.includes(key)) {
-      if (value === true) {
+    if (value === true) {
+      if (key.endsWith(VARIANT_SUFFIX)) {
+        fields.push(`${key} { data { value variant } }`);
+      } else {
         fields.push(key);
       }
       continue;
     }
-    if (variantFieldNames.includes(key)) {
-      if (value === true) {
-        fields.push(`${key} { data { value variant } }`);
-      }
-      continue;
+    if (typeof value !== "object" || value === null) continue;
+    const relation = value;
+    const argParts = [];
+    if (relation.filter !== void 0) {
+      const varName = `${prefix}${key}_filter`;
+      variables[varName] = relation.filter;
+      variableTypes.set(varName, "FilterInput");
+      argParts.push(`filter: $${varName}`);
     }
-    const relation = entityMeta.relations[key];
-    if (!relation) {
-      if (schemaMetadata.unknownFieldBehavior === "ignore") continue;
-      const validFields = [...entityMeta.scalarFieldNames, ...variantFieldNames].join(", ");
-      const validRelations = Object.keys(entityMeta.relations).join(", ");
-      throw new Error(
-        `Unknown field "${key}" on entity "${entityMeta.pascalName}". Valid fields: ${validFields}. Valid relations: ${validRelations}`
-      );
+    const wantsPagination = relation.pagination !== void 0;
+    if (wantsPagination) {
+      const varName = `${prefix}${key}_pagination`;
+      variables[varName] = relation.pagination;
+      variableTypes.set(varName, "PaginationInput");
+      argParts.push(`pagination: $${varName}`);
     }
-    const targetMeta = schemaMetadata.entities[relation.entity];
-    if (!targetMeta) continue;
-    const isHasMany = relation.type === "hasMany";
-    if (value === true) {
-      const targetFieldParts = [...targetMeta.scalarFieldNames];
-      for (const vf of (_b = targetMeta.variantFieldNames) != null ? _b : []) {
-        targetFieldParts.push(`${vf} { data { value variant } }`);
-      }
-      const targetFields = targetFieldParts.join(" ");
-      if (isHasMany) {
-        fields.push(`${key} { data { ${targetFields} } ${PAGINATION_FIELDS} }`);
-      } else {
-        fields.push(`${key} { data { ${targetFields} } }`);
-      }
-    } else if (typeof value === "object" && value !== null) {
-      const argParts = [];
-      if (value.filter !== void 0) {
-        const varName = `${prefix}${key}_filter`;
-        variables[varName] = value.filter;
-        variableTypes.set(varName, "FilterInput");
-        argParts.push(`filter: $${varName}`);
-      }
-      if (isHasMany && value.pagination !== void 0) {
-        const varName = `${prefix}${key}_pagination`;
-        variables[varName] = value.pagination;
-        variableTypes.set(varName, "PaginationInput");
-        argParts.push(`pagination: $${varName}`);
-      }
-      const args = argParts.length > 0 ? `(${argParts.join(", ")})` : "";
-      const nestedSelection = buildSelectionSet(
-        value.select,
-        targetMeta,
-        schemaMetadata,
-        variables,
-        variableTypes,
-        `${prefix}${key}_`
-      );
-      if (isHasMany) {
-        fields.push(
-          `${key}${args} { data { ${nestedSelection} } ${PAGINATION_FIELDS} }`
-        );
-      } else {
-        fields.push(`${key}${args} { data { ${nestedSelection} } }`);
-      }
+    const args = argParts.length > 0 ? `(${argParts.join(", ")})` : "";
+    if (!relation.select) {
+      throw new Error(`Relation "${key}" requires an explicit { select: {...} }.`);
+    }
+    const nestedSelection = buildSelectionSet(
+      relation.select,
+      variables,
+      variableTypes,
+      `${prefix}${key}_`
+    );
+    if (wantsPagination) {
+      fields.push(`${key}${args} { data { ${nestedSelection} } ${PAGINATION_FIELDS} }`);
+    } else {
+      fields.push(`${key}${args} { data { ${nestedSelection} } }`);
     }
   }
   return fields.join("\n    ");
 }
-function buildListQuery(entityKey, options, schemaMetadata) {
-  const entityMeta = schemaMetadata.entities[entityKey];
-  if (!entityMeta) {
-    throw new Error(`Unknown entity: ${entityKey}`);
+function requireSelect(entityKey, operation, select) {
+  if (!select || typeof select !== "object" || Object.keys(select).length === 0) {
+    throw new Error(`${operation}("${entityKey}") requires an explicit 'select'.`);
   }
+  return select;
+}
+function buildListQuery(entityKey, options) {
+  const select = requireSelect(entityKey, "list", options == null ? void 0 : options.select);
   const variables = {};
   const variableTypes = /* @__PURE__ */ new Map();
   if ((options == null ? void 0 : options.filter) !== void 0) {
@@ -151,14 +119,7 @@ function buildListQuery(entityKey, options, schemaMetadata) {
     variables["pagination"] = options.pagination;
     variableTypes.set("pagination", "PaginationInput");
   }
-  const selectionSet = buildSelectionSet(
-    options == null ? void 0 : options.select,
-    entityMeta,
-    schemaMetadata,
-    variables,
-    variableTypes,
-    "r_"
-  );
+  const selectionSet = buildSelectionSet(select, variables, variableTypes, "r_");
   const varDecls = Array.from(variableTypes.entries()).map(([name, type]) => `$${name}: ${type}`).join(", ");
   const varSection = varDecls ? `(${varDecls})` : "";
   const argParts = [];
@@ -180,21 +141,11 @@ function buildListQuery(entityKey, options, schemaMetadata) {
 }`;
   return { query, variables };
 }
-function buildByIdQuery(entityKey, id, options, schemaMetadata) {
-  const entityMeta = schemaMetadata.entities[entityKey];
-  if (!entityMeta) {
-    throw new Error(`Unknown entity: ${entityKey}`);
-  }
+function buildByIdQuery(entityKey, id, options) {
+  const select = requireSelect(entityKey, "byId", options == null ? void 0 : options.select);
   const variables = { id };
   const variableTypes = /* @__PURE__ */ new Map([["id", "ID!"]]);
-  const selectionSet = buildSelectionSet(
-    options == null ? void 0 : options.select,
-    entityMeta,
-    schemaMetadata,
-    variables,
-    variableTypes,
-    "r_"
-  );
+  const selectionSet = buildSelectionSet(select, variables, variableTypes, "r_");
   const varDecls = Array.from(variableTypes.entries()).map(([name, type]) => `$${name}: ${type}`).join(", ");
   const query = `query ${capitalize(entityKey)}ById(${varDecls}) {
   ${entityKey}ById(id: $id) {
@@ -369,13 +320,12 @@ async function executeGraphQL(endpoint, query, variables, auth, headers) {
   }
   return response.data;
 }
-function createEntityClient(entityKey, endpoint, metadata, auth, globalHeaders) {
+function createEntityClient(entityKey, endpoint, auth, globalHeaders) {
   return {
     async list(options) {
       const { query, variables } = buildListQuery(
         entityKey,
-        options,
-        metadata
+        options
       );
       const data = await executeGraphQL(
         endpoint,
@@ -395,8 +345,7 @@ function createEntityClient(entityKey, endpoint, metadata, auth, globalHeaders)
       const { query, variables } = buildByIdQuery(
         entityKey,
         id,
-        options,
-        metadata
+        options
       );
       const data = await executeGraphQL(
         endpoint,
@@ -411,13 +360,10 @@ function createEntityClient(entityKey, endpoint, metadata, auth, globalHeaders)
       return result.data;
     },
     async upsert(input, options) {
-      const entityMeta = metadata.entities[entityKey];
-      if (!entityMeta) {
-        throw new PyloError(`Unknown entity: ${entityKey}`);
-      }
+      const pascalName = capitalize(entityKey);
       const { query, variables } = buildUpsertMutation(
         entityKey,
-        entityMeta.pascalName,
+        pascalName,
         input
       );
       const data = await executeGraphQL(
@@ -430,7 +376,7 @@ function createEntityClient(entityKey, endpoint, metadata, auth, globalHeaders)
           flagsToHeaders(options != null ? options : {})
         )
       );
-      const mutationKey = `update${entityMeta.pascalName}`;
+      const mutationKey = `update${pascalName}`;
       const result = data[mutationKey];
       if (!result) {
         throw new PyloError(`Unexpected response shape \u2014 missing ${mutationKey}`);
@@ -438,13 +384,10 @@ function createEntityClient(entityKey, endpoint, metadata, auth, globalHeaders)
       return result.data;
     },
     async delete(ids, options) {
-      const entityMeta = metadata.entities[entityKey];
-      if (!entityMeta) {
-        throw new PyloError(`Unknown entity: ${entityKey}`);
-      }
+      const pascalName = capitalize(entityKey);
       const { query, variables } = buildDeleteMutation(
         entityKey,
-        entityMeta.pascalName,
+        pascalName,
         ids
       );
       const data = await executeGraphQL(
@@ -457,7 +400,7 @@ function createEntityClient(entityKey, endpoint, metadata, auth, globalHeaders)
           flagsToHeaders(options != null ? options : {})
         )
       );
-      const mutationKey = `delete${entityMeta.pascalName}`;
+      const mutationKey = `delete${pascalName}`;
       const result = data[mutationKey];
       if (!result) {
         throw new PyloError(`Unexpected response shape \u2014 missing ${mutationKey}`);
@@ -531,7 +474,6 @@ function createEventsClient(endpoint, auth, globalHeaders) {
 }
 function createPyloClient(options) {
   const endpoint = getEndpoint(options.endpoint);
-  const metadata = options.schemaMetadata;
   const auth = options.auth;
   const globalHeaders = options.headers;
   const ingestEvents = createIngestEvents(endpoint, auth, globalHeaders);
@@ -541,7 +483,7 @@ function createPyloClient(options) {
       if (typeof prop !== "string") return void 0;
       if (prop === "ingestEvents") return ingestEvents;
       if (prop === "events") return events;
-      return createEntityClient(prop, endpoint, metadata, auth, globalHeaders);
+      return createEntityClient(prop, endpoint, auth, globalHeaders);
     }
   });
 }
@@ -550,12 +492,26 @@ function createPyloClient(options) {
 function createPyloNode(options) {
   return createPyloClient({
     ...options.endpoint !== void 0 ? { endpoint: options.endpoint } : {},
-    schemaMetadata: options.schemaMetadata,
     auth: async () => ({ apiKey: options.apiKey }),
     ...options.headers !== void 0 ? { headers: options.headers } : {}
   });
 }
+var pylo = new Proxy(
+  {},
+  {
+    get(_target, prop) {
+      const client = globalThis["__PYLO_FLOW_CLIENT__"];
+      if (!client) {
+        throw new Error(
+          "Pylo flow client unavailable (globalThis.__PYLO_FLOW_CLIENT__ is unset). `pylo` is only usable inside a Pylo flow action."
+        );
+      }
+      return client[prop];
+    }
+  }
+);
 export {
   PyloError,
-  createPyloNode
+  createPyloNode,
+  pylo
 };

package/dist/schema.d.ts

@@ -0,0 +1 @@
+export { AnalyzedEntity, AnalyzedField, AnalyzedRelation, ENTITY_LIST_QUERY, EntityListResponse, RawEntity, RawEntityField, RawEntityRelation, SchemaFetcher, analyzeEntities, fetchSchemaWith, generateEntitiesFile, generateIndexFile } from '@pylo/core/schema';

package/dist/schema.js

@@ -0,0 +1,406 @@
+// ../core/dist/schema.js
+var ENTITY_LIST_QUERY = `
+query PyloSchemaFetch($pagination: PaginationInput) {
+  entityList(pagination: $pagination) {
+    data {
+      name
+      shortcode
+      is_system_entity
+      entity_fields {
+        data {
+          name
+          data_type
+          validation_string
+          form_type
+          default_value
+          variant_entity_field {
+            data {
+              name
+            }
+          }
+          entity_field_enum_values {
+            data {
+              value
+            }
+          }
+        }
+      }
+      entity_relations {
+        data {
+          type
+          field_name
+          target_field_name
+          target_entity {
+            data {
+              name
+            }
+          }
+          entity_is_tightly_coupled
+          target_entity_is_tightly_coupled
+          allow_connect_create
+          allow_connect_existing
+        }
+      }
+      entity_related {
+        data {
+          type
+          field_name
+          target_field_name
+          entity {
+            data {
+              name
+            }
+          }
+          entity_is_tightly_coupled
+          target_entity_is_tightly_coupled
+          allow_connect_create
+          allow_connect_existing
+        }
+      }
+    }
+    pagination {
+      total
+      has_more_pages
+      current_page
+    }
+  }
+}
+`;
+async function fetchSchemaWith(request) {
+  var _a, _b;
+  const allEntities = [];
+  let page = 1;
+  let hasMore = true;
+  while (hasMore) {
+    const response = await request(ENTITY_LIST_QUERY, {
+      pagination: { page, per_page: 50 }
+    });
+    if (response.errors) {
+      const errMsg = Array.isArray(response.errors) ? response.errors.map((e) => e.message).join(", ") : (_b = (_a = response.errors.generalError) == null ? void 0 : _a.message) != null ? _b : "Unknown error";
+      throw new Error(`Failed to fetch schema: ${errMsg}`);
+    }
+    if (!response.data) {
+      throw new Error("No data returned from schema fetch");
+    }
+    const { data, pagination } = response.data.entityList;
+    allEntities.push(...data);
+    hasMore = pagination.has_more_pages;
+    page++;
+  }
+  return allEntities;
+}
+var DATA_TYPE_MAP = {
+  TEXT: "string",
+  LONGTEXT: "string",
+  RICHTEXT: "string",
+  INT: "number",
+  FLOAT: "number",
+  JSON: "string",
+  DATE: "string",
+  DATETIME: "string",
+  TIME: "string",
+  BOOLEAN: "boolean"
+};
+function mapDataType(dataType) {
+  var _a;
+  return (_a = DATA_TYPE_MAP[dataType]) != null ? _a : "string";
+}
+function isNullable(field) {
+  return field.validation_string !== "required";
+}
+function classifyRelation(relationType) {
+  if (relationType === "ManyToOne" || relationType === "OneToOne") {
+    return "hasOne";
+  }
+  return "hasMany";
+}
+function classifyReverseRelation(relationType) {
+  if (relationType === "OneToMany" || relationType === "OneToOne") {
+    return "hasOne";
+  }
+  return "hasMany";
+}
+function getMutationSuffixes(relType) {
+  if (relType === "hasOne") {
+    return ["_set"];
+  }
+  return ["_set", "_connect", "_disconnect"];
+}
+function toEntityKey(pascalName) {
+  return pascalName.charAt(0).toLowerCase() + pascalName.slice(1);
+}
+function toPascalCase(snake) {
+  return snake.split("_").filter((part) => part.length > 0).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function analyzeField(field, entityPascalName) {
+  var _a, _b, _c, _d;
+  const hasVariants = ((_b = (_a = field.variant_entity_field) == null ? void 0 : _a.data) == null ? void 0 : _b.name) != null;
+  const enumValues = (_d = (_c = field.entity_field_enum_values) == null ? void 0 : _c.data) != null ? _d : [];
+  if (enumValues.length > 0) {
+    const typeName = `${entityPascalName}${toPascalCase(field.name)}`;
+    const values = enumValues.map((v) => v.value);
+    return {
+      name: field.name,
+      tsType: typeName,
+      nullable: isNullable(field),
+      variantFieldName: hasVariants ? `${field.name}_variants` : null,
+      enum: { typeName, values }
+    };
+  }
+  return {
+    name: field.name,
+    tsType: mapDataType(field.data_type),
+    nullable: isNullable(field),
+    variantFieldName: hasVariants ? `${field.name}_variants` : null,
+    enum: null
+  };
+}
+function analyzeRelation(relation) {
+  var _a, _b;
+  const targetName = (_b = (_a = relation.target_entity) == null ? void 0 : _a.data) == null ? void 0 : _b.name;
+  if (!targetName || !relation.field_name) return null;
+  const relType = classifyRelation(relation.type);
+  return {
+    fieldName: relation.field_name,
+    type: relType,
+    targetEntityKey: toEntityKey(targetName),
+    targetEntityPascalName: targetName,
+    suffixes: getMutationSuffixes(relType)
+  };
+}
+function analyzeReverseRelation(relation) {
+  var _a, _b;
+  const sourceName = (_b = (_a = relation.entity) == null ? void 0 : _a.data) == null ? void 0 : _b.name;
+  if (!sourceName || !relation.target_field_name) return null;
+  const relType = classifyReverseRelation(relation.type);
+  return {
+    fieldName: relation.target_field_name,
+    type: relType,
+    targetEntityKey: toEntityKey(sourceName),
+    targetEntityPascalName: sourceName,
+    suffixes: getMutationSuffixes(relType)
+  };
+}
+function analyzeEntities(rawEntities) {
+  return rawEntities.map((entity) => {
+    var _a, _b, _c, _d, _e, _f;
+    const fields = ((_b = (_a = entity.entity_fields) == null ? void 0 : _a.data) != null ? _b : []).map(
+      (f) => analyzeField(f, entity.name)
+    );
+    const forwardRelations = ((_d = (_c = entity.entity_relations) == null ? void 0 : _c.data) != null ? _d : []).map(analyzeRelation).filter((r) => r !== null);
+    const reverseRelations = ((_f = (_e = entity.entity_related) == null ? void 0 : _e.data) != null ? _f : []).map(analyzeReverseRelation).filter((r) => r !== null);
+    const seen = new Set(forwardRelations.map((r) => r.fieldName));
+    const deduped = reverseRelations.filter((r) => !seen.has(r.fieldName));
+    return {
+      key: toEntityKey(entity.name),
+      pascalName: entity.name,
+      shortcode: entity.shortcode,
+      isSystem: entity.is_system_entity,
+      fields,
+      relations: [...forwardRelations, ...deduped]
+    };
+  });
+}
+var VARIANT_TYPE = "{ variant: string; value: string }";
+var REGISTERABLE_SOURCES = /* @__PURE__ */ new Set(["@pylo/node", "@pylo/nextjs"]);
+function fieldTypeString(field) {
+  if (field.nullable) {
+    return `${field.tsType} | null`;
+  }
+  return field.tsType;
+}
+function indent(text, level) {
+  const spaces = "  ".repeat(level);
+  return text.split("\n").map((line) => line.trim() ? spaces + line : line).join("\n");
+}
+function getVariantFieldNames(entity) {
+  return entity.fields.filter((f) => f.variantFieldName !== null).map((f) => f.variantFieldName);
+}
+var NON_WRITABLE_FIELDS = /* @__PURE__ */ new Set(["integer_id", "created_at", "updated_at"]);
+function generateReplaceVariablesField(entity) {
+  const fieldNames = entity.fields.map((f) => f.name).filter((name) => !NON_WRITABLE_FIELDS.has(name));
+  if (fieldNames.length === 0) return null;
+  const union = fieldNames.map((name) => `'${name}'`).join(" | ");
+  return [
+    "/**",
+    " * Field names whose template variables (e.g. `${replace_uuid.myNewEntity}`) the server",
+    " * should resolve to their concrete values during this upsert.",
+    " */",
+    `replace_variables?: Array<${union}>;`
+  ].join("\n");
+}
+function generateEntityFieldsType(entity) {
+  const lines = entity.fields.map((f) => `${f.name}: ${fieldTypeString(f)};`);
+  for (const variantName of getVariantFieldNames(entity)) {
+    lines.push(`${variantName}: ${VARIANT_TYPE}[] | null;`);
+  }
+  return lines.join("\n");
+}
+function generateEntityRelationsType(entity) {
+  if (entity.relations.length === 0) return "";
+  const lines = entity.relations.map(
+    (r) => `${r.fieldName}: { type: '${r.type}'; entity: '${r.targetEntityKey}' };`
+  );
+  return lines.join("\n");
+}
+function generateCreateInputType(entity) {
+  const lines = [];
+  for (const field of entity.fields) {
+    if (field.name === "id" || field.name === "integer_id") continue;
+    if (field.name === "created_at" || field.name === "updated_at") continue;
+    lines.push(`${field.name}?: ${fieldTypeString(field)};`);
+  }
+  for (const variantName of getVariantFieldNames(entity)) {
+    lines.push(`${variantName}?: ${VARIANT_TYPE}[];`);
+  }
+  for (const rel of entity.relations) {
+    for (const suffix of rel.suffixes) {
+      const valueType = rel.type === "hasMany" ? "Record<string, unknown>[]" : "Record<string, unknown>";
+      lines.push(`${rel.fieldName}${suffix}?: ${valueType};`);
+    }
+  }
+  return lines.join("\n");
+}
+function generateUpdateInputType(entity) {
+  const lines = [];
+  lines.push("id?: string;");
+  lines.push(
+    "__search_value?: { field: string; value?: string; not_found_behavior?: 'create' | 'ignore' | 'error'; search_in_all_field_variants?: boolean; multiple_results_allowed?: boolean; multiple_results_use_latest?: boolean };"
+  );
+  const replaceVariables = generateReplaceVariablesField(entity);
+  if (replaceVariables) {
+    lines.push(replaceVariables);
+  }
+  for (const field of entity.fields) {
+    if (field.name === "id" || field.name === "integer_id") continue;
+    if (field.name === "created_at" || field.name === "updated_at") continue;
+    lines.push(`${field.name}?: ${fieldTypeString(field)};`);
+  }
+  for (const variantName of getVariantFieldNames(entity)) {
+    lines.push(`${variantName}?: ${VARIANT_TYPE}[];`);
+  }
+  for (const rel of entity.relations) {
+    for (const suffix of rel.suffixes) {
+      const valueType = rel.type === "hasMany" ? "Record<string, unknown>[]" : "Record<string, unknown>";
+      lines.push(`${rel.fieldName}${suffix}?: ${valueType};`);
+    }
+  }
+  return lines.join("\n");
+}
+function collectEnumTypes(entities) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const entity of entities) {
+    for (const field of entity.fields) {
+      if (field.enum && !seen.has(field.enum.typeName)) {
+        seen.set(field.enum.typeName, field.enum.values);
+      }
+    }
+  }
+  return Array.from(seen, ([typeName, values]) => ({ typeName, values }));
+}
+function generateIndexFile(entities, importSource) {
+  const lines = [];
+  lines.push(
+    "// Auto-generated by @pylo/core codegen \u2014 DO NOT EDIT",
+    "",
+    "export type {",
+    "  FilterInput,",
+    "  PaginationData,",
+    "  PaginationInput,",
+    "  QueryInput,",
+    "  QueryInputCondition,",
+    "  QueryOperator,",
+    "  SortInput,",
+    "  SortOrder,",
+    "  SearchValueInput,",
+    `} from '${importSource}';`,
+    ""
+  );
+  const enumTypes = collectEnumTypes(entities);
+  if (enumTypes.length > 0) {
+    for (const { typeName, values } of enumTypes) {
+      const union = values.map((v) => `'${v}'`).join(" | ");
+      lines.push(`export type ${typeName} = ${union};`);
+    }
+    lines.push("");
+  }
+  for (const entity of entities) {
+    lines.push(`export interface Create${entity.pascalName}Input {`);
+    lines.push(indent(generateCreateInputType(entity), 1));
+    lines.push("}", "");
+    lines.push(`export interface Update${entity.pascalName}Input {`);
+    lines.push(indent(generateUpdateInputType(entity), 1));
+    lines.push("}", "");
+  }
+  lines.push("export interface PyloSchema {");
+  for (const entity of entities) {
+    lines.push(`  ${entity.key}: {`);
+    lines.push("    fields: {");
+    lines.push(indent(generateEntityFieldsType(entity), 3));
+    lines.push("    };");
+    const relType = generateEntityRelationsType(entity);
+    lines.push("    relations: {");
+    if (relType) {
+      lines.push(indent(relType, 3));
+    }
+    lines.push("    };");
+    lines.push(`    createInput: Create${entity.pascalName}Input;`);
+    lines.push(`    updateInput: Update${entity.pascalName}Input;`);
+    lines.push("  };");
+  }
+  lines.push("}", "");
+  if (REGISTERABLE_SOURCES.has(importSource)) {
+    lines.push(
+      `declare module '${importSource}' {`,
+      "  interface PyloRegister {",
+      "    schema: PyloSchema;",
+      "  }",
+      "}",
+      ""
+    );
+  }
+  return lines.join("\n");
+}
+function generateEntitiesFile(entities, importSource) {
+  const lines = [];
+  lines.push(
+    "// Auto-generated by @pylo/core codegen \u2014 DO NOT EDIT",
+    "",
+    `import type { PaginationData } from '${importSource}';`
+  );
+  const enumTypes = collectEnumTypes(entities);
+  if (enumTypes.length > 0) {
+    const names = enumTypes.map((e) => e.typeName).join(", ");
+    lines.push(`import type { ${names} } from './index.js';`);
+  }
+  lines.push("");
+  for (const entity of entities) {
+    lines.push(`export interface ${entity.pascalName} {`);
+    for (const field of entity.fields) {
+      lines.push(`  ${field.name}: ${fieldTypeString(field)};`);
+    }
+    for (const variantName of getVariantFieldNames(entity)) {
+      lines.push(`  ${variantName}: ${VARIANT_TYPE}[] | null;`);
+    }
+    for (const rel of entity.relations) {
+      if (rel.type === "hasOne") {
+        lines.push(
+          `  ${rel.fieldName}?: { data: ${rel.targetEntityPascalName} } | null;`
+        );
+      } else {
+        lines.push(
+          `  ${rel.fieldName}?: { data: ${rel.targetEntityPascalName}[]; pagination: PaginationData };`
+        );
+      }
+    }
+    lines.push("}", "");
+  }
+  return lines.join("\n");
+}
+export {
+  ENTITY_LIST_QUERY,
+  analyzeEntities,
+  fetchSchemaWith,
+  generateEntitiesFile,
+  generateIndexFile
+};

package/dist/shared-types-DqRv2JHW.d.ts

@@ -0,0 +1,67 @@
+type QueryOperator = "equal" | "notEqual" | "greaterThan" | "lessThan" | "greaterThanOrEqual" | "lessThanOrEqual" | "isNull" | "isNotNull" | "like" | "notLike" | "ilike" | "notiLike" | "regex" | "notRegex" | "iregex" | "notiRegex" | "in" | "notIn" | "isEmpty" | "isNotEmpty" | "isTrue" | "isFalse";
+type SortOrder = "asc" | "desc";
+interface QueryInputCondition {
+    field: string;
+    operator: QueryOperator;
+    value?: string | number;
+    values?: Array<string | number>;
+}
+interface QueryInput {
+    and?: QueryInput[];
+    or?: QueryInput[];
+    condition?: QueryInputCondition;
+}
+interface SortInput {
+    field: string;
+    order: SortOrder;
+}
+interface FilterInput {
+    query?: QueryInput[];
+    sortby?: SortInput[];
+}
+interface PaginationInput {
+    page?: number;
+    per_page?: number;
+}
+interface PaginationData {
+    total: number;
+    current_page: number;
+    per_page: number;
+    last_page: number;
+    has_more_pages: boolean;
+}
+interface SearchValueInput {
+    field: string;
+    value?: string;
+    not_found_behavior?: "create" | "ignore" | "error";
+    search_in_all_field_variants?: boolean;
+    multiple_results_allowed?: boolean;
+    multiple_results_use_latest?: boolean;
+}
+interface PyloEventInput {
+    event_name: string;
+    properties: Record<string, unknown>;
+}
+interface PyloEvent {
+    event_name: string;
+    ts: string;
+    properties: Record<string, unknown>;
+}
+interface EntityMetadata {
+    pascalName: string;
+    scalarFieldNames: string[];
+    variantFieldNames?: string[];
+    jsonFieldNames?: string[];
+    enumFields?: Record<string, string[]>;
+    relations: Record<string, {
+        type: "hasOne" | "hasMany";
+        entity: string;
+        pascalName: string;
+    }>;
+}
+interface SchemaMetadata {
+    entities: Record<string, EntityMetadata>;
+    unknownFieldBehavior?: "error" | "ignore";
+}
+
+export type { EntityMetadata as E, FilterInput as F, PaginationInput as P, QueryInput as Q, SchemaMetadata as S, PaginationData as a, PyloEventInput as b, PyloEvent as c, QueryInputCondition as d, QueryOperator as e, SearchValueInput as f, SortInput as g, SortOrder as h };

package/package.json

@@ -1,15 +1,22 @@
 {
   "name": "@pylo/node",
-  "version": "0.0.12",
+  "version": "0.1.1",
   "description": "Server-side Pylo SDK with API key authentication",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     },
     "./codegen": {
       "types": "./dist/codegen.d.ts",
-      "import": "./dist/codegen.js"
+      "import": "./dist/codegen.js",
+      "default": "./dist/codegen.js"
+    },
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "import": "./dist/schema.js",
+      "default": "./dist/schema.js"
     }
   },
   "main": "dist/index.js",
@@ -29,8 +36,8 @@
     "@types/node": "^22.15.21",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "@pylo/core": "0.0.14",
-    "@pylo/auth": "0.0.5"
+    "@pylo/auth": "0.0.5",
+    "@pylo/core": "0.1.1"
   },
   "author": "Okeano GmbH",
   "license": "MIT",