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

RocketMQ Node.js Client

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

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

import * as jspb from "google-protobuf";
import * as google_protobuf_timestamp_pb from "google-protobuf/google/protobuf/timestamp_pb";
import * as google_protobuf_duration_pb from "google-protobuf/google/protobuf/duration_pb";

export class FilterExpression extends jspb.Message { 
    getType(): FilterType;
    setType(value: FilterType): FilterExpression;
    getExpression(): string;
    setExpression(value: string): FilterExpression;

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

export namespace FilterExpression {
    export type AsObject = {
        type: FilterType,
        expression: string,
    }
}

export class RetryPolicy extends jspb.Message { 
    getMaxAttempts(): number;
    setMaxAttempts(value: number): RetryPolicy;

    hasExponentialBackoff(): boolean;
    clearExponentialBackoff(): void;
    getExponentialBackoff(): ExponentialBackoff | undefined;
    setExponentialBackoff(value?: ExponentialBackoff): RetryPolicy;

    hasCustomizedBackoff(): boolean;
    clearCustomizedBackoff(): void;
    getCustomizedBackoff(): CustomizedBackoff | undefined;
    setCustomizedBackoff(value?: CustomizedBackoff): RetryPolicy;

    getStrategyCase(): RetryPolicy.StrategyCase;

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

export namespace RetryPolicy {
    export type AsObject = {
        maxAttempts: number,
        exponentialBackoff?: ExponentialBackoff.AsObject,
        customizedBackoff?: CustomizedBackoff.AsObject,
    }

    export enum StrategyCase {
        STRATEGY_NOT_SET = 0,
        EXPONENTIAL_BACKOFF = 2,
        CUSTOMIZED_BACKOFF = 3,
    }

}

export class ExponentialBackoff extends jspb.Message { 

    hasInitial(): boolean;
    clearInitial(): void;
    getInitial(): google_protobuf_duration_pb.Duration | undefined;
    setInitial(value?: google_protobuf_duration_pb.Duration): ExponentialBackoff;

    hasMax(): boolean;
    clearMax(): void;
    getMax(): google_protobuf_duration_pb.Duration | undefined;
    setMax(value?: google_protobuf_duration_pb.Duration): ExponentialBackoff;
    getMultiplier(): number;
    setMultiplier(value: number): ExponentialBackoff;

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

export namespace ExponentialBackoff {
    export type AsObject = {
        initial?: google_protobuf_duration_pb.Duration.AsObject,
        max?: google_protobuf_duration_pb.Duration.AsObject,
        multiplier: number,
    }
}

export class CustomizedBackoff extends jspb.Message { 
    clearNextList(): void;
    getNextList(): Array<google_protobuf_duration_pb.Duration>;
    setNextList(value: Array<google_protobuf_duration_pb.Duration>): CustomizedBackoff;
    addNext(value?: google_protobuf_duration_pb.Duration, index?: number): google_protobuf_duration_pb.Duration;

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

export namespace CustomizedBackoff {
    export type AsObject = {
        nextList: Array<google_protobuf_duration_pb.Duration.AsObject>,
    }
}

export class Resource extends jspb.Message { 
    getResourceNamespace(): string;
    setResourceNamespace(value: string): Resource;
    getName(): string;
    setName(value: string): Resource;

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

export namespace Resource {
    export type AsObject = {
        resourceNamespace: string,
        name: string,
    }
}

export class SubscriptionEntry extends jspb.Message { 

    hasTopic(): boolean;
    clearTopic(): void;
    getTopic(): Resource | undefined;
    setTopic(value?: Resource): SubscriptionEntry;

    hasExpression(): boolean;
    clearExpression(): void;
    getExpression(): FilterExpression | undefined;
    setExpression(value?: FilterExpression): SubscriptionEntry;

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

export namespace SubscriptionEntry {
    export type AsObject = {
        topic?: Resource.AsObject,
        expression?: FilterExpression.AsObject,
    }
}

export class Address extends jspb.Message { 
    getHost(): string;
    setHost(value: string): Address;
    getPort(): number;
    setPort(value: number): Address;

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

export namespace Address {
    export type AsObject = {
        host: string,
        port: number,
    }
}

export class Endpoints extends jspb.Message { 
    getScheme(): AddressScheme;
    setScheme(value: AddressScheme): Endpoints;
    clearAddressesList(): void;
    getAddressesList(): Array<Address>;
    setAddressesList(value: Array<Address>): Endpoints;
    addAddresses(value?: Address, index?: number): Address;

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

export namespace Endpoints {
    export type AsObject = {
        scheme: AddressScheme,
        addressesList: Array<Address.AsObject>,
    }
}

export class Broker extends jspb.Message { 
    getName(): string;
    setName(value: string): Broker;
    getId(): number;
    setId(value: number): Broker;

