@sanity/agent-schema 0.0.1

package/README.md

@@ -0,0 +1,277 @@
+# @sanity/agent-schema
+
+Schema processing utilities for Sanity Agent. Parses Lexicon schemas, compresses them for LLM context, provides full JSON views for schema explorers, and navigates schema trees for validation and mutation agents.
+
+## Install
+
+```bash
+pnpm add @sanity/agent-schema
+```
+
+## Quick start
+
+```ts
+import {
+  fetchSchemaByDescriptorId,
+  fetchDatasetStats,
+  compressedSchema,
+} from "@sanity/agent-schema";
+
+// 1. Fetch and parse the schema
+const types = await fetchSchemaByDescriptorId(lexiconClient, descriptorId);
+
+// 2. Optionally fetch dataset stats (enriches output with counts)
+const statsResult = await fetchDatasetStats(agentClient, {
+  organizationId,
+  projectId,
+  dataset,
+});
+
+// 3. Compress into agent-friendly text
+const text = await compressedSchema(types, {
+  datasetStats: statsResult.status === "ready" ? statsResult.stats : undefined,
+  filter: { read: '_type in ["post", "author"]' },
+});
+```
+
+## API
+
+### Fetch
+
+#### `fetchSchemaByDescriptorId(client, descriptorId, options?)`
+
+Fetches a schema from the Lexicon API and returns parsed `ManifestSchemaType[]`.
+
+```ts
+const types = await fetchSchemaByDescriptorId(client, descriptorId);
+```
+
+Enable caching with `{ cache: true }` (in-memory, 5 min TTL) or a custom adapter:
+
+```ts
+// Built-in memory cache
+const types = await fetchSchemaByDescriptorId(client, id, { cache: true });
+
+// Custom cache (e.g. Redis)
+const types = await fetchSchemaByDescriptorId(client, id, {
+  cache: {
+    get: (id) => redis.get(id),
+    set: (id, response) => redis.set(id, response),
+  },
+});
+```
+
+#### `fetchDatasetStats(client, options)`
+
+Fetches document and reference counts from the agent API. Returns `{ status: 'ready', stats }` or `{ status: 'processing' }` if still being computed.
+
+```ts
+const result = await fetchDatasetStats(client, {
+  organizationId: "org-abc",
+  projectId: "my-project",
+  dataset: "production",
+});
+
+if (result.status === "ready") {
+  result.stats.documentCount; // { post: 42, author: 7 }
+  result.stats.referenceCount; // { post: { incoming: {...}, outgoing: {...} } }
+}
+```
+
+### Compress
+
+#### `compressedSchema(types, options?)`
+
+The main entry point. Takes parsed types and returns compact text for agents.
+
+The `filter` option controls which document types to include. Pass a GROQ filter (requires `groq-js` peer dep) or an explicit list of type names:
+
+```ts
+// GROQ filter — types are inferred from the expression
+await compressedSchema(types, {
+  filter: { read: '_type in ["post", "author"]' },
+});
+
+// Explicit type list
+await compressedSchema(types, {
+  filter: ["post", "author"],
+});
+
+// All options
+await compressedSchema(types, {
+  filter: { read: '_type == "post"', write: '_type == "draft"' },
+  datasetStats,
+  fields: { maxCount: 5, includeDescription: true },
+});
+```
+
+| Option         | Type                        | Description                                   |
+| -------------- | --------------------------- | --------------------------------------------- |
+| `filter`       | `SchemaFilter`              | GROQ filter `{ read?, write? }` or `string[]` |
+| `datasetStats` | `DatasetStats`              | Document/reference counts to enrich output    |
+| `fields`       | `SchemaFieldDisplayOptions` | Control field display (see below)             |
+
+**Field display options:**
+
+| Option                 | Type      | Default | Description                                         |
+| ---------------------- | --------- | ------- | --------------------------------------------------- |
+| `showAll`              | `boolean` | `false` | Show all fields (ignores `maxCount`)                |
+| `maxCount`             | `number`  | `10`    | Max fields to display per type                      |
+| `includeDescription`   | `boolean` | `false` | Append field titles that differ from the field name |
+| `includeHidden`        | `boolean` | `false` | Include hidden fields                               |
+| `includeDeprecated`    | `boolean` | `false` | Include deprecated fields                           |
+| `maxEnumValues`        | `number`  | `10`    | Max enum values before truncating                   |
+| `maxDescriptionLength` | `number`  | `50`    | Truncate field descriptions beyond this length      |
+
+### Full schema
+
+#### `fullSchema(types, options)`
+
+Returns a **JSON subtree** of a schema type — everything inside it (all fields, nested objects, validation rules, options). Used by schema explorer tools to let the LLM browse type structures.
+
+Without `path`, you get the entire type. With `path`, you get the subtree rooted at that field — still the full structure from that point down, just scoped to a smaller starting point. This is useful because some types are huge; `path` lets you zoom in.
+
+```ts
+import { fullSchema } from "@sanity/agent-schema";
+
+fullSchema(types, { type: "post" });
+// Returns: { name: "post", type: "document", fields: [
+//   { name: "title", type: "string" },
+//   { name: "content", type: "array", of: [
+//     { name: "block", type: "block", marks: {...}, styles: [...], ... },
+//     { name: "codeBlock", type: "object", fields: [
+//       { name: "language", type: "string", options: { list: [...] } },
+//       { name: "code", type: "text" },
+//     ]},
+//   ]},
+//   ... every field, fully expanded ...
+// ]}
+
+// Same structure, just starting from content[].codeBlock instead of the root
+fullSchema(types, { type: "post", path: "content[].codeBlock" });
+// Returns: { name: "codeBlock", type: "object", fields: [
+//   { name: "language", type: "string", options: { list: [...] } },
+//   { name: "code", type: "text" },
+// ]}
+```
+
+If the output exceeds `sizeThreshold`, a navigator object is returned instead with child paths to drill into.
+
+| Option          | Type     | Default  | Description                                           |
+| --------------- | -------- | -------- | ----------------------------------------------------- |
+| `type`          | `string` | required | Document type name to return                          |
+| `path`          | `string` |          | Field path — returns the subtree from this point down |
+| `sizeThreshold` | `number` | `200KB`  | Byte limit before returning a navigator instead       |
+
+### Navigate
+
+#### `resolveFieldSchema(path, typeSchema, schema)`
+
+Returns the **single field definition** at the end of a path. No subtree, no nested fields — just the node itself. Used by validators and mutation code that need to answer "what type is the value at this path?"
+
+```ts
+import { resolveFieldSchema } from "@sanity/agent-schema";
+
+resolveFieldSchema("content[0].text", postSchema, allTypes);
+// Returns: { name: "text", type: "string" }
+//
+// Compare with fullSchema — that would return the entire content array
+// with all its item types expanded. This just tells you "it's a string."
+
+resolveFieldSchema("tags", postSchema, allTypes);
+// Returns: { name: "tags", type: "array", of: [...] }
+//
+// You get the field node, not the expanded contents of every array item.
+
+resolveFieldSchema("nonexistent.path", postSchema, allTypes);
+// Returns: null
+```
+
+Handles nested objects, array indices, built-in type fields (`slug.current`, `block.children`), and type references.
+
+#### `resolveFieldSchemaAllUnions(path, typeSchema, schema)`
+
+Same as `resolveFieldSchema`, but when the path crosses a union array, returns the field definition from **every** item type instead of just the first match.
+
+```ts
+import { resolveFieldSchemaAllUnions } from "@sanity/agent-schema";
+
+resolveFieldSchemaAllUnions("content", postSchema, allTypes);
+// Returns: [blockSchema, imageSchema, codeSchema]
+```
+
+#### `filterToPath(type, path, schema)`
+
+Returns a schema type narrowed to a specific field path — the same subtree extraction that `fullSchema` uses internally.
+
+```ts
+import { filterToPath } from "@sanity/agent-schema";
+
+const filtered = filterToPath(postType, "content[].codeBlock", allTypes);
+```
+
+#### `toSchemaPath(path)`
+
+Converts a document path to a schema path by stripping array indices and key selectors.
+
+```ts
+import { toSchemaPath } from "@sanity/agent-schema";
+
+toSchemaPath('content[_key=="abc"].children[0].text');
+// "content.children.text"
+```
+
+#### Type helpers
+
+```ts
+import {
+  isPrimitiveType,
+  isBuiltInType,
+  isGenericObject,
+} from "@sanity/agent-schema";
+
+isPrimitiveType("string"); // true
+isPrimitiveType("block", { includeBlockTypes: true }); // true
+isBuiltInType("image"); // true
+isGenericObject(node); // true for object-like nodes without fields array
+```
+
+#### Constants
+
+```ts
+import {
+  BUILT_IN_TYPE_FIELDS,
+  ARRAY_ITEM_SYSTEM_FIELDS,
+} from "@sanity/agent-schema";
+
+BUILT_IN_TYPE_FIELDS.slug.current; // { name: "current", type: "string" }
+ARRAY_ITEM_SYSTEM_FIELDS._key; // { name: "_key", type: "string" }
+```
+
+## Types
+
+| Type                        | Description                                                     |
+| --------------------------- | --------------------------------------------------------------- |
+| `ManifestSchemaType`        | A parsed schema type (document, object, array, etc.)            |
+| `ManifestField`             | A field definition (ManifestSchemaType with optional fieldset)  |
+| `DatasetStats`              | `{ documentCount?, referenceCount? }`                           |
+| `CompressedSchemaOptions`   | Options for `compressedSchema()` (filter, datasetStats, fields) |
+| `SchemaFilter`              | `{ read?, write? }` GROQ filter or `string[]` of type names     |
+| `FullSchemaOptions`         | Options for `fullSchema()`                                      |
+| `SchemaFieldDisplayOptions` | Options for field display in `compressedSchema`                 |
+| `SchemaCache`               | Cache adapter for `fetchSchemaByDescriptorId`                   |
+
+## Architecture
+
+```
+fetchSchemaByDescriptorId()         fetchDatasetStats()
+         │                                   │
+         ▼                                   │
+  ManifestSchemaType[]                       │
+         │                                   │
+         ├──► compressedSchema()               ──► text summary of all types
+         ├──► fullSchema()                     ──► JSON subtree of one type (all fields expanded)
+         ├──► resolveFieldSchema()              ──► single field definition at a path
+         ├──► resolveFieldSchemaAllUnions()      ──► same, all union branches
+         └──► processSchema()                  ──► categorize types, expand fields, compute refs
+```

