@skmtc/core 0.0.984 → 0.16.1

package/esm/gql/_helpers/unwrapType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unwrapType.d.ts","sourceRoot":"","sources":["../../../src/gql/_helpers/unwrapType.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,gBAAgB,EAGtB,MAAM,SAAS,CAAA;AAEhB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,qEAAqE;IACrE,KAAK,EAAE,gBAAgB,CAAA;IACvB,yDAAyD;IACzD,MAAM,EAAE,OAAO,CAAA;IACf,oDAAoD;IACpD,aAAa,EAAE,OAAO,CAAA;IACtB,gFAAgF;IAChF,YAAY,EAAE,OAAO,CAAA;IACrB,yDAAyD;IACzD,UAAU,EAAE,OAAO,CAAA;CACpB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,WAAW,KAAG,aA2C9C,CAAA"}

package/esm/gql/_helpers/unwrapType.js

@@ -0,0 +1,47 @@
+import { isNonNullType, isListType } from 'graphql';
+/**
+ * Strips list and non-null wrappers from a GraphQL type, returning the
+ * innermost named type and a structural description of its modifiers.
+ *
+ * GraphQL wrapping types are always shaped `(NonNull? List? NonNull? Named)`,
+ * peeled outermost first. This walks the chain and records the bookkeeping.
+ */
+export const unwrapType = (type) => {
+    let outerNullable = true;
+    let isList = false;
+    let itemNullable = true;
+    let nestedList = false;
+    let current = type;
+    // Outer non-null
+    if (isNonNullType(current)) {
+        outerNullable = false;
+        current = current.ofType;
+    }
+    // List
+    if (isListType(current)) {
+        isList = true;
+        current = current.ofType;
+        // Item non-null
+        if (isNonNullType(current)) {
+            itemNullable = false;
+            current = current.ofType;
+        }
+        // Detect nested lists
+        if (isListType(current) || (isNonNullType(current) && isListType(current.ofType))) {
+            nestedList = true;
+            // Walk to the eventual named type
+            let walker = current;
+            while (isListType(walker) || isNonNullType(walker)) {
+                walker = walker.ofType;
+            }
+            current = walker;
+        }
+    }
+    return {
+        named: current,
+        isList,
+        outerNullable,
+        itemNullable,
+        nestedList
+    };
+};

package/esm/gql/argument/GqlArgument.d.ts

@@ -0,0 +1,55 @@
+import type { OasSchema } from '../../oas/schema/Schema.js';
+import type { OasRef } from '../../oas/ref/Ref.js';
+import { OasBase } from '../../types/OasBase.js';
+import type { ParseContextType } from '../../context/parseTypes.js';
+/**
+ * Fields used to construct a {@link GqlArgument}.
+ */
+export type GqlArgumentFields = {
+    name: string;
+    schema: OasSchema | OasRef<'schema'>;
+    required: boolean;
+    /**
+     * The original GraphQL type string for this argument (e.g. `'ID!'`,
+     * `'CreatePostInput!'`, `'[String!]'`). Captured at parse time so
+     * generators that need to reconstruct an SDL fragment — like
+     * `gen-graphql-typed-document-node` building a `gql\`...\`` template
+     * — don't have to reverse-engineer it from the OAS form.
+     *
+     * Optional at construction so test fixtures don't have to fabricate
+     * one; falls back to `''` when omitted.
+     */
+    gqlType?: string;
+    defaultValue?: unknown;
+    description?: string;
+    deprecated?: boolean;
+    deprecationReason?: string;
+};
+/**
+ * A single argument on a GraphQL field.
+ *
+ * Intentionally slimmer than `OasParameter`: GraphQL field arguments are
+ * just `(name, type, default, description)` plus a required flag. None of
+ * the OpenAPI HTTP encoding state (`location`, `style`, `explode`,
+ * `allowReserved`, content-by-mediaType) applies, so we keep this class
+ * focused.
+ *
+ * The `required` flag corresponds directly to the GraphQL non-null
+ * indicator on the argument's type. A `defaultValue` makes an otherwise
+ * required argument effectively optional from the caller's perspective —
+ * but we surface both fields as the schema declared them and let
+ * downstream generators decide what to do with the combination.
+ */
+export declare class GqlArgument extends OasBase {
+    readonly oasType: "gqlArgument";
+    readonly name: string;
+    readonly schema: OasSchema | OasRef<'schema'>;
+    readonly required: boolean;
+    readonly gqlType: string;
+    readonly defaultValue: unknown;
+    readonly description: string | undefined;
+    readonly deprecated: boolean;
+    readonly deprecationReason: string | undefined;
+    constructor(fields: GqlArgumentFields, context?: ParseContextType);
+}
+//# sourceMappingURL=GqlArgument.d.ts.map

