@amritk/lint 0.4.7 → 0.5.0

package/dist/rules/asyncapi/functions/asyncapi-channel-parameters.js

@@ -0,0 +1,46 @@
+import { isObject, parseUrlVariables } from "./helpers.js";
+const channelAddress = (channel, path, document) => {
+  const declaredAddress = channel["address"];
+  if (typeof declaredAddress === "string")
+    return declaredAddress;
+  const version = isObject(document) ? document["asyncapi"] : void 0;
+  if (typeof version !== "string" || !version.startsWith("2."))
+    return void 0;
+  if (path.length !== 2 || path[0] !== "channels")
+    return void 0;
+  return typeof path[1] === "string" ? path[1] : void 0;
+};
+const asyncApiChannelParameters = (channel, _options, context) => {
+  if (!isObject(channel))
+    return [];
+  if (typeof channel["$ref"] === "string")
+    return [];
+  const declaredParameters = channel["parameters"];
+  if (declaredParameters !== void 0 && !isObject(declaredParameters))
+    return [];
+  const parameters = isObject(declaredParameters) ? declaredParameters : {};
+  const address = channelAddress(channel, context.path, context.document.data);
+  if (address === void 0)
+    return [];
+  const declared = new Set(parseUrlVariables(address));
+  const results = [];
+  const missing = [...declared].filter((name) => !Object.hasOwn(parameters, name));
+  if (missing.length > 0) {
+    results.push({
+      message: `Channel parameters must be described: ${missing.join(", ")}`,
+      path: [...context.path, "parameters"]
+    });
+  }
+  for (const name of Object.keys(parameters)) {
+    if (!declared.has(name)) {
+      results.push({
+        message: `Channel parameter "${name}" is not used in the channel address`,
+        path: [...context.path, "parameters", name]
+      });
+    }
+  }
+  return results;
+};
+export {
+  asyncApiChannelParameters
+};

package/dist/rules/asyncapi/functions/asyncapi-channel-servers.d.ts

@@ -0,0 +1,27 @@
+import type { RulesetFunction } from '../../../core/types.js';
+/**
+ * Checks that every server a channel lists is one the document declares.
+ *
+ * The spec scopes this to where the channel is written, and the two cases differ
+ * (AsyncAPI 3.0, Channel Object `servers`): a channel in the **root** Channels
+ * Object "MUST point to a subset of server definitions located in the root
+ * Servers Object, and MUST NOT point to … the Components Object or anywhere
+ * else", while a channel in the Components Object "MAY point to a Server Object
+ * in any location".
+ *
+ * The carve-out excuses only references pointing *outside* `#/servers`, so it
+ * suspends one of the two checks and not the other. A reusable 3.0 channel
+ * pointing at `#/components/servers/staging` is permitted and must stay silent;
+ * one pointing at `#/servers/nope` still names the root Servers Object and must
+ * still exist there. Skipping reusable channels altogether lost that second
+ * check, and reporting them lost the first.
+ *
+ * 2.x has no carve-out at all — a channel's `servers` is a list of names from
+ * the root Servers Object wherever the channel is written — so both checks apply
+ * to both locations there.
+ *
+ * Given the whole document (`$`), because the check needs the top-level
+ * `servers` map as well as each channel. Runs unresolved, so a 3.0 `$ref` is
+ * still a reference rather than the server it points at.
+ */
+export declare const asyncApiChannelServers: RulesetFunction;

package/dist/rules/asyncapi/functions/asyncapi-channel-servers.js

