rocketmq-client-nodejs/proto/apache/rocketmq/v2/service_pb.d.ts

RocketMQ Node.js Client

// package: apache.rocketmq.v2
// file: apache/rocketmq/v2/service.proto

/* tslint:disable */
/* eslint-disable */

import * as jspb from "google-protobuf";
import * as google_protobuf_duration_pb from "google-protobuf/google/protobuf/duration_pb";
import * as google_protobuf_timestamp_pb from "google-protobuf/google/protobuf/timestamp_pb";
import * as apache_rocketmq_v2_definition_pb from "../../../apache/rocketmq/v2/definition_pb";

export class QueryRouteRequest extends jspb.Message { 

    hasTopic(): boolean;
    clearTopic(): void;
    getTopic(): apache_rocketmq_v2_definition_pb.Resource | undefined;
    setTopic(value?: apache_rocketmq_v2_definition_pb.Resource): QueryRouteRequest;

    hasEndpoints(): boolean;
    clearEndpoints(): void;
    getEndpoints(): apache_rocketmq_v2_definition_pb.Endpoints | undefined;
    setEndpoints(value?: apache_rocketmq_v2_definition_pb.Endpoints): QueryRouteRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): QueryRouteRequest.AsObject;
    static toObject(includeInstance: boolean, msg: QueryRouteRequest): QueryRouteRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: QueryRouteRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): QueryRouteRequest;
    static deserializeBinaryFromReader(message: QueryRouteRequest, reader: jspb.BinaryReader): QueryRouteRequest;
}

export namespace QueryRouteRequest {
    export type AsObject = {
        topic?: apache_rocketmq_v2_definition_pb.Resource.AsObject,
        endpoints?: apache_rocketmq_v2_definition_pb.Endpoints.AsObject,
    }
}

export class QueryRouteResponse extends jspb.Message { 

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): apache_rocketmq_v2_definition_pb.Status | undefined;
    setStatus(value?: apache_rocketmq_v2_definition_pb.Status): QueryRouteResponse;
    clearMessageQueuesList(): void;
    getMessageQueuesList(): Array<apache_rocketmq_v2_definition_pb.MessageQueue>;
    setMessageQueuesList(value: Array<apache_rocketmq_v2_definition_pb.MessageQueue>): QueryRouteResponse;
    addMessageQueues(value?: apache_rocketmq_v2_definition_pb.MessageQueue, index?: number): apache_rocketmq_v2_definition_pb.MessageQueue;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): QueryRouteResponse.AsObject;
    static toObject(includeInstance: boolean, msg: QueryRouteResponse): QueryRouteResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: QueryRouteResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): QueryRouteResponse;
    static deserializeBinaryFromReader(message: QueryRouteResponse, reader: jspb.BinaryReader): QueryRouteResponse;
}

export namespace QueryRouteResponse {
    export type AsObject = {
        status?: apache_rocketmq_v2_definition_pb.Status.AsObject,
        messageQueuesList: Array<apache_rocketmq_v2_definition_pb.MessageQueue.AsObject>,
    }
}

export class SendMessageRequest extends jspb.Message { 
    clearMessagesList(): void;
    getMessagesList(): Array<apache_rocketmq_v2_definition_pb.Message>;
    setMessagesList(value: Array<apache_rocketmq_v2_definition_pb.Message>): SendMessageRequest;
    addMessages(value?: apache_rocketmq_v2_definition_pb.Message, index?: number): apache_rocketmq_v2_definition_pb.Message;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): SendMessageRequest.AsObject;
    static toObject(includeInstance: boolean, msg: SendMessageRequest): SendMessageRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: SendMessageRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): SendMessageRequest;
    static deserializeBinaryFromReader(message: SendMessageRequest, reader: jspb.BinaryReader): SendMessageRequest;
}

export namespace SendMessageRequest {
    export type AsObject = {
        messagesList: Array<apache_rocketmq_v2_definition_pb.Message.AsObject>,
    }
}

export class SendResultEntry extends jspb.Message { 

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): apache_rocketmq_v2_definition_pb.Status | undefined;
    setStatus(value?: apache_rocketmq_v2_definition_pb.Status): SendResultEntry;
    getMessageId(): string;
    setMessageId(value: string): SendResultEntry;
    getTransactionId(): string;
    setTransactionId(value: string): SendResultEntry;
    getOffset(): number;
    setOffset(value: number): SendResultEntry;
    getRecallHandle(): string;
    setRecallHandle(value: string): SendResultEntry;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): SendResultEntry.AsObject;
    static toObject(includeInstance: boolean, msg: SendResultEntry): SendResultEntry.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: SendResultEntry, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): SendResultEntry;
    static deserializeBinaryFromReader(message: SendResultEntry, reader: jspb.BinaryReader): SendResultEntry;
}

export namespace SendResultEntry {
    export type AsObject = {
        status?: apache_rocketmq_v2_definition_pb.Status.AsObject,
        messageId: string,
        transactionId: string,
        offset: number,
        recallHandle: string,
    }
}