package/esm/gql/argument/GqlArgument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GqlArgument.d.ts","sourceRoot":"","sources":["../../../src/gql/argument/GqlArgument.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAEnE;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAA;IACpC,QAAQ,EAAE,OAAO,CAAA;IACjB;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,WAAY,SAAQ,OAAO;IACtC,QAAQ,CAAC,OAAO,EAAG,aAAa,CAAS;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAA;IAC7C,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IACxC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,GAAG,SAAS,CAAA;gBAElC,MAAM,EAAE,iBAAiB,EAAE,OAAO,CAAC,EAAE,gBAAgB;CAWlE"}

package/esm/gql/argument/GqlArgument.js

@@ -0,0 +1,83 @@
+import { OasBase } from '../../types/OasBase.js';
+/**
+ * A single argument on a GraphQL field.
+ *
+ * Intentionally slimmer than `OasParameter`: GraphQL field arguments are
+ * just `(name, type, default, description)` plus a required flag. None of
+ * the OpenAPI HTTP encoding state (`location`, `style`, `explode`,
+ * `allowReserved`, content-by-mediaType) applies, so we keep this class
+ * focused.
+ *
+ * The `required` flag corresponds directly to the GraphQL non-null
+ * indicator on the argument's type. A `defaultValue` makes an otherwise
+ * required argument effectively optional from the caller's perspective —
+ * but we surface both fields as the schema declared them and let
+ * downstream generators decide what to do with the combination.
+ */
+export class GqlArgument extends OasBase {
+    constructor(fields, context) {
+        super(context);
+        Object.defineProperty(this, "oasType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'gqlArgument'
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "required", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "gqlType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "defaultValue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "deprecated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "deprecationReason", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = fields.name;
+        this.schema = fields.schema;
+        this.required = fields.required;
+        this.gqlType = fields.gqlType ?? '';
+        this.defaultValue = fields.defaultValue;
+        this.description = fields.description;
+        this.deprecated = fields.deprecated ?? false;
+        this.deprecationReason = fields.deprecationReason;
+    }
+}

package/esm/gql/document/GqlDocument.d.ts

@@ -0,0 +1,93 @@
+import type { GqlRegistry } from '../registry/GqlRegistry.js';
+import type { GqlOperation } from '../operation/GqlOperation.js';
+import type { GqlRootTypes } from '../rootType/GqlRootTypes.js';
+import type { OasInfo } from '../../oas/info/Info.js';
+import type { StackTrail } from '../../context/StackTrail.js';
+/**
+ * Fields used to construct (or populate) a {@link GqlDocument}.
+ */
+export type GqlDocumentFields = {
+    /** Type registry containing all named GraphQL types as OAS schema objects. */
+    registry: GqlRegistry;
+    /** Root-level fields exposed as Query, Mutation, or Subscription. */
+    operations: GqlOperation[];
+    /** Names of the root operation types (Query, Mutation, Subscription). */
+    rootTypes: GqlRootTypes;
+    /** Schema-level metadata (title, version, description). Optional. */
+    info?: OasInfo;
+};
+/**
+ * Top-level container for a parsed GraphQL schema.
+ *
+ * `GqlDocument` is the GraphQL counterpart to {@link OasDocument}. It owns
+ * a {@link GqlRegistry} (the named-type registry, parallel to
+ * `OasComponents.schemas`), the list of root-level fields exposed as
+ * {@link GqlOperation} entries, and pointers to the schema's root operation
+ * types.
+ *
+ * Both documents are wrapped by {@link SkmtcParsedDocument} so the pipeline
+ * can carry either through the same generate phase.
+ *
+ * ## Empty-at-construction
+ *
+ * Like {@link OasDocument}, `GqlDocument` is intentionally constructable
+ * without fields — the parser creates an empty instance up front, hands
+ * out `OasRef`s that resolve through it, then populates
+ * `gqlDocument.fields = { ... }` at the end of parsing. See the
+ * "forward-declared refs" section on {@link OasDocument} for the full
+ * rationale; the short version is that refs need a stable resolution
+ * target *before* every target has been parsed, so the document and the
+ * refs that point at it must both be constructable up front and tied to
+ * the same instance.
+ */
+export declare class GqlDocument {
+    #private;
+    readonly oasType: "gqlDocument";
+    /**
+     * Creates a new GqlDocument instance.
+     *
+     * The document is typically created without fields and populated later
+     * during parsing. See the class-level docstring for why.
+     */
+    constructor(fields?: GqlDocumentFields);
+    /**
+     * Populates the document's fields after parsing.
+     */
+    set fields(fields: GqlDocumentFields);
+    /** Named-type registry. */
+    get registry(): GqlRegistry;
+    /** Root-field operations. */
+    get operations(): GqlOperation[];
+    /** Pointers to the schema's root operation types. */
+    get rootTypes(): GqlRootTypes;
+    /** Optional schema-level metadata. */
+    get info(): OasInfo | undefined;
+    /**
+     * Removes the consumer addressed by `stackTrail`. Parallel to
+     * {@link OasDocument.removeItem}; used by
+     * `ParseContext.removeErroredItems` to prune references whose target
+     * type failed to parse.
+     *
+     * Two consumer shapes are handled today:
+     *
+     * - `[<RootType>, <fieldName>, …]` where `<RootType>` matches one of
+     *   `rootTypes.{query,mutation,subscription}` → the matching
+     *   {@link GqlOperation} is removed from `operations`.
+     * - `[<ParentType>, <fieldName>, …]` where `<ParentType>` is a
+     *   registered object/input/interface → the named field is deleted
+     *   from the parent's properties (and from its `required` list if
+     *   present). The deeper segments of the stack trail are ignored,
+     *   matching `OasDocument.removeItem`'s coarse-grained behavior.
+     * - `[<UnionType>, members, <index>]` where `<UnionType>` is a
+     *   registered union or interface union → the indexed member is
+     *   removed.
+     *
+     * Returns the removed entity (`GqlOperation`, the removed property
+     * schema, or the removed union member) when removal happened, or
+     * `undefined` if no matching consumer was found. The return value
+     * acts as the truthy signal `removeErroredItems` uses to decide
+     * whether to emit an `INVALID_DEPENDENCY_REF` issue.
+     */
+    removeItem(stackTrail: StackTrail): unknown;
+}
+//# sourceMappingURL=GqlDocument.d.ts.map

package/esm/gql/document/GqlDocument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GqlDocument.d.ts","sourceRoot":"","sources":["../../../src/gql/document/GqlDocument.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAC/D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAI7D;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,8EAA8E;IAC9E,QAAQ,EAAE,WAAW,CAAA;IACrB,qEAAqE;IACrE,UAAU,EAAE,YAAY,EAAE,CAAA;IAC1B,yEAAyE;IACzE,SAAS,EAAE,YAAY,CAAA;IACvB,qEAAqE;IACrE,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,WAAW;;IACtB,QAAQ,CAAC,OAAO,EAAG,aAAa,CAAS;IAKzC;;;;;OAKG;gBACS,MAAM,CAAC,EAAE,iBAAiB;IAItC;;OAEG;IACH,IAAI,MAAM,CAAC,MAAM,EAAE,iBAAiB,EAEnC;IAED,2BAA2B;IAC3B,IAAI,QAAQ,IAAI,WAAW,CAK1B;IAED,6BAA6B;IAC7B,IAAI,UAAU,IAAI,YAAY,EAAE,CAK/B;IAED,qDAAqD;IACrD,IAAI,SAAS,IAAI,YAAY,CAK5B;IAED,sCAAsC;IACtC,IAAI,IAAI,IAAI,OAAO,GAAG,SAAS,CAK9B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,UAAU,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO;CAqD5C"}

package/esm/gql/document/GqlDocument.js

@@ -0,0 +1,170 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _GqlDocument_fields;
+import { OasObject } from '../../oas/object/Object.js';
+import { OasUnion } from '../../oas/union/Union.js';
+/**
+ * Top-level container for a parsed GraphQL schema.
+ *
+ * `GqlDocument` is the GraphQL counterpart to {@link OasDocument}. It owns
+ * a {@link GqlRegistry} (the named-type registry, parallel to
+ * `OasComponents.schemas`), the list of root-level fields exposed as
+ * {@link GqlOperation} entries, and pointers to the schema's root operation
+ * types.
+ *
+ * Both documents are wrapped by {@link SkmtcParsedDocument} so the pipeline
+ * can carry either through the same generate phase.
+ *
+ * ## Empty-at-construction
+ *
+ * Like {@link OasDocument}, `GqlDocument` is intentionally constructable
+ * without fields — the parser creates an empty instance up front, hands
+ * out `OasRef`s that resolve through it, then populates
+ * `gqlDocument.fields = { ... }` at the end of parsing. See the
+ * "forward-declared refs" section on {@link OasDocument} for the full
+ * rationale; the short version is that refs need a stable resolution
+ * target *before* every target has been parsed, so the document and the
+ * refs that point at it must both be constructable up front and tied to
+ * the same instance.
+ */
+export class GqlDocument {
+    /**
+     * Creates a new GqlDocument instance.
+     *
+     * The document is typically created without fields and populated later
+     * during parsing. See the class-level docstring for why.
+     */
+    constructor(fields) {
+        Object.defineProperty(this, "oasType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'gqlDocument'
+        });
+        /** @internal Private fields storage — set after parsing. */
+        _GqlDocument_fields.set(this, void 0);
+        __classPrivateFieldSet(this, _GqlDocument_fields, fields, "f");
+    }
+    /**
+     * Populates the document's fields after parsing.
+     */
+    set fields(fields) {
+        __classPrivateFieldSet(this, _GqlDocument_fields, fields, "f");
+    }
+    /** Named-type registry. */
+    get registry() {
+        if (!__classPrivateFieldGet(this, _GqlDocument_fields, "f")) {
+            throw new Error(`Accessing 'registry' before fields are set`);
+        }
+        return __classPrivateFieldGet(this, _GqlDocument_fields, "f").registry;
+    }
+    /** Root-field operations. */
+    get operations() {
+        if (!__classPrivateFieldGet(this, _GqlDocument_fields, "f")) {
+            throw new Error(`Accessing 'operations' before fields are set`);
+        }
+        return __classPrivateFieldGet(this, _GqlDocument_fields, "f").operations;
+    }
+    /** Pointers to the schema's root operation types. */
+    get rootTypes() {
+        if (!__classPrivateFieldGet(this, _GqlDocument_fields, "f")) {
+            throw new Error(`Accessing 'rootTypes' before fields are set`);
+        }
+        return __classPrivateFieldGet(this, _GqlDocument_fields, "f").rootTypes;
+    }
+    /** Optional schema-level metadata. */
+    get info() {
+        if (!__classPrivateFieldGet(this, _GqlDocument_fields, "f")) {
+            throw new Error(`Accessing 'info' before fields are set`);
+        }
+        return __classPrivateFieldGet(this, _GqlDocument_fields, "f").info;
+    }
+    /**
+     * Removes the consumer addressed by `stackTrail`. Parallel to
+     * {@link OasDocument.removeItem}; used by
+     * `ParseContext.removeErroredItems` to prune references whose target
+     * type failed to parse.
+     *
+     * Two consumer shapes are handled today:
+     *
+     * - `[<RootType>, <fieldName>, …]` where `<RootType>` matches one of
+     *   `rootTypes.{query,mutation,subscription}` → the matching
+     *   {@link GqlOperation} is removed from `operations`.
+     * - `[<ParentType>, <fieldName>, …]` where `<ParentType>` is a
+     *   registered object/input/interface → the named field is deleted
+     *   from the parent's properties (and from its `required` list if
+     *   present). The deeper segments of the stack trail are ignored,
+     *   matching `OasDocument.removeItem`'s coarse-grained behavior.
+     * - `[<UnionType>, members, <index>]` where `<UnionType>` is a
+     *   registered union or interface union → the indexed member is
+     *   removed.
+     *
+     * Returns the removed entity (`GqlOperation`, the removed property
+     * schema, or the removed union member) when removal happened, or
+     * `undefined` if no matching consumer was found. The return value
+     * acts as the truthy signal `removeErroredItems` uses to decide
+     * whether to emit an `INVALID_DEPENDENCY_REF` issue.
+     */
+    removeItem(stackTrail) {
+        if (!__classPrivateFieldGet(this, _GqlDocument_fields, "f")) {
+            // Mirrors OasDocument's behavior: prune calls before fields are
+            // set are a no-op, matching the "empty-at-construction" contract.
+            return undefined;
+        }
+        const path = stackTrail.stackTrail;
+        if (path.length < 2)
+            return undefined;
+        const [first, second, third] = path;
+        if (typeof first !== 'string' || typeof second !== 'string')
+            return undefined;
+        const { registry, operations, rootTypes } = __classPrivateFieldGet(this, _GqlDocument_fields, "f");
+        // Case 1: root-field operation removal.
+        const isRootType = first === rootTypes.query || first === rootTypes.mutation || first === rootTypes.subscription;
+        if (isRootType) {
+            const index = operations.findIndex(op => op.fieldName === second);
+            if (index === -1)
+                return undefined;
+            const [removed] = operations.splice(index, 1);
+            return removed;
+        }
+        // Case 2: union or interface-union member removal at `[Type, members, index]`.
+        if (second === 'members' && typeof third === 'string') {
+            const parent = registry.schemas[first];
+            if (parent instanceof OasUnion) {
+                const idx = Number.parseInt(third, 10);
+                if (!Number.isFinite(idx) || idx < 0 || idx >= parent.members.length)
+                    return undefined;
+                const [removed] = parent.members.splice(idx, 1);
+                return removed;
+            }
+            return undefined;
+        }
+        // Case 3: field-of-object removal at `[ParentType, fieldName]` (deeper
+        // segments ignored).
+        const parent = registry.schemas[first];
+        if (parent instanceof OasObject) {
+            const properties = parent.properties;
+            if (!properties || !(second in properties))
+                return undefined;
+            const removed = properties[second];
+            delete properties[second];
+            if (parent.required) {
+                const i = parent.required.indexOf(second);
+                if (i !== -1)
+                    parent.required.splice(i, 1);
+            }
+            return removed;
+        }
+        return undefined;
+    }
+}
+_GqlDocument_fields = new WeakMap();

