apiuikit 0.1.0

package/dist/components/schema/schemaDisplayUtils.d.ts

@@ -0,0 +1,10 @@
+import { SchemaNodeData } from '../../types/schema';
+export interface TypeDisplay {
+    text: string;
+    format?: string;
+    refHint?: string;
+}
+/** Builds structured type display for SchemaTypeLabel. */
+export declare const buildTypeDisplay: (schema: SchemaNodeData, refLabel?: string) => TypeDisplay;
+/** Whether to show a separate ref footnote beside the type label. */
+export declare const shouldShowRefFootnote: (schema: SchemaNodeData, refLabel?: string) => boolean;

package/dist/components/schema/schemaUtils.d.ts

@@ -0,0 +1,74 @@
+import { SchemaNodeData } from '../../types/schema';
+/** Extracts the schema name from a JSON Pointer, e.g. "#/components/schemas/sentAt" → "sentAt". */
+export declare const refNameFromPath: (ref: string) => string;
+export interface NormalizedSchema {
+    schema: SchemaNodeData;
+    refLabel?: string;
+    circular?: boolean;
+}
+/** Resolves $ref inline via deref; refStack tracks the active chain to detect circular refs. */
+export declare const normalizeSchema: (raw: SchemaNodeData, deref: (ref: string) => unknown, refStack: Set<string>) => NormalizedSchema;
+/** Returns the first item schema from an array definition, if any. */
+export declare const getItemSchema: (schema: SchemaNodeData) => SchemaNodeData | null;
+/** Returns all positional item schemas when items is an array (tuple mode). */
+export declare const getTupleItemSchemas: (schema: SchemaNodeData) => SchemaNodeData[] | null;
+/** Returns additionalItems subschema when in tuple mode (items is an array). */
+export declare const getAdditionalItemsSchema: (schema: SchemaNodeData) => SchemaNodeData | boolean | null;
+/**
+ * Returns the contains subschema (or boolean) when present.
+ * JSON Schema allows contains:true (any item satisfies), contains:false (impossible),
+ * or an object schema. Absent means no constraint.
+ */
+export declare const getContainsSchema: (schema: SchemaNodeData) => SchemaNodeData | boolean | null;
+/** Whether the schema defines a contains keyword. */
+export declare const hasContains: (schema: SchemaNodeData) => boolean;
+/** Combines array- and item-level descriptions when they differ. */
+export declare const mergeDescriptions: (arrayDescription?: string, itemDescription?: string) => string | undefined;
+/** Merges two schema records for display; later values win on scalar conflicts. */
+export declare const mergeSchemaObjects: (a: SchemaNodeData, b: SchemaNodeData, deref: (ref: string) => unknown, refStack: Set<string>) => SchemaNodeData;
+/** Merges allOf subschemas into one; no allOf key in the result. */
+export declare const flattenAllOf: (schema: SchemaNodeData, deref: (ref: string) => unknown, refStack: Set<string>) => SchemaNodeData;
+/** Returns oneOf subschemas when present. */
+export declare const getOneOfItems: (schema: SchemaNodeData) => SchemaNodeData[] | null;
+/** Returns anyOf subschemas when present. */
+export declare const getAnyOfItems: (schema: SchemaNodeData) => SchemaNodeData[] | null;
+/** Returns the not subschema when present. */
+export declare const getNotSchema: (schema: SchemaNodeData) => SchemaNodeData | boolean | null;
+/** Whether the schema defines a not keyword. */
+export declare const hasNotSchema: (schema: SchemaNodeData) => boolean;
+/** Returns a copy of the schema without not (for shape detection). */
+export declare const omitNot: (schema: SchemaNodeData) => SchemaNodeData;
+/** Returns a copy of the schema without if/then/else (for shape detection). */
+export declare const omitIfThenElse: (schema: SchemaNodeData) => SchemaNodeData;
+/** Whether the schema defines an if keyword. */
+export declare const hasIfThenElse: (schema: SchemaNodeData) => boolean;
+/** Safely casts an unknown schema value to SchemaNodeData | boolean | null. */
+export declare const getSubschema: (value: unknown) => SchemaNodeData | boolean | null;
+/** Returns _allOfConditionals set during allOf flattening. */
+export declare const getAllOfConditionals: (schema: SchemaNodeData) => SchemaNodeData[];
+/**
+ * Whether the schema has additional conditionals from allOf flattening.
+ * O(1) check — reads the array length directly rather than allocating a
+ * filtered copy via getAllOfConditionals.
+ */
+export declare const hasAllOfConditionals: (schema: SchemaNodeData) => boolean;
+/** Returns the propertyNames subschema when present. */
+export declare const getPropertyNamesSchema: (schema: SchemaNodeData) => SchemaNodeData | boolean | null;
+/** Returns the additionalProperties subschema when present. */
+export declare const getAdditionalPropertiesSchema: (schema: SchemaNodeData) => SchemaNodeData | boolean | null;
+/** Returns patternProperties entries whose values are schema objects. */
+export declare const getPatternPropertiesEntries: (schema: SchemaNodeData) => [string, SchemaNodeData][];
+/** Path segment for a patternProperties row. */
+export declare const patternPropertyPath: (path: string, pattern: string) => string;
+/** True when the schema defines explicit named properties. */
+export declare const hasExplicitProperties: (schema: SchemaNodeData) => boolean;
+/** True when map keywords yield tree rows (not boolean-only pills). */
+export declare const hasObjectMapContent: (schema: SchemaNodeData) => boolean;
+/** True when the schema has a renderable shape besides not. */
+export declare const hasStructuralShape: (schema: SchemaNodeData) => boolean;
+/** True when a schema has no nested structure worth expanding. */
+export declare const isLeafItemSchema: (schema: SchemaNodeData) => boolean;
+/** Whether a schema (and optional array item schema) has constraints to show. */
+export declare const hasConstraints: (schema: SchemaNodeData, itemSchema?: SchemaNodeData | null) => boolean;
+/** Whether a schema node has children worth showing behind an expand toggle. */
+export declare const hasExpandableContent: (schema: SchemaNodeData, deref?: (ref: string) => unknown) => boolean;

