// package: skywalking.v3
// file: logging/Logging.proto

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

import * as jspb from "google-protobuf";
import * as common_Common_pb from "../common/Common_pb";

export class LogData extends jspb.Message { 
    getTimestamp(): number;
    setTimestamp(value: number): LogData;
    getService(): string;
    setService(value: string): LogData;
    getServiceinstance(): string;
    setServiceinstance(value: string): LogData;
    getEndpoint(): string;
    setEndpoint(value: string): LogData;

    hasBody(): boolean;
    clearBody(): void;
    getBody(): LogDataBody | undefined;
    setBody(value?: LogDataBody): LogData;

    hasTracecontext(): boolean;
    clearTracecontext(): void;
    getTracecontext(): TraceContext | undefined;
    setTracecontext(value?: TraceContext): LogData;

    hasTags(): boolean;
    clearTags(): void;
    getTags(): LogTags | undefined;
    setTags(value?: LogTags): LogData;
    getLayer(): string;
    setLayer(value: string): LogData;

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

export namespace LogData {
    export type AsObject = {
        timestamp: number,
        service: string,
        serviceinstance: string,
        endpoint: string,
        body?: LogDataBody.AsObject,
        tracecontext?: TraceContext.AsObject,
        tags?: LogTags.AsObject,
        layer: string,
    }
}

export class LogDataBody extends jspb.Message { 
    getType(): string;
    setType(value: string): LogDataBody;

    hasText(): boolean;
    clearText(): void;
    getText(): TextLog | undefined;
    setText(value?: TextLog): LogDataBody;

    hasJson(): boolean;
    clearJson(): void;
    getJson(): JSONLog | undefined;
    setJson(value?: JSONLog): LogDataBody;

    hasYaml(): boolean;
    clearYaml(): void;
    getYaml(): YAMLLog | undefined;
    setYaml(value?: YAMLLog): LogDataBody;

    getContentCase(): LogDataBody.ContentCase;

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

export namespace LogDataBody {
    export type AsObject = {
        type: string,
        text?: TextLog.AsObject,
        json?: JSONLog.AsObject,
        yaml?: YAMLLog.AsObject,
    }

    export enum ContentCase {
        CONTENT_NOT_SET = 0,
        TEXT = 2,
        JSON = 3,
        YAML = 4,
    }

}

export class TextLog extends jspb.Message { 
    getText(): string;
    setText(value: string): TextLog;

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

export namespace TextLog {
    export type AsObject = {
        text: string,
    }
}

export class JSONLog extends jspb.Message { 
    getJson(): string;
    setJson(value: string): JSONLog;

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

export namespace JSONLog {
    export type AsObject = {
        json: string,
    }
}

export class YAMLLog extends jspb.Message { 
    getYaml(): string;
    setYaml(value: string): YAMLLog;

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

export namespace YAMLLog {
    export type AsObject = {
        yaml: string,
    }
}

export class TraceContext extends jspb.Message { 
    getTraceid(): string;
    setTraceid(value: string): TraceContext;
    getTracesegmentid(): string;
    setTracesegmentid(value: string): TraceContext;
    getSpanid(): number;
    setSpanid(value: number): TraceContext;

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

export namespace TraceContext {
    export type AsObject = {
        traceid: string,
        tracesegmentid: string,
        spanid: number,
    }
}

export class LogTags extends jspb.Message { 
    clearDataList(): void;
    getDataList(): Array<common_Common_pb.KeyStringValuePair>;
    setDataList(value: Array<common_Common_pb.KeyStringValuePair>): LogTags;
    addData(value?: common_Common_pb.KeyStringValuePair, index?: number): common_Common_pb.KeyStringValuePair;

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

export namespace LogTags {
    export type AsObject = {
        dataList: Array<common_Common_pb.KeyStringValuePair.AsObject>,
    }
}