@amritk/lint 0.4.8 → 0.5.0

package/dist/rules/asyncapi/asyncapi.js

@@ -0,0 +1,563 @@
+import { ASYNCAPI_SCHEMA_FORMAT_FILTER } from "./functions/schema-format.js";
+import { LATEST_ASYNCAPI_VERSION } from "./schemas/index.js";
+const V2_OPERATIONS = "$.channels[*][publish,subscribe]";
+const V2_COMPONENT_OPERATIONS = "$.components.channels[*][publish,subscribe]";
+const V2_MESSAGES = [
+  `${V2_OPERATIONS}.message`,
+  `${V2_OPERATIONS}.message.oneOf[*]`,
+  `${V2_COMPONENT_OPERATIONS}.message`,
+  `${V2_COMPONENT_OPERATIONS}.message.oneOf[*]`,
+  "$.components.messages[*]"
+];
+const V2_MESSAGE_TRAITS = [
+  `${V2_OPERATIONS}.message.traits[*]`,
+  `${V2_OPERATIONS}.message.oneOf[*].traits[*]`,
+  `${V2_COMPONENT_OPERATIONS}.message.traits[*]`,
+  `${V2_COMPONENT_OPERATIONS}.message.oneOf[*].traits[*]`,
+  "$.components.messages[*].traits[*]",
+  "$.components.messageTraits[*]"
+];
+const V2_ALL_MESSAGES = [...V2_MESSAGES, ...V2_MESSAGE_TRAITS];
+const defaultFormatOnly = (given) => given.endsWith(".message") ? `${given.slice(0, -".message".length)}[?(@property === 'message' && (${ASYNCAPI_SCHEMA_FORMAT_FILTER}))]` : `${given.slice(0, -"[*]".length)}[?(${ASYNCAPI_SCHEMA_FORMAT_FILTER})]`;
+const V2_DEFAULT_FORMAT_PAYLOADS = V2_ALL_MESSAGES.map((given) => `${defaultFormatOnly(given)}.payload`);
+const payloadSiblings = (keyword) => V2_DEFAULT_FORMAT_PAYLOADS.map((given) => `${given}.${keyword}^`);
+const sharedRules = {
+  "asyncapi-channel-parameters": {
+    description: "Channel parameters must be defined, and none may be redundant.",
+    // Unresolved: this rule reads what the author wrote — names, addresses,
+    // variables — and never needs to see through a `$ref`. Its given already
+    // covers the reusable location, so nothing is missed by not dereferencing.
+    resolved: false,
+    given: ["$.channels[*]", "$.components.channels[*]"],
+    severity: "error",
+    then: { function: "asyncApiChannelParameters" }
+  },
+  "asyncapi-info-contact": {
+    description: "Info object must have a contact object.",
+    given: "$.info",
+    then: { field: "contact", function: "truthy" }
+  },
+  "asyncapi-info-contact-properties": {
+    description: "Contact object must have name, url, and email.",
+    given: "$.info.contact",
+    severity: "warn",
+    then: [
+      { field: "name", function: "truthy" },
+      { field: "url", function: "truthy" },
+      { field: "email", function: "truthy" }
+    ]
+  },
+  "asyncapi-info-description": {
+    description: "Info object must have a description.",
+    given: "$.info",
+    then: { field: "description", function: "truthy" }
+  },
+  "asyncapi-info-license": {
+    description: "Info object must have a license object.",
+    given: "$.info",
+    then: { field: "license", function: "truthy" }
+  },
+  "asyncapi-info-license-url": {
+    description: "License object should have a url.",
+    given: "$.info.license",
+    severity: "warn",
+    recommended: false,
+    then: { field: "url", function: "truthy" }
+  },
+  "asyncapi-latest-version": {
+    // Informational: an older document is valid, just not current. The version
+    // named here is the newest one this package bundles a meta-schema for, so the
+    // advice never points past what the linter can actually check.
+    description: "AsyncAPI document should use the latest specification version.",
+    message: `The latest version is not used. You should update to the "${LATEST_ASYNCAPI_VERSION}" version.`,
+    given: "$.asyncapi",
+    severity: "info",
+    then: { function: "schema", functionOptions: { schema: { const: LATEST_ASYNCAPI_VERSION } } }
+  },
+  "asyncapi-parameter-description": {
+    description: "Parameter objects should have a description.",
+    given: ["$.components.parameters[*]", "$.channels[*].parameters[*]"],
+    severity: "warn",
+    recommended: false,
+    then: { field: "description", function: "truthy" }
+  },
+  "asyncapi-servers": {
+    description: "AsyncAPI object must have a non-empty servers object.",
+    given: "$",
+    severity: "warn",
+    then: {
+      field: "servers",
+      function: "schema",
+      functionOptions: { schema: { type: "object", minProperties: 1 }, allErrors: true }
+    }
+  },
+  "asyncapi-unused-components-schema": {
+    description: "Potentially unused components schema has been detected.",
+    // Unresolved: once `$ref`s are inlined there is nothing left pointing at
+    // `#/components/schemas`, so every entry would look unused.
+    resolved: false,
+    given: "$.components.schemas",
+    severity: "warn",
+    then: {
+      function: "unreferencedReusableObject",
+      functionOptions: { reusableObjectsLocation: "#/components/schemas" }
+    }
+  },
+  "asyncapi-unused-components-server": {
+    description: "Potentially unused components server has been detected.",
+    resolved: false,
+    given: "$.components.servers",
+    severity: "warn",
+    then: {
+      function: "unreferencedReusableObject",
+      functionOptions: { reusableObjectsLocation: "#/components/servers" }
+    }
+  }
+};
+const v2Rules = {
+  "asyncapi-channel-no-empty-parameter": {
+    description: "Channel path must not have an empty parameter substitution pattern.",
+    formats: ["aas2"],
+    given: "$.channels",
+    severity: "warn",
+    then: { field: "@key", function: "pattern", functionOptions: { notMatch: "{}" } }
+  },
+  "asyncapi-channel-no-query-nor-fragment": {
+    description: 'Channel path must not include a query ("?") or fragment ("#") delimiter.',
+    formats: ["aas2"],
+    given: "$.channels",
+    severity: "warn",
+    then: { field: "@key", function: "pattern", functionOptions: { notMatch: "[\\?#]" } }
+  },
+  "asyncapi-channel-no-trailing-slash": {
+    description: "Channel path must not end with a slash.",
+    formats: ["aas2"],
+    given: "$.channels",
+    severity: "warn",
+    then: { field: "@key", function: "pattern", functionOptions: { notMatch: ".+\\/$" } }
+  },
+  "asyncapi-channel-servers": {
+    description: "Channel servers must be defined in the servers object.",
+    formats: ["aas2"],
+    // Unresolved: this rule reads what the author wrote — names, addresses,
+    // variables — and never needs to see through a `$ref`. Its given already
+    // covers the reusable location, so nothing is missed by not dereferencing.
+    resolved: false,
+    given: "$",
+    severity: "error",
+    then: { function: "asyncApiChannelServers" }
+  },
+  "asyncapi-headers-schema-type-object": {
+    description: 'Headers schema type must be "object".',
+    formats: ["aas2"],
+    given: V2_ALL_MESSAGES.map((given) => `${given}.headers`),
+    severity: "error",
+    then: { function: "asyncApiHeadersObject" }
+  },
+  "asyncapi-message-examples": {
+    description: "Message examples must be valid against the payload and headers schemas.",
+    formats: ["aas2"],
+    // Messages only. The pass folds traits in — including a `$ref`'d one, since
+    // this runs resolved — and reports against whichever array the merge took,
+    // so matching each trait location as well printed the identical finding
+    // twice. The one thing this misses is a `components.messageTraits` entry no
+    // message ever references, which is an unused component.
+    given: V2_MESSAGES,
+    severity: "error",
+    then: { function: "asyncApiMessageExamples" }
+  },
+  "asyncapi-message-messageId-uniqueness": {
+    description: "Every messageId must be unique.",
+    formats: ["aas2"],
+    // Unresolved: a reusable `components` entry reached by two `$ref`s appears
+    // twice in the dereferenced tree, and counting those as two declarations
+    // reported a duplicate id for a document that only ever declared one.
+    resolved: false,
+    given: "$",
+    severity: "error",
+    then: { function: "asyncApiMessageIdUnique" }
+  },
+  "asyncapi-operation-description": {
+    description: "Operation must have a description.",
+    formats: ["aas2"],
+    given: V2_OPERATIONS,
+    then: { field: "description", function: "truthy" }
+  },
+  "asyncapi-operation-operationId": {
+    description: "Operation must have an operationId.",
+    formats: ["aas2"],
+    given: V2_OPERATIONS,
+    severity: "error",
+    then: { field: "operationId", function: "truthy" }
+  },
+  "asyncapi-operation-operationId-uniqueness": {
+    description: "Every operationId must be unique.",
+    formats: ["aas2"],
+    // Unresolved: a reusable `components` entry reached by two `$ref`s appears
+    // twice in the dereferenced tree, and counting those as two declarations
+    // reported a duplicate id for a document that only ever declared one.
+    resolved: false,
+    given: "$",
+    severity: "error",
+    then: { function: "asyncApiOperationIdUnique" }
+  },
+  "asyncapi-operation-security": {
+    description: "Operation security must reference a defined security scheme.",
+    formats: ["aas2"],
+    given: [`${V2_OPERATIONS}.security[*]`, `${V2_COMPONENT_OPERATIONS}.security[*]`],
+    severity: "error",
+    then: { function: "asyncApiSecurity", functionOptions: { objectType: "Operation" } }
+  },
+  "asyncapi-payload": {
+    description: "Payloads must be valid against the AsyncAPI Schema object.",
+    formats: ["aas2"],
+    // Given the message rather than the payload, so the `schemaFormat` gate can
+    // fold traits in first. A trait-supplied `schemaFormat` is invisible to a
+    // `given` filter, which judged an Avro payload as an AsyncAPI Schema Object.
+    given: V2_ALL_MESSAGES,
+    severity: "error",
+    then: { function: "asyncApiPayload" }
+  },
+  "asyncapi-payload-default": {
+    description: "Payload default must be valid against its schema.",
+    formats: ["aas2"],
+    given: payloadSiblings("default"),
+    severity: "error",
+    then: { function: "asyncApiSchemaValidation", functionOptions: { type: "default" } }
+  },
+  "asyncapi-payload-examples": {
+    description: "Payload examples must be valid against their schema.",
+    formats: ["aas2"],
+    given: payloadSiblings("examples"),
+    severity: "error",
+    then: { function: "asyncApiSchemaValidation", functionOptions: { type: "examples" } }
+  },
+  "asyncapi-payload-unsupported-schemaFormat": {
+    description: "Message payload validation is only supported with an unspecified schemaFormat.",
+    formats: ["aas2"],
+    given: V2_ALL_MESSAGES,
+    severity: "info",
+    resolved: false,
+    // Only a format this package cannot validate is worth a note; naming the
+    // AsyncAPI dialect explicitly is not "unsupported".
+    then: {
+      field: "schemaFormat",
+      function: "pattern",
+      functionOptions: { match: "^application/vnd\\.aai\\.asyncapi([+;])" }
+    }
+  },
+  "asyncapi-schema": {
+    description: "Validate structure of AsyncAPI v2 specification.",
+    formats: ["aas2"],
+    severity: "error",
+    resolved: false,
+    given: "$",
+    then: { function: "asyncApiDocumentSchema" }
+  },
+  "asyncapi-schema-default": {
+    description: "Schema default must be valid against its schema.",
+    formats: ["aas2"],
+    given: [
+      "$.components.schemas[*].default^",
+      "$.components.parameters[*].schema.default^",
+      "$.channels[*].parameters[*].schema.default^"
+    ],
+    severity: "error",
+    then: { function: "asyncApiSchemaValidation", functionOptions: { type: "default" } }
+  },
+  "asyncapi-schema-examples": {
+    description: "Schema examples must be valid against their schema.",
+    formats: ["aas2"],
+    given: [
+      "$.components.schemas[*].examples^",
+      "$.components.parameters[*].schema.examples^",
+      "$.channels[*].parameters[*].schema.examples^"
+    ],
+    severity: "error",
+    then: { function: "asyncApiSchemaValidation", functionOptions: { type: "examples" } }
+  },
+  "asyncapi-server-no-empty-variable": {
+    description: "Server URL must not have an empty variable substitution pattern.",
+    formats: ["aas2"],
+    given: "$.servers[*].url",
+    severity: "warn",
+    then: { function: "pattern", functionOptions: { notMatch: "{}" } }
+  },
+  "asyncapi-server-no-trailing-slash": {
+    description: "Server URL must not end with a slash.",
+    formats: ["aas2"],
+    given: "$.servers[*].url",
+    severity: "warn",
+    then: { function: "pattern", functionOptions: { notMatch: "/$" } }
+  },
+  "asyncapi-server-not-example-com": {
+    description: "Server URL must not point at example.com.",
+    formats: ["aas2"],
+    given: "$.servers[*].url",
+    severity: "warn",
+    recommended: false,
+    then: { function: "pattern", functionOptions: { notMatch: "example\\.com" } }
+  },
+  "asyncapi-server-security": {
+    description: "Server security must reference a defined security scheme.",
+    formats: ["aas2"],
+    given: ["$.servers[*].security[*]", "$.components.servers[*].security[*]"],
+    severity: "error",
+    then: { function: "asyncApiSecurity", functionOptions: { objectType: "Server" } }
+  },
+  "asyncapi-server-variables": {
+    description: "Server variables must be defined, and none may be redundant.",
+    formats: ["aas2"],
+    // Unresolved: this rule reads what the author wrote — names, addresses,
+    // variables — and never needs to see through a `$ref`. Its given already
+    // covers the reusable location, so nothing is missed by not dereferencing.
+    resolved: false,
+    given: ["$.servers[*]", "$.components.servers[*]"],
+    severity: "error",
+    then: { function: "aasServerVariables" }
+  },
+  "asyncapi-tag-description": {
+    description: "Tag object should have a description.",
+    formats: ["aas2"],
+    given: "$.tags[*]",
+    severity: "warn",
+    recommended: false,
+    then: { field: "description", function: "truthy" }
+  },
+  "asyncapi-tags": {
+    description: "AsyncAPI object should have a non-empty tags array.",
+    formats: ["aas2"],
+    given: "$",
+    severity: "warn",
+    then: { field: "tags", function: "truthy" }
+  },
+  "asyncapi-tags-alphabetical": {
+    description: "Tags should be in alphabetical order.",
+    formats: ["aas2"],
+    given: "$",
+    severity: "warn",
+    recommended: false,
+    then: { field: "tags", function: "alphabetical", functionOptions: { keyedBy: "name" } }
+  },
+  "asyncapi-tags-uniqueness": {
+    description: "Tag names must be unique within each tags array.",
+    formats: ["aas2"],
+    // Unresolved: this rule reads what the author wrote — names, addresses,
+    // variables — and never needs to see through a `$ref`. Its given already
+    // covers the reusable location, so nothing is missed by not dereferencing.
+    resolved: false,
+    given: [
+      "$.tags",
+      "$.servers[*].tags",
+      "$.components.servers[*].tags",
+      `${V2_OPERATIONS}.tags`,
+      `${V2_COMPONENT_OPERATIONS}.tags`,
+      `${V2_OPERATIONS}.traits[*].tags`,
+      `${V2_COMPONENT_OPERATIONS}.traits[*].tags`,
+      "$.components.operationTraits[*].tags",
+      ...V2_ALL_MESSAGES.map((given) => `${given}.tags`)
+    ],
+    severity: "error",
+    then: { function: "aasTagsUnique" }
+  }
+};
+const V3_MESSAGES = ["$.channels[*].messages[*]", "$.components.channels[*].messages[*]", "$.components.messages[*]"];
+const V3_MESSAGE_TRAITS = [
+  "$.channels[*].messages[*].traits[*]",
+  "$.components.channels[*].messages[*].traits[*]",
+  "$.components.messages[*].traits[*]",
+  "$.components.messageTraits[*]"
+];
+const V3_ALL_MESSAGES = [...V3_MESSAGES, ...V3_MESSAGE_TRAITS];
+const v3Rules = {
+  "asyncapi-3-channel-no-empty-parameter": {
+    description: "Channel address must not have an empty parameter substitution pattern.",
+    formats: ["aas3"],
+    given: "$.channels[*]",
+    severity: "warn",
+    then: { field: "address", function: "pattern", functionOptions: { notMatch: "{}" } }
+  },
+  "asyncapi-3-channel-no-query-nor-fragment": {
+    description: 'Channel address must not include a query ("?") or fragment ("#") delimiter.',
+    formats: ["aas3"],
+    given: "$.channels[*]",
+    severity: "warn",
+    then: { field: "address", function: "pattern", functionOptions: { notMatch: "[\\?#]" } }
+  },
+  "asyncapi-3-channel-no-trailing-slash": {
+    description: "Channel address must not end with a slash.",
+    formats: ["aas3"],
+    given: "$.channels[*]",
+    severity: "warn",
+    then: { field: "address", function: "pattern", functionOptions: { notMatch: ".+\\/$" } }
+  },
+  "asyncapi-3-channel-servers": {
+    // 3.0 replaced the 2.x list of server *names* with references, so the check
+    // is that each one points into `#/servers`. Unresolved, or the `$ref` this
+    // reads would already have been replaced by the server it names.
+    description: "Channel servers must reference servers defined in the servers object.",
+    formats: ["aas3"],
+    // Unresolved, or the `$ref` this reads would already have been replaced by
+    // the server it names.
+    resolved: false,
+    given: "$",
+    severity: "error",
+    then: { function: "asyncApiChannelServers" }
+  },
+  "asyncapi-3-document-unresolved": {
+    // One structural pass per major, against the document as written — see
+    // `asyncApiDocumentSchema`. Spectral pairs this with an
+    // `asyncapi-3-document-resolved` twin; running both here reported every
+    // structural error twice whenever a `$ref` resolver was injected, which the
+    // CLI always does.
+    description: "Validate structure of AsyncAPI v3 specification.",
+    formats: ["aas3"],
+    severity: "error",
+    resolved: false,
+    given: "$",
+    then: { function: "asyncApiDocumentSchema" }
+  },
+  "asyncapi-3-headers-schema-type-object": {
+    description: 'Headers schema type must be "object".',
+    formats: ["aas3"],
+    given: V3_ALL_MESSAGES.map((given) => `${given}.headers`),
+    severity: "error",
+    then: { function: "asyncApiHeadersObject", functionOptions: { multiFormat: true } }
+  },
+  "asyncapi-3-operation-description": {
+    description: "Operation must have a description.",
+    formats: ["aas3"],
+    given: "$.operations[*]",
+    then: { field: "description", function: "truthy" }
+  },
+  "asyncapi-3-operation-security": {
+    description: "Operation security must reference a defined security scheme.",
+    formats: ["aas3"],
+    resolved: false,
+    given: ["$.operations[*].security[*]", "$.components.operations[*].security[*]"],
+    severity: "error",
+    then: { function: "asyncApiSecurity", functionOptions: { objectType: "Operation" } }
+  },
+  "asyncapi-3-payload-unsupported-schemaFormat": {
+    description: "Message payload validation is only supported with an unspecified schemaFormat.",
+    formats: ["aas3"],
+    given: V3_ALL_MESSAGES.map((given) => `${given}.payload`),
+    severity: "info",
+    resolved: false,
+    then: {
+      field: "schemaFormat",
+      function: "pattern",
+      functionOptions: { match: "^application/vnd\\.aai\\.asyncapi([+;])" }
+    }
+  },
+  "asyncapi-3-server-security": {
+    // 3.0 keeps `security` on the Server Object, in the same
+    // Reference-or-inline-scheme shape `asyncapi-3-operation-security` checks.
+    description: "Server security must reference a defined security scheme.",
+    formats: ["aas3"],
+    resolved: false,
+    given: ["$.servers[*].security[*]", "$.components.servers[*].security[*]"],
+    severity: "error",
+    then: { function: "asyncApiSecurity", functionOptions: { objectType: "Server" } }
+  },
+  "asyncapi-3-server-variables": {
+    // The 2.x rule reads `url`; 3.0 splits the address into `host` and
+    // `pathname`, which the shared check now understands.
+    description: "Server variables must be defined, and none may be redundant.",
+    formats: ["aas3"],
+    resolved: false,
+    given: ["$.servers[*]", "$.components.servers[*]"],
+    severity: "error",
+    then: { function: "aasServerVariables", functionOptions: { addressFields: ["host", "pathname"] } }
+  },
+  "asyncapi-3-server-no-empty-variable": {
+    // 3.0 split the 2.x `url` into `host` and `pathname`, and either may be
+    // templated.
+    description: "Server host and pathname must not have an empty variable substitution pattern.",
+    formats: ["aas3"],
+    given: ["$.servers[*].host", "$.servers[*].pathname"],
+    severity: "warn",
+    then: { function: "pattern", functionOptions: { notMatch: "{}" } }
+  },
+  "asyncapi-3-server-no-trailing-slash": {
+    description: "Server host must not end with a slash.",
+    formats: ["aas3"],
+    given: "$.servers[*].host",
+    severity: "warn",
+    then: { function: "pattern", functionOptions: { notMatch: "/$" } }
+  },
+  "asyncapi-3-server-not-example-com": {
+    description: "Server host must not point at example.com.",
+    formats: ["aas3"],
+    given: "$.servers[*].host",
+    severity: "warn",
+    recommended: false,
+    then: { function: "pattern", functionOptions: { notMatch: "example\\.com" } }
+  },
+  "asyncapi-3-tag-description": {
+    description: "Tag object should have a description.",
+    formats: ["aas3"],
+    given: "$.info.tags[*]",
+    severity: "warn",
+    recommended: false,
+    then: { field: "description", function: "truthy" }
+  },
+  "asyncapi-3-tags": {
+    // 3.0 moved the document's tags under `info`.
+    description: "Info object should have a non-empty tags array.",
+    formats: ["aas3"],
+    given: "$.info",
+    severity: "warn",
+    then: { field: "tags", function: "truthy" }
+  },
+  "asyncapi-3-tags-alphabetical": {
+    description: "Tags should be in alphabetical order.",
+    formats: ["aas3"],
+    given: "$.info",
+    severity: "warn",
+    recommended: false,
+    then: { field: "tags", function: "alphabetical", functionOptions: { keyedBy: "name" } }
+  },
+  "asyncapi-3-tags-uniqueness": {
+    description: "Tag names must be unique within each tags array.",
+    formats: ["aas3"],
+    // Unresolved: this rule reads what the author wrote — names, addresses,
+    // variables — and never needs to see through a `$ref`. Its given already
+    // covers the reusable location, so nothing is missed by not dereferencing.
+    resolved: false,
+    given: [
+      "$.info.tags",
+      "$.servers[*].tags",
+      "$.components.servers[*].tags",
+      // The Channel Object carries `tags` in 3.0 too, and it is the most obvious
+      // place for a duplicate to be written.
+      "$.channels[*].tags",
+      "$.components.channels[*].tags",
+      "$.operations[*].tags",
+      "$.components.operations[*].tags",
+      "$.operations[*].traits[*].tags",
+      "$.components.operations[*].traits[*].tags",
+      "$.components.operationTraits[*].tags",
+      "$.channels[*].messages[*].tags",
+      "$.channels[*].messages[*].traits[*].tags",
+      "$.components.channels[*].messages[*].tags",
+      "$.components.channels[*].messages[*].traits[*].tags",
+      "$.components.messages[*].tags",
+      "$.components.messages[*].traits[*].tags",
+      "$.components.messageTraits[*].tags"
+    ],
+    severity: "error",
+    then: { function: "aasTagsUnique" }
+  }
+};
+const asyncapi = {
+  formats: ["aas2", "aas3"],
+  rules: {
+    ...sharedRules,
+    ...v2Rules,
+    ...v3Rules
+  }
+};
+export {
+  asyncapi
+};