export class SendMessageResponse extends jspb.Message { 

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): apache_rocketmq_v2_definition_pb.Status | undefined;
    setStatus(value?: apache_rocketmq_v2_definition_pb.Status): SendMessageResponse;
    clearEntriesList(): void;
    getEntriesList(): Array<SendResultEntry>;
    setEntriesList(value: Array<SendResultEntry>): SendMessageResponse;
    addEntries(value?: SendResultEntry, index?: number): SendResultEntry;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): SendMessageResponse.AsObject;
    static toObject(includeInstance: boolean, msg: SendMessageResponse): SendMessageResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: SendMessageResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): SendMessageResponse;
    static deserializeBinaryFromReader(message: SendMessageResponse, reader: jspb.BinaryReader): SendMessageResponse;
}

export namespace SendMessageResponse {
    export type AsObject = {
        status?: apache_rocketmq_v2_definition_pb.Status.AsObject,
        entriesList: Array<SendResultEntry.AsObject>,
    }
}

export class QueryAssignmentRequest extends jspb.Message { 

    hasTopic(): boolean;
    clearTopic(): void;
    getTopic(): apache_rocketmq_v2_definition_pb.Resource | undefined;
    setTopic(value?: apache_rocketmq_v2_definition_pb.Resource): QueryAssignmentRequest;

    hasGroup(): boolean;
    clearGroup(): void;
    getGroup(): apache_rocketmq_v2_definition_pb.Resource | undefined;
    setGroup(value?: apache_rocketmq_v2_definition_pb.Resource): QueryAssignmentRequest;

    hasEndpoints(): boolean;
    clearEndpoints(): void;
    getEndpoints(): apache_rocketmq_v2_definition_pb.Endpoints | undefined;
    setEndpoints(value?: apache_rocketmq_v2_definition_pb.Endpoints): QueryAssignmentRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): QueryAssignmentRequest.AsObject;
    static toObject(includeInstance: boolean, msg: QueryAssignmentRequest): QueryAssignmentRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: QueryAssignmentRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): QueryAssignmentRequest;
    static deserializeBinaryFromReader(message: QueryAssignmentRequest, reader: jspb.BinaryReader): QueryAssignmentRequest;
}

export namespace QueryAssignmentRequest {
    export type AsObject = {
        topic?: apache_rocketmq_v2_definition_pb.Resource.AsObject,
        group?: apache_rocketmq_v2_definition_pb.Resource.AsObject,
        endpoints?: apache_rocketmq_v2_definition_pb.Endpoints.AsObject,
    }
}

export class QueryAssignmentResponse extends jspb.Message { 

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): apache_rocketmq_v2_definition_pb.Status | undefined;
    setStatus(value?: apache_rocketmq_v2_definition_pb.Status): QueryAssignmentResponse;
    clearAssignmentsList(): void;
    getAssignmentsList(): Array<apache_rocketmq_v2_definition_pb.Assignment>;
    setAssignmentsList(value: Array<apache_rocketmq_v2_definition_pb.Assignment>): QueryAssignmentResponse;
    addAssignments(value?: apache_rocketmq_v2_definition_pb.Assignment, index?: number): apache_rocketmq_v2_definition_pb.Assignment;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): QueryAssignmentResponse.AsObject;
    static toObject(includeInstance: boolean, msg: QueryAssignmentResponse): QueryAssignmentResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: QueryAssignmentResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): QueryAssignmentResponse;
    static deserializeBinaryFromReader(message: QueryAssignmentResponse, reader: jspb.BinaryReader): QueryAssignmentResponse;
}

export namespace QueryAssignmentResponse {
    export type AsObject = {
        status?: apache_rocketmq_v2_definition_pb.Status.AsObject,
        assignmentsList: Array<apache_rocketmq_v2_definition_pb.Assignment.AsObject>,
    }
}

export class ReceiveMessageRequest extends jspb.Message { 

    hasGroup(): boolean;
    clearGroup(): void;
    getGroup(): apache_rocketmq_v2_definition_pb.Resource | undefined;
    setGroup(value?: apache_rocketmq_v2_definition_pb.Resource): ReceiveMessageRequest;

    hasMessageQueue(): boolean;
    clearMessageQueue(): void;
    getMessageQueue(): apache_rocketmq_v2_definition_pb.MessageQueue | undefined;
    setMessageQueue(value?: apache_rocketmq_v2_definition_pb.MessageQueue): ReceiveMessageRequest;

    hasFilterExpression(): boolean;
    clearFilterExpression(): void;
    getFilterExpression(): apache_rocketmq_v2_definition_pb.FilterExpression | undefined;
    setFilterExpression(value?: apache_rocketmq_v2_definition_pb.FilterExpression): ReceiveMessageRequest;
    getBatchSize(): number;
    setBatchSize(value: number): ReceiveMessageRequest;

    hasInvisibleDuration(): boolean;
    clearInvisibleDuration(): void;
    getInvisibleDuration(): google_protobuf_duration_pb.Duration | undefined;
    setInvisibleDuration(value?: google_protobuf_duration_pb.Duration): ReceiveMessageRequest;
    getAutoRenew(): boolean;
    setAutoRenew(value: boolean): ReceiveMessageRequest;

    hasLongPollingTimeout(): boolean;
    clearLongPollingTimeout(): void;
    getLongPollingTimeout(): google_protobuf_duration_pb.Duration | undefined;
    setLongPollingTimeout(value?: google_protobuf_duration_pb.Duration): ReceiveMessageRequest;