@@ -0,0 +1,61 @@
+import { isObject } from "./helpers.js";
+import { pointerSegment } from "./pointer.js";
+const SERVERS_REF = "#/servers/";
+const readEntry = (entry) => {
+  if (typeof entry === "string")
+    return { kind: "named", name: entry, path: [] };
+  if (!isObject(entry))
+    return void 0;
+  const ref = entry["$ref"];
+  if (typeof ref !== "string")
+    return void 0;
+  if (!ref.startsWith(SERVERS_REF))
+    return { kind: "elsewhere", ref, path: ["$ref"] };
+  return { kind: "named", name: pointerSegment(ref.slice(SERVERS_REF.length)), path: ["$ref"] };
+};
+const asyncApiChannelServers = (document, _options, _context) => {
+  if (!isObject(document))
+    return [];
+  const declared = new Set(isObject(document["servers"]) ? Object.keys(document["servers"]) : []);
+  const version = document["asyncapi"];
+  const isV2 = typeof version === "string" && version.startsWith("2.");
+  const components = isObject(document["components"]) ? document["components"] : void 0;
+  const roots = [
+    { path: ["channels"], channels: document["channels"], mustPointAtRootServers: true },
+    // Reusable channels: in 3.0 they may reference a server anywhere, so only the
+    // "does it exist" half applies to the ones that do name `#/servers`.
+    { path: ["components", "channels"], channels: components?.["channels"], mustPointAtRootServers: isV2 }
+  ];
+  const results = [];
+  for (const root of roots) {
+    if (!isObject(root.channels))
+      continue;
+    for (const [address, channel] of Object.entries(root.channels)) {
+      if (!isObject(channel))
+        continue;
+      const servers = channel["servers"];
+      if (!Array.isArray(servers))
+        continue;
+      servers.forEach((entry, index) => {
+        const read = readEntry(entry);
+        if (read === void 0)
+          return;
+        const at = () => [...root.path, address, "servers", index, ...read.path];
+        if (read.kind === "elsewhere") {
+          if (!root.mustPointAtRootServers)
+            return;
+          results.push({
+            message: `A root channel's server must reference "${SERVERS_REF}\u2026", not "${read.ref}"`,
+            path: at()
+          });
+        } else if (!declared.has(read.name)) {
+          results.push({ message: `Channel server "${read.name}" is not defined in the "servers" object`, path: at() });
+        }
+      });
+    }
+  }
+  return results;
+};
+export {
+  asyncApiChannelServers
+};

package/dist/rules/asyncapi/functions/asyncapi-document-schema.d.ts

@@ -0,0 +1,17 @@
+import type { RulesetFunction } from '../../../core/types.js';
+/**
+ * Validates a whole AsyncAPI document against the official structural
+ * meta-schema for the version it declares, parsing that version's schema on
+ * first use. A document declaring a version this package bundles no schema for
+ * (a future 2.7, say) reports nothing rather than being judged against a
+ * neighbouring version's schema.
+ *
+ * The rule that calls this runs `resolved: false`, against the document as
+ * written, which is what keeps one authored mistake to one finding. Validating
+ * the dereferenced tree instead would re-check every `components` entry once per
+ * `$ref` that reaches it, so a single bad reusable message reported three times
+ * in a document that used it twice. The cost is that content pulled in from
+ * another file is not structurally checked — the same trade-off the OpenAPI
+ * preset's `oas*-schema` rules make.
+ */
+export declare const asyncApiDocumentSchema: RulesetFunction;

package/dist/rules/asyncapi/functions/asyncapi-document-schema.js

@@ -0,0 +1,12 @@
+import { schema as schemaFunction } from "../../../functions/index.js";
+import { asyncApiSchemaVersion, loadAsyncApiSchema } from "../schemas/index.js";
+import { isObject } from "./helpers.js";
+const asyncApiDocumentSchema = (input, _options, context) => {
+  const version = asyncApiSchemaVersion(isObject(input) ? input["asyncapi"] : void 0);
+  if (version === void 0)
+    return [];
+  return schemaFunction(input, { schema: loadAsyncApiSchema(version), allErrors: true }, context) ?? [];
+};
+export {
+  asyncApiDocumentSchema
+};

package/dist/rules/asyncapi/functions/asyncapi-headers-object.d.ts

@@ -0,0 +1,23 @@
+import type { RulesetFunction } from '../../../core/types.js';
+/**
+ * A message's `headers` must describe an object — headers are name/value pairs,
+ * so any other type is a mistake.
+ *
+ * 3.0 lets `headers` be either a Schema Object or a Multi Format Schema Object
+ * (`{ schemaFormat, schema }`), and a plain `type: object` check rejected the
+ * second form outright — flagging documents the bundled meta-schema accepts, so
+ * the ruleset contradicted its own structural rule. When the headers are wrapped
+ * that way the check moves inside `schema`, and headers written in some other
+ * schema language are left alone, exactly as a non-AsyncAPI payload is.
+ */
+/** Options for {@link asyncApiHeadersObject}. */
+export type IAsyncApiHeadersOptions = {
+    /**
+     * Whether `headers` may be a Multi Format Schema Object (`{ schemaFormat,
+     * schema }`). That shape is 3.0 only — in 2.x `headers` is a Schema Object and
+     * nothing else, so accepting the wrapper there let a `schema` key switch the
+     * check off entirely on a document that never had one.
+     */
+    multiFormat?: boolean;
+};
+export declare const asyncApiHeadersObject: RulesetFunction<unknown, IAsyncApiHeadersOptions | undefined>;