    hasEndpoints(): boolean;
    clearEndpoints(): void;
    getEndpoints(): Endpoints | undefined;
    setEndpoints(value?: Endpoints): Broker;

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

export namespace Broker {
    export type AsObject = {
        name: string,
        id: number,
        endpoints?: Endpoints.AsObject,
    }
}

export class MessageQueue extends jspb.Message { 

    hasTopic(): boolean;
    clearTopic(): void;
    getTopic(): Resource | undefined;
    setTopic(value?: Resource): MessageQueue;
    getId(): number;
    setId(value: number): MessageQueue;
    getPermission(): Permission;
    setPermission(value: Permission): MessageQueue;

    hasBroker(): boolean;
    clearBroker(): void;
    getBroker(): Broker | undefined;
    setBroker(value?: Broker): MessageQueue;
    clearAcceptMessageTypesList(): void;
    getAcceptMessageTypesList(): Array<MessageType>;
    setAcceptMessageTypesList(value: Array<MessageType>): MessageQueue;
    addAcceptMessageTypes(value: MessageType, index?: number): MessageType;

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

export namespace MessageQueue {
    export type AsObject = {
        topic?: Resource.AsObject,
        id: number,
        permission: Permission,
        broker?: Broker.AsObject,
        acceptMessageTypesList: Array<MessageType>,
    }
}

export class Digest extends jspb.Message { 
    getType(): DigestType;
    setType(value: DigestType): Digest;
    getChecksum(): string;
    setChecksum(value: string): Digest;

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

export namespace Digest {
    export type AsObject = {
        type: DigestType,
        checksum: string,
    }
}

export class SystemProperties extends jspb.Message { 

    hasTag(): boolean;
    clearTag(): void;
    getTag(): string | undefined;
    setTag(value: string): SystemProperties;
    clearKeysList(): void;
    getKeysList(): Array<string>;
    setKeysList(value: Array<string>): SystemProperties;
    addKeys(value: string, index?: number): string;
    getMessageId(): string;
    setMessageId(value: string): SystemProperties;

    hasBodyDigest(): boolean;
    clearBodyDigest(): void;
    getBodyDigest(): Digest | undefined;
    setBodyDigest(value?: Digest): SystemProperties;
    getBodyEncoding(): Encoding;
    setBodyEncoding(value: Encoding): SystemProperties;
    getMessageType(): MessageType;
    setMessageType(value: MessageType): SystemProperties;

