@skmtc/core 0.0.984 → 0.16.2

package/esm/gql/operation/GqlOperation.d.ts

@@ -0,0 +1,63 @@
+import type { OasSchema } from '../../oas/schema/Schema.js';
+import type { OasRef } from '../../oas/ref/Ref.js';
+import type { GqlArgument } from '../argument/GqlArgument.js';
+import { OasBase } from '../../types/OasBase.js';
+import type { ParseContextType } from '../../context/parseTypes.js';
+/**
+ * GraphQL root operation kind. Maps directly onto the schema's root type
+ * pointers (Query / Mutation / Subscription).
+ */
+export type GqlRootKind = 'query' | 'mutation' | 'subscription';
+/**
+ * Fields used to construct a {@link GqlOperation}.
+ */
+export type GqlOperationFields = {
+    rootKind: GqlRootKind;
+    fieldName: string;
+    arguments: GqlArgument[];
+    returnType: OasSchema | OasRef<'schema'>;
+    /**
+     * The original GraphQL return-type string (e.g. `'User'`,
+     * `'[Post!]!'`). Captured at parse time so generators don't have
+     * to reverse-engineer it from the OAS form when emitting SDL
+     * fragments. Optional in construction with `''` fallback so test
+     * fixtures don't have to fabricate one.
+     */
+    returnTypeString?: string;
+    description?: string;
+    deprecated?: boolean;
+    deprecationReason?: string;
+};
+/**
+ * GraphQL counterpart to `OasOperation`.
+ *
+ * Each instance represents a single root-level field exposed by the schema
+ * (e.g. `Query.user`, `Mutation.createPost`). Operation generators marked
+ * `protocol: 'gql'` receive these via the same `transform({ context, operation, acc })`
+ * shape as their HTTP siblings, but with this class instead of
+ * `OasOperation`.
+ *
+ * Field arguments are kept structured (a list of `GqlArgument`) rather
+ * than synthesized into an `OasObject` upfront — generators that want an
+ * args object can build one at emit time, while generators that just need
+ * the per-argument metadata don't pay for the synthesis.
+ */
+export declare class GqlOperation extends OasBase {
+    readonly oasType: "gqlOperation";
+    readonly rootKind: GqlRootKind;
+    readonly fieldName: string;
+    readonly arguments: GqlArgument[];
+    readonly returnType: OasSchema | OasRef<'schema'>;
+    readonly returnTypeString: string;
+    readonly description: string | undefined;
+    readonly deprecated: boolean;
+    readonly deprecationReason: string | undefined;
+    constructor(fields: GqlOperationFields, context?: ParseContextType);
+    /**
+     * Stable identifier for this operation, suitable for file naming and
+     * cache keying. Concatenates the root kind and field name with an
+     * underscore: `query_getUser`, `mutation_createPost`.
+     */
+    get identifier(): string;
+}
+//# sourceMappingURL=GqlOperation.d.ts.map

package/esm/gql/operation/GqlOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GqlOperation.d.ts","sourceRoot":"","sources":["../../../src/gql/operation/GqlOperation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAC7D,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAEnE;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,UAAU,GAAG,cAAc,CAAA;AAE/D;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,WAAW,CAAA;IACrB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,WAAW,EAAE,CAAA;IACxB,UAAU,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAA;IACxC;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,YAAa,SAAQ,OAAO;IACvC,QAAQ,CAAC,OAAO,EAAG,cAAc,CAAS;IAC1C,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAA;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,SAAS,EAAE,WAAW,EAAE,CAAA;IACjC,QAAQ,CAAC,UAAU,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAA;IACjD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,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,kBAAkB,EAAE,OAAO,CAAC,EAAE,gBAAgB;IAYlE;;;;OAIG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;CACF"}

package/esm/gql/operation/GqlOperation.js