package/dist/rules/asyncapi/functions/asyncapi-headers-object.js

@@ -0,0 +1,25 @@
+import { isObject } from "./helpers.js";
+import { isAsyncApiSchemaFormat } from "./schema-format.js";
+const MESSAGE = 'Headers schema type must be "object"';
+const asyncApiHeadersObject = (headers, options, context) => {
+  if (typeof headers === "boolean")
+    return [{ message: MESSAGE, path: [...context.path] }];
+  if (!isObject(headers))
+    return [];
+  if (typeof headers["$ref"] === "string")
+    return [];
+  if (options?.multiFormat === true && Object.hasOwn(headers, "schema")) {
+    if (!isAsyncApiSchemaFormat(headers["schemaFormat"]))
+      return [];
+    const inner = headers["schema"];
+    if (!isObject(inner))
+      return [{ message: MESSAGE, path: [...context.path, "schema"] }];
+    if (typeof inner["$ref"] === "string" || inner["type"] === "object")
+      return [];
+    return [{ message: MESSAGE, path: [...context.path, "schema"] }];
+  }
+  return headers["type"] === "object" ? [] : [{ message: MESSAGE, path: [...context.path] }];
+};
+export {
+  asyncApiHeadersObject
+};

package/dist/rules/asyncapi/functions/asyncapi-message-examples.d.ts

@@ -0,0 +1,8 @@
+import type { RulesetFunction } from '../../../core/types.js';
+/**
+ * Checks every entry of a Message Object's `examples` against the message's own
+ * `payload` and `headers` schemas. Traits are folded in first, so an example is
+ * judged against the message a tool would actually assemble rather than against
+ * the half of it written inline.
+ */
+export declare const asyncApiMessageExamples: RulesetFunction;

package/dist/rules/asyncapi/functions/asyncapi-message-examples.js

@@ -0,0 +1,42 @@
+import { schema as schemaFunction } from "../../../functions/index.js";
+import { isObject, mergeTraits } from "./helpers.js";
+import { isAsyncApiSchemaFormat } from "./schema-format.js";
+const examplesOrigin = (message) => {
+  const traits = message["traits"];
+  if (Array.isArray(traits)) {
+    for (let index = traits.length - 1; index >= 0; index--) {
+      const trait = traits[index];
+      if (isObject(trait) && Array.isArray(trait["examples"]))
+        return ["traits", index, "examples"];
+    }
+  }
+  return ["examples"];
+};
+const asyncApiMessageExamples = (input, _options, context) => {
+  if (!isObject(input))
+    return [];
+  const message = mergeTraits(input);
+  const examples = message["examples"];
+  if (!Array.isArray(examples))
+    return [];
+  const origin = examplesOrigin(input);
+  const payloadIsSchema = isAsyncApiSchemaFormat(message["schemaFormat"]);
+  const results = [];
+  examples.forEach((example, index) => {
+    if (!isObject(example))
+      return;
+    for (const part of ["payload", "headers"]) {
+      if (example[part] === void 0)
+        continue;
+      if (part === "payload" && !payloadIsSchema)
+        continue;
+      const findings = schemaFunction(example[part], { schema: isObject(message[part]) ? message[part] : {}, allErrors: true, skipUnusableSchema: true }, { ...context, path: [...context.path, ...origin, index, part] });
+      if (findings)
+        results.push(...findings);
+    }
+  });
+  return results;
+};
+export {
+  asyncApiMessageExamples
+};

package/dist/rules/asyncapi/functions/asyncapi-message-id-unique.d.ts

@@ -0,0 +1,3 @@
+import type { RulesetFunction } from '../../../core/types.js';
+/** Ensures `messageId` values are unique across every message in a 2.x document. */
+export declare const asyncApiMessageIdUnique: RulesetFunction;

package/dist/rules/asyncapi/functions/asyncapi-message-id-unique.js