    hasAttemptId(): boolean;
    clearAttemptId(): void;
    getAttemptId(): string | undefined;
    setAttemptId(value: string): ReceiveMessageRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReceiveMessageRequest.AsObject;
    static toObject(includeInstance: boolean, msg: ReceiveMessageRequest): ReceiveMessageRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReceiveMessageRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReceiveMessageRequest;
    static deserializeBinaryFromReader(message: ReceiveMessageRequest, reader: jspb.BinaryReader): ReceiveMessageRequest;
}

export namespace ReceiveMessageRequest {
    export type AsObject = {
        group?: apache_rocketmq_v2_definition_pb.Resource.AsObject,
        messageQueue?: apache_rocketmq_v2_definition_pb.MessageQueue.AsObject,
        filterExpression?: apache_rocketmq_v2_definition_pb.FilterExpression.AsObject,
        batchSize: number,
        invisibleDuration?: google_protobuf_duration_pb.Duration.AsObject,
        autoRenew: boolean,
        longPollingTimeout?: google_protobuf_duration_pb.Duration.AsObject,
        attemptId?: string,
    }
}

export class ReceiveMessageResponse extends jspb.Message { 

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): apache_rocketmq_v2_definition_pb.Status | undefined;
    setStatus(value?: apache_rocketmq_v2_definition_pb.Status): ReceiveMessageResponse;

    hasMessage(): boolean;
    clearMessage(): void;
    getMessage(): apache_rocketmq_v2_definition_pb.Message | undefined;
    setMessage(value?: apache_rocketmq_v2_definition_pb.Message): ReceiveMessageResponse;

    hasDeliveryTimestamp(): boolean;
    clearDeliveryTimestamp(): void;
    getDeliveryTimestamp(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setDeliveryTimestamp(value?: google_protobuf_timestamp_pb.Timestamp): ReceiveMessageResponse;

    getContentCase(): ReceiveMessageResponse.ContentCase;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReceiveMessageResponse.AsObject;
    static toObject(includeInstance: boolean, msg: ReceiveMessageResponse): ReceiveMessageResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReceiveMessageResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReceiveMessageResponse;
    static deserializeBinaryFromReader(message: ReceiveMessageResponse, reader: jspb.BinaryReader): ReceiveMessageResponse;
}

export namespace ReceiveMessageResponse {
    export type AsObject = {
        status?: apache_rocketmq_v2_definition_pb.Status.AsObject,
        message?: apache_rocketmq_v2_definition_pb.Message.AsObject,
        deliveryTimestamp?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    }

    export enum ContentCase {
        CONTENT_NOT_SET = 0,
        STATUS = 1,
        MESSAGE = 2,
        DELIVERY_TIMESTAMP = 3,
    }

}

export class AckMessageEntry extends jspb.Message { 
    getMessageId(): string;
    setMessageId(value: string): AckMessageEntry;
    getReceiptHandle(): string;
    setReceiptHandle(value: string): AckMessageEntry;

    hasLiteTopic(): boolean;
    clearLiteTopic(): void;
    getLiteTopic(): string | undefined;
    setLiteTopic(value: string): AckMessageEntry;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AckMessageEntry.AsObject;
    static toObject(includeInstance: boolean, msg: AckMessageEntry): AckMessageEntry.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AckMessageEntry, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AckMessageEntry;
    static deserializeBinaryFromReader(message: AckMessageEntry, reader: jspb.BinaryReader): AckMessageEntry;
}

export namespace AckMessageEntry {
    export type AsObject = {
        messageId: string,
        receiptHandle: string,
        liteTopic?: string,
    }
}

export class AckMessageRequest extends jspb.Message { 

    hasGroup(): boolean;
    clearGroup(): void;
    getGroup(): apache_rocketmq_v2_definition_pb.Resource | undefined;
    setGroup(value?: apache_rocketmq_v2_definition_pb.Resource): AckMessageRequest;

    hasTopic(): boolean;
    clearTopic(): void;
    getTopic(): apache_rocketmq_v2_definition_pb.Resource | undefined;
    setTopic(value?: apache_rocketmq_v2_definition_pb.Resource): AckMessageRequest;
    clearEntriesList(): void;
    getEntriesList(): Array<AckMessageEntry>;
    setEntriesList(value: Array<AckMessageEntry>): AckMessageRequest;
    addEntries(value?: AckMessageEntry, index?: number): AckMessageEntry;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AckMessageRequest.AsObject;
    static toObject(includeInstance: boolean, msg: AckMessageRequest): AckMessageRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AckMessageRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AckMessageRequest;
    static deserializeBinaryFromReader(message: AckMessageRequest, reader: jspb.BinaryReader): AckMessageRequest;
}

export namespace AckMessageRequest {
    export type AsObject = {
        group?: apache_rocketmq_v2_definition_pb.Resource.AsObject,
        topic?: apache_rocketmq_v2_definition_pb.Resource.AsObject,
        entriesList: Array<AckMessageEntry.AsObject>,
    }
}