package/dist/index.d.ts

@@ -0,0 +1,356 @@
+import { SanityClient } from "@sanity/client";
+import { z } from "zod";
+type ManifestSerializable = string | number | boolean | {
+  [k: string]: ManifestSerializable;
+} | ManifestSerializable[];
+type ManifestSchemaType = {
+  type: string;
+  name: string;
+  title?: string;
+  description?: string;
+  deprecated?: {
+    reason: string;
+  };
+  readOnly?: boolean | 'conditional';
+  hidden?: boolean | 'conditional';
+  validation?: ManifestValidationGroup[];
+  fields?: ManifestField[];
+  to?: ManifestReferenceMember[];
+  of?: ManifestArrayMember[];
+  preview?: {
+    select: Record<string, string>;
+  };
+  fieldsets?: ManifestFieldset[];
+  options?: Record<string, ManifestSerializable>;
+  marks?: {
+    annotations?: ManifestArrayMember[];
+    decorators?: ManifestTitledValue[];
+  };
+  lists?: ManifestTitledValue[];
+  styles?: ManifestTitledValue[];
+  [index: string]: unknown;
+};
+type ManifestFieldset = {
+  name: string;
+  title?: string;
+  [index: string]: ManifestSerializable | undefined;
+};
+type ManifestTitledValue = {
+  value: string;
+  title?: string;
+};
+type ManifestField = ManifestSchemaType & {
+  fieldset?: string;
+};
+type ManifestArrayMember = Omit<ManifestSchemaType, 'name'> & {
+  name?: string;
+};
+type ManifestReferenceMember = Omit<ManifestSchemaType, 'name'> & {
+  name?: string;
+};
+type ManifestValidationGroup = {
+  rules: ManifestValidationRule[];
+  message?: string;
+  level?: 'error' | 'warning' | 'info';
+};
+type ManifestValidationRule = {
+  flag: 'presence' | string;
+  constraint?: 'required' | ManifestSerializable;
+  [index: string]: ManifestSerializable | undefined;
+};
+type HoistedEntry = {
+  name: string;
+  typeDef: TypeDef;
+  groups?: unknown;
+  fieldset?: unknown;
+};
+type HoistedMarker = {
+  __type: 'hoisted';
+  key: string;
+};
+type InlineOrHoisted = {
+  name: string;
+  typeDef: TypeDef;
+} | HoistedMarker;
+type LexiconResponse = {
+  types: Record<string, TypeDef>;
+  hoisted: Record<string, HoistedEntry>;
+  registries?: string[];
+};
+type TypeDef = {
+  extends: string;
+  fields?: InlineOrHoisted[];
+  to?: Array<{
+    name: string;
+  }>;
+  of?: InlineOrHoisted[];
+  fieldsets?: string[];
+  validation?: unknown;
+  [key: string]: unknown;
+};
+declare const DatasetStatsSchema: z.ZodObject<{
+  documentCount: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+  referenceCount: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    incoming: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"unknown">]>>;
+    outgoing: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodNumber, z.ZodLiteral<"unknown">]>>;
+  }, "strip", z.ZodTypeAny, {
+    incoming: Record<string, number | "unknown">;
+    outgoing: Record<string, number | "unknown">;
+  }, {
+    incoming: Record<string, number | "unknown">;
+    outgoing: Record<string, number | "unknown">;
+  }>>>;
+}, "strip", z.ZodTypeAny, {
+  documentCount?: Record<string, number> | undefined;
+  referenceCount?: Record<string, {
+    incoming: Record<string, number | "unknown">;
+    outgoing: Record<string, number | "unknown">;
+  }> | undefined;
+}, {
+  documentCount?: Record<string, number> | undefined;
+  referenceCount?: Record<string, {
+    incoming: Record<string, number | "unknown">;
+    outgoing: Record<string, number | "unknown">;
+  }> | undefined;
+}>;
+type DatasetStats = z.infer<typeof DatasetStatsSchema>;
+type ReferenceInfo = {
+  type: string;
+  path: string;
+};
+type ProcessedDocumentType = {
+  name: string;
+  title?: string;
+  description?: string;
+  deprecated?: {
+    reason: string;
+  };
+  titleField: string;
+  fields: ManifestField[];
+  outgoingReferences: string[];
+  incomingReferences: string[];
+  outgoingReferencePaths?: ReferenceInfo[];
+  incomingReferencePaths?: ReferenceInfo[];
+};
+type SchemaTypes = {
+  documentTypes: Map<string, ProcessedDocumentType>;
+  objectTypes: Map<string, ManifestSchemaType>;
+};
+/**
+ * Filter document types by GROQ expressions or an explicit list.
+ * - `{ read?, write? }` — GROQ boolean expressions (requires groq-js peer dep).
+ *   Types matching either expression are included (union).
+ * - `string[]` — explicit list of document type names to include.
+ * - `undefined` / empty — include all document types.
+ */
+type SchemaFilter = {
+  read?: string;
+  write?: string;
+} | string[];
+type SchemaFieldDisplayOptions = {
+  showAll?: boolean;
+  maxCount?: number;
+  includeDescription?: boolean;
+  includeHidden?: boolean;
+  includeDeprecated?: boolean;
+  maxEnumValues?: number;
+  maxDescriptionLength?: number;
+};
+type CompressedSchemaOptions = {
+  datasetStats?: DatasetStats;
+  filter?: SchemaFilter;
+  fields?: SchemaFieldDisplayOptions;
+};
+type SchemaProcessorOptions = {
+  filter?: SchemaFilter;
+  fields?: SchemaFieldDisplayOptions;
+};
+type DatasetStatsResult = {
+  status: 'ready';
+  stats: DatasetStats;
+} | {
+  status: 'processing';
+};
+type FetchDatasetStatsOptions = {
+  organizationId: string;
+  projectId: string;
+  dataset: string;
+};
+/**
+ * Fetches dataset stats (document counts, reference counts) from the agent API.
+ *
+ * Returns `{ status: 'processing' }` if stats are still being computed (HTTP 202).
+ * The caller should retry after a short delay.
+ *
+ * The `client` should be configured to point at the agent API host
+ * (e.g. `api.sanity.io`) with `useProjectHostname: false`.
+ */
+declare function fetchDatasetStats(client: SanityClient, options: FetchDatasetStatsOptions): Promise<DatasetStatsResult>;
+/**
+ * Cache adapter for raw Lexicon API responses.
+ * Wire this to any backing store (Redis, in-memory Map, etc.).
+ */
+type SchemaCache = {
+  get: (descriptorId: string) => Promise<LexiconResponse | null | undefined>;
+  set: (descriptorId: string, response: LexiconResponse) => Promise<void>;
+};
+type FetchSchemaOptions = {
+  /**
+   * Enable caching of raw Lexicon responses.
+   * - `true` uses a built-in in-memory cache with a 5-minute TTL
+   * - A `SchemaCache` adapter delegates to any external store (Redis, etc.)
+   */
+  cache?: boolean | SchemaCache; /** Cache TTL in milliseconds (default 5 min). Only applies to the built-in memory cache. */
+  ttlMs?: number;
+};
+/**
+ * Fetches and parses a schema from the Lexicon descriptor API.
+ *
+ * Takes a configured `@sanity/client` instance (which handles auth, host, timeouts)
+ * and a descriptor ID. Returns the fully parsed ManifestSchemaType array.
+ *
+ * Pass `{ cache: true }` to enable in-memory caching (5 min TTL),
+ * or provide a custom `SchemaCache` adapter for external stores.
+ */
+declare function fetchSchemaByDescriptorId(client: SanityClient, descriptorId: string, options?: FetchSchemaOptions): Promise<ManifestSchemaType[]>;
+/**
+ * Processes a ManifestSchemaType[] into categorized document/object types
+ * with expanded fields, computed references, and identified title fields.
+ */
+declare function processSchema(schema: ManifestSchemaType[], options?: SchemaProcessorOptions): SchemaTypes;
+/**
+ * Built-in Sanity type fields that exist implicitly (not in schema).
+ * Maps type name to field definitions.
+ */
+declare const BUILT_IN_TYPE_FIELDS: Record<string, Record<string, ManifestSchemaType>>;
+/**
+ * Default annotation type for Portable Text blocks.
+ * Sanity implicitly includes "link" when no marks.annotations are declared.
+ */
+declare const DEFAULT_LINK_ANNOTATION: ManifestSchemaType;
+/**
+ * System fields that exist on all array items.
+ */
+declare const ARRAY_ITEM_SYSTEM_FIELDS: Record<string, ManifestSchemaType>;
+/**
+ * Filter a schema type to a specific field path.
+ * Supports complex path navigation including:
+ * - Dot notation: "author.person"
+ * - Array notation: "content[]"
+ * - Array item navigation: "content[].image"
+ * - of[N] indexed navigation: "of[0]", "content.of[1]"
+ * - Property navigation: "of[0].marks", "of[0].marks.annotations"
+ *
+ * @param type - The schema type to filter
+ * @param path - The path to filter to
+ * @param schema - Full schema array to resolve type references
+ * @returns A modified type containing only the specified field path, or a not-found marker
+ */
+declare function filterToPath(type: ManifestSchemaType, path: string, schema: ManifestSchemaType[]): ManifestSchemaType;
+/**
+ * Resolves a document path to field schemas, returning ALL possible schemas for union types.
+ * This is important for arrays with multiple `of` types where a field might exist
+ * in some but not all union types.
+ */
+declare function resolveFieldSchemaAllUnions(path: string, typeSchema: ManifestSchemaType, schema: ManifestSchemaType[]): ManifestSchemaType[];
+/**
+ * Resolves a document path to the field schema at that location.
+ * Handles nested paths like "author.name" and array paths like "tags[0]".
+ *
+ * Returns the field schema at the path, NOT navigating into arrays.
+ * For "tags" (an array field), returns the array field schema (with 'of').
+ * For "tags[0].foo", returns the "foo" field from the array item schema.
+ */
+declare function resolveFieldSchema(path: string, typeSchema: ManifestSchemaType, schema: ManifestSchemaType[]): ManifestSchemaType | null;
+/**
+ * Convert a document path string to a schema path string.
+ * Strips array indices, _key selectors, and internal markers.
+ *
+ * Examples:
+ * - `"content[_key==\"abc\"].children[0].text"` → `"content.children.text"`
+ * - `"tags[0]"` → `"tags"`
+ * - `"seo.image.asset"` → `"seo.image.asset"`
+ * - `"items[append:3]"` → `"items"`
+ *
+ * This is a self-contained implementation that avoids depending on
+ * `@sanity/types` for path segment parsing.
+ */
+declare function toSchemaPath(path: string): string;
+/**
+ * Check if a type name represents a primitive type.
+ *
+ * When `includeBlockTypes` is true, 'block' and 'reference' are also
+ * considered primitive (useful for navigator/large-node detection where
+ * you don't want to drill into these).
+ */
+declare function isPrimitiveType(typeName: string | undefined, options?: {
+  includeBlockTypes?: boolean;
+}): boolean;
+/**
+ * Check if a type is a built-in Sanity type (superset of primitives).
+ * Includes complex built-in types like array, object, image, file, slug, etc.
+ */
+declare function isBuiltInType(type: string): boolean;
+/**
+ * Check if a node is a generic object-like node.
+ * Generic objects are objects that don't have a `fields` array and
+ * aren't array types with `of`. These include block types and other
+ * object-shaped schemas with properties like marks, lists, styles, etc.
+ */
+declare function isGenericObject(node: unknown): boolean;
+type FullSchemaOptions = {
+  /** The document type name to return (e.g. "post"). */type: string; /** Optional field path to scope the result (e.g. "content" or "content[].codeBlock"). */
+  path?: string; /** Size threshold in bytes before returning a navigator instead of the full JSON (default 200KB). */
+  sizeThreshold?: number;
+};
+type LargeNodeNavigator = {
+  _rawLargeNode: true;
+  name: string;
+  type: string;
+  children: Array<{
+    type: string;
+    path: string;
+  }>;
+  hint: string;
+};
+/**
+ * Returns the complete JSON structure for a specific document type, optionally
+ * scoped to a field path. Internal/system types are filtered out.
+ *
+ * When the JSON output exceeds `sizeThreshold`, a navigator object is returned
+ * instead — listing child paths the caller can drill into.
+ *
+ * This is the counterpart to `compressedSchema`:
+ * - `compressedSchema` → lossy text summary for LLM context windows
+ * - `fullSchema` → complete JSON for schema explorer tools and mutation agents
+ */
+declare function fullSchema(schema: ManifestSchemaType[], options: FullSchemaOptions): Record<string, unknown> | LargeNodeNavigator;
+declare const SCHEMA_CONSTANTS: {
+  readonly SKIP_PATTERNS: RegExp;
+  readonly TITLE_FIELD_CANDIDATES: readonly ["title", "name", "heading", "label"];
+  readonly DEFAULT_OPTIONS: {
+    readonly trackPaths: boolean;
+    readonly maxExpansionDepth: number;
+  };
+  readonly DEFAULTS: {
+    readonly titleField: "title";
+    readonly fallbackTitleField: "_id";
+    readonly maxFieldsInSummary: number;
+    readonly maxEnumValues: number;
+    readonly maxDescriptionLength: number;
+    readonly maxDocDescriptionLength: number;
+  };
+};
+declare function shouldSkipType(typeName: string): boolean;
+/**
+ * Generates a compressed text representation of a schema for agent consumption.
+ *
+ * Takes parsed schema types and returns compact text summarizing document types,
+ * fields, references, and optionally document/reference counts.
+ *
+ * The `filter` option accepts either a GROQ filter `{ read?, write? }` or
+ * a pre-resolved `string[]` of document type names.
+ */
+declare function compressedSchema(types: ManifestSchemaType[], options?: CompressedSchemaOptions): Promise<string>;
+export { ARRAY_ITEM_SYSTEM_FIELDS, BUILT_IN_TYPE_FIELDS, type CompressedSchemaOptions, DEFAULT_LINK_ANNOTATION, type DatasetStats, DatasetStatsSchema, type FetchSchemaOptions, type FullSchemaOptions, type ManifestField, type ManifestSchemaType, type ProcessedDocumentType, SCHEMA_CONSTANTS, type SchemaCache, type SchemaFieldDisplayOptions, type SchemaFilter, type SchemaTypes, compressedSchema, fetchDatasetStats, fetchSchemaByDescriptorId, filterToPath, fullSchema, isBuiltInType, isGenericObject, isPrimitiveType, resolveFieldSchema as navigateToFieldSchema, resolveFieldSchema, resolveFieldSchemaAllUnions as navigateToFieldSchemaAllUnions, resolveFieldSchemaAllUnions, processSchema, shouldSkipType, toSchemaPath };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/fetchDatasetStats.ts","../src/fetchSchemaByDescriptorId.ts","../src/processSchema.ts","../src/navigate/constants.ts","../src/navigate/filterToPath.ts","../src/navigate/navigateAllUnions.ts","../src/navigate/navigateToField.ts","../src/navigate/path.ts","../src/navigate/types.ts","../src/fullSchema.ts","../src/constants.ts","../src/utils.ts","../src/index.ts"],"mappings":"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"}