@@ -0,0 +1,30 @@
+import { getAllMessages, isObject } from "./helpers.js";
+const effectiveMessageId = (message) => {
+  const traits = message["traits"];
+  if (Array.isArray(traits)) {
+    for (let index = traits.length - 1; index >= 0; index--) {
+      const trait = traits[index];
+      if (isObject(trait) && typeof trait["messageId"] === "string") {
+        return { id: trait["messageId"], path: ["traits", index, "messageId"] };
+      }
+    }
+  }
+  return typeof message["messageId"] === "string" ? { id: message["messageId"], path: ["messageId"] } : void 0;
+};
+const asyncApiMessageIdUnique = (document, _options, _context) => {
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const { path, message } of getAllMessages(document)) {
+    const found = effectiveMessageId(message);
+    if (found === void 0)
+      continue;
+    if (seen.has(found.id)) {
+      results.push({ message: `messageId "${found.id}" must be unique`, path: [...path, ...found.path] });
+    }
+    seen.add(found.id);
+  }
+  return results;
+};
+export {
+  asyncApiMessageIdUnique
+};

package/dist/rules/asyncapi/functions/asyncapi-operation-id-unique.d.ts

@@ -0,0 +1,3 @@
+import type { RulesetFunction } from '../../../core/types.js';
+/** Ensures `operationId` values are unique across every operation in a 2.x document. */
+export declare const asyncApiOperationIdUnique: RulesetFunction;

package/dist/rules/asyncapi/functions/asyncapi-operation-id-unique.js

@@ -0,0 +1,30 @@
+import { getAllOperations, isObject } from "./helpers.js";
+const effectiveOperationId = (operation) => {
+  const traits = operation["traits"];
+  if (Array.isArray(traits)) {
+    for (let index = traits.length - 1; index >= 0; index--) {
+      const trait = traits[index];
+      if (isObject(trait) && typeof trait["operationId"] === "string") {
+        return { id: trait["operationId"], path: ["traits", index, "operationId"] };
+      }
+    }
+  }
+  return typeof operation["operationId"] === "string" ? { id: operation["operationId"], path: ["operationId"] } : void 0;
+};
+const asyncApiOperationIdUnique = (document, _options, _context) => {
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const { path, operation } of getAllOperations(document)) {
+    const found = effectiveOperationId(operation);
+    if (found === void 0)
+      continue;
+    if (seen.has(found.id)) {
+      results.push({ message: `operationId "${found.id}" must be unique`, path: [...path, ...found.path] });
+    }
+    seen.add(found.id);
+  }
+  return results;
+};
+export {
+  asyncApiOperationIdUnique
+};

package/dist/rules/asyncapi/functions/asyncapi-payload.d.ts

@@ -0,0 +1,14 @@
+import type { RulesetFunction } from '../../../core/types.js';
+/**
+ * Validates a message's `payload` against the AsyncAPI Schema Object definition
+ * of the document's own version — the check that catches a payload using a JSON
+ * Schema keyword AsyncAPI does not allow, or a `type` that is not a type.
+ *
+ * Takes the whole message rather than the payload so that traits are folded in
+ * before the `schemaFormat` is read. A payload in Avro or Protobuf is not an
+ * AsyncAPI Schema Object at all, and a `schemaFormat` naming one of those can be
+ * contributed by a trait — invisible to a `given` filter, which is how an Avro
+ * payload came to be judged as JSON Schema and reported at error severity.
+ * `asyncapi-payload-unsupported-schemaFormat` reports those separately.
+ */
+export declare const asyncApiPayload: RulesetFunction;

package/dist/rules/asyncapi/functions/asyncapi-payload.js

@@ -0,0 +1,32 @@
+import { schema as schemaFunction } from "../../../functions/index.js";
+import { asyncApiSchemaVersion, loadAsyncApiSchema } from "../schemas/index.js";
+import { isObject, mergeTraits } from "./helpers.js";
+import { isAsyncApiSchemaFormat } from "./schema-format.js";
+const payloadSchemaId = (version) => `http://asyncapi.com/definitions/${version}.0/schema.json`;
+const payloadSchemas = /* @__PURE__ */ new Map();
+const payloadSchema = (version) => {
+  let wrapper = payloadSchemas.get(version);
+  if (!wrapper) {
+    const meta = loadAsyncApiSchema(version);
+    wrapper = { $ref: payloadSchemaId(version), definitions: meta.definitions };
+    payloadSchemas.set(version, wrapper);
+  }
+  return wrapper;
+};
+const asyncApiPayload = (message, _options, context) => {
+  if (!isObject(message))
+    return [];
+  const merged = mergeTraits(message);
+  if (!isAsyncApiSchemaFormat(merged["schemaFormat"]))
+    return [];
+  const payload = merged["payload"];
+  if (payload === void 0)
+    return [];
+  const version = asyncApiSchemaVersion(isObject(context.document.data) ? context.document.data["asyncapi"] : void 0);
+  if (version === void 0)
+    return [];
+  return schemaFunction(payload, { schema: payloadSchema(version), allErrors: true }, { ...context, path: [...context.path, "payload"] }) ?? [];
+};
+export {
+  asyncApiPayload
+};