@@ -0,0 +1,90 @@
+import { OasBase } from '../../types/OasBase.js';
+/**
+ * GraphQL counterpart to `OasOperation`.
+ *
+ * Each instance represents a single root-level field exposed by the schema
+ * (e.g. `Query.user`, `Mutation.createPost`). Operation generators marked
+ * `protocol: 'gql'` receive these via the same `transform({ context, operation, acc })`
+ * shape as their HTTP siblings, but with this class instead of
+ * `OasOperation`.
+ *
+ * Field arguments are kept structured (a list of `GqlArgument`) rather
+ * than synthesized into an `OasObject` upfront — generators that want an
+ * args object can build one at emit time, while generators that just need
+ * the per-argument metadata don't pay for the synthesis.
+ */
+export class GqlOperation extends OasBase {
+    constructor(fields, context) {
+        super(context);
+        Object.defineProperty(this, "oasType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'gqlOperation'
+        });
+        Object.defineProperty(this, "rootKind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fieldName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "arguments", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "returnType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "returnTypeString", {
+            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.rootKind = fields.rootKind;
+        this.fieldName = fields.fieldName;
+        this.arguments = fields.arguments;
+        this.returnType = fields.returnType;
+        this.returnTypeString = fields.returnTypeString ?? '';
+        this.description = fields.description;
+        this.deprecated = fields.deprecated ?? false;
+        this.deprecationReason = fields.deprecationReason;
+    }
+    /**
+     * Stable identifier for this operation, suitable for file naming and
+     * cache keying. Concatenates the root kind and field name with an
+     * underscore: `query_getUser`, `mutation_createPost`.
+     */
+    get identifier() {
+        return `${this.rootKind}_${this.fieldName}`;
+    }
+}

package/esm/gql/operation/synthesizeArgsObject.d.ts

@@ -0,0 +1,22 @@
+import type { GqlOperation } from './GqlOperation.js';
+import { OasObject } from '../../oas/object/Object.js';
+/**
+ * Builds an `OasObject` representing the arguments tuple of a GraphQL
+ * operation.
+ *
+ * Each argument becomes a property; required arguments without default
+ * values go on the parent's `required` list (OAS convention). An
+ * argument with both `required: true` and a non-undefined `defaultValue`
+ * is *not* listed as required, because the caller can omit it and the
+ * server fills in the default — surfacing it as required would be
+ * misleading at the consumer side.
+ *
+ * Returns `undefined` when the operation takes no arguments. Callers can
+ * use that to skip emitting an args type entirely.
+ *
+ * Lives in core (not in gen-graphql-operation) because it is generic
+ * enough to be reused by any GraphQL operation generator and has no
+ * generator-specific output assumptions.
+ */
+export declare const synthesizeArgsObject: (operation: GqlOperation) => OasObject | undefined;
+//# sourceMappingURL=synthesizeArgsObject.d.ts.map

package/esm/gql/operation/synthesizeArgsObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synthesizeArgsObject.d.ts","sourceRoot":"","sources":["../../../src/gql/operation/synthesizeArgsObject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAItD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,oBAAoB,GAAI,WAAW,YAAY,KAAG,SAAS,GAAG,SAoB1E,CAAA"}

package/esm/gql/operation/synthesizeArgsObject.js

@@ -0,0 +1,37 @@
+import { OasObject } from '../../oas/object/Object.js';
+/**
+ * Builds an `OasObject` representing the arguments tuple of a GraphQL
+ * operation.
+ *
+ * Each argument becomes a property; required arguments without default
+ * values go on the parent's `required` list (OAS convention). An
+ * argument with both `required: true` and a non-undefined `defaultValue`
+ * is *not* listed as required, because the caller can omit it and the
+ * server fills in the default — surfacing it as required would be
+ * misleading at the consumer side.
+ *
+ * Returns `undefined` when the operation takes no arguments. Callers can
+ * use that to skip emitting an args type entirely.
+ *
+ * Lives in core (not in gen-graphql-operation) because it is generic
+ * enough to be reused by any GraphQL operation generator and has no
+ * generator-specific output assumptions.
+ */
+export const synthesizeArgsObject = (operation) => {
+    if (operation.arguments.length === 0) {
+        return undefined;
+    }
+    const properties = {};
+    const required = [];
+    for (const arg of operation.arguments) {
+        properties[arg.name] = arg.schema;
+        if (arg.required && arg.defaultValue === undefined) {
+            required.push(arg.name);
+        }
+    }
+    return new OasObject({
+        title: `${operation.fieldName} arguments`,
+        properties,
+        required: required.length > 0 ? required : undefined
+    });
+};

package/esm/gql/operation/toRootField.d.ts

@@ -0,0 +1,26 @@
+import type { GraphQLField } from 'graphql';
+import { GqlOperation, type GqlRootKind } from './GqlOperation.js';
+import type { ParseContextType } from '../../context/parseTypes.js';
+import type { StackTrail } from '../../context/StackTrail.js';
+export type ToRootFieldArgs = {
+    rootKind: GqlRootKind;
+    field: GraphQLField<unknown, unknown>;
+    context: ParseContextType;
+    /**
+     * Stack trail for the root field. Typical shape is `[<RootType>,
+     * <fieldName>]` (e.g. `[Query, getUser]`); the function descends
+     * into `args:<argName>` and `return` traces for child parses, so
+     * `removeErroredItems` can prune individual args or the entire
+     * operation depending on which target type errored.
+     */
+    stackTrail: StackTrail;
+};
+/**
+ * Converts a single root-level GraphQL field into a {@link GqlOperation}.
+ *
+ * Used for each field on the Query / Mutation / Subscription root types.
+ * Field arguments become {@link GqlArgument} instances; the return type
+ * runs through {@link toFieldSchema} like any other field type.
+ */
+export declare const toRootField: ({ rootKind, field, context, stackTrail }: ToRootFieldArgs) => GqlOperation;
+//# sourceMappingURL=toRootField.d.ts.map

package/esm/gql/operation/toRootField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toRootField.d.ts","sourceRoot":"","sources":["../../../src/gql/operation/toRootField.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,SAAS,CAAA;AAE5D,OAAO,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAIlE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAE7D,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,WAAW,CAAA;IACrB,KAAK,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;IACrC,OAAO,EAAE,gBAAgB,CAAA;IACzB;;;;;;OAMG;IACH,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,0CAKzB,eAAe,KAAG,YAyDpB,CAAA"}

package/esm/gql/operation/toRootField.js

@@ -0,0 +1,51 @@
+import { isNonNullType } from 'graphql';
+import { GqlOperation } from './GqlOperation.js';
+import { GqlArgument } from '../argument/GqlArgument.js';
+import { toFieldSchema } from '../field/toFieldSchema.js';
+import { recordAppliedDirectives } from '../_helpers/recordAppliedDirectives.js';
+/**
+ * Converts a single root-level GraphQL field into a {@link GqlOperation}.
+ *
+ * Used for each field on the Query / Mutation / Subscription root types.
+ * Field arguments become {@link GqlArgument} instances; the return type
+ * runs through {@link toFieldSchema} like any other field type.
+ */
+export const toRootField = ({ rootKind, field, context, stackTrail }) => {
+    // Field-level directives on the root field itself (`me: User @auth`).
+    recordAppliedDirectives({ astNode: field.astNode, stackTrail, context });
+    const args = field.args.map((arg) => stackTrail.trace(`args:${arg.name}`, argStack => {
+        const schema = toFieldSchema({
+            type: arg.type,
+            context,
+            stackTrail: argStack
+        });
+        return context.withStackTrail(argStack, () => new GqlArgument({
+            name: arg.name,
+            schema,
+            required: isNonNullType(arg.type),
+            // graphql-js's `GraphQLType.toString()` produces SDL syntax
+            // (`'ID!'`, `'[String!]'`). Stash it for downstream generators
+            // that need to reconstruct an SDL fragment.
+            gqlType: arg.type.toString(),
+            defaultValue: arg.defaultValue,
+            description: arg.description ?? undefined,
+            deprecated: arg.deprecationReason !== null && arg.deprecationReason !== undefined,
+            deprecationReason: arg.deprecationReason ?? undefined
+        }, context));
+    }));
+    const returnType = stackTrail.trace('return', returnStack => toFieldSchema({
+        type: field.type,
+        context,
+        stackTrail: returnStack
+    }));
+    return context.withStackTrail(stackTrail, () => new GqlOperation({
+        rootKind,
+        fieldName: field.name,
+        arguments: args,
+        returnType,
+        returnTypeString: field.type.toString(),
+        description: field.description ?? undefined,
+        deprecated: field.deprecationReason !== null && field.deprecationReason !== undefined,
+        deprecationReason: field.deprecationReason ?? undefined
+    }, context));
+};

package/esm/gql/registry/GqlRegistry.d.ts

@@ -0,0 +1,70 @@
+import type { OasSchema } from '../../oas/schema/Schema.js';
+import { OasRef } from '../../oas/ref/Ref.js';
+import type { RefName } from '../../types/RefName.js';
+import type { ParseContextType } from '../../context/parseTypes.js';
+/**
+ * Fields used to construct a {@link GqlRegistry}.
+ */
+export type GqlRegistryFields = {
+    /**
+     * Initial set of named-type entries. The registry holds a live reference
+     * to this record — additions made via {@link GqlRegistry.add} are visible
+     * to anything that reads `registry.schemas` later.
+     */
+    schemas?: Record<RefName, OasSchema | OasRef<'schema'>>;
+};
+/**
+ * The named-type registry for a {@link GqlDocument}.
+ *
+ * `GqlRegistry` mirrors the schemas bucket of `OasComponents` — it is the
+ * registry side of the lingua franca that both protocols share. Model
+ * generators read from it via the discriminated dispatch in
+ * `GenerateContext`.
+ *
+ * Refs resolve through the parent {@link GqlDocument} via
+ * {@link SkmtcParsedDocument}'s GQL variant — no fake `OasDocument`
+ * mirror needed. `createRef` takes the document at call time so the
+ * resulting `OasRef` points at the same instance that will eventually
+ * carry the populated registry. See the forward-declared-refs notes on
+ * `OasDocument` / `GqlDocument` for why the document must exist (empty)
+ * before any ref is constructed.
+ */
+export declare class GqlRegistry {
+    readonly schemas: Record<RefName, OasSchema | OasRef<'schema'>>;
+    constructor(fields?: GqlRegistryFields);
+    /**
+     * Returns all RefNames currently registered, in insertion order.
+     *
+     * Mirrors `OasComponents.toSchemasRefNames()` so model generators can
+     * iterate the registry uniformly across protocols.
+     */
+    toSchemasRefNames(): RefName[];
+    /**
+     * Adds (or replaces) a schema entry under `refName`.
+     *
+     * The mutation is visible to any previously constructed `OasRef` that
+     * resolves through this registry, because resolution reads through the
+     * shared `schemas` record by reference.
+     */
+    add(refName: RefName, schema: OasSchema | OasRef<'schema'>): void;
+    /**
+     * Returns true if `refName` is currently registered.
+     */
+    has(refName: RefName): boolean;
+    /**
+     * Constructs an `OasRef<'schema'>` that resolves to the entry registered
+     * under `refName`. Use this to build cross-type references during
+     * GraphQL parsing instead of constructing `OasRef` directly.
+     *
+     * The ref resolves through the context's `parsedDocument` (the parent
+     * `GqlDocument` wrapped as `SkmtcParsedDocument`). The document can be
+     * empty-at-construction; the ref resolves correctly once the document's
+     * fields are populated at the end of parsing.
+     */
+    createRef(refName: RefName, context: ParseContextType): OasRef<'schema'>;
+    /**
+     * Removes a schema entry by name. Returns `true` if removed.
+     */
+    removeSchema(refName: RefName): boolean;
+}
+//# sourceMappingURL=GqlRegistry.d.ts.map

package/esm/gql/registry/GqlRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GqlRegistry.d.ts","sourceRoot":"","sources":["../../../src/gql/registry/GqlRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAEnE;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAA;CACxD,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,WAAW;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAA;gBAEnD,MAAM,GAAE,iBAAsB;IAI1C;;;;;OAKG;IACH,iBAAiB,IAAI,OAAO,EAAE;IAI9B;;;;;;OAMG;IACH,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,IAAI;IAIjE;;OAEG;IACH,GAAG,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO;IAI9B;;;;;;;;;OASG;IACH,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAAC,QAAQ,CAAC;IAOxE;;OAEG;IACH,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO;CAOxC"}

package/esm/gql/registry/GqlRegistry.js

@@ -0,0 +1,76 @@
+import { OasRef } from '../../oas/ref/Ref.js';
+/**
+ * The named-type registry for a {@link GqlDocument}.
+ *
+ * `GqlRegistry` mirrors the schemas bucket of `OasComponents` — it is the
+ * registry side of the lingua franca that both protocols share. Model
+ * generators read from it via the discriminated dispatch in
+ * `GenerateContext`.
+ *
+ * Refs resolve through the parent {@link GqlDocument} via
+ * {@link SkmtcParsedDocument}'s GQL variant — no fake `OasDocument`
+ * mirror needed. `createRef` takes the document at call time so the
+ * resulting `OasRef` points at the same instance that will eventually
+ * carry the populated registry. See the forward-declared-refs notes on
+ * `OasDocument` / `GqlDocument` for why the document must exist (empty)
+ * before any ref is constructed.
+ */
+export class GqlRegistry {
+    constructor(fields = {}) {
+        Object.defineProperty(this, "schemas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.schemas = fields.schemas ?? {};
+    }
+    /**
+     * Returns all RefNames currently registered, in insertion order.
+     *
+     * Mirrors `OasComponents.toSchemasRefNames()` so model generators can
+     * iterate the registry uniformly across protocols.
+     */
+    toSchemasRefNames() {
+        return Object.keys(this.schemas);
+    }
+    /**
+     * Adds (or replaces) a schema entry under `refName`.
+     *
+     * The mutation is visible to any previously constructed `OasRef` that
+     * resolves through this registry, because resolution reads through the
+     * shared `schemas` record by reference.
+     */
+    add(refName, schema) {
+        this.schemas[refName] = schema;
+    }
+    /**
+     * Returns true if `refName` is currently registered.
+     */
+    has(refName) {
+        return refName in this.schemas;
+    }
+    /**
+     * Constructs an `OasRef<'schema'>` that resolves to the entry registered
+     * under `refName`. Use this to build cross-type references during
+     * GraphQL parsing instead of constructing `OasRef` directly.
+     *
+     * The ref resolves through the context's `parsedDocument` (the parent
+     * `GqlDocument` wrapped as `SkmtcParsedDocument`). The document can be
+     * empty-at-construction; the ref resolves correctly once the document's
+     * fields are populated at the end of parsing.
+     */
+    createRef(refName, context) {
+        return new OasRef({ refType: 'schema', $ref: `#/components/schemas/${refName}` }, context);
+    }
+    /**
+     * Removes a schema entry by name. Returns `true` if removed.
+     */
+    removeSchema(refName) {
+        if (refName in this.schemas) {
+            delete this.schemas[refName];
+            return true;
+        }
+        return false;
+    }
+}

package/esm/gql/rootType/GqlRootTypes.d.ts

@@ -0,0 +1,15 @@
+import type { RefName } from '../../types/RefName.js';
+/**
+ * Names of the root operation types declared by a GraphQL schema.
+ *
+ * Defaults are `Query`, `Mutation`, and `Subscription` but a schema may
+ * override any of them via `schema { query: Foo, mutation: Bar }`. Each
+ * field, when set, is a {@link RefName} into the document's
+ * {@link GqlRegistry}.
+ */
+export type GqlRootTypes = {
+    query?: RefName;
+    mutation?: RefName;
+    subscription?: RefName;
+};
+//# sourceMappingURL=GqlRootTypes.d.ts.map

package/esm/gql/rootType/GqlRootTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GqlRootTypes.d.ts","sourceRoot":"","sources":["../../../src/gql/rootType/GqlRootTypes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAErD;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA"}

package/esm/gql/rootType/GqlRootTypes.js

@@ -0,0 +1 @@
+export {};

package/esm/gql/scalar/toScalarType.d.ts

@@ -0,0 +1,33 @@
+import type { GraphQLScalarType } from 'graphql';
+import type { OasSchema } from '../../oas/schema/Schema.js';
+import type { ParseContextType } from '../../context/parseTypes.js';
+import type { StackTrail } from '../../context/StackTrail.js';
+export type ToScalarTypeArgs = {
+    scalar: GraphQLScalarType;
+    nullable: boolean;
+    context: ParseContextType;
+    stackTrail: StackTrail;
+};
+/**
+ * Maps a GraphQL scalar to an `OasSchema` primitive.
+ *
+ * Built-in GraphQL scalars map to their natural OAS counterparts:
+ * - `Int`     → `OasInteger` (`format: 'int32'`)
+ * - `Float`   → `OasNumber`  (`format: 'float'`)
+ * - `String`  → `OasString`
+ * - `Boolean` → `OasBoolean`
+ * - `ID`      → `OasString` with `format: 'id'` so generators that want
+ *               to treat IDs specially can narrow on the format key.
+ *
+ * Custom scalars (everything else) become `OasString` with
+ * `format: '<scalarName>'`. Downstream generators (`gen-typescript`,
+ * `gen-zod`, etc.) consult their own `scalars` config map keyed on the
+ * format string to decide the actual emitted type.
+ *
+ * `context` and `stackTrail` are accepted (and currently unused) so the
+ * signature matches the OAS parser family; future error reporting on
+ * unknown scalars or constraint conflicts can flow through `context`
+ * without an API change.
+ */
+export declare const toScalarType: ({ scalar, nullable, context, stackTrail }: ToScalarTypeArgs) => OasSchema;
+//# sourceMappingURL=toScalarType.d.ts.map

package/esm/gql/scalar/toScalarType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toScalarType.d.ts","sourceRoot":"","sources":["../../../src/gql/scalar/toScalarType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAKhD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAE7D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,iBAAiB,CAAA;IACzB,QAAQ,EAAE,OAAO,CAAA;IACjB,OAAO,EAAE,gBAAgB,CAAA;IACzB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,YAAY,GAAI,2CAK1B,gBAAgB,KAAG,SAkBlB,CAAA"}

package/esm/gql/scalar/toScalarType.js

@@ -0,0 +1,43 @@
+import { OasString } from '../../oas/string/String.js';
+import { OasInteger } from '../../oas/integer/Integer.js';
+import { OasNumber } from '../../oas/number/Number.js';
+import { OasBoolean } from '../../oas/boolean/Boolean.js';
+/**
+ * Maps a GraphQL scalar to an `OasSchema` primitive.
+ *
+ * Built-in GraphQL scalars map to their natural OAS counterparts:
+ * - `Int`     → `OasInteger` (`format: 'int32'`)
+ * - `Float`   → `OasNumber`  (`format: 'float'`)
+ * - `String`  → `OasString`
+ * - `Boolean` → `OasBoolean`
+ * - `ID`      → `OasString` with `format: 'id'` so generators that want
+ *               to treat IDs specially can narrow on the format key.
+ *
+ * Custom scalars (everything else) become `OasString` with
+ * `format: '<scalarName>'`. Downstream generators (`gen-typescript`,
+ * `gen-zod`, etc.) consult their own `scalars` config map keyed on the
+ * format string to decide the actual emitted type.
+ *
+ * `context` and `stackTrail` are accepted (and currently unused) so the
+ * signature matches the OAS parser family; future error reporting on
+ * unknown scalars or constraint conflicts can flow through `context`
+ * without an API change.
+ */
+export const toScalarType = ({ scalar, nullable, context, stackTrail }) => context.withStackTrail(stackTrail, () => {
+    switch (scalar.name) {
+        case 'Int':
+            return new OasInteger({ format: 'int32', nullable }, context);
+        case 'Float':
+            return new OasNumber({ format: 'float', nullable }, context);
+        case 'String':
+            return new OasString({ nullable }, context);
+        case 'Boolean':
+            return new OasBoolean({ nullable }, context);
+        case 'ID':
+            return new OasString({ format: 'id', nullable }, context);
+        default:
+            // Custom scalar — preserve the scalar name as `format` so downstream
+            // generators can map it via their `scalars` config.
+            return new OasString({ format: scalar.name, nullable }, context);
+    }
+});

package/esm/gql/union/toUnionType.d.ts

@@ -0,0 +1,24 @@
+import type { GraphQLUnionType } from 'graphql';
+import { OasUnion } from '../../oas/union/Union.js';
+import type { ParseContextType } from '../../context/parseTypes.js';
+import type { StackTrail } from '../../context/StackTrail.js';
+export type ToUnionTypeArgs = {
+    unionType: GraphQLUnionType;
+    context: ParseContextType;
+    stackTrail: StackTrail;
+};
+/**
+ * Converts a GraphQL union type into an `OasUnion` over refs to its
+ * member types.
+ *
+ * GraphQL unions are always discriminated by `__typename` at the wire
+ * level, so we record that discriminator on the union. Generators that
+ * emit discriminated TS unions can read it; generators that don't care
+ * about discrimination ignore it.
+ *
+ * Each member ref records the consumer location via `registerRef` so
+ * if a member type fails to parse, the union's reference to it can be
+ * pruned at the end of parsing.
+ */
+export declare const toUnionType: ({ unionType, context, stackTrail }: ToUnionTypeArgs) => OasUnion;
+//# sourceMappingURL=toUnionType.d.ts.map

package/esm/gql/union/toUnionType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toUnionType.d.ts","sourceRoot":"","sources":["../../../src/gql/union/toUnionType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AAKnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAE7D,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,EAAE,gBAAgB,CAAA;IAC3B,OAAO,EAAE,gBAAgB,CAAA;IACzB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GAAI,oCAIzB,eAAe,KAAG,QAuBpB,CAAA"}

package/esm/gql/union/toUnionType.js

@@ -0,0 +1,29 @@
+import { OasUnion } from '../../oas/union/Union.js';
+import { OasDiscriminator } from '../../oas/discriminator/Discriminator.js';
+import { recordAppliedDirectives } from '../_helpers/recordAppliedDirectives.js';
+/**
+ * Converts a GraphQL union type into an `OasUnion` over refs to its
+ * member types.
+ *
+ * GraphQL unions are always discriminated by `__typename` at the wire
+ * level, so we record that discriminator on the union. Generators that
+ * emit discriminated TS unions can read it; generators that don't care
+ * about discrimination ignore it.
+ *
+ * Each member ref records the consumer location via `registerRef` so
+ * if a member type fails to parse, the union's reference to it can be
+ * pruned at the end of parsing.
+ */
+export const toUnionType = ({ unionType, context, stackTrail }) => {
+    recordAppliedDirectives({ astNode: unionType.astNode, stackTrail, context });
+    const members = stackTrail.trace('members', membersStack => unionType.getTypes().map((member, index) => membersStack.trace(String(index), memberStack => {
+        context.registerRef(memberStack.clone(), member.name);
+        return context.registry.createRef(member.name, context);
+    })));
+    return context.withStackTrail(stackTrail, () => new OasUnion({
+        title: unionType.name,
+        description: unionType.description ?? undefined,
+        members,
+        discriminator: new OasDiscriminator({ propertyName: '__typename' })
+    }, context));
+};

package/esm/helpers/collateExamples.d.ts

@@ -1,3 +1,4 @@
+import "../_dnt.polyfills.js";
 import type { OasRef } from '../oas/ref/Ref.js';
 import type { OasSchema } from '../oas/schema/Schema.js';
 /**

package/esm/helpers/collateExamples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collateExamples.d.ts","sourceRoot":"","sources":["../../src/helpers/collateExamples.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAGxD;;GAEG;AACH,KAAK,mBAAmB,GAAG;IACzB,+DAA+D;IAC/D,YAAY,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAA;IACtD,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgJG;AACH,eAAO,MAAM,eAAe,GAAI,yBAAyB,mBAAmB,KAAG,OAyF9E,CAAA"}
+{"version":3,"file":"collateExamples.d.ts","sourceRoot":"","sources":["../../src/helpers/collateExamples.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAGxD;;GAEG;AACH,KAAK,mBAAmB,GAAG;IACzB,+DAA+D;IAC/D,YAAY,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAA;IACtD,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgJG;AACH,eAAO,MAAM,eAAe,GAAI,yBAAyB,mBAAmB,KAAG,OAyF9E,CAAA"}

package/esm/helpers/collateExamples.js

@@ -1,3 +1,4 @@
+import "../_dnt.polyfills.js";
 import { isEmpty } from './isEmpty.js';
 /**
  * Recursively collates and builds example values from OpenAPI schemas.

package/esm/helpers/formatNumber.d.ts

@@ -93,5 +93,6 @@
  * // Japanese: 50,000
  * ```
  */
+import "../_dnt.polyfills.js";
 export declare const formatNumber: (value: number, locales?: Intl.LocalesArgument) => string;
 //# sourceMappingURL=formatNumber.d.ts.map