package/dist/rules/asyncapi/formats.d.ts

@@ -0,0 +1,23 @@
+import type { Format } from '../../core/index.js';
+/** Matches any AsyncAPI 2.x (`asyncapi: 2.*`). */
+export declare const aas2: Format;
+/** Matches AsyncAPI 2.0.x specifically. */
+export declare const aas2_0: Format;
+/** Matches AsyncAPI 2.1.x specifically. */
+export declare const aas2_1: Format;
+/** Matches AsyncAPI 2.2.x specifically. */
+export declare const aas2_2: Format;
+/** Matches AsyncAPI 2.3.x specifically. */
+export declare const aas2_3: Format;
+/** Matches AsyncAPI 2.4.x specifically. */
+export declare const aas2_4: Format;
+/** Matches AsyncAPI 2.5.x specifically. */
+export declare const aas2_5: Format;
+/** Matches AsyncAPI 2.6.x specifically. */
+export declare const aas2_6: Format;
+/** Matches any AsyncAPI 3.x (`asyncapi: 3.*`). */
+export declare const aas3: Format;
+/** Matches AsyncAPI 3.0.x specifically. */
+export declare const aas3_0: Format;
+/** AsyncAPI format detectors keyed by Loupe-compatible names. */
+export declare const aasFormats: Record<string, Format>;