    hasBornTimestamp(): boolean;
    clearBornTimestamp(): void;
    getBornTimestamp(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setBornTimestamp(value?: google_protobuf_timestamp_pb.Timestamp): SystemProperties;
    getBornHost(): string;
    setBornHost(value: string): SystemProperties;

    hasStoreTimestamp(): boolean;
    clearStoreTimestamp(): void;
    getStoreTimestamp(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setStoreTimestamp(value?: google_protobuf_timestamp_pb.Timestamp): SystemProperties;
    getStoreHost(): string;
    setStoreHost(value: string): SystemProperties;

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

    hasReceiptHandle(): boolean;
    clearReceiptHandle(): void;
    getReceiptHandle(): string | undefined;
    setReceiptHandle(value: string): SystemProperties;
    getQueueId(): number;
    setQueueId(value: number): SystemProperties;

    hasQueueOffset(): boolean;
    clearQueueOffset(): void;
    getQueueOffset(): number | undefined;
    setQueueOffset(value: number): SystemProperties;

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

    hasDeliveryAttempt(): boolean;
    clearDeliveryAttempt(): void;
    getDeliveryAttempt(): number | undefined;
    setDeliveryAttempt(value: number): SystemProperties;

    hasMessageGroup(): boolean;
    clearMessageGroup(): void;
    getMessageGroup(): string | undefined;
    setMessageGroup(value: string): SystemProperties;

    hasTraceContext(): boolean;
    clearTraceContext(): void;
    getTraceContext(): string | undefined;
    setTraceContext(value: string): SystemProperties;

    hasOrphanedTransactionRecoveryDuration(): boolean;
    clearOrphanedTransactionRecoveryDuration(): void;
    getOrphanedTransactionRecoveryDuration(): google_protobuf_duration_pb.Duration | undefined;
    setOrphanedTransactionRecoveryDuration(value?: google_protobuf_duration_pb.Duration): SystemProperties;

    hasDeadLetterQueue(): boolean;
    clearDeadLetterQueue(): void;
    getDeadLetterQueue(): DeadLetterQueue | undefined;
    setDeadLetterQueue(value?: DeadLetterQueue): SystemProperties;

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

export namespace SystemProperties {
    export type AsObject = {
        tag?: string,
        keysList: Array<string>,
        messageId: string,
        bodyDigest?: Digest.AsObject,
        bodyEncoding: Encoding,
        messageType: MessageType,
        bornTimestamp?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        bornHost: string,
        storeTimestamp?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        storeHost: string,
        deliveryTimestamp?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        receiptHandle?: string,
        queueId: number,
        queueOffset?: number,
        invisibleDuration?: google_protobuf_duration_pb.Duration.AsObject,
        deliveryAttempt?: number,
        messageGroup?: string,
        traceContext?: string,
        orphanedTransactionRecoveryDuration?: google_protobuf_duration_pb.Duration.AsObject,
        deadLetterQueue?: DeadLetterQueue.AsObject,
    }
}

export class DeadLetterQueue extends jspb.Message { 
    getTopic(): string;
    setTopic(value: string): DeadLetterQueue;
    getMessageId(): string;
    setMessageId(value: string): DeadLetterQueue;

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

export namespace DeadLetterQueue {
    export type AsObject = {
        topic: string,
        messageId: string,
    }
}

export class Message extends jspb.Message { 

    hasTopic(): boolean;
    clearTopic(): void;
    getTopic(): Resource | undefined;
    setTopic(value?: Resource): Message;

    getUserPropertiesMap(): jspb.Map<string, string>;
    clearUserPropertiesMap(): void;

    hasSystemProperties(): boolean;
    clearSystemProperties(): void;
    getSystemProperties(): SystemProperties | undefined;
    setSystemProperties(value?: SystemProperties): Message;
    getBody(): Uint8Array | string;
    getBody_asU8(): Uint8Array;
    getBody_asB64(): string;
    setBody(value: Uint8Array | string): Message;

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

export namespace Message {
    export type AsObject = {
        topic?: Resource.AsObject,

        userPropertiesMap: Array<[string, string]>,
        systemProperties?: SystemProperties.AsObject,
        body: Uint8Array | string,
    }
}

export class Assignment extends jspb.Message { 

    hasMessageQueue(): boolean;
    clearMessageQueue(): void;
    getMessageQueue(): MessageQueue | undefined;
    setMessageQueue(value?: MessageQueue): Assignment;

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

export namespace Assignment {
    export type AsObject = {
        messageQueue?: MessageQueue.AsObject,
    }
}

export class Status extends jspb.Message { 
    getCode(): Code;
    setCode(value: Code): Status;
    getMessage(): string;
    setMessage(value: string): Status;

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

export namespace Status {
    export type AsObject = {
        code: Code,
        message: string,
    }
}

export class UA extends jspb.Message { 
    getLanguage(): Language;
    setLanguage(value: Language): UA;
    getVersion(): string;
    setVersion(value: string): UA;
    getPlatform(): string;
    setPlatform(value: string): UA;
    getHostname(): string;
    setHostname(value: string): UA;

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

export namespace UA {
    export type AsObject = {
        language: Language,
        version: string,
        platform: string,
        hostname: string,
    }
}

export class Settings extends jspb.Message { 

    hasClientType(): boolean;
    clearClientType(): void;
    getClientType(): ClientType | undefined;
    setClientType(value: ClientType): Settings;

    hasAccessPoint(): boolean;
    clearAccessPoint(): void;
    getAccessPoint(): Endpoints | undefined;
    setAccessPoint(value?: Endpoints): Settings;

    hasBackoffPolicy(): boolean;
    clearBackoffPolicy(): void;
    getBackoffPolicy(): RetryPolicy | undefined;
    setBackoffPolicy(value?: RetryPolicy): Settings;

    hasRequestTimeout(): boolean;
    clearRequestTimeout(): void;
    getRequestTimeout(): google_protobuf_duration_pb.Duration | undefined;
    setRequestTimeout(value?: google_protobuf_duration_pb.Duration): Settings;

    hasPublishing(): boolean;
    clearPublishing(): void;
    getPublishing(): Publishing | undefined;
    setPublishing(value?: Publishing): Settings;

    hasSubscription(): boolean;
    clearSubscription(): void;
    getSubscription(): Subscription | undefined;
    setSubscription(value?: Subscription): Settings;

    hasUserAgent(): boolean;
    clearUserAgent(): void;
    getUserAgent(): UA | undefined;
    setUserAgent(value?: UA): Settings;

    hasMetric(): boolean;
    clearMetric(): void;
    getMetric(): Metric | undefined;
    setMetric(value?: Metric): Settings;

    getPubSubCase(): Settings.PubSubCase;

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

export namespace Settings {
    export type AsObject = {
        clientType?: ClientType,
        accessPoint?: Endpoints.AsObject,
        backoffPolicy?: RetryPolicy.AsObject,
        requestTimeout?: google_protobuf_duration_pb.Duration.AsObject,
        publishing?: Publishing.AsObject,
        subscription?: Subscription.AsObject,
        userAgent?: UA.AsObject,
        metric?: Metric.AsObject,
    }

    export enum PubSubCase {
        PUB_SUB_NOT_SET = 0,
        PUBLISHING = 5,
        SUBSCRIPTION = 6,
    }

}

export class Publishing extends jspb.Message { 
    clearTopicsList(): void;
    getTopicsList(): Array<Resource>;
    setTopicsList(value: Array<Resource>): Publishing;
    addTopics(value?: Resource, index?: number): Resource;
    getMaxBodySize(): number;
    setMaxBodySize(value: number): Publishing;
    getValidateMessageType(): boolean;
    setValidateMessageType(value: boolean): Publishing;

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

export namespace Publishing {
    export type AsObject = {
        topicsList: Array<Resource.AsObject>,
        maxBodySize: number,
        validateMessageType: boolean,
    }
}

export class Subscription extends jspb.Message { 

    hasGroup(): boolean;
    clearGroup(): void;
    getGroup(): Resource | undefined;
    setGroup(value?: Resource): Subscription;
    clearSubscriptionsList(): void;
    getSubscriptionsList(): Array<SubscriptionEntry>;
    setSubscriptionsList(value: Array<SubscriptionEntry>): Subscription;
    addSubscriptions(value?: SubscriptionEntry, index?: number): SubscriptionEntry;

    hasFifo(): boolean;
    clearFifo(): void;
    getFifo(): boolean | undefined;
    setFifo(value: boolean): Subscription;

    hasReceiveBatchSize(): boolean;
    clearReceiveBatchSize(): void;
    getReceiveBatchSize(): number | undefined;
    setReceiveBatchSize(value: number): Subscription;

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

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

export namespace Subscription {
    export type AsObject = {
        group?: Resource.AsObject,
        subscriptionsList: Array<SubscriptionEntry.AsObject>,
        fifo?: boolean,
        receiveBatchSize?: number,
        longPollingTimeout?: google_protobuf_duration_pb.Duration.AsObject,
    }
}

export class Metric extends jspb.Message { 
    getOn(): boolean;
    setOn(value: boolean): Metric;

    hasEndpoints(): boolean;
    clearEndpoints(): void;
    getEndpoints(): Endpoints | undefined;
    setEndpoints(value?: Endpoints): Metric;

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

export namespace Metric {
    export type AsObject = {
        on: boolean,
        endpoints?: Endpoints.AsObject,
    }
}

export enum TransactionResolution {
    TRANSACTION_RESOLUTION_UNSPECIFIED = 0,
    COMMIT = 1,
    ROLLBACK = 2,
}

export enum TransactionSource {
    SOURCE_UNSPECIFIED = 0,
    SOURCE_CLIENT = 1,
    SOURCE_SERVER_CHECK = 2,
}

export enum Permission {
    PERMISSION_UNSPECIFIED = 0,
    NONE = 1,
    READ = 2,
    WRITE = 3,
    READ_WRITE = 4,
}

export enum FilterType {
    FILTER_TYPE_UNSPECIFIED = 0,
    TAG = 1,
    SQL = 2,
}

export enum AddressScheme {
    ADDRESS_SCHEME_UNSPECIFIED = 0,
    IPV4 = 1,
    IPV6 = 2,
    DOMAIN_NAME = 3,
}

export enum MessageType {
    MESSAGE_TYPE_UNSPECIFIED = 0,
    NORMAL = 1,
    FIFO = 2,
    DELAY = 3,
    TRANSACTION = 4,
}

export enum DigestType {
    DIGEST_TYPE_UNSPECIFIED = 0,
    CRC32 = 1,
    MD5 = 2,
    SHA1 = 3,
}

export enum ClientType {
    CLIENT_TYPE_UNSPECIFIED = 0,
    PRODUCER = 1,
    PUSH_CONSUMER = 2,
    SIMPLE_CONSUMER = 3,
    PULL_CONSUMER = 4,
}

export enum Encoding {
    ENCODING_UNSPECIFIED = 0,
    IDENTITY = 1,
    GZIP = 2,
}

export enum Code {
    CODE_UNSPECIFIED = 0,
    OK = 20000,
    MULTIPLE_RESULTS = 30000,
    BAD_REQUEST = 40000,
    ILLEGAL_ACCESS_POINT = 40001,
    ILLEGAL_TOPIC = 40002,
    ILLEGAL_CONSUMER_GROUP = 40003,
    ILLEGAL_MESSAGE_TAG = 40004,
    ILLEGAL_MESSAGE_KEY = 40005,
    ILLEGAL_MESSAGE_GROUP = 40006,
    ILLEGAL_MESSAGE_PROPERTY_KEY = 40007,
    INVALID_TRANSACTION_ID = 40008,
    ILLEGAL_MESSAGE_ID = 40009,
    ILLEGAL_FILTER_EXPRESSION = 40010,
    ILLEGAL_INVISIBLE_TIME = 40011,
    ILLEGAL_DELIVERY_TIME = 40012,
    INVALID_RECEIPT_HANDLE = 40013,
    MESSAGE_PROPERTY_CONFLICT_WITH_TYPE = 40014,
    UNRECOGNIZED_CLIENT_TYPE = 40015,
    MESSAGE_CORRUPTED = 40016,
    CLIENT_ID_REQUIRED = 40017,
    ILLEGAL_POLLING_TIME = 40018,
    UNAUTHORIZED = 40100,
    PAYMENT_REQUIRED = 40200,
    FORBIDDEN = 40300,
    NOT_FOUND = 40400,
    MESSAGE_NOT_FOUND = 40401,
    TOPIC_NOT_FOUND = 40402,
    CONSUMER_GROUP_NOT_FOUND = 40403,
    REQUEST_TIMEOUT = 40800,
    PAYLOAD_TOO_LARGE = 41300,
    MESSAGE_BODY_TOO_LARGE = 41301,
    PRECONDITION_FAILED = 42800,
    TOO_MANY_REQUESTS = 42900,
    REQUEST_HEADER_FIELDS_TOO_LARGE = 43100,
    MESSAGE_PROPERTIES_TOO_LARGE = 43101,
    INTERNAL_ERROR = 50000,
    INTERNAL_SERVER_ERROR = 50001,
    HA_NOT_AVAILABLE = 50002,
    NOT_IMPLEMENTED = 50100,
    PROXY_TIMEOUT = 50400,
    MASTER_PERSISTENCE_TIMEOUT = 50401,
    SLAVE_PERSISTENCE_TIMEOUT = 50402,
    UNSUPPORTED = 50500,
    VERSION_UNSUPPORTED = 50501,
    VERIFY_FIFO_MESSAGE_UNSUPPORTED = 50502,
    FAILED_TO_CONSUME_MESSAGE = 60000,
}

export enum Language {
    LANGUAGE_UNSPECIFIED = 0,
    JAVA = 1,
    CPP = 2,
    DOT_NET = 3,
    GOLANG = 4,
    RUST = 5,
    PYTHON = 6,
    PHP = 7,
    NODE_JS = 8,
    RUBY = 9,
    OBJECTIVE_C = 10,
    DART = 11,
    KOTLIN = 12,
}

export enum QueryOffsetPolicy {
    BEGINNING = 0,
    END = 1,
    TIMESTAMP = 2,
}