@kurrent/kurrentdb-client/generated/kurrentdb/protocols/v2/streams/streams_pb.d.ts

KurrentDB gRPC NodeJS Client SDK

// package: kurrentdb.protocol.v2.streams
// file: kurrentdb/protocols/v2/streams/streams.proto

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

import * as jspb from "google-protobuf";
import * as google_protobuf_struct_pb from "google-protobuf/google/protobuf/struct_pb";

export class AppendRequest extends jspb.Message { 
    getStream(): string;
    setStream(value: string): AppendRequest;
    clearRecordsList(): void;
    getRecordsList(): Array<AppendRecord>;
    setRecordsList(value: Array<AppendRecord>): AppendRequest;
    addRecords(value?: AppendRecord, index?: number): AppendRecord;

    hasExpectedRevision(): boolean;
    clearExpectedRevision(): void;
    getExpectedRevision(): string | undefined;
    setExpectedRevision(value: string): AppendRequest;

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

export namespace AppendRequest {
    export type AsObject = {
        stream: string,
        recordsList: Array<AppendRecord.AsObject>,
        expectedRevision?: string,
    }
}

export class AppendResponse extends jspb.Message { 
    getStream(): string;
    setStream(value: string): AppendResponse;
    getStreamRevision(): string;
    setStreamRevision(value: string): AppendResponse;

    hasPosition(): boolean;
    clearPosition(): void;
    getPosition(): string | undefined;
    setPosition(value: string): AppendResponse;

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

export namespace AppendResponse {
    export type AsObject = {
        stream: string,
        streamRevision: string,
        position?: string,
    }
}

export class AppendSessionResponse extends jspb.Message { 
    clearOutputList(): void;
    getOutputList(): Array<AppendResponse>;
    setOutputList(value: Array<AppendResponse>): AppendSessionResponse;
    addOutput(value?: AppendResponse, index?: number): AppendResponse;
    getPosition(): string;
    setPosition(value: string): AppendSessionResponse;

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

export namespace AppendSessionResponse {
    export type AsObject = {
        outputList: Array<AppendResponse.AsObject>,
        position: string,
    }
}

export class SchemaInfo extends jspb.Message { 
    getFormat(): SchemaFormat;
    setFormat(value: SchemaFormat): SchemaInfo;
    getName(): string;
    setName(value: string): SchemaInfo;

    hasId(): boolean;
    clearId(): void;
    getId(): string | undefined;
    setId(value: string): SchemaInfo;

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

export namespace SchemaInfo {
    export type AsObject = {
        format: SchemaFormat,
        name: string,
        id?: string,
    }
}

export class AppendRecord extends jspb.Message { 

    hasRecordId(): boolean;
    clearRecordId(): void;
    getRecordId(): string | undefined;
    setRecordId(value: string): AppendRecord;

    getPropertiesMap(): jspb.Map<string, google_protobuf_struct_pb.Value>;
    clearPropertiesMap(): void;

    hasSchema(): boolean;
    clearSchema(): void;
    getSchema(): SchemaInfo | undefined;
    setSchema(value?: SchemaInfo): AppendRecord;
    getData(): Uint8Array | string;
    getData_asU8(): Uint8Array;
    getData_asB64(): string;
    setData(value: Uint8Array | string): AppendRecord;
    getStream(): string;
    setStream(value: string): AppendRecord;

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

export namespace AppendRecord {
    export type AsObject = {
        recordId?: string,

        propertiesMap: Array<[string, google_protobuf_struct_pb.Value.AsObject]>,
        schema?: SchemaInfo.AsObject,
        data: Uint8Array | string,
        stream: string,
    }
}

export class AppendRecordsRequest extends jspb.Message { 
    clearRecordsList(): void;
    getRecordsList(): Array<AppendRecord>;
    setRecordsList(value: Array<AppendRecord>): AppendRecordsRequest;
    addRecords(value?: AppendRecord, index?: number): AppendRecord;
    clearChecksList(): void;
    getChecksList(): Array<ConsistencyCheck>;
    setChecksList(value: Array<ConsistencyCheck>): AppendRecordsRequest;
    addChecks(value?: ConsistencyCheck, index?: number): ConsistencyCheck;

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

export namespace AppendRecordsRequest {
    export type AsObject = {
        recordsList: Array<AppendRecord.AsObject>,
        checksList: Array<ConsistencyCheck.AsObject>,
    }
}

export class AppendRecordsResponse extends jspb.Message { 
    clearRevisionsList(): void;
    getRevisionsList(): Array<StreamRevision>;
    setRevisionsList(value: Array<StreamRevision>): AppendRecordsResponse;
    addRevisions(value?: StreamRevision, index?: number): StreamRevision;
    getPosition(): string;
    setPosition(value: string): AppendRecordsResponse;

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

export namespace AppendRecordsResponse {
    export type AsObject = {
        revisionsList: Array<StreamRevision.AsObject>,
        position: string,
    }
}

export class ConsistencyCheck extends jspb.Message { 

    hasStreamState(): boolean;
    clearStreamState(): void;
    getStreamState(): ConsistencyCheck.StreamStateCheck | undefined;
    setStreamState(value?: ConsistencyCheck.StreamStateCheck): ConsistencyCheck;

    getTypeCase(): ConsistencyCheck.TypeCase;

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

export namespace ConsistencyCheck {
    export type AsObject = {
        streamState?: ConsistencyCheck.StreamStateCheck.AsObject,
    }


    export class StreamStateCheck extends jspb.Message { 
        getStream(): string;
        setStream(value: string): StreamStateCheck;
        getExpectedState(): string;
        setExpectedState(value: string): StreamStateCheck;

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

    export namespace StreamStateCheck {
        export type AsObject = {
            stream: string,
            expectedState: string,
        }
    }


    export enum TypeCase {
        TYPE_NOT_SET = 0,
        STREAM_STATE = 1,
    }

}

export class StreamRevision extends jspb.Message { 
    getStream(): string;
    setStream(value: string): StreamRevision;
    getRevision(): string;
    setRevision(value: string): StreamRevision;

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

export namespace StreamRevision {
    export type AsObject = {
        stream: string,
        revision: string,
    }
}

export enum SchemaFormat {
    SCHEMA_FORMAT_UNSPECIFIED = 0,
    SCHEMA_FORMAT_JSON = 1,
    SCHEMA_FORMAT_PROTOBUF = 2,
    SCHEMA_FORMAT_AVRO = 3,
    SCHEMA_FORMAT_BYTES = 4,
}

export enum ExpectedRevisionConstants {
    EXPECTED_REVISION_CONSTANTS_SINGLE_EVENT = 0,
    EXPECTED_REVISION_CONSTANTS_NO_STREAM = -1,
    EXPECTED_REVISION_CONSTANTS_ANY = -2,
    EXPECTED_REVISION_CONSTANTS_EXISTS = -4,
}