export class AckMessageResultEntry extends jspb.Message { 
    getMessageId(): string;
    setMessageId(value: string): AckMessageResultEntry;
    getReceiptHandle(): string;
    setReceiptHandle(value: string): AckMessageResultEntry;

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): apache_rocketmq_v2_definition_pb.Status | undefined;
    setStatus(value?: apache_rocketmq_v2_definition_pb.Status): AckMessageResultEntry;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AckMessageResultEntry.AsObject;
    static toObject(includeInstance: boolean, msg: AckMessageResultEntry): AckMessageResultEntry.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AckMessageResultEntry, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AckMessageResultEntry;
    static deserializeBinaryFromReader(message: AckMessageResultEntry, reader: jspb.BinaryReader): AckMessageResultEntry;
}

export namespace AckMessageResultEntry {
    export type AsObject = {
        messageId: string,
        receiptHandle: string,
        status?: apache_rocketmq_v2_definition_pb.Status.AsObject,
    }
}

export class AckMessageResponse extends jspb.Message { 

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): apache_rocketmq_v2_definition_pb.Status | undefined;
    setStatus(value?: apache_rocketmq_v2_definition_pb.Status): AckMessageResponse;
    clearEntriesList(): void;
    getEntriesList(): Array<AckMessageResultEntry>;
    setEntriesList(value: Array<AckMessageResultEntry>): AckMessageResponse;
    addEntries(value?: AckMessageResultEntry, index?: number): AckMessageResultEntry;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): AckMessageResponse.AsObject;
    static toObject(includeInstance: boolean, msg: AckMessageResponse): AckMessageResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: AckMessageResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): AckMessageResponse;
    static deserializeBinaryFromReader(message: AckMessageResponse, reader: jspb.BinaryReader): AckMessageResponse;
}

export namespace AckMessageResponse {
    export type AsObject = {
        status?: apache_rocketmq_v2_definition_pb.Status.AsObject,
        entriesList: Array<AckMessageResultEntry.AsObject>,
    }
}

export class ForwardMessageToDeadLetterQueueRequest extends jspb.Message { 

    hasGroup(): boolean;
    clearGroup(): void;
    getGroup(): apache_rocketmq_v2_definition_pb.Resource | undefined;
    setGroup(value?: apache_rocketmq_v2_definition_pb.Resource): ForwardMessageToDeadLetterQueueRequest;

    hasTopic(): boolean;
    clearTopic(): void;
    getTopic(): apache_rocketmq_v2_definition_pb.Resource | undefined;
    setTopic(value?: apache_rocketmq_v2_definition_pb.Resource): ForwardMessageToDeadLetterQueueRequest;
    getReceiptHandle(): string;
    setReceiptHandle(value: string): ForwardMessageToDeadLetterQueueRequest;
    getMessageId(): string;
    setMessageId(value: string): ForwardMessageToDeadLetterQueueRequest;
    getDeliveryAttempt(): number;
    setDeliveryAttempt(value: number): ForwardMessageToDeadLetterQueueRequest;
    getMaxDeliveryAttempts(): number;
    setMaxDeliveryAttempts(value: number): ForwardMessageToDeadLetterQueueRequest;

    hasLiteTopic(): boolean;
    clearLiteTopic(): void;
    getLiteTopic(): string | undefined;
    setLiteTopic(value: string): ForwardMessageToDeadLetterQueueRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ForwardMessageToDeadLetterQueueRequest.AsObject;
    static toObject(includeInstance: boolean, msg: ForwardMessageToDeadLetterQueueRequest): ForwardMessageToDeadLetterQueueRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ForwardMessageToDeadLetterQueueRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ForwardMessageToDeadLetterQueueRequest;
    static deserializeBinaryFromReader(message: ForwardMessageToDeadLetterQueueRequest, reader: jspb.BinaryReader): ForwardMessageToDeadLetterQueueRequest;
}

export namespace ForwardMessageToDeadLetterQueueRequest {
    export type AsObject = {
        group?: apache_rocketmq_v2_definition_pb.Resource.AsObject,
        topic?: apache_rocketmq_v2_definition_pb.Resource.AsObject,
        receiptHandle: string,
        messageId: string,
        deliveryAttempt: number,
        maxDeliveryAttempts: number,
        liteTopic?: string,
    }
}

export class ForwardMessageToDeadLetterQueueResponse extends jspb.Message { 

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): apache_rocketmq_v2_definition_pb.Status | undefined;
    setStatus(value?: apache_rocketmq_v2_definition_pb.Status): ForwardMessageToDeadLetterQueueResponse;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ForwardMessageToDeadLetterQueueResponse.AsObject;
    static toObject(includeInstance: boolean, msg: ForwardMessageToDeadLetterQueueResponse): ForwardMessageToDeadLetterQueueResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ForwardMessageToDeadLetterQueueResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ForwardMessageToDeadLetterQueueResponse;
    static deserializeBinaryFromReader(message: ForwardMessageToDeadLetterQueueResponse, reader: jspb.BinaryReader): ForwardMessageToDeadLetterQueueResponse;
}

export namespace ForwardMessageToDeadLetterQueueResponse {
    export type AsObject = {
        status?: apache_rocketmq_v2_definition_pb.Status.AsObject,
    }
}

export class HeartbeatRequest extends jspb.Message { 

