@nice2dev/ui-tools 1.0.10

package/dist/api-designer.d.ts

@@ -0,0 +1,1568 @@
+/**
+ * @file api-designer.ts
+ * @module @nice2dev/ui-tools
+ * @description PRO-13.1 — API Designer
+ *
+ * Types for API design tools: OpenAPI, GraphQL, AsyncAPI, Protocol Buffers,
+ * Thrift, Avro, schema visualization, mock servers, code generation, and more.
+ */
+/** HTTP method type */
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE';
+/** Parameter location */
+export type ParameterLocation = 'path' | 'query' | 'header' | 'cookie' | 'body';
+/** Data format type */
+export type SchemaFormat = 'int32' | 'int64' | 'float' | 'double' | 'byte' | 'binary' | 'date' | 'date-time' | 'password' | 'email' | 'uri' | 'uuid' | 'hostname' | 'ipv4' | 'ipv6';
+/** Primitive schema type */
+export type SchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object' | 'null';
+/** OpenAPI specification document */
+export interface OpenAPISpec {
+    /** OpenAPI version (3.0.x, 3.1.x) */
+    openapi: string;
+    /** API information */
+    info: OpenAPIInfo;
+    /** Server URLs */
+    servers?: OpenAPIServer[];
+    /** API paths */
+    paths: Record<string, OpenAPIPathItem>;
+    /** Reusable components */
+    components?: OpenAPIComponents;
+    /** Security requirements */
+    security?: OpenAPISecurityRequirement[];
+    /** Tags for grouping */
+    tags?: OpenAPITag[];
+    /** External documentation */
+    externalDocs?: OpenAPIExternalDocs;
+}
+/** API info object */
+export interface OpenAPIInfo {
+    /** API title */
+    title: string;
+    /** API version */
+    version: string;
+    /** API description */
+    description?: string;
+    /** Terms of service URL */
+    termsOfService?: string;
+    /** Contact information */
+    contact?: OpenAPIContact;
+    /** License information */
+    license?: OpenAPILicense;
+}
+/** Contact information */
+export interface OpenAPIContact {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+/** License information */
+export interface OpenAPILicense {
+    name: string;
+    url?: string;
+    identifier?: string;
+}
+/** Server object */
+export interface OpenAPIServer {
+    url: string;
+    description?: string;
+    variables?: Record<string, OpenAPIServerVariable>;
+}
+/** Server variable */
+export interface OpenAPIServerVariable {
+    default: string;
+    description?: string;
+    enum?: string[];
+}
+/** Path item object */
+export interface OpenAPIPathItem {
+    summary?: string;
+    description?: string;
+    get?: OpenAPIOperation;
+    post?: OpenAPIOperation;
+    put?: OpenAPIOperation;
+    patch?: OpenAPIOperation;
+    delete?: OpenAPIOperation;
+    head?: OpenAPIOperation;
+    options?: OpenAPIOperation;
+    trace?: OpenAPIOperation;
+    parameters?: OpenAPIParameter[];
+}
+/** Operation object */
+export interface OpenAPIOperation {
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    parameters?: OpenAPIParameter[];
+    requestBody?: OpenAPIRequestBody;
+    responses: Record<string, OpenAPIResponse>;
+    security?: OpenAPISecurityRequirement[];
+    deprecated?: boolean;
+    servers?: OpenAPIServer[];
+    externalDocs?: OpenAPIExternalDocs;
+    'x-codegen-request-body-name'?: string;
+    callbacks?: Record<string, Record<string, OpenAPIPathItem>>;
+}
+/** Parameter object */
+export interface OpenAPIParameter {
+    name: string;
+    in: ParameterLocation;
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    schema?: OpenAPISchema;
+    style?: ParameterStyle;
+    explode?: boolean;
+    example?: unknown;
+    examples?: Record<string, OpenAPIExample>;
+}
+/** Parameter serialization style */
+export type ParameterStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+/** Request body object */
+export interface OpenAPIRequestBody {
+    description?: string;
+    required?: boolean;
+    content: Record<string, OpenAPIMediaType>;
+}
+/** Media type object */
+export interface OpenAPIMediaType {
+    schema?: OpenAPISchema;
+    example?: unknown;
+    examples?: Record<string, OpenAPIExample>;
+    encoding?: Record<string, OpenAPIEncoding>;
+}
+/** Encoding object for multipart */
+export interface OpenAPIEncoding {
+    contentType?: string;
+    headers?: Record<string, OpenAPIHeader>;
+    style?: ParameterStyle;
+    explode?: boolean;
+    allowReserved?: boolean;
+}
+/** Header object */
+export interface OpenAPIHeader extends Omit<OpenAPIParameter, 'name' | 'in'> {
+}
+/** Response object */
+export interface OpenAPIResponse {
+    description: string;
+    headers?: Record<string, OpenAPIHeader>;
+    content?: Record<string, OpenAPIMediaType>;
+    links?: Record<string, OpenAPILink>;
+}
+/** Link object */
+export interface OpenAPILink {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: Record<string, unknown>;
+    requestBody?: unknown;
+    description?: string;
+    server?: OpenAPIServer;
+}
+/** Schema object */
+export interface OpenAPISchema {
+    $ref?: string;
+    type?: SchemaType | SchemaType[];
+    format?: SchemaFormat | string;
+    title?: string;
+    description?: string;
+    default?: unknown;
+    example?: unknown;
+    enum?: unknown[];
+    const?: unknown;
+    nullable?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    deprecated?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number | boolean;
+    exclusiveMaximum?: number | boolean;
+    multipleOf?: number;
+    items?: OpenAPISchema;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    contains?: OpenAPISchema;
+    minContains?: number;
+    maxContains?: number;
+    properties?: Record<string, OpenAPISchema>;
+    additionalProperties?: boolean | OpenAPISchema;
+    required?: string[];
+    minProperties?: number;
+    maxProperties?: number;
+    patternProperties?: Record<string, OpenAPISchema>;
+    propertyNames?: OpenAPISchema;
+    allOf?: OpenAPISchema[];
+    oneOf?: OpenAPISchema[];
+    anyOf?: OpenAPISchema[];
+    not?: OpenAPISchema;
+    discriminator?: OpenAPIDiscriminator;
+    externalDocs?: OpenAPIExternalDocs;
+    xml?: OpenAPIXml;
+}
+/** Discriminator object */
+export interface OpenAPIDiscriminator {
+    propertyName: string;
+    mapping?: Record<string, string>;
+}
+/** XML object */
+export interface OpenAPIXml {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+}
+/** Example object */
+export interface OpenAPIExample {
+    summary?: string;
+    description?: string;
+    value?: unknown;
+    externalValue?: string;
+}
+/** Security scheme object */
+export interface OpenAPISecurityScheme {
+    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect' | 'mutualTLS';
+    description?: string;
+    name?: string;
+    in?: 'query' | 'header' | 'cookie';
+    scheme?: string;
+    bearerFormat?: string;
+    flows?: OpenAPIOAuthFlows;
+    openIdConnectUrl?: string;
+}
+/** OAuth flows object */
+export interface OpenAPIOAuthFlows {
+    implicit?: OpenAPIOAuthFlow;
+    password?: OpenAPIOAuthFlow;
+    clientCredentials?: OpenAPIOAuthFlow;
+    authorizationCode?: OpenAPIOAuthFlow;
+}
+/** OAuth flow object */
+export interface OpenAPIOAuthFlow {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: Record<string, string>;
+}
+/** Security requirement object */
+export type OpenAPISecurityRequirement = Record<string, string[]>;
+/** Tag object */
+export interface OpenAPITag {
+    name: string;
+    description?: string;
+    externalDocs?: OpenAPIExternalDocs;
+}
+/** External documentation object */
+export interface OpenAPIExternalDocs {
+    url: string;
+    description?: string;
+}
+/** Components object */
+export interface OpenAPIComponents {
+    schemas?: Record<string, OpenAPISchema>;
+    responses?: Record<string, OpenAPIResponse>;
+    parameters?: Record<string, OpenAPIParameter>;
+    examples?: Record<string, OpenAPIExample>;
+    requestBodies?: Record<string, OpenAPIRequestBody>;
+    headers?: Record<string, OpenAPIHeader>;
+    securitySchemes?: Record<string, OpenAPISecurityScheme>;
+    links?: Record<string, OpenAPILink>;
+    callbacks?: Record<string, Record<string, OpenAPIPathItem>>;
+    pathItems?: Record<string, OpenAPIPathItem>;
+}
+/** OpenAPI editor configuration */
+export interface OpenAPIEditorConfig {
+    /** Spec source (URL, file, or inline)*/
+    source: OpenAPISource;
+    /** Editor theme */
+    theme?: 'light' | 'dark' | 'swagger';
+    /** Enable spec validation */
+    validation?: boolean;
+    /** Validation rules */
+    validationRules?: OpenAPIValidationConfig;
+    /** Enable autocomplete */
+    autocomplete?: boolean;
+    /** Show preview panel */
+    showPreview?: boolean;
+    /** Preview layout */
+    previewLayout?: 'split' | 'tabs';
+    /** Enable YAML/JSON toggle */
+    formatToggle?: boolean;
+    /** Default format */
+    defaultFormat?: 'yaml' | 'json';
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Auto-save interval (ms) */
+    autoSaveInterval?: number;
+    /** Version history */
+    enableHistory?: boolean;
+    /** Collaboration mode */
+    collaboration?: CollaborationConfig;
+}
+/** OpenAPI source configuration */
+export interface OpenAPISource {
+    type: 'url' | 'file' | 'inline';
+    url?: string;
+    content?: string;
+    format?: 'yaml' | 'json';
+}
+/** Validation configuration */
+export interface OpenAPIValidationConfig {
+    /** Validate on change */
+    validateOnChange?: boolean;
+    /** Validation level */
+    level?: 'error' | 'warning' | 'info';
+    /** Rules to enable/disable */
+    rules?: Record<string, boolean>;
+    /** Custom validators */
+    customValidators?: OpenAPIValidator[];
+}
+/** Custom validator */
+export interface OpenAPIValidator {
+    name: string;
+    description?: string;
+    validate: (spec: OpenAPISpec) => OpenAPIValidationResult[];
+}
+/** Validation result */
+export interface OpenAPIValidationResult {
+    level: 'error' | 'warning' | 'info';
+    message: string;
+    path: string;
+    line?: number;
+    column?: number;
+    rule?: string;
+}
+/** Collaboration configuration */
+export interface CollaborationConfig {
+    enabled: boolean;
+    provider?: 'yjs' | 'automerge' | 'custom';
+    serverUrl?: string;
+    roomId?: string;
+    userName?: string;
+    userColor?: string;
+}
+/** GraphQL schema document */
+export interface GraphQLSchemaDefinition {
+    /** Raw SDL */
+    sdl: string;
+    /** Parsed types */
+    types: GraphQLTypeDefinition[];
+    /** Root query type name */
+    queryType?: string;
+    /** Root mutation type name */
+    mutationType?: string;
+    /** Root subscription type name */
+    subscriptionType?: string;
+    /** Directives */
+    directives: GraphQLDirectiveDefinition[];
+}
+/** GraphQL type definition */
+export interface GraphQLTypeDefinition {
+    kind: GraphQLTypeKind;
+    name: string;
+    description?: string;
+    fields?: GraphQLFieldDefinition[];
+    interfaces?: string[];
+    possibleTypes?: string[];
+    enumValues?: GraphQLEnumValue[];
+    inputFields?: GraphQLInputValue[];
+    directives?: GraphQLDirectiveUsage[];
+}
+/** GraphQL type kind */
+export type GraphQLTypeKind = 'SCALAR' | 'OBJECT' | 'INTERFACE' | 'UNION' | 'ENUM' | 'INPUT_OBJECT';
+/** GraphQL field definition */
+export interface GraphQLFieldDefinition {
+    name: string;
+    description?: string;
+    type: GraphQLTypeRef;
+    args?: GraphQLInputValue[];
+    deprecationReason?: string;
+    directives?: GraphQLDirectiveUsage[];
+}
+/** GraphQL type reference */
+export interface GraphQLTypeRef {
+    kind: 'SCALAR' | 'OBJECT' | 'INTERFACE' | 'UNION' | 'ENUM' | 'INPUT_OBJECT' | 'NON_NULL' | 'LIST';
+    name?: string;
+    ofType?: GraphQLTypeRef;
+}
+/** GraphQL input value (field arg or input field) */
+export interface GraphQLInputValue {
+    name: string;
+    description?: string;
+    type: GraphQLTypeRef;
+    defaultValue?: string;
+    deprecationReason?: string;
+    directives?: GraphQLDirectiveUsage[];
+}
+/** GraphQL enum value */
+export interface GraphQLEnumValue {
+    name: string;
+    description?: string;
+    deprecationReason?: string;
+    directives?: GraphQLDirectiveUsage[];
+}
+/** GraphQL directive definition */
+export interface GraphQLDirectiveDefinition {
+    name: string;
+    description?: string;
+    locations: GraphQLDirectiveLocation[];
+    args?: GraphQLInputValue[];
+    isRepeatable?: boolean;
+}
+/** GraphQL directive location */
+export type GraphQLDirectiveLocation = 'QUERY' | 'MUTATION' | 'SUBSCRIPTION' | 'FIELD' | 'FRAGMENT_DEFINITION' | 'FRAGMENT_SPREAD' | 'INLINE_FRAGMENT' | 'VARIABLE_DEFINITION' | 'SCHEMA' | 'SCALAR' | 'OBJECT' | 'FIELD_DEFINITION' | 'ARGUMENT_DEFINITION' | 'INTERFACE' | 'UNION' | 'ENUM' | 'ENUM_VALUE' | 'INPUT_OBJECT' | 'INPUT_FIELD_DEFINITION';
+/** GraphQL directive usage */
+export interface GraphQLDirectiveUsage {
+    name: string;
+    args?: Record<string, unknown>;
+}
+/** GraphQL editor configuration */
+export interface GraphQLEditorConfig {
+    /** Schema source */
+    source: GraphQLSource;
+    /** Explorer enabled */
+    showExplorer?: boolean;
+    /** Documentation panel */
+    showDocs?: boolean;
+    /** Query history */
+    enableHistory?: boolean;
+    /** Prettify on save */
+    prettify?: boolean;
+    /** Tab size */
+    tabSize?: number;
+    /** Use tabs */
+    useTabs?: boolean;
+    /** Theme */
+    theme?: 'light' | 'dark' | 'graphiql';
+    /** Headers for introspection */
+    headers?: Record<string, string>;
+    /** Subscription endpoint */
+    subscriptionEndpoint?: string;
+}
+/** GraphQL source */
+export interface GraphQLSource {
+    type: 'url' | 'file' | 'inline';
+    /** Introspection endpoint URL */
+    url?: string;
+    /** SDL content */
+    sdl?: string;
+    /** File path */
+    path?: string;
+}
+/** AsyncAPI specification document */
+export interface AsyncAPISpec {
+    asyncapi: string;
+    info: AsyncAPIInfo;
+    servers?: Record<string, AsyncAPIServer>;
+    channels: Record<string, AsyncAPIChannel>;
+    components?: AsyncAPIComponents;
+    tags?: AsyncAPITag[];
+    externalDocs?: AsyncAPIExternalDocs;
+    defaultContentType?: string;
+}
+/** AsyncAPI info */
+export interface AsyncAPIInfo {
+    title: string;
+    version: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: AsyncAPIContact;
+    license?: AsyncAPILicense;
+}
+/** AsyncAPI contact */
+export interface AsyncAPIContact {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+/** AsyncAPI license */
+export interface AsyncAPILicense {
+    name: string;
+    url?: string;
+}
+/** AsyncAPI server */
+export interface AsyncAPIServer {
+    url: string;
+    protocol: AsyncAPIProtocol;
+    protocolVersion?: string;
+    description?: string;
+    variables?: Record<string, AsyncAPIServerVariable>;
+    security?: Record<string, string[]>[];
+    bindings?: AsyncAPIServerBindings;
+}
+/** AsyncAPI protocol */
+export type AsyncAPIProtocol = 'amqp' | 'amqps' | 'http' | 'https' | 'kafka' | 'kafka-secure' | 'mqtt' | 'mqtts' | 'ws' | 'wss' | 'stomp' | 'stomps' | 'jms' | 'nats' | 'redis' | 'sns' | 'sqs' | 'pulsar' | 'solace';
+/** Server variable */
+export interface AsyncAPIServerVariable {
+    default?: string;
+    description?: string;
+    enum?: string[];
+    examples?: string[];
+}
+/** Server bindings */
+export interface AsyncAPIServerBindings {
+    mqtt?: MqttServerBinding;
+    kafka?: KafkaServerBinding;
+    amqp?: AmqpServerBinding;
+    [key: string]: unknown;
+}
+/** MQTT server binding */
+export interface MqttServerBinding {
+    clientId?: string;
+    cleanSession?: boolean;
+    lastWill?: MqttLastWill;
+    keepAlive?: number;
+}
+/** MQTT last will */
+export interface MqttLastWill {
+    topic: string;
+    qos?: 0 | 1 | 2;
+    message?: string;
+    retain?: boolean;
+}
+/** Kafka server binding */
+export interface KafkaServerBinding {
+    schemaRegistryUrl?: string;
+    schemaRegistryVendor?: string;
+}
+/** AMQP server binding */
+export interface AmqpServerBinding {
+}
+/** AsyncAPI channel */
+export interface AsyncAPIChannel {
+    description?: string;
+    subscribe?: AsyncAPIOperation;
+    publish?: AsyncAPIOperation;
+    parameters?: Record<string, AsyncAPIParameter>;
+    bindings?: AsyncAPIChannelBindings;
+}
+/** Channel bindings */
+export interface AsyncAPIChannelBindings {
+    kafka?: KafkaChannelBinding;
+    amqp?: AmqpChannelBinding;
+    [key: string]: unknown;
+}
+/** Kafka channel binding */
+export interface KafkaChannelBinding {
+    topic?: string;
+    partitions?: number;
+    replicas?: number;
+    topicConfiguration?: Record<string, unknown>;
+}
+/** AMQP channel binding */
+export interface AmqpChannelBinding {
+    is?: 'queue' | 'routingKey';
+    exchange?: AmqpExchange;
+    queue?: AmqpQueue;
+}
+/** AMQP exchange */
+export interface AmqpExchange {
+    name?: string;
+    type?: 'topic' | 'direct' | 'fanout' | 'default' | 'headers';
+    durable?: boolean;
+    autoDelete?: boolean;
+    vhost?: string;
+}
+/** AMQP queue */
+export interface AmqpQueue {
+    name?: string;
+    durable?: boolean;
+    exclusive?: boolean;
+    autoDelete?: boolean;
+    vhost?: string;
+}
+/** AsyncAPI operation */
+export interface AsyncAPIOperation {
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    tags?: AsyncAPITag[];
+    externalDocs?: AsyncAPIExternalDocs;
+    bindings?: AsyncAPIOperationBindings;
+    traits?: AsyncAPIOperationTrait[];
+    message?: AsyncAPIMessage | AsyncAPIMessageOneOf;
+    security?: Record<string, string[]>[];
+}
+/** Operation bindings */
+export interface AsyncAPIOperationBindings {
+    kafka?: KafkaOperationBinding;
+    amqp?: AmqpOperationBinding;
+    [key: string]: unknown;
+}
+/** Kafka operation binding */
+export interface KafkaOperationBinding {
+    groupId?: AsyncAPISchema;
+    clientId?: AsyncAPISchema;
+}
+/** AMQP operation binding */
+export interface AmqpOperationBinding {
+    expiration?: number;
+    userId?: string;
+    cc?: string[];
+    priority?: number;
+    deliveryMode?: 1 | 2;
+    mandatory?: boolean;
+    bcc?: string[];
+    replyTo?: string;
+    timestamp?: boolean;
+    ack?: boolean;
+}
+/** Operation trait */
+export interface AsyncAPIOperationTrait {
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    tags?: AsyncAPITag[];
+    externalDocs?: AsyncAPIExternalDocs;
+    bindings?: AsyncAPIOperationBindings;
+}
+/** AsyncAPI message */
+export interface AsyncAPIMessage {
+    messageId?: string;
+    headers?: AsyncAPISchema;
+    payload?: AsyncAPISchema;
+    correlationId?: AsyncAPICorrelationId;
+    schemaFormat?: string;
+    contentType?: string;
+    name?: string;
+    title?: string;
+    summary?: string;
+    description?: string;
+    tags?: AsyncAPITag[];
+    externalDocs?: AsyncAPIExternalDocs;
+    bindings?: AsyncAPIMessageBindings;
+    examples?: AsyncAPIMessageExample[];
+    traits?: AsyncAPIMessageTrait[];
+}
+/** Message oneOf */
+export interface AsyncAPIMessageOneOf {
+    oneOf: AsyncAPIMessage[];
+}
+/** Message bindings */
+export interface AsyncAPIMessageBindings {
+    kafka?: KafkaMessageBinding;
+    amqp?: AmqpMessageBinding;
+    [key: string]: unknown;
+}
+/** Kafka message binding */
+export interface KafkaMessageBinding {
+    key?: AsyncAPISchema;
+}
+/** AMQP message binding */
+export interface AmqpMessageBinding {
+    contentEncoding?: string;
+    messageType?: string;
+}
+/** Message example */
+export interface AsyncAPIMessageExample {
+    name?: string;
+    summary?: string;
+    headers?: Record<string, unknown>;
+    payload?: unknown;
+}
+/** Message trait */
+export interface AsyncAPIMessageTrait {
+    messageId?: string;
+    headers?: AsyncAPISchema;
+    correlationId?: AsyncAPICorrelationId;
+    schemaFormat?: string;
+    contentType?: string;
+    name?: string;
+    title?: string;
+    summary?: string;
+    description?: string;
+    tags?: AsyncAPITag[];
+    externalDocs?: AsyncAPIExternalDocs;
+    bindings?: AsyncAPIMessageBindings;
+    examples?: AsyncAPIMessageExample[];
+}
+/** Correlation ID */
+export interface AsyncAPICorrelationId {
+    description?: string;
+    location: string;
+}
+/** AsyncAPI parameter */
+export interface AsyncAPIParameter {
+    description?: string;
+    schema?: AsyncAPISchema;
+    location?: string;
+}
+/** AsyncAPI schema (JSON Schema) */
+export interface AsyncAPISchema extends OpenAPISchema {
+}
+/** AsyncAPI tag */
+export interface AsyncAPITag {
+    name: string;
+    description?: string;
+    externalDocs?: AsyncAPIExternalDocs;
+}
+/** AsyncAPI external docs */
+export interface AsyncAPIExternalDocs {
+    url: string;
+    description?: string;
+}
+/** AsyncAPI components */
+export interface AsyncAPIComponents {
+    schemas?: Record<string, AsyncAPISchema>;
+    messages?: Record<string, AsyncAPIMessage>;
+    securitySchemes?: Record<string, AsyncAPISecurityScheme>;
+    parameters?: Record<string, AsyncAPIParameter>;
+    correlationIds?: Record<string, AsyncAPICorrelationId>;
+    operationTraits?: Record<string, AsyncAPIOperationTrait>;
+    messageTraits?: Record<string, AsyncAPIMessageTrait>;
+    serverBindings?: Record<string, AsyncAPIServerBindings>;
+    channelBindings?: Record<string, AsyncAPIChannelBindings>;
+    operationBindings?: Record<string, AsyncAPIOperationBindings>;
+    messageBindings?: Record<string, AsyncAPIMessageBindings>;
+}
+/** AsyncAPI security scheme */
+export interface AsyncAPISecurityScheme {
+    type: 'userPassword' | 'apiKey' | 'X509' | 'symmetricEncryption' | 'asymmetricEncryption' | 'httpApiKey' | 'http' | 'oauth2' | 'openIdConnect' | 'plain' | 'scramSha256' | 'scramSha512' | 'gssapi';
+    description?: string;
+    name?: string;
+    in?: 'user' | 'password' | 'query' | 'header' | 'cookie';
+    scheme?: string;
+    bearerFormat?: string;
+    flows?: AsyncAPIOAuthFlows;
+    openIdConnectUrl?: string;
+}
+/** OAuth flows for AsyncAPI */
+export interface AsyncAPIOAuthFlows {
+    implicit?: AsyncAPIOAuthFlow;
+    password?: AsyncAPIOAuthFlow;
+    clientCredentials?: AsyncAPIOAuthFlow;
+    authorizationCode?: AsyncAPIOAuthFlow;
+}
+/** OAuth flow */
+export interface AsyncAPIOAuthFlow {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: Record<string, string>;
+}
+/** AsyncAPI editor configuration */
+export interface AsyncAPIEditorConfig {
+    source: AsyncAPISource;
+    validation?: boolean;
+    theme?: 'light' | 'dark';
+    showPreview?: boolean;
+    formatToggle?: boolean;
+    readOnly?: boolean;
+}
+/** AsyncAPI source */
+export interface AsyncAPISource {
+    type: 'url' | 'file' | 'inline';
+    url?: string;
+    content?: string;
+    format?: 'yaml' | 'json';
+}
+/** Protobuf file definition */
+export interface ProtobufDefinition {
+    syntax: 'proto2' | 'proto3';
+    package?: string;
+    imports: ProtobufImport[];
+    options: ProtobufOption[];
+    messages: ProtobufMessage[];
+    enums: ProtobufEnum[];
+    services: ProtobufService[];
+}
+/** Protobuf import */
+export interface ProtobufImport {
+    path: string;
+    public?: boolean;
+    weak?: boolean;
+}
+/** Protobuf option */
+export interface ProtobufOption {
+    name: string;
+    value: unknown;
+}
+/** Protobuf message */
+export interface ProtobufMessage {
+    name: string;
+    fields: ProtobufField[];
+    nestedMessages: ProtobufMessage[];
+    nestedEnums: ProtobufEnum[];
+    oneofs: ProtobufOneof[];
+    options: ProtobufOption[];
+    reserved: ProtobufReserved[];
+    extensions: ProtobufExtension[];
+    comments?: string;
+}
+/** Protobuf field */
+export interface ProtobufField {
+    name: string;
+    number: number;
+    type: string;
+    label?: 'optional' | 'required' | 'repeated';
+    options?: ProtobufOption[];
+    map?: ProtobufMapType;
+    comments?: string;
+}
+/** Protobuf map type */
+export interface ProtobufMapType {
+    keyType: string;
+    valueType: string;
+}
+/** Protobuf oneof */
+export interface ProtobufOneof {
+    name: string;
+    fields: ProtobufField[];
+    options?: ProtobufOption[];
+}
+/** Protobuf reserved */
+export interface ProtobufReserved {
+    ranges?: Array<number | {
+        start: number;
+        end: number;
+    }>;
+    names?: string[];
+}
+/** Protobuf extension */
+export interface ProtobufExtension {
+    extendee: string;
+    fields: ProtobufField[];
+}
+/** Protobuf enum */
+export interface ProtobufEnum {
+    name: string;
+    values: ProtobufEnumValue[];
+    options?: ProtobufOption[];
+    reserved?: ProtobufReserved[];
+    comments?: string;
+}
+/** Protobuf enum value */
+export interface ProtobufEnumValue {
+    name: string;
+    number: number;
+    options?: ProtobufOption[];
+    comments?: string;
+}
+/** Protobuf service */
+export interface ProtobufService {
+    name: string;
+    methods: ProtobufMethod[];
+    options?: ProtobufOption[];
+    comments?: string;
+}
+/** Protobuf method */
+export interface ProtobufMethod {
+    name: string;
+    inputType: string;
+    outputType: string;
+    clientStreaming?: boolean;
+    serverStreaming?: boolean;
+    options?: ProtobufOption[];
+    comments?: string;
+}
+/** Protobuf editor configuration */
+export interface ProtobufEditorConfig {
+    source: ProtobufSource;
+    syntax?: 'proto2' | 'proto3';
+    validation?: boolean;
+    theme?: 'light' | 'dark';
+    showLineNumbers?: boolean;
+    includePaths?: string[];
+}
+/** Protobuf source */
+export interface ProtobufSource {
+    type: 'file' | 'inline';
+    path?: string;
+    content?: string;
+}
+/** Thrift document */
+export interface ThriftDocument {
+    headers: ThriftHeader[];
+    definitions: ThriftDefinition[];
+}
+/** Thrift header */
+export interface ThriftHeader {
+    type: 'include' | 'cppInclude' | 'namespace';
+    value: string;
+    scope?: string;
+}
+/** Thrift definition */
+export type ThriftDefinition = ThriftConst | ThriftTypedef | ThriftEnum | ThriftStruct | ThriftUnion | ThriftException | ThriftService;
+/** Thrift constant */
+export interface ThriftConst {
+    kind: 'const';
+    name: string;
+    type: ThriftType;
+    value: unknown;
+}
+/** Thrift typedef */
+export interface ThriftTypedef {
+    kind: 'typedef';
+    name: string;
+    type: ThriftType;
+}
+/** Thrift enum */
+export interface ThriftEnum {
+    kind: 'enum';
+    name: string;
+    members: ThriftEnumMember[];
+}
+/** Thrift enum member */
+export interface ThriftEnumMember {
+    name: string;
+    value?: number;
+}
+/** Thrift struct */
+export interface ThriftStruct {
+    kind: 'struct';
+    name: string;
+    fields: ThriftField[];
+    annotations?: Record<string, string>;
+}
+/** Thrift union */
+export interface ThriftUnion {
+    kind: 'union';
+    name: string;
+    fields: ThriftField[];
+}
+/** Thrift exception */
+export interface ThriftException {
+    kind: 'exception';
+    name: string;
+    fields: ThriftField[];
+}
+/** Thrift field */
+export interface ThriftField {
+    id?: number;
+    name: string;
+    type: ThriftType;
+    requiredness?: 'required' | 'optional';
+    defaultValue?: unknown;
+    annotations?: Record<string, string>;
+}
+/** Thrift type */
+export interface ThriftType {
+    kind: 'base' | 'identifier' | 'map' | 'set' | 'list';
+    name?: string;
+    keyType?: ThriftType;
+    valueType?: ThriftType;
+}
+/** Thrift service */
+export interface ThriftService {
+    kind: 'service';
+    name: string;
+    extends?: string;
+    functions: ThriftFunction[];
+    annotations?: Record<string, string>;
+}
+/** Thrift function */
+export interface ThriftFunction {
+    name: string;
+    returnType: ThriftType | 'void';
+    oneway?: boolean;
+    parameters: ThriftField[];
+    throws?: ThriftField[];
+    annotations?: Record<string, string>;
+}
+/** Thrift editor configuration */
+export interface ThriftEditorConfig {
+    source: ThriftSource;
+    validation?: boolean;
+    theme?: 'light' | 'dark';
+    includePaths?: string[];
+}
+/** Thrift source */
+export interface ThriftSource {
+    type: 'file' | 'inline';
+    path?: string;
+    content?: string;
+}
+/** Avro schema */
+export type AvroSchema = AvroPrimitive | AvroRecord | AvroEnum | AvroArray | AvroMap | AvroUnion | AvroFixed | AvroNamedType | AvroLogicalType;
+/** Avro primitive types */
+export type AvroPrimitive = 'null' | 'boolean' | 'int' | 'long' | 'float' | 'double' | 'bytes' | 'string';
+/** Avro record schema */
+export interface AvroRecord {
+    type: 'record';
+    name: string;
+    namespace?: string;
+    doc?: string;
+    aliases?: string[];
+    fields: AvroField[];
+}
+/** Avro field */
+export interface AvroField {
+    name: string;
+    type: AvroSchema;
+    doc?: string;
+    default?: unknown;
+    order?: 'ascending' | 'descending' | 'ignore';
+    aliases?: string[];
+}
+/** Avro enum schema */
+export interface AvroEnum {
+    type: 'enum';
+    name: string;
+    namespace?: string;
+    doc?: string;
+    aliases?: string[];
+    symbols: string[];
+    default?: string;
+}
+/** Avro array schema */
+export interface AvroArray {
+    type: 'array';
+    items: AvroSchema;
+}
+/** Avro map schema */
+export interface AvroMap {
+    type: 'map';
+    values: AvroSchema;
+}
+/** Avro union (array of types) */
+export type AvroUnion = AvroSchema[];
+/** Avro fixed schema */
+export interface AvroFixed {
+    type: 'fixed';
+    name: string;
+    namespace?: string;
+    aliases?: string[];
+    size: number;
+}
+/** Named type reference */
+export type AvroNamedType = string;
+/** Avro logical type */
+export interface AvroLogicalType {
+    type: AvroPrimitive | AvroFixed | 'bytes' | 'string';
+    logicalType: 'decimal' | 'uuid' | 'date' | 'time-millis' | 'time-micros' | 'timestamp-millis' | 'timestamp-micros' | 'duration' | 'local-timestamp-millis' | 'local-timestamp-micros';
+    precision?: number;
+    scale?: number;
+}
+/** Avro protocol */
+export interface AvroProtocol {
+    protocol: string;
+    namespace?: string;
+    doc?: string;
+    types?: AvroSchema[];
+    messages?: Record<string, AvroMessage>;
+}
+/** Avro message (RPC) */
+export interface AvroMessage {
+    doc?: string;
+    request: AvroField[];
+    response: AvroSchema;
+    errors?: AvroSchema[];
+    one_way?: boolean;
+}
+/** Avro editor configuration */
+export interface AvroEditorConfig {
+    source: AvroSource;
+    validation?: boolean;
+    theme?: 'light' | 'dark';
+    schemaRegistry?: AvroSchemaRegistryConfig;
+}
+/** Avro source */
+export interface AvroSource {
+    type: 'file' | 'inline' | 'registry';
+    path?: string;
+    content?: string;
+    subject?: string;
+    version?: number | 'latest';
+}
+/** Schema registry configuration */
+export interface AvroSchemaRegistryConfig {
+    url: string;
+    auth?: {
+        type: 'basic' | 'bearer';
+        username?: string;
+        password?: string;
+        token?: string;
+    };
+}
+/** Schema diagram configuration */
+export interface SchemaDiagramConfig {
+    /** Schema source */
+    schema: SchemaSource;
+    /** Diagram layout */
+    layout?: DiagramLayout;
+    /** Show relationships */
+    showRelationships?: boolean;
+    /** Show field types */
+    showTypes?: boolean;
+    /** Show descriptions */
+    showDescriptions?: boolean;
+    /** Collapsible nodes */
+    collapsible?: boolean;
+    /** Zoom controls */
+    zoomControls?: boolean;
+    /** Pan enabled */
+    panEnabled?: boolean;
+    /** Export formats */
+    exportFormats?: DiagramExportFormat[];
+    /** Theme */
+    theme?: 'light' | 'dark';
+    /** Custom colors */
+    colors?: DiagramColors;
+}
+/** Schema source for visualization */
+export interface SchemaSource {
+    type: 'openapi' | 'graphql' | 'asyncapi' | 'protobuf' | 'avro' | 'jsonschema';
+    content: string | object;
+    format?: 'yaml' | 'json' | 'sdl' | 'proto';
+}
+/** Diagram layout options */
+export interface DiagramLayout {
+    algorithm: 'dagre' | 'elk' | 'force' | 'hierarchy' | 'radial';
+    direction?: 'TB' | 'BT' | 'LR' | 'RL';
+    nodeSpacing?: number;
+    rankSpacing?: number;
+    grouping?: 'none' | 'namespace' | 'tag';
+}
+/** Diagram export format */
+export type DiagramExportFormat = 'png' | 'svg' | 'pdf' | 'json';
+/** Diagram colors */
+export interface DiagramColors {
+    background?: string;
+    node?: string;
+    nodeBorder?: string;
+    nodeText?: string;
+    edge?: string;
+    edgeLabel?: string;
+    highlight?: string;
+}
+/** Diagram node */
+export interface DiagramNode {
+    id: string;
+    type: 'type' | 'endpoint' | 'channel' | 'message' | 'service' | 'method';
+    label: string;
+    description?: string;
+    properties?: DiagramNodeProperty[];
+    group?: string;
+    x?: number;
+    y?: number;
+    collapsed?: boolean;
+}
+/** Diagram node property */
+export interface DiagramNodeProperty {
+    name: string;
+    type: string;
+    required?: boolean;
+    deprecated?: boolean;
+    description?: string;
+}
+/** Diagram edge */
+export interface DiagramEdge {
+    id: string;
+    source: string;
+    target: string;
+    label?: string;
+    type: 'reference' | 'inheritance' | 'composition' | 'association' | 'dependency';
+    cardinality?: string;
+}
+/** Mock server configuration */
+export interface MockServerConfig {
+    /** Schema source */
+    schema: SchemaSource;
+    /** Server port */
+    port?: number;
+    /** Host */
+    host?: string;
+    /** Base path */
+    basePath?: string;
+    /** Response delay (ms) */
+    delay?: number | {
+        min: number;
+        max: number;
+    };
+    /** Mock data configuration */
+    mockData?: MockDataConfig;
+    /** CORS configuration */
+    cors?: MockCorsConfig;
+    /** Request logging */
+    logging?: boolean;
+    /** Record requests */
+    recording?: boolean;
+    /** Dynamic mocks */
+    dynamicMocks?: MockOverride[];
+    /** Proxy fallback */
+    proxy?: MockProxyConfig;
+}
+/** Mock data configuration */
+export interface MockDataConfig {
+    /** Use schema examples */
+    useExamples?: boolean;
+    /** Generate random data */
+    generateRandom?: boolean;
+    /** Faker.js locale */
+    locale?: string;
+    /** Custom generators */
+    generators?: Record<string, MockGenerator>;
+    /** Field overrides */
+    fieldOverrides?: Record<string, unknown>;
+}
+/** Mock data generator */
+export interface MockGenerator {
+    type: 'faker' | 'custom' | 'static';
+    fakerMethod?: string;
+    customFn?: string;
+    staticValue?: unknown;
+}
+/** Mock CORS config */
+export interface MockCorsConfig {
+    enabled?: boolean;
+    origin?: string | string[];
+    methods?: string[];
+    headers?: string[];
+    credentials?: boolean;
+}
+/** Mock override */
+export interface MockOverride {
+    path: string;
+    method?: HttpMethod;
+    response?: MockResponse;
+    condition?: MockCondition;
+    priority?: number;
+}
+/** Mock response */
+export interface MockResponse {
+    statusCode?: number;
+    headers?: Record<string, string>;
+    body?: unknown;
+    delay?: number;
+    file?: string;
+}
+/** Mock condition */
+export interface MockCondition {
+    query?: Record<string, string | RegExp>;
+    headers?: Record<string, string | RegExp>;
+    body?: Record<string, unknown>;
+    jsonPath?: string;
+    jsonPathValue?: unknown;
+}
+/** Mock proxy config */
+export interface MockProxyConfig {
+    target: string;
+    paths?: string[];
+    changeOrigin?: boolean;
+    rewrite?: Record<string, string>;
+}
+/** Mock server status */
+export interface MockServerStatus {
+    running: boolean;
+    port?: number;
+    host?: string;
+    startTime?: Date;
+    requestCount: number;
+    endpoints: MockEndpointStatus[];
+}
+/** Mock endpoint status */
+export interface MockEndpointStatus {
+    path: string;
+    method: HttpMethod;
+    hitCount: number;
+    lastRequest?: Date;
+    averageLatency?: number;
+}
+/** Code generation configuration */
+export interface CodeGenConfig {
+    /** Schema source */
+    schema: SchemaSource;
+    /** Output language */
+    language: CodeGenLanguage;
+    /** Output type (client/server) */
+    outputType: 'client' | 'server' | 'both' | 'types';
+    /** Framework */
+    framework?: string;
+    /** Output directory */
+    outputDir?: string;
+    /** Package/namespace name */
+    packageName?: string;
+    /** Generation options */
+    options?: CodeGenOptions;
+    /** Template overrides */
+    templates?: CodeGenTemplate[];
+}
+/** Supported languages / framework targets for code generation */
+export type CodeGenLanguage = 'typescript' | 'javascript' | 'python' | 'java' | 'kotlin' | 'csharp' | 'go' | 'rust' | 'ruby' | 'php' | 'swift' | 'dart' | 'nextjs' | 'nuxt' | 'sveltekit' | 'remix' | 'react-native' | 'flutter' | 'blazor';
+/** Code generation options */
+export interface CodeGenOptions {
+    /** Include documentation */
+    includeDocs?: boolean;
+    /** Include examples */
+    includeExamples?: boolean;
+    /** Generate validators */
+    generateValidators?: boolean;
+    /** Generate mocks */
+    generateMocks?: boolean;
+    /** Enum style */
+    enumStyle?: 'string' | 'numeric' | 'const';
+    /** Date/time library */
+    dateTimeLibrary?: string;
+    /** HTTP client library */
+    httpClient?: string;
+    /** Use optional chaining */
+    useOptionalChaining?: boolean;
+    /** Strict null checks */
+    strictNullChecks?: boolean;
+    /** Generate index file */
+    generateIndex?: boolean;
+    /** File naming convention */
+    fileNaming?: 'camelCase' | 'PascalCase' | 'snake_case' | 'kebab-case';
+}
+/** Custom template */
+export interface CodeGenTemplate {
+    name: string;
+    template: string;
+    outputPath: string;
+    condition?: string;
+}
+/** Code generation result */
+export interface CodeGenResult {
+    success: boolean;
+    files: GeneratedFile[];
+    errors?: CodeGenError[];
+    warnings?: CodeGenWarning[];
+}
+/** Generated file */
+export interface GeneratedFile {
+    path: string;
+    content: string;
+    size: number;
+    hash?: string;
+}
+/** Code generation error */
+export interface CodeGenError {
+    message: string;
+    location?: string;
+    code?: string;
+}
+/** Code generation warning */
+export interface CodeGenWarning {
+    message: string;
+    location?: string;
+    code?: string;
+}
+/** Documentation configuration */
+export interface APIDocConfig {
+    /** Schema source */
+    schema: SchemaSource;
+    /** Documentation style */
+    style: 'swagger-ui' | 'redoc' | 'stoplight' | 'slate' | 'custom';
+    /** Theme */
+    theme?: DocTheme;
+    /** Logo */
+    logo?: DocLogo;
+    /** Navigation */
+    navigation?: DocNavigation;
+    /** Custom sections */
+    sections?: DocSection[];
+    /** Code samples */
+    codeSamples?: DocCodeSampleConfig;
+    /** Try-it-out */
+    tryItOut?: boolean;
+    /** Authentication */
+    auth?: DocAuthConfig;
+    /** Output format */
+    output?: 'html' | 'markdown' | 'pdf';
+}
+/** Documentation theme */
+export interface DocTheme {
+    primaryColor?: string;
+    accentColor?: string;
+    textColor?: string;
+    backgroundColor?: string;
+    codeBackground?: string;
+    fontFamily?: string;
+    codeFontFamily?: string;
+}
+/** Documentation logo */
+export interface DocLogo {
+    url: string;
+    altText?: string;
+    link?: string;
+    height?: number;
+}
+/** Documentation navigation */
+export interface DocNavigation {
+    position?: 'left' | 'right' | 'top';
+    collapsed?: boolean;
+    searchEnabled?: boolean;
+    tagGroups?: DocTagGroup[];
+}
+/** Tag group */
+export interface DocTagGroup {
+    name: string;
+    tags: string[];
+}
+/** Custom documentation section */
+export interface DocSection {
+    title: string;
+    content: string;
+    position?: 'before' | 'after';
+    target?: string;
+}
+/** Code sample configuration */
+export interface DocCodeSampleConfig {
+    enabled?: boolean;
+    languages?: DocCodeLanguage[];
+    defaultLanguage?: string;
+}
+/** Code sample language */
+export interface DocCodeLanguage {
+    name: string;
+    label: string;
+    prism?: string;
+    generator?: 'automatic' | 'manual';
+}
+/** Documentation auth config */
+export interface DocAuthConfig {
+    enabled?: boolean;
+    persistAuth?: boolean;
+    defaultScheme?: string;
+    credentials?: Record<string, string>;
+}
+/** Version diff configuration */
+export interface VersionDiffConfig {
+    /** Old version */
+    oldVersion: SchemaVersion;
+    /** New version */
+    newVersion: SchemaVersion;
+    /** Rules */
+    rules?: BreakingChangeRules;
+    /** Output format */
+    outputFormat?: 'json' | 'markdown' | 'html';
+}
+/** Schema version */
+export interface SchemaVersion {
+    source: SchemaSource;
+    version?: string;
+    label?: string;
+}
+/** Breaking change rules */
+export interface BreakingChangeRules {
+    /** Treat removals as breaking */
+    removalsBreaking?: boolean;
+    /** Treat type changes as breaking */
+    typeChangesBreaking?: boolean;
+    /** Treat required changes as breaking */
+    requiredChangesBreaking?: boolean;
+    /** Allow deprecation grace period */
+    deprecationGracePeriod?: boolean;
+    /** Custom rules */
+    customRules?: BreakingChangeRule[];
+}
+/** Custom breaking change rule */
+export interface BreakingChangeRule {
+    name: string;
+    description?: string;
+    severity: 'error' | 'warning' | 'info';
+    check: string;
+}
+/** Version diff result */
+export interface VersionDiffResult {
+    compatible: boolean;
+    breakingChanges: SchemaChange[];
+    nonBreakingChanges: SchemaChange[];
+    deprecations: SchemaChange[];
+    additions: SchemaChange[];
+    summary: DiffSummary;
+}
+/** Schema change */
+export interface SchemaChange {
+    type: 'addition' | 'removal' | 'modification' | 'deprecation';
+    severity: 'breaking' | 'non-breaking' | 'info';
+    path: string;
+    message: string;
+    oldValue?: unknown;
+    newValue?: unknown;
+    rule?: string;
+}
+/** Diff summary */
+export interface DiffSummary {
+    totalChanges: number;
+    breakingCount: number;
+    nonBreakingCount: number;
+    additionCount: number;
+    removalCount: number;
+    modificationCount: number;
+}
+/** Linting configuration */
+export interface APILintConfig {
+    /** Schema source */
+    schema: SchemaSource;
+    /** Ruleset */
+    ruleset?: 'spectral:oas' | 'spectral:asyncapi' | 'custom';
+    /** Custom rules path */
+    customRulesPath?: string;
+    /** Rule overrides */
+    rules?: Record<string, APILintRuleSeverity>;
+    /** Output format */
+    outputFormat?: 'json' | 'pretty' | 'stylish';
+}
+/** Rule severity */
+export type APILintRuleSeverity = 'off' | 'warn' | 'error';
+/** Linting result */
+export interface APILintResult {
+    valid: boolean;
+    errors: APILintIssue[];
+    warnings: APILintIssue[];
+    info: APILintIssue[];
+}
+/** Linting issue */
+export interface APILintIssue {
+    code: string;
+    message: string;
+    severity: 'error' | 'warning' | 'info';
+    path: string[];
+    range?: {
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    };
+    source?: string;
+}
+/** Built-in linting rules */
+export interface APILintRuleDefinition {
+    name: string;
+    description: string;
+    severity: APILintRuleSeverity;
+    category: 'naming' | 'structure' | 'documentation' | 'security' | 'performance' | 'compatibility';
+    fixable?: boolean;
+}
+/** Common OpenAPI linting rules */
+export declare const OPENAPI_LINT_RULES: Record<string, APILintRuleDefinition>;
+/** Editor change event */
+export interface APIEditorChangeEvent {
+    type: 'change' | 'save' | 'validate' | 'format';
+    content: string;
+    format: 'yaml' | 'json';
+    timestamp: Date;
+    valid?: boolean;
+    errors?: OpenAPIValidationResult[];
+}
+/** Editor selection event */
+export interface APIEditorSelectionEvent {
+    path: string;
+    range: {
+        start: {
+            line: number;
+            column: number;
+        };
+        end: {
+            line: number;
+            column: number;
+        };
+    };
+    selectedText: string;
+}
+/** Editor navigation event */
+export interface APIEditorNavigationEvent {
+    from: string;
+    to: string;
+    type: 'reference' | 'definition' | 'usage';
+}
+//# sourceMappingURL=api-designer.d.ts.map