package/dist/components/schema/tests/SchemaTab.test.d.ts

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

package/dist/components/schema/tests/schemaUtils.test.d.ts

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

package/dist/config/config.d.ts

@@ -0,0 +1,62 @@
+export interface ConfigInterface {
+    show?: ShowConfig;
+    expand?: ExpandConfig;
+    sidebar?: SideBarConfig;
+    theme?: ThemeConfig;
+    parserOptions?: any;
+    requestLabel?: string;
+    replyLabel?: string;
+}
+export interface ShowConfig {
+    sidebar?: boolean;
+    info?: boolean;
+    servers?: boolean;
+    operations?: boolean;
+    messages?: boolean;
+    messageExamples?: boolean;
+    schemas?: boolean;
+    errors?: boolean;
+}
+export interface ExpandConfig {
+    messageExamples?: boolean;
+    /**
+     * Whether nested schema tree nodes (object properties, array items, etc.) start expanded.
+     * The top-most level of each schema is always visible. Defaults to false.
+     */
+    schemas?: boolean;
+}
+export interface SideBarConfig {
+    useChannelAddressAsIdentifier?: boolean;
+}
+export interface ThemeColorScale {
+    50?: string;
+    100?: string;
+    200?: string;
+    300?: string;
+    500?: string;
+    600?: string;
+    700?: string;
+}
+/** Brand color scales — shared across light and dark, since they don't usually change per-mode. */
+export interface ThemeColors {
+    primary?: ThemeColorScale;
+    secondary?: ThemeColorScale;
+    neutral?: ThemeColorScale;
+}
+/** Semantic surface/text colors for a single mode — these inherently differ between light and dark. */
+export interface ThemeModeColors {
+    background?: string;
+    surface?: string;
+    border?: string;
+    textPrimary?: string;
+    textSecondary?: string;
+    textMuted?: string;
+}
+export interface ThemeConfig {
+    /** Brand color scale overrides, applied regardless of which mode is active. */
+    colors?: ThemeColors;
+    /** Applied when only a light theme is configured. */
+    light?: ThemeModeColors;
+    /** Applied when a dark theme is configured. Wins over `light` if both are set. */
+    dark?: ThemeModeColors;
+}

package/dist/config/default.d.ts

@@ -0,0 +1,2 @@
+import { ConfigInterface } from './config';
+export declare const defaultConfig: ConfigInterface;

package/dist/config/index.d.ts

@@ -0,0 +1,2 @@
+export * from './config';
+export * from './default';