    hasGroup(): boolean;
    clearGroup(): void;
    getGroup(): apache_rocketmq_v2_definition_pb.Resource | undefined;
    setGroup(value?: apache_rocketmq_v2_definition_pb.Resource): HeartbeatRequest;
    getClientType(): apache_rocketmq_v2_definition_pb.ClientType;
    setClientType(value: apache_rocketmq_v2_definition_pb.ClientType): HeartbeatRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): HeartbeatRequest.AsObject;
    static toObject(includeInstance: boolean, msg: HeartbeatRequest): HeartbeatRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: HeartbeatRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): HeartbeatRequest;
    static deserializeBinaryFromReader(message: HeartbeatRequest, reader: jspb.BinaryReader): HeartbeatRequest;
}

export namespace HeartbeatRequest {
    export type AsObject = {
        group?: apache_rocketmq_v2_definition_pb.Resource.AsObject,
        clientType: apache_rocketmq_v2_definition_pb.ClientType,
    }
}

export class HeartbeatResponse extends jspb.Message { 

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): apache_rocketmq_v2_definition_pb.Status | undefined;
    setStatus(value?: apache_rocketmq_v2_definition_pb.Status): HeartbeatResponse;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): HeartbeatResponse.AsObject;
    static toObject(includeInstance: boolean, msg: HeartbeatResponse): HeartbeatResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: HeartbeatResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): HeartbeatResponse;
    static deserializeBinaryFromReader(message: HeartbeatResponse, reader: jspb.BinaryReader): HeartbeatResponse;
}

export namespace HeartbeatResponse {
    export type AsObject = {
        status?: apache_rocketmq_v2_definition_pb.Status.AsObject,
    }
}

export class EndTransactionRequest extends jspb.Message { 

    hasTopic(): boolean;
    clearTopic(): void;
    getTopic(): apache_rocketmq_v2_definition_pb.Resource | undefined;
    setTopic(value?: apache_rocketmq_v2_definition_pb.Resource): EndTransactionRequest;
    getMessageId(): string;
    setMessageId(value: string): EndTransactionRequest;
    getTransactionId(): string;
    setTransactionId(value: string): EndTransactionRequest;
    getResolution(): apache_rocketmq_v2_definition_pb.TransactionResolution;
    setResolution(value: apache_rocketmq_v2_definition_pb.TransactionResolution): EndTransactionRequest;
    getSource(): apache_rocketmq_v2_definition_pb.TransactionSource;
    setSource(value: apache_rocketmq_v2_definition_pb.TransactionSource): EndTransactionRequest;
    getTraceContext(): string;
    setTraceContext(value: string): EndTransactionRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): EndTransactionRequest.AsObject;
    static toObject(includeInstance: boolean, msg: EndTransactionRequest): EndTransactionRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: EndTransactionRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): EndTransactionRequest;
    static deserializeBinaryFromReader(message: EndTransactionRequest, reader: jspb.BinaryReader): EndTransactionRequest;
}

export namespace EndTransactionRequest {
    export type AsObject = {
        topic?: apache_rocketmq_v2_definition_pb.Resource.AsObject,
        messageId: string,
        transactionId: string,
        resolution: apache_rocketmq_v2_definition_pb.TransactionResolution,
        source: apache_rocketmq_v2_definition_pb.TransactionSource,
        traceContext: string,
    }
}

export class EndTransactionResponse extends jspb.Message { 

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): apache_rocketmq_v2_definition_pb.Status | undefined;
    setStatus(value?: apache_rocketmq_v2_definition_pb.Status): EndTransactionResponse;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): EndTransactionResponse.AsObject;
    static toObject(includeInstance: boolean, msg: EndTransactionResponse): EndTransactionResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: EndTransactionResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): EndTransactionResponse;
    static deserializeBinaryFromReader(message: EndTransactionResponse, reader: jspb.BinaryReader): EndTransactionResponse;
}

export namespace EndTransactionResponse {
    export type AsObject = {
        status?: apache_rocketmq_v2_definition_pb.Status.AsObject,
    }
}

export class PrintThreadStackTraceCommand extends jspb.Message { 
    getNonce(): string;
    setNonce(value: string): PrintThreadStackTraceCommand;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): PrintThreadStackTraceCommand.AsObject;
    static toObject(includeInstance: boolean, msg: PrintThreadStackTraceCommand): PrintThreadStackTraceCommand.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: PrintThreadStackTraceCommand, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): PrintThreadStackTraceCommand;
    static deserializeBinaryFromReader(message: PrintThreadStackTraceCommand, reader: jspb.BinaryReader): PrintThreadStackTraceCommand;
}

export namespace PrintThreadStackTraceCommand {
    export type AsObject = {
        nonce: string,
    }
}

export class ReconnectEndpointsCommand extends jspb.Message { 
    getNonce(): string;
    setNonce(value: string): ReconnectEndpointsCommand;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ReconnectEndpointsCommand.AsObject;
    static toObject(includeInstance: boolean, msg: ReconnectEndpointsCommand): ReconnectEndpointsCommand.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ReconnectEndpointsCommand, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ReconnectEndpointsCommand;
    static deserializeBinaryFromReader(message: ReconnectEndpointsCommand, reader: jspb.BinaryReader): ReconnectEndpointsCommand;
}

export namespace ReconnectEndpointsCommand {
    export type AsObject = {
        nonce: string,
    }
}

export class ThreadStackTrace extends jspb.Message { 
    getNonce(): string;
    setNonce(value: string): ThreadStackTrace;