package/dist/rules/asyncapi/functions/asyncapi-schema-validation.d.ts

@@ -0,0 +1,11 @@
+import type { RulesetFunction } from '../../../core/types.js';
+/** Options for {@link asyncApiSchemaValidation}: which sibling of the schema to check. */
+export type IAsyncApiSchemaValidationOptions = {
+    type: 'default' | 'examples';
+};
+/**
+ * Validates a Schema Object's own `default` or `examples` against that same
+ * schema. The rule targets the schema (via a `^` parent selector), so the input
+ * here is the schema and the values under test sit inside it.
+ */
+export declare const asyncApiSchemaValidation: RulesetFunction<unknown, IAsyncApiSchemaValidationOptions>;

package/dist/rules/asyncapi/functions/asyncapi-schema-validation.js

@@ -0,0 +1,17 @@
+import { schema as schemaFunction } from "../../../functions/index.js";
+import { isObject } from "./helpers.js";
+const asyncApiSchemaValidation = (input, options, context) => {
+  if (!isObject(input) || options?.type === void 0)
+    return [];
+  const targets = options.type === "default" ? [{ path: ["default"], value: input["default"] }] : Array.isArray(input["examples"]) ? input["examples"].map((value, index) => ({ path: ["examples", index], value })) : [];
+  const results = [];
+  for (const target of targets) {
+    const findings = schemaFunction(target.value, { schema: input, allErrors: true, skipUnusableSchema: true }, { ...context, path: [...context.path, ...target.path] });
+    if (findings)
+      results.push(...findings);
+  }
+  return results;
+};
+export {
+  asyncApiSchemaValidation
+};

package/dist/rules/asyncapi/functions/asyncapi-security.d.ts

@@ -0,0 +1,22 @@
+import type { RulesetFunction } from '../../../core/types.js';
+/** Options for {@link asyncApiSecurity}: which object the requirement hangs off, for the message. */
+export type IAsyncApiSecurityOptions = {
+    objectType: 'Server' | 'Operation';
+};
+/**
+ * Checks that a security entry points at a security scheme the document
+ * declares. The two spec majors spell that entry differently, so the shape
+ * decides which check runs:
+ *
+ * - **2.x** — a Security Requirement Object: `{ <schemeName>: [<scope>, …] }`.
+ *   Every key must name a declared scheme, and for an OAuth2 scheme every
+ *   requested scope must be one its flows declare.
+ * - **3.x** — a Security Scheme Object or a Reference to one. A reference must
+ *   point into `#/components/securitySchemes/` and name a scheme that exists; an
+ *   inline scheme carries its own definition and has nothing to cross-check
+ *   (the structural rules validate its shape).
+ *
+ * The lookup goes through the raw document, since a requirement names its scheme
+ * by key rather than by holding it.
+ */
+export declare const asyncApiSecurity: RulesetFunction<unknown, IAsyncApiSecurityOptions>;

package/dist/rules/asyncapi/functions/asyncapi-security.js