package/dist/containers/AsyncAPI/AsyncAPI.d.ts

@@ -0,0 +1,12 @@
+import { ConfigInterface } from '../../config';
+import { AsyncAPIDocumentData } from '../../types/schema';
+export type IAsyncAPIProps = {
+    asyncapi: AsyncAPIDocumentData;
+    config?: ConfigInterface;
+} | {
+    kind: "resolved";
+    doc: AsyncAPIDocumentData;
+    config?: ConfigInterface;
+};
+declare const AsyncAPI: (props: IAsyncAPIProps) => import("react").JSX.Element;
+export default AsyncAPI;

package/dist/containers/AsyncAPI/AsyncAPIRenderer.d.ts

@@ -0,0 +1,8 @@
+import { ConfigInterface } from '../../config/config';
+interface AsyncAPIRendererProps {
+    raw: string;
+    config?: ConfigInterface;
+    onDiagnostics?: (diagnostics: unknown[]) => void;
+}
+export declare function AsyncAPIRenderer({ raw, config, onDiagnostics }: AsyncAPIRendererProps): import("react").JSX.Element | null;
+export {};

package/dist/containers/AsyncAPI/Layout.d.ts

@@ -0,0 +1,7 @@
+import { ConfigInterface } from '../../config';
+import { AsyncAPIDocumentData } from '../../types/schema';
+export interface LayoutProps {
+    asyncapi: AsyncAPIDocumentData;
+    config: ConfigInterface;
+}
+export default function Layout({ asyncapi, config }: LayoutProps): import("react").JSX.Element;

package/dist/containers/AsyncAPI/tests/AsyncAPI.test.d.ts

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

package/dist/containers/AsyncAPI/tests/AsyncAPIRenderer.test.d.ts

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

package/dist/containers/Information/Information.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { Info as AsyncAPIMetadata } from '../../types/asyncapi/Info';
+declare const Information: React.FunctionComponent<AsyncAPIMetadata>;
+export default Information;

package/dist/containers/Messages/Message.d.ts

@@ -0,0 +1,8 @@
+import { MessageObject } from '../../types/asyncapi/MessageObject';
+interface MessageProps {
+    message: MessageObject;
+    messageId?: string;
+    i: number;
+}
+export declare function Message({ message, messageId, i }: MessageProps): import("react").JSX.Element;
+export {};

package/dist/containers/Messages/MessageDetails.d.ts

@@ -0,0 +1,9 @@
+import { MessageObject } from '../../types/asyncapi/MessageObject';
+interface MessageDetailsProps {
+    message: MessageObject;
+    expanded: boolean;
+    onToggleExpanded: () => void;
+    paddingX?: string;
+}
+export declare function MessageDetails({ message, expanded, onToggleExpanded, paddingX, }: MessageDetailsProps): import("react").JSX.Element;
+export {};

package/dist/containers/Messages/Messages.d.ts

@@ -0,0 +1,7 @@
+import { MessageObject } from '../../types/asyncapi/MessageObject';
+interface MessagesProps {
+    messages: Record<string, MessageObject>;
+    selectedKey?: string | null;
+}
+export default function Messages({ messages, selectedKey }: MessagesProps): import("react").JSX.Element;
+export {};

package/dist/containers/Operation/Operation.d.ts

@@ -0,0 +1,7 @@
+import { Operation as OperationInterface } from '../../types/asyncapi/Operation';
+interface OperationProps {
+    op: OperationInterface;
+    id: string | null;
+}
+export default function Operation({ op, id }: OperationProps): import("react").JSX.Element;
+export {};

package/dist/containers/Operation/Operations.d.ts

@@ -0,0 +1,8 @@
+import { Operation as OperationType } from '../../types/asyncapi/Operation';
+interface OperationsProps {
+    operations: Record<string, OperationType>;
+    selectedKey?: string | null;
+    onSelectKey?: (key: string | null) => void;
+}
+export default function Operations({ operations, selectedKey, onSelectKey }: OperationsProps): import("react").JSX.Element | null;
+export {};

package/dist/containers/Schema/SchemaViewer.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+interface SchemaViewerProps {
+    schema: object | unknown;
+    title?: string;
+}
+export declare const SchemaViewer: React.FC<SchemaViewerProps>;
+export {};

package/dist/containers/Schema/Schemas.d.ts