    hasThreadStackTrace(): boolean;
    clearThreadStackTrace(): void;
    getThreadStackTrace(): string | undefined;
    setThreadStackTrace(value: string): ThreadStackTrace;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ThreadStackTrace.AsObject;
    static toObject(includeInstance: boolean, msg: ThreadStackTrace): ThreadStackTrace.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ThreadStackTrace, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ThreadStackTrace;
    static deserializeBinaryFromReader(message: ThreadStackTrace, reader: jspb.BinaryReader): ThreadStackTrace;
}

export namespace ThreadStackTrace {
    export type AsObject = {
        nonce: string,
        threadStackTrace?: string,
    }
}

export class VerifyMessageCommand extends jspb.Message { 
    getNonce(): string;
    setNonce(value: string): VerifyMessageCommand;

    hasMessage(): boolean;
    clearMessage(): void;
    getMessage(): apache_rocketmq_v2_definition_pb.Message | undefined;
    setMessage(value?: apache_rocketmq_v2_definition_pb.Message): VerifyMessageCommand;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): VerifyMessageCommand.AsObject;
    static toObject(includeInstance: boolean, msg: VerifyMessageCommand): VerifyMessageCommand.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: VerifyMessageCommand, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): VerifyMessageCommand;
    static deserializeBinaryFromReader(message: VerifyMessageCommand, reader: jspb.BinaryReader): VerifyMessageCommand;
}

export namespace VerifyMessageCommand {
    export type AsObject = {
        nonce: string,
        message?: apache_rocketmq_v2_definition_pb.Message.AsObject,
    }
}

export class VerifyMessageResult extends jspb.Message { 
    getNonce(): string;
    setNonce(value: string): VerifyMessageResult;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): VerifyMessageResult.AsObject;
    static toObject(includeInstance: boolean, msg: VerifyMessageResult): VerifyMessageResult.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: VerifyMessageResult, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): VerifyMessageResult;
    static deserializeBinaryFromReader(message: VerifyMessageResult, reader: jspb.BinaryReader): VerifyMessageResult;
}

export namespace VerifyMessageResult {
    export type AsObject = {
        nonce: string,
    }
}

export class RecoverOrphanedTransactionCommand extends jspb.Message { 

    hasMessage(): boolean;
    clearMessage(): void;
    getMessage(): apache_rocketmq_v2_definition_pb.Message | undefined;
    setMessage(value?: apache_rocketmq_v2_definition_pb.Message): RecoverOrphanedTransactionCommand;
    getTransactionId(): string;
    setTransactionId(value: string): RecoverOrphanedTransactionCommand;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): RecoverOrphanedTransactionCommand.AsObject;
    static toObject(includeInstance: boolean, msg: RecoverOrphanedTransactionCommand): RecoverOrphanedTransactionCommand.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: RecoverOrphanedTransactionCommand, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): RecoverOrphanedTransactionCommand;
    static deserializeBinaryFromReader(message: RecoverOrphanedTransactionCommand, reader: jspb.BinaryReader): RecoverOrphanedTransactionCommand;
}

export namespace RecoverOrphanedTransactionCommand {
    export type AsObject = {
        message?: apache_rocketmq_v2_definition_pb.Message.AsObject,
        transactionId: string,
    }
}

export class NotifyUnsubscribeLiteCommand extends jspb.Message { 
    getLiteTopic(): string;
    setLiteTopic(value: string): NotifyUnsubscribeLiteCommand;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): NotifyUnsubscribeLiteCommand.AsObject;
    static toObject(includeInstance: boolean, msg: NotifyUnsubscribeLiteCommand): NotifyUnsubscribeLiteCommand.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: NotifyUnsubscribeLiteCommand, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): NotifyUnsubscribeLiteCommand;
    static deserializeBinaryFromReader(message: NotifyUnsubscribeLiteCommand, reader: jspb.BinaryReader): NotifyUnsubscribeLiteCommand;
}

export namespace NotifyUnsubscribeLiteCommand {
    export type AsObject = {
        liteTopic: string,
    }
}