package/dist/rules/asyncapi/formats.js

@@ -0,0 +1,49 @@
+const isObject = (value) => typeof value === "object" && value !== null;
+const asyncApiVersion = (document) => isObject(document) && typeof document["asyncapi"] === "string" ? document["asyncapi"] : void 0;
+const matchesMinor = (document, major, minor) => {
+  const version = asyncApiVersion(document);
+  return version !== void 0 && new RegExp(`^${major}\\.${minor}(\\.|$)`).test(version);
+};
+const aas2 = (document) => /^2\.\d/.test(asyncApiVersion(document) ?? "");
+const aas2_0 = (document) => matchesMinor(document, 2, 0);
+const aas2_1 = (document) => matchesMinor(document, 2, 1);
+const aas2_2 = (document) => matchesMinor(document, 2, 2);
+const aas2_3 = (document) => matchesMinor(document, 2, 3);
+const aas2_4 = (document) => matchesMinor(document, 2, 4);
+const aas2_5 = (document) => matchesMinor(document, 2, 5);
+const aas2_6 = (document) => matchesMinor(document, 2, 6);
+const aas3 = (document) => /^3\.\d/.test(asyncApiVersion(document) ?? "");
+const aas3_0 = (document) => matchesMinor(document, 3, 0);
+const aasFormats = {
+  aas2,
+  "aas2.0": aas2_0,
+  aas2_0,
+  "aas2.1": aas2_1,
+  aas2_1,
+  "aas2.2": aas2_2,
+  aas2_2,
+  "aas2.3": aas2_3,
+  aas2_3,
+  "aas2.4": aas2_4,
+  aas2_4,
+  "aas2.5": aas2_5,
+  aas2_5,
+  "aas2.6": aas2_6,
+  aas2_6,
+  aas3,
+  "aas3.0": aas3_0,
+  aas3_0
+};
+export {
+  aas2,
+  aas2_0,
+  aas2_1,
+  aas2_2,
+  aas2_3,
+  aas2_4,
+  aas2_5,
+  aas2_6,
+  aas3,
+  aas3_0,
+  aasFormats
+};