package/esm/gql/document/parseGqlDocument.d.ts

@@ -0,0 +1,33 @@
+import type { GqlDocumentFields } from './GqlDocument.js';
+import type { ParseContext, GqlParseOptions } from '../../context/ParseContext.js';
+import type { StackTrail } from '../../context/StackTrail.js';
+export type ParseGqlDocumentArgs = {
+    options: GqlParseOptions;
+    context: ParseContext;
+    /**
+     * Root stack trail to descend from. Each named type and root field
+     * is parsed inside `stackTrail.trace(<name>, ...)` so consumer
+     * stack trails (recorded via `context.registerRef`) line up with
+     * the addresses `removeErroredItems` uses to prune.
+     */
+    stackTrail: StackTrail;
+};
+/**
+ * Internal implementation behind `ParseContext.parse()` (GQL branch)
+ * and the convenience free function `toGqlDocument`.
+ *
+ * Returns the `GqlDocumentFields` ready to be assigned via
+ * `gqlDocument.fields = ...` onto the empty `GqlDocument` that
+ * `ParseContext` issued at construction time. This indirection exists
+ * so refs constructed during the walk hold a reference to the same
+ * `GqlDocument` instance that will eventually carry the fields — see
+ * the forward-declared-refs notes on `OasDocument` / `GqlDocument`.
+ *
+ * Reads `context.schema` and `context.registry` directly — both are
+ * populated by the `ParseContext` constructor, so this function does
+ * no setup.
+ */
+export declare const parseGqlDocument: ({ options, context, stackTrail }: ParseGqlDocumentArgs) => {
+    fields: GqlDocumentFields;
+};
+//# sourceMappingURL=parseGqlDocument.d.ts.map

package/esm/gql/document/parseGqlDocument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseGqlDocument.d.ts","sourceRoot":"","sources":["../../../src/gql/document/parseGqlDocument.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAazD,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAU7D,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,eAAe,CAAA;IACxB,OAAO,EAAE,YAAY,CAAA;IACrB;;;;;OAKG;IACH,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,GAAI,kCAI9B,oBAAoB,KAAG;IAAE,MAAM,EAAE,iBAAiB,CAAA;CA2GpD,CAAA"}