export class TelemetryCommand extends jspb.Message { 

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): apache_rocketmq_v2_definition_pb.Status | undefined;
    setStatus(value?: apache_rocketmq_v2_definition_pb.Status): TelemetryCommand;

    hasSettings(): boolean;
    clearSettings(): void;
    getSettings(): apache_rocketmq_v2_definition_pb.Settings | undefined;
    setSettings(value?: apache_rocketmq_v2_definition_pb.Settings): TelemetryCommand;

    hasThreadStackTrace(): boolean;
    clearThreadStackTrace(): void;
    getThreadStackTrace(): ThreadStackTrace | undefined;
    setThreadStackTrace(value?: ThreadStackTrace): TelemetryCommand;

    hasVerifyMessageResult(): boolean;
    clearVerifyMessageResult(): void;
    getVerifyMessageResult(): VerifyMessageResult | undefined;
    setVerifyMessageResult(value?: VerifyMessageResult): TelemetryCommand;

    hasRecoverOrphanedTransactionCommand(): boolean;
    clearRecoverOrphanedTransactionCommand(): void;
    getRecoverOrphanedTransactionCommand(): RecoverOrphanedTransactionCommand | undefined;
    setRecoverOrphanedTransactionCommand(value?: RecoverOrphanedTransactionCommand): TelemetryCommand;

    hasPrintThreadStackTraceCommand(): boolean;
    clearPrintThreadStackTraceCommand(): void;
    getPrintThreadStackTraceCommand(): PrintThreadStackTraceCommand | undefined;
    setPrintThreadStackTraceCommand(value?: PrintThreadStackTraceCommand): TelemetryCommand;

    hasVerifyMessageCommand(): boolean;
    clearVerifyMessageCommand(): void;
    getVerifyMessageCommand(): VerifyMessageCommand | undefined;
    setVerifyMessageCommand(value?: VerifyMessageCommand): TelemetryCommand;

    hasReconnectEndpointsCommand(): boolean;
    clearReconnectEndpointsCommand(): void;
    getReconnectEndpointsCommand(): ReconnectEndpointsCommand | undefined;
    setReconnectEndpointsCommand(value?: ReconnectEndpointsCommand): TelemetryCommand;

    hasNotifyUnsubscribeLiteCommand(): boolean;
    clearNotifyUnsubscribeLiteCommand(): void;
    getNotifyUnsubscribeLiteCommand(): NotifyUnsubscribeLiteCommand | undefined;
    setNotifyUnsubscribeLiteCommand(value?: NotifyUnsubscribeLiteCommand): TelemetryCommand;

    getCommandCase(): TelemetryCommand.CommandCase;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): TelemetryCommand.AsObject;
    static toObject(includeInstance: boolean, msg: TelemetryCommand): TelemetryCommand.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: TelemetryCommand, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): TelemetryCommand;
    static deserializeBinaryFromReader(message: TelemetryCommand, reader: jspb.BinaryReader): TelemetryCommand;
}

export namespace TelemetryCommand {
    export type AsObject = {
        status?: apache_rocketmq_v2_definition_pb.Status.AsObject,
        settings?: apache_rocketmq_v2_definition_pb.Settings.AsObject,
        threadStackTrace?: ThreadStackTrace.AsObject,
        verifyMessageResult?: VerifyMessageResult.AsObject,
        recoverOrphanedTransactionCommand?: RecoverOrphanedTransactionCommand.AsObject,
        printThreadStackTraceCommand?: PrintThreadStackTraceCommand.AsObject,
        verifyMessageCommand?: VerifyMessageCommand.AsObject,
        reconnectEndpointsCommand?: ReconnectEndpointsCommand.AsObject,
        notifyUnsubscribeLiteCommand?: NotifyUnsubscribeLiteCommand.AsObject,
    }

    export enum CommandCase {
        COMMAND_NOT_SET = 0,
        SETTINGS = 2,
        THREAD_STACK_TRACE = 3,
        VERIFY_MESSAGE_RESULT = 4,
        RECOVER_ORPHANED_TRANSACTION_COMMAND = 5,
        PRINT_THREAD_STACK_TRACE_COMMAND = 6,
        VERIFY_MESSAGE_COMMAND = 7,
        RECONNECT_ENDPOINTS_COMMAND = 8,
        NOTIFY_UNSUBSCRIBE_LITE_COMMAND = 9,
    }

}

export class NotifyClientTerminationRequest extends jspb.Message { 

    hasGroup(): boolean;
    clearGroup(): void;
    getGroup(): apache_rocketmq_v2_definition_pb.Resource | undefined;
    setGroup(value?: apache_rocketmq_v2_definition_pb.Resource): NotifyClientTerminationRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): NotifyClientTerminationRequest.AsObject;
    static toObject(includeInstance: boolean, msg: NotifyClientTerminationRequest): NotifyClientTerminationRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: NotifyClientTerminationRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): NotifyClientTerminationRequest;
    static deserializeBinaryFromReader(message: NotifyClientTerminationRequest, reader: jspb.BinaryReader): NotifyClientTerminationRequest;
}

export namespace NotifyClientTerminationRequest {
    export type AsObject = {
        group?: apache_rocketmq_v2_definition_pb.Resource.AsObject,
    }
}

export class NotifyClientTerminationResponse extends jspb.Message { 

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): apache_rocketmq_v2_definition_pb.Status | undefined;
    setStatus(value?: apache_rocketmq_v2_definition_pb.Status): NotifyClientTerminationResponse;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): NotifyClientTerminationResponse.AsObject;
    static toObject(includeInstance: boolean, msg: NotifyClientTerminationResponse): NotifyClientTerminationResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: NotifyClientTerminationResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): NotifyClientTerminationResponse;
    static deserializeBinaryFromReader(message: NotifyClientTerminationResponse, reader: jspb.BinaryReader): NotifyClientTerminationResponse;
}

export namespace NotifyClientTerminationResponse {
    export type AsObject = {
        status?: apache_rocketmq_v2_definition_pb.Status.AsObject,
    }
}

export class ChangeInvisibleDurationRequest extends jspb.Message { 

    hasGroup(): boolean;
    clearGroup(): void;
    getGroup(): apache_rocketmq_v2_definition_pb.Resource | undefined;
    setGroup(value?: apache_rocketmq_v2_definition_pb.Resource): ChangeInvisibleDurationRequest;