package/dist/rules/asyncapi/functions/aas-server-variables.d.ts

@@ -0,0 +1,8 @@
+import { type IServerVariablesOptions } from '../../shared/server-variables.js';
+/**
+ * Validates a 2.x Server Object's `variables`. The AsyncAPI and OpenAPI Server
+ * Objects are the same shape here, so the implementation is shared — see
+ * {@link serverVariables}.
+ */
+export declare const aasServerVariables: import("../../../core/types.js").RulesetFunction<unknown, IServerVariablesOptions | undefined>;
+export type { IServerVariablesOptions };

package/dist/rules/asyncapi/functions/aas-server-variables.js

@@ -0,0 +1,5 @@
+import { serverVariables } from "../../shared/server-variables.js";
+const aasServerVariables = serverVariables;
+export {
+  aasServerVariables
+};

package/dist/rules/asyncapi/functions/aas-tags-unique.d.ts

@@ -0,0 +1,2 @@
+/** Flags duplicate tag names within a tags array. Shared with OpenAPI — see {@link tagsUnique}. */
+export declare const aasTagsUnique: import("../../../core/types.js").RulesetFunction;

package/dist/rules/asyncapi/functions/aas-tags-unique.js

@@ -0,0 +1,5 @@
+import { tagsUnique } from "../../shared/tags-unique.js";
+const aasTagsUnique = tagsUnique;
+export {
+  aasTagsUnique
+};

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

@@ -0,0 +1,7 @@
+import type { RulesetFunction } from '../../../core/types.js';
+/**
+ * Every `{parameter}` in a channel's address must be described in its
+ * `parameters` object, and nothing may be described that the address does not
+ * use.
+ */
+export declare const asyncApiChannelParameters: RulesetFunction;