@@ -0,0 +1,7 @@
+import { SchemaNodeData } from '../../types/schema';
+interface SchemasProps {
+    schemas: Record<string, SchemaNodeData>;
+    selectedKey?: string | null;
+}
+export default function Schemas({ schemas, selectedKey }: SchemasProps): import("react").JSX.Element;
+export {};

package/dist/containers/Server/Server.d.ts

@@ -0,0 +1,2 @@
+import { Server as ServerInterface } from '../../types/asyncapi/Server';
+export default function Server({ host, protocol, description, tags, variables, security, bindings, }: ServerInterface): import("react").JSX.Element;

package/dist/containers/Server/Servers.d.ts

@@ -0,0 +1,6 @@
+import { Server as ServerInterface } from '../../types/asyncapi/Server';
+interface ServersInterface {
+    [key: string]: Record<string, ServerInterface>;
+}
+export default function Servers({ servers }: ServersInterface): import("react").JSX.Element;
+export {};

package/dist/contants.d.ts

@@ -0,0 +1,26 @@
+export declare const CONTACT_TEXT = "Contact";
+export declare const NAM_TEXT = "Name";
+export declare const URL_TEXT = "Url";
+export declare const EMAIL_TEXT = "Email";
+export declare const LICENSE_TEXT = "License";
+export declare const TERMS_OF_SERVICE_TEXT = "Terms of service";
+export declare const URL_SUPPORT_TEXT = "Support";
+export declare const EMAIL_SUPPORT_TEXT = "Email support";
+export declare const EXTERNAL_DOCUMENTATION_TEXT = "External Documentation";
+export declare const TAGS_TEXT = "Tags";
+export declare const IMPLICIT_TEXT = "Implicit";
+export declare const IMPLICIT_DESCRIPTION = "The Implicit flow is a simplified OAuth flow previously recommended\n          for native apps and JavaScript apps where the access token is returned\n          immediately without an extra authorization code exchange step.";
+export declare const CLIENT_CREDENTIALS_TEXT = "Client Credentials";
+export declare const CLIENT_CREDENTIALS_DESCRIPTION = "The Client Credentials grant type is used by clients to obtain an access token outside of the context of a user.";
+export declare const PASSWORD_TEXT = "Password";
+export declare const PASSWORD_DESCRIPTION = "The Password grant type is a legacy way to exchange a user's credentials for an access token.";
+export declare const AUTHORIZATION_CODE_TEXT = "Authorization Code";
+export declare const AUTHORIZATION_CODE_DESCRIPTION = "The Authorization Code grant type is used by confidential and public clients to exchange an authorization code for an access token.";
+export declare const SERVER_TEXT = "Connecting to a server";
+export declare const Operation_TEXT = "";
+export declare const chunkColors: string[];
+export declare const SHADES: readonly [50, 100, 200, 300, 500, 600, 700];
+export declare const PROTOCOL_META: Record<string, {
+    label: string;
+    color: string;
+}>;

package/dist/contexts/index.d.ts

@@ -0,0 +1 @@
+export * from './useSpec';

package/dist/contexts/useSpec.d.ts

@@ -0,0 +1,14 @@
+type AsyncAPIDocument = Record<string, unknown>;
+interface AsyncAPIContextValue {
+    document: AsyncAPIDocument;
+    /** Resolves a JSON Pointer $ref string to the object it references in the document. */
+    deref: (ref: string) => unknown;
+    portalHost: HTMLElement | null;
+    /** The Layout component's own root element — used to scope viewport-fixed overlays (e.g. SidePanel) to where <AsyncAPI> is actually embedded, rather than the full browser viewport. */
+    rootElement: HTMLElement | null;
+    /** Whether schema tree nodes start expanded by default. Defaults to false. */
+    defaultSchemaExpanded?: boolean;
+}
+export declare const AsyncAPIDocumentContext: import('react').Context<AsyncAPIContextValue | null>;
+export declare const useAsyncAPIDocument: () => AsyncAPIContextValue;
+export {};

package/dist/helpers/avro/avroSchemaParser.d.ts

@@ -0,0 +1,8 @@
+import { SchemaParser } from '@asyncapi/parser';
+import { SchemaParserHost } from '../schemaParserRegistry';
+export declare function AvroSchemaParser(): SchemaParser;
+/**
+ * Registers the Avro schema parser and makes parser-js accept any Avro
+ * schemaFormat version (not only the exact strings in AVRO_MIME_TYPES).
+ */
+export declare function registerAvroSchemaParser(parser: SchemaParserHost): void;