@@ -0,0 +1,78 @@
+import { isObject } from "./helpers.js";
+import { pointerSegment } from "./pointer.js";
+const OAUTH2_FLOWS = ["implicit", "password", "clientCredentials", "authorizationCode"];
+const SECURITY_SCHEMES_REF = "#/components/securitySchemes/";
+const declaredScopes = (flows) => {
+  const scopes = /* @__PURE__ */ new Set();
+  if (!isObject(flows))
+    return scopes;
+  for (const name of OAUTH2_FLOWS) {
+    const flow = flows[name];
+    if (!isObject(flow) || !isObject(flow["scopes"]))
+      continue;
+    for (const scope of Object.keys(flow["scopes"]))
+      scopes.add(scope);
+  }
+  return scopes;
+};
+const securitySchemes = (data) => {
+  const components = isObject(data) ? data["components"] : void 0;
+  const schemes = isObject(components) ? components["securitySchemes"] : void 0;
+  return isObject(schemes) ? schemes : {};
+};
+const isDeclared = (schemes, name) => Object.hasOwn(schemes, name);
+const asyncApiSecurity = (entry, options, context) => {
+  if (!isObject(entry))
+    return [];
+  const objectType = options?.objectType ?? "Operation";
+  const schemes = securitySchemes(context.document.data);
+  const ref = entry["$ref"];
+  if (typeof ref === "string") {
+    if (!ref.startsWith(SECURITY_SCHEMES_REF)) {
+      return [
+        {
+          message: `${objectType} security must reference "${SECURITY_SCHEMES_REF}\u2026", not "${ref}"`,
+          path: [...context.path, "$ref"]
+        }
+      ];
+    }
+    const name = pointerSegment(ref.slice(SECURITY_SCHEMES_REF.length));
+    return isDeclared(schemes, name) ? [] : [
+      {
+        message: `${objectType} security requirement "${name}" is not a defined security scheme`,
+        path: [...context.path, "$ref"]
+      }
+    ];
+  }
+  if (typeof entry["type"] === "string")
+    return [];
+  const results = [];
+  for (const key of Object.keys(entry)) {
+    const requested = entry[key];
+    if (!Array.isArray(requested))
+      continue;
+    if (!isDeclared(schemes, key)) {
+      results.push({
+        message: `${objectType} security requirement "${key}" is not a defined security scheme`,
+        path: [...context.path, key]
+      });
+      continue;
+    }
+    const scheme = schemes[key];
+    if (!isObject(scheme) || scheme["type"] !== "oauth2")
+      continue;
+    const available = declaredScopes(scheme["flows"]);
+    requested.forEach((scope, index) => {
+      if (typeof scope === "string" && !available.has(scope)) {
+        results.push({
+          message: `Security scope "${scope}" is not declared by the "${key}" scheme. Available: [${[...available].join(", ")}]`,
+          path: [...context.path, key, index]
+        });
+      }
+    });
+  }
+  return results;
+};
+export {
+  asyncApiSecurity
+};

package/dist/rules/asyncapi/functions/helpers.d.ts

@@ -0,0 +1,51 @@
+import type { JsonPath } from '../../../core/types.js';
+export { isObject } from '../../shared/helpers.js';
+/** The two operation fields an AsyncAPI 2.x Channel Item Object may carry. */
+export declare const V2_OPERATIONS: readonly ['subscribe', 'publish'];
+/** One AsyncAPI 2.x operation, with the path it sits at. */
+export type LocatedOperation = {
+    path: JsonPath;
+    kind: (typeof V2_OPERATIONS)[number];
+    operation: Record<string, unknown>;
+};
+/** One AsyncAPI 2.x message, with the path it sits at. */
+export type LocatedMessage = {
+    path: JsonPath;
+    message: Record<string, unknown>;
+};
+/**
+ * Every `{variable}` name in a channel address or server URL, in order. A name
+ * is a run of non-`}` characters, so `{}` yields nothing (the dedicated
+ * `*-no-empty-parameter` rules report that).
+ *
+ * The character class matters: a lazy `.+?` swallowed the closing brace of `{}`
+ * and ran on to the next one, so `a/{}/b/{id}` yielded the single name
+ * `}/b/{id` — a parameter nobody wrote, while the one that really was
+ * undescribed went unnamed.
+ */
+export declare const parseUrlVariables: (value: unknown) => string[];
+/**
+ * Walks the `publish`/`subscribe` operations of every 2.x channel — both the
+ * channels the document serves and the reusable ones under
+ * `components.channels`. A reusable channel is a declaration like any other, so
+ * a rule asking for "every operation" has to see it; leaving it out meant a
+ * duplicate `operationId` between a served channel and a reusable one went
+ * unreported.
+ */
+export declare function getAllOperations(document: unknown): Generator<LocatedOperation>;
+/**
+ * Walks every 2.x message: each operation's `message` (or, when that message is a
+ * `oneOf` list, each alternative in it), plus every reusable message under
+ * `components.messages`. These are the same locations the ruleset's `V2_MESSAGES`
+ * enumerates, so "every message" means the same thing to a rule and to this
+ * walker.
+ */
+export declare function getAllMessages(document: unknown): Generator<LocatedMessage>;
+/**
+ * Folds a Message (or Operation) Object's `traits` into the object itself, the
+ * way a 2.x tool resolving the document would. The spec applies each trait as a
+ * JSON Merge Patch in declaration order, so a trait overrides what the object
+ * (and any earlier trait) declared. Returns the input unchanged when it declares
+ * no `traits`.
+ */
+export declare const mergeTraits: (target: Record<string, unknown>) => Record<string, unknown>;