    hasTopic(): boolean;
    clearTopic(): void;
    getTopic(): apache_rocketmq_v2_definition_pb.Resource | undefined;
    setTopic(value?: apache_rocketmq_v2_definition_pb.Resource): ChangeInvisibleDurationRequest;
    getReceiptHandle(): string;
    setReceiptHandle(value: string): ChangeInvisibleDurationRequest;

    hasInvisibleDuration(): boolean;
    clearInvisibleDuration(): void;
    getInvisibleDuration(): google_protobuf_duration_pb.Duration | undefined;
    setInvisibleDuration(value?: google_protobuf_duration_pb.Duration): ChangeInvisibleDurationRequest;
    getMessageId(): string;
    setMessageId(value: string): ChangeInvisibleDurationRequest;

    hasLiteTopic(): boolean;
    clearLiteTopic(): void;
    getLiteTopic(): string | undefined;
    setLiteTopic(value: string): ChangeInvisibleDurationRequest;

    hasSuspend(): boolean;
    clearSuspend(): void;
    getSuspend(): boolean | undefined;
    setSuspend(value: boolean): ChangeInvisibleDurationRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ChangeInvisibleDurationRequest.AsObject;
    static toObject(includeInstance: boolean, msg: ChangeInvisibleDurationRequest): ChangeInvisibleDurationRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ChangeInvisibleDurationRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ChangeInvisibleDurationRequest;
    static deserializeBinaryFromReader(message: ChangeInvisibleDurationRequest, reader: jspb.BinaryReader): ChangeInvisibleDurationRequest;
}

export namespace ChangeInvisibleDurationRequest {
    export type AsObject = {
        group?: apache_rocketmq_v2_definition_pb.Resource.AsObject,
        topic?: apache_rocketmq_v2_definition_pb.Resource.AsObject,
        receiptHandle: string,
        invisibleDuration?: google_protobuf_duration_pb.Duration.AsObject,
        messageId: string,
        liteTopic?: string,
        suspend?: boolean,
    }
}

export class ChangeInvisibleDurationResponse extends jspb.Message { 

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): apache_rocketmq_v2_definition_pb.Status | undefined;
    setStatus(value?: apache_rocketmq_v2_definition_pb.Status): ChangeInvisibleDurationResponse;
    getReceiptHandle(): string;
    setReceiptHandle(value: string): ChangeInvisibleDurationResponse;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ChangeInvisibleDurationResponse.AsObject;
    static toObject(includeInstance: boolean, msg: ChangeInvisibleDurationResponse): ChangeInvisibleDurationResponse.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ChangeInvisibleDurationResponse, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ChangeInvisibleDurationResponse;
    static deserializeBinaryFromReader(message: ChangeInvisibleDurationResponse, reader: jspb.BinaryReader): ChangeInvisibleDurationResponse;
}

export namespace ChangeInvisibleDurationResponse {
    export type AsObject = {
        status?: apache_rocketmq_v2_definition_pb.Status.AsObject,
        receiptHandle: string,
    }
}

export class PullMessageRequest extends jspb.Message { 

    hasGroup(): boolean;
    clearGroup(): void;
    getGroup(): apache_rocketmq_v2_definition_pb.Resource | undefined;
    setGroup(value?: apache_rocketmq_v2_definition_pb.Resource): PullMessageRequest;

    hasMessageQueue(): boolean;
    clearMessageQueue(): void;
    getMessageQueue(): apache_rocketmq_v2_definition_pb.MessageQueue | undefined;
    setMessageQueue(value?: apache_rocketmq_v2_definition_pb.MessageQueue): PullMessageRequest;
    getOffset(): number;
    setOffset(value: number): PullMessageRequest;
    getBatchSize(): number;
    setBatchSize(value: number): PullMessageRequest;

    hasFilterExpression(): boolean;
    clearFilterExpression(): void;
    getFilterExpression(): apache_rocketmq_v2_definition_pb.FilterExpression | undefined;
    setFilterExpression(value?: apache_rocketmq_v2_definition_pb.FilterExpression): PullMessageRequest;

    hasLongPollingTimeout(): boolean;
    clearLongPollingTimeout(): void;
    getLongPollingTimeout(): google_protobuf_duration_pb.Duration | undefined;
    setLongPollingTimeout(value?: google_protobuf_duration_pb.Duration): PullMessageRequest;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): PullMessageRequest.AsObject;
    static toObject(includeInstance: boolean, msg: PullMessageRequest): PullMessageRequest.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: PullMessageRequest, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): PullMessageRequest;
    static deserializeBinaryFromReader(message: PullMessageRequest, reader: jspb.BinaryReader): PullMessageRequest;
}

export namespace PullMessageRequest {
    export type AsObject = {
        group?: apache_rocketmq_v2_definition_pb.Resource.AsObject,
        messageQueue?: apache_rocketmq_v2_definition_pb.MessageQueue.AsObject,
        offset: number,
        batchSize: number,
        filterExpression?: apache_rocketmq_v2_definition_pb.FilterExpression.AsObject,
        longPollingTimeout?: google_protobuf_duration_pb.Duration.AsObject,
    }
}

export class PullMessageResponse extends jspb.Message { 

    hasStatus(): boolean;
    clearStatus(): void;
    getStatus(): apache_rocketmq_v2_definition_pb.Status | undefined;
    setStatus(value?: apache_rocketmq_v2_definition_pb.Status): PullMessageResponse;

    hasMessage(): boo