package/dist/helpers/avro/avroToJsonSchema.d.ts

@@ -0,0 +1,4 @@
+import { SchemaNodeData } from '../../types/schema';
+import { AvroSchema } from './types';
+/** Converts an Avro schema into a JSON-Schema-shaped object for rendering. */
+export declare function avroToJsonSchema(avroDefinition: AvroSchema): SchemaNodeData;

package/dist/helpers/avro/index.d.ts

@@ -0,0 +1,3 @@
+export { avroToJsonSchema } from './avroToJsonSchema';
+export { validateAvroStructure } from './validateAvroStructure';
+export type { AvroSchema, AvroSchemaObject, AvroField, AvroPrimitiveType, } from './types';

package/dist/helpers/avro/tests/avroToJsonSchema.test.d.ts

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

package/dist/helpers/avro/types.d.ts

@@ -0,0 +1,70 @@
+export type AvroPrimitiveType = "null" | "boolean" | "int" | "long" | "float" | "double" | "bytes" | "string" | "uuid";
+export interface AvroField {
+    name: string;
+    type: AvroSchema;
+    doc?: string;
+    default?: unknown;
+    order?: "ascending" | "descending" | "ignore";
+    aliases?: string[];
+    [key: string]: unknown;
+}
+export interface AvroRecordSchema {
+    type: "record";
+    name: string;
+    namespace?: string;
+    doc?: string;
+    aliases?: string[];
+    fields: AvroField[];
+    [key: string]: unknown;
+}
+export interface AvroEnumSchema {
+    type: "enum";
+    name: string;
+    namespace?: string;
+    doc?: string;
+    symbols: string[];
+    default?: string;
+    [key: string]: unknown;
+}
+export interface AvroArraySchema {
+    type: "array";
+    items: AvroSchema;
+    default?: unknown[];
+    [key: string]: unknown;
+}
+export interface AvroMapSchema {
+    type: "map";
+    values: AvroSchema;
+    default?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface AvroFixedSchema {
+    type: "fixed";
+    name: string;
+    namespace?: string;
+    size: number;
+    [key: string]: unknown;
+}
+export interface AvroPrimitiveSchema {
+    type: AvroPrimitiveType;
+    logicalType?: string;
+    [key: string]: unknown;
+}
+/**
+ * Object-shaped reference to a previously defined named type, optionally with
+ * site-specific attributes (e.g. `{ type: "MyRecord", doc: "…" }`).
+ */
+export interface AvroNamedTypeReference {
+    type: string;
+    name?: string;
+    namespace?: string;
+    doc?: string;
+    default?: unknown;
+    [key: string]: unknown;
+}
+export type AvroSchemaObject = AvroRecordSchema | AvroEnumSchema | AvroArraySchema | AvroMapSchema | AvroFixedSchema | AvroPrimitiveSchema | AvroNamedTypeReference;
+/**
+ * An Avro schema definition: a primitive-type or named-type-reference string,
+ * a definition object, or a union (array of alternatives).
+ */
+export type AvroSchema = string | AvroSchemaObject | AvroSchema[];

package/dist/helpers/avro/validateAvroStructure.d.ts

@@ -0,0 +1,2 @@
+/** Returns a list of structural problems; an empty list means convertible. */
+export declare function validateAvroStructure(definition: unknown): string[];

package/dist/helpers/bindingsSelector.d.ts

@@ -0,0 +1,2 @@
+import { JSONSchema7 } from 'json-schema';
+export default function bindingSelector(protocol: string, version: string | null): JSONSchema7;

package/dist/helpers/classNames.d.ts

@@ -0,0 +1 @@
+export default function classNames(...classes: (string | undefined | null | false | 0)[]): string;

package/dist/helpers/common.d.ts

@@ -0,0 +1,6 @@
+import { OperationAction } from '../types/asyncapi/OperationAction';
+import { Operation } from '../types/asyncapi/Operation';
+export declare function isUrl(value: string): boolean;
+export declare class CommonHelpers {
+    static getOperationType(operation: Operation): OperationAction;
+}

package/dist/helpers/formatEnumDescription.d.ts

@@ -0,0 +1,3 @@
+import { JSX } from 'react';
+export default function formatEnumDescription(values: string[]): JSX.Element;
+export declare function formatArrayToCodeString(arr: string[]): string;

package/dist/helpers/marked.d.ts

@@ -0,0 +1,3 @@
+import { default as hljs } from 'highlight.js/lib/core';
+export declare function renderMarkdown(content: string): string;
+export { hljs };

package/dist/helpers/parser.d.ts

@@ -0,0 +1,10 @@
+import { AsyncAPIDocumentData } from '../types/schema';
+import { ConfigInterface } from '../config/config';
+export declare function parseDocument(raw: string): Promise<{
+    diagnostics: unknown[];
+    document: AsyncAPIDocumentData | null;
+}>;
+export declare function parseAndRender(raw: string, config?: ConfigInterface): Promise<{
+    diagnostics: unknown[];
+    view: import("react").JSX.Element | null;
+}>;

package/dist/helpers/protobuf/googleTypes.d.ts

@@ -0,0 +1 @@
+export declare const googleProtoTypes: Record<string, Record<string, unknown>>;

package/dist/helpers/protobuf/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Pure protobuf → JSON Schema conversion API, consumed by schemaFormat.ts.
+ *
+ * protobufSchemaParser.ts (the @asyncapi/parser plugin) is deliberately NOT
+ * re-exported here: the plugin imports from schemaFormat.ts, so routing it
+ * through this barrel would create an import cycle
+ * (schemaFormat → protobuf barrel → plugin → schemaFormat).
+ */
+export { protoToJsonSchema } from './protoToJsonSchema';
+export { validateProtobufStructure } from './validateProtobufStructure';

package/dist/helpers/protobuf/pathUtils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Minimal path normalization/resolution for `.proto` import statements,
+ * dependency-free so it runs in the browser (Node's `path` is unavailable).
+ *
+ * Ported verbatim from @asyncapi/protobuf-schema-parser
+ * (https://github.com/asyncapi/protobuf-schema-parser), Copyright the
+ * AsyncAPI Initiative, licensed under Apache-2.0 — see THIRD_PARTY_NOTICES.md.
+ */
+export declare class Path {
+    static isAbsolute(path: string): boolean;
+    static normalize(path: string): string;
+    static resolve(originPath: string, includePath: string, alreadyNormalized?: boolean): string;
+}

package/dist/helpers/protobuf/primitiveTypes.d.ts

@@ -0,0 +1,16 @@
+import { SchemaNodeData } from '../../types/schema';
+export interface ProtoTypeMap {
+    [key: string]: SchemaNodeData;
+}
+export declare class PrimitiveTypes {
+    private static readonly MAX_SAFE_INTEGER;
+    private static readonly MIN_SAFE_INTEGER;
+    static readonly PRIMITIVE_TYPES_WITH_LIMITS: ProtoTypeMap;
+    /**
+     * Same as PRIMITIVE_TYPES_WITH_LIMITS but without the numeric
+     * `minimum`/`maximum` range limits. Derived from the map above to avoid
+     * duplicating every entry.
+     */
+    static readonly PRIMITIVE_TYPES_MINIMAL: ProtoTypeMap;
+    private static withoutRangeLimits;
+}

package/dist/helpers/protobuf/protoToJsonSchema.d.ts

@@ -0,0 +1,7 @@
+import { SchemaNodeData } from '../../types/schema';
+/**
+ * Converts `.proto` source text into a JSON-Schema-shaped object. Throws on
+ * unparsable source, unresolvable (non-bundled) imports, or ambiguous root
+ * messages — callers are expected to fail soft.
+ */
+export declare function protoToJsonSchema(rawSchema: string): SchemaNodeData;

package/dist/helpers/protobuf/protobufSchemaParser.d.ts

@@ -0,0 +1,9 @@
+import { SchemaParser } from '@asyncapi/parser';
+import { SchemaParserHost } from '../schemaParserRegistry';
+export declare function ProtobufSchemaParser(): SchemaParser;
+/**
+ * Registers the Protobuf schema parser and makes parser-js accept any
+ * protobuf schemaFormat version (not only the exact strings in
+ * PROTOBUF_MIME_TYPES).
+ */
+export declare function registerProtobufSchemaParser(parser: SchemaParserHost): void;

package/dist/helpers/protobuf/protocGenValidate.d.ts

@@ -0,0 +1,3 @@
+import { Field } from 'protobufjs';
+import { SchemaNodeData } from '../../types/schema';
+export declare function visit(obj: SchemaNodeData, field: Field): void;

package/dist/helpers/protobuf/protovalidate.d.ts

@@ -0,0 +1,8 @@
+import { Field } from 'protobufjs';
+import { SchemaNodeData } from '../../types/schema';
+type HashMap = Record<string, unknown>;
+export declare function visit(obj: SchemaNodeData, field: Field): void;
+export declare function findRootOption(field: Field, optionPrefix: string): null | HashMap;
+export declare function protocGenValidate(option: HashMap, obj: SchemaNodeData): void;
+export declare function isOptional(field: Field): boolean;
+export {};

package/dist/helpers/protobuf/tests/protoToJsonSchema.test.d.ts

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

package/dist/helpers/protobuf/tests/protobufSchemaParser.test.d.ts

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

package/dist/helpers/protobuf/validateProtobufStructure.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns human-readable problems with a protobuf schema definition, or an
+ * empty array when the source compiles. Never throws.
+ */
+export declare function validateProtobufStructure(definition: unknown): string[];

package/dist/helpers/schemaFormat.d.ts

@@ -0,0 +1,53 @@
+import { SchemaNodeData } from '../types/schema';
+export declare const X_PARSER_ORIGINAL_PAYLOAD = "x-parser-original-payload";
+/** Marker set by the with-parser fail-soft path when conversion throws. */
+export declare const X_LIB_CONVERSION_ERROR = "x-lib-conversion-error";
+export interface ResolvedSchemaInput {
+    /** The JSON-Schema-shaped object SchemaTree/Examples should render. */
+    schema: SchemaNodeData;
+    /** The declared schemaFormat, when the input was a multi-format wrapper. */
+    schemaFormat?: string;
+    /** The source schema (e.g. raw Avro), when a conversion happened. */
+    originalSchema?: unknown;
+    /** Set when an Avro/Protobuf format was declared but conversion failed;
+     * `schema` falls back to the raw definition (or `{}` when the raw input is
+     * not object-shaped, e.g. protobuf source text). */
+    conversionError?: string;
+    /** Description to display: the resolved schema's own `description`, falling
+     * back to one carried on the multi-format wrapper (not spec-defined there,
+     * but tolerated — the parser passes it through untouched). */
+    description?: string;
+}
+export declare function isAvroSchemaFormat(format: unknown): boolean;
+export declare function isProtobufSchemaFormat(format: unknown): boolean;
+export declare function isMultiFormatSchema(value: unknown): value is {
+    schemaFormat: string;
+    schema: unknown;
+} & Record<string, unknown>;
+/** Short badge text for a declared schemaFormat, e.g. "avro 1.9.0"; null for
+ * the default AsyncAPI / JSON Schema formats that need no callout. */
+export declare function schemaFormatBadge(format: unknown): string | null;
+/** Human-readable name for a declared schemaFormat, used in messages like
+ * "Could not convert Avro schema"; null when the format has no short name
+ * (callers phrase around it, e.g. "Could not convert the schema"). */
+export declare function schemaFormatName(format: unknown): string | null;
+/** Whether the Example tab can safely generate samples via json-schema-faker.
+ * Formats the lib converts (Avro, Protobuf) qualify; other non-JSON-Schema
+ * multi-format bodies (RAML, …) are excluded. */
+export declare function supportsGeneratedExamples(schemaFormat?: string, conversionError?: string): boolean;
+/**
+ * Discriminates a raw Avro definition from an already-converted JSON Schema,
+ * for the case where a document declares an Avro schemaFormat but the schema
+ * may have been converted upstream. Ambiguous leaves (e.g. {type:"string"})
+ * count as raw — converting them is harmless.
+ */
+export declare function looksLikeRawAvro(value: unknown): boolean;
+/**
+ * Normalizes any payload/headers/components.schemas entry for rendering:
+ * unwraps v3 multi-format wrappers and converts raw Avro to JSON Schema when
+ * an Avro schemaFormat is declared. Never throws.
+ *
+ * When `deref` is provided, a top-level `$ref` is resolved first so multi-format
+ * Avro wrappers behind a ref still convert (and surface format/error metadata).
+ */
+export declare function resolveSchemaInput(input: unknown, deref?: (ref: string) => unknown): ResolvedSchemaInput;