import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
import type { IBinaryWriter } from "@protobuf-ts/runtime";
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
import type { IBinaryReader } from "@protobuf-ts/runtime";
import type { PartialMessage } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
import { HttpRequest } from "../type/http_request";
import { LogSeverity } from "../type/log_severity";
import { Timestamp } from "../../protobuf/timestamp";
import { Struct } from "../../protobuf/struct";
import { Any } from "../../protobuf/any";
import { MonitoredResource } from "../../api/monitored_resource";
/**
 * An individual entry in a log.
 *
 * @generated from protobuf message google.logging.v2.LogEntry
 */
export interface LogEntry {
    /**
     * Required. The resource name of the log to which this log entry belongs:
     *
     *     "projects/[PROJECT_ID]/logs/[LOG_ID]"
     *     "organizations/[ORGANIZATION_ID]/logs/[LOG_ID]"
     *     "billingAccounts/[BILLING_ACCOUNT_ID]/logs/[LOG_ID]"
     *     "folders/[FOLDER_ID]/logs/[LOG_ID]"
     *
     * A project number may be used in place of PROJECT_ID. The project number is
     * translated to its corresponding PROJECT_ID internally and the `log_name`
     * field will contain PROJECT_ID in queries and exports.
     *
     * `[LOG_ID]` must be URL-encoded within `log_name`. Example:
     * `"organizations/1234567890/logs/cloudresourcemanager.googleapis.com%2Factivity"`.
     *
     * `[LOG_ID]` must be less than 512 characters long and can only include the
     * following characters: upper and lower case alphanumeric characters,
     * forward-slash, underscore, hyphen, and period.
     *
     * For backward compatibility, if `log_name` begins with a forward-slash, such
     * as `/projects/...`, then the log entry is ingested as usual, but the
     * forward-slash is removed. Listing the log entry will not show the leading
     * slash and filtering for a log name with a leading slash will never return
     * any results.
     *
     * @generated from protobuf field: string log_name = 12;
     */
    logName: string;
    /**
     * Required. The monitored resource that produced this log entry.
     *
     * Example: a log entry that reports a database error would be associated with
     * the monitored resource designating the particular database that reported
     * the error.
     *
     * @generated from protobuf field: google.api.MonitoredResource resource = 8;
     */
    resource?: MonitoredResource;
    /**
     * @generated from protobuf oneof: payload
     */
    payload: {
        oneofKind: "protoPayload";
        /**
         * The log entry payload, represented as a protocol buffer. Some Google
         * Cloud Platform services use this field for their log entry payloads.
         *
         * The following protocol buffer types are supported; user-defined types
         * are not supported:
         *
         *   "type.googleapis.com/google.cloud.audit.AuditLog"
         *   "type.googleapis.com/google.appengine.logging.v1.RequestLog"
         *
         * @generated from protobuf field: google.protobuf.Any proto_payload = 2;
         */
        protoPayload: Any;
    } | {
        oneofKind: "textPayload";
        /**
         * The log entry payload, represented as a Unicode string (UTF-8).
         *
         * @generated from protobuf field: string text_payload = 3;
         */
        textPayload: string;
    } | {
        oneofKind: "jsonPayload";
        /**
         * The log entry payload, represented as a structure that is
         * expressed as a JSON object.
         *
         * @generated from protobuf field: google.protobuf.Struct json_payload = 6;
         */
        jsonPayload: Struct;
    } | {
        oneofKind: undefined;
    };
    /**
     * Optional. The time the event described by the log entry occurred. This time is used
     * to compute the log entry's age and to enforce the logs retention period.
     * If this field is omitted in a new log entry, then Logging assigns it the
     * current time. Timestamps have nanosecond accuracy, but trailing zeros in
     * the fractional seconds might be omitted when the timestamp is displayed.
     *
     * Incoming log entries must have timestamps that don't exceed the
     * [logs retention
     * period](https://cloud.google.com/logging/quotas#logs_retention_periods) in
     * the past, and that don't exceed 24 hours in the future. Log entries outside
     * those time boundaries aren't ingested by Logging.
     *
     * @generated from protobuf field: google.protobuf.Timestamp timestamp = 9;
     */
    timestamp?: Timestamp;
    /**
     * Output only. The time the log entry was received by Logging.
     *
     * @generated from protobuf field: google.protobuf.Timestamp receive_timestamp = 24;
     */
    receiveTimestamp?: Timestamp;
    /**
     * Optional. The severity of the log entry. The default value is `LogSeverity.DEFAULT`.
     *
     * @generated from protobuf field: google.logging.type.LogSeverity severity = 10;
     */
    severity: LogSeverity;
    /**
     * Optional. A unique identifier for the log entry. If you provide a value, then
     * Logging considers other log entries in the same project, with the same
     * `timestamp`, and with the same `insert_id` to be duplicates which are
     * removed in a single query result. However, there are no guarantees of
     * de-duplication in the export of logs.
     *
     * If the `insert_id` is omitted when writing a log entry, the Logging API
     * assigns its own unique identifier in this field.
     *
     * In queries, the `insert_id` is also used to order log entries that have
     * the same `log_name` and `timestamp` values.
     *
     * @generated from protobuf field: string insert_id = 4;
     */
    insertId: string;
    /**
     * Optional. Information about the HTTP request associated with this log entry, if
     * applicable.
     *
     * @generated from protobuf field: google.logging.type.HttpRequest http_request = 7;
     */
    httpRequest?: HttpRequest;
    /**
     * Optional. A map of key, value pairs that provides additional information about the
     * log entry. The labels can be user-defined or system-defined.
     *
     * User-defined labels are arbitrary key, value pairs that you can use to
     * classify logs.
     *
     * System-defined labels are defined by GCP services for platform logs.
     * They have two components - a service namespace component and the
     * attribute name. For example: `compute.googleapis.com/resource_name`.
     *
     * Cloud Logging truncates label keys that exceed 512 B and label
     * values that exceed 64 KB upon their associated log entry being
     * written. The truncation is indicated by an ellipsis at the
     * end of the character string.
     *
     * @generated from protobuf field: map<string, string> labels = 11;
     */
    labels: {
        [key: string]: string;
    };
    /**
     * Optional. Information about an operation associated with the log entry, if
     * applicable.
     *
     * @generated from protobuf field: google.logging.v2.LogEntryOperation operation = 15;
     */
    operation?: LogEntryOperation;
    /**
     * Optional. Resource name of the trace associated with the log entry, if any. If it
     * contains a relative resource name, the name is assumed to be relative to
     * `//tracing.googleapis.com`. Example:
     * `projects/my-projectid/traces/06796866738c859f2f19b7cfb3214824`
     *
     * @generated from protobuf field: string trace = 22;
     */
    trace: string;
    /**
     * Optional. The span ID within the trace associated with the log entry.
     *
     * For Trace spans, this is the same format that the Trace API v2 uses: a
     * 16-character hexadecimal encoding of an 8-byte array, such as
     * `000000000000004a`.
     *
     * @generated from protobuf field: string span_id = 27;
     */
    spanId: string;
    /**
     * Optional. The sampling decision of the trace associated with the log entry.
     *
     * True means that the trace resource name in the `trace` field was sampled
     * for storage in a trace backend. False means that the trace was not sampled
     * for storage when this log entry was written, or the sampling decision was
     * unknown at the time. A non-sampled `trace` value is still useful as a
     * request correlation identifier. The default is False.
     *
     * @generated from protobuf field: bool trace_sampled = 30;
     */
    traceSampled: boolean;
    /**
     * Optional. Source code location information associated with the log entry, if any.
     *
     * @generated from protobuf field: google.logging.v2.LogEntrySourceLocation source_location = 23;
     */
    sourceLocation?: LogEntrySourceLocation;
    /**
     * Optional. Information indicating this LogEntry is part of a sequence of multiple log
     * entries split from a single LogEntry.
     *
     * @generated from protobuf field: google.logging.v2.LogSplit split = 35;
     */
    split?: LogSplit;
}
/**
 * Additional information about a potentially long-running operation with which
 * a log entry is associated.
 *
 * @generated from protobuf message google.logging.v2.LogEntryOperation
 */
export interface LogEntryOperation {
    /**
     * Optional. An arbitrary operation identifier. Log entries with the same
     * identifier are assumed to be part of the same operation.
     *
     * @generated from protobuf field: string id = 1;
     */
    id: string;
    /**
     * Optional. An arbitrary producer identifier. The combination of `id` and
     * `producer` must be globally unique. Examples for `producer`:
     * `"MyDivision.MyBigCompany.com"`, `"github.com/MyProject/MyApplication"`.
     *
     * @generated from protobuf field: string producer = 2;
     */
    producer: string;
    /**
     * Optional. Set this to True if this is the first log entry in the operation.
     *
     * @generated from protobuf field: bool first = 3;
     */
    first: boolean;
    /**
     * Optional. Set this to True if this is the last log entry in the operation.
     *
     * @generated from protobuf field: bool last = 4;
     */
    last: boolean;
}
/**
 * Additional information about the source code location that produced the log
 * entry.
 *
 * @generated from protobuf message google.logging.v2.LogEntrySourceLocation
 */
export interface LogEntrySourceLocation {
    /**
     * Optional. Source file name. Depending on the runtime environment, this
     * might be a simple name or a fully-qualified name.
     *
     * @generated from protobuf field: string file = 1;
     */
    file: string;
    /**
     * Optional. Line within the source file. 1-based; 0 indicates no line number
     * available.
     *
     * @generated from protobuf field: int64 line = 2;
     */
    line: bigint;
    /**
     * Optional. Human-readable name of the function or method being invoked, with
     * optional context such as the class or package name. This information may be
     * used in contexts such as the logs viewer, where a file and line number are
     * less meaningful. The format can vary by language. For example:
     * `qual.if.ied.Class.method` (Java), `dir/package.func` (Go), `function`
     * (Python).
     *
     * @generated from protobuf field: string function = 3;
     */
    function: string;
}
/**
 * Additional information used to correlate multiple log entries. Used when a
 * single LogEntry would exceed the Google Cloud Logging size limit and is
 * split across multiple log entries.
 *
 * @generated from protobuf message google.logging.v2.LogSplit
 */
export interface LogSplit {
    /**
     * A globally unique identifier for all log entries in a sequence of split log
     * entries. All log entries with the same |LogSplit.uid| are assumed to be
     * part of the same sequence of split log entries.
     *
     * @generated from protobuf field: string uid = 1;
     */
    uid: string;
    /**
     * The index of this LogEntry in the sequence of split log entries. Log
     * entries are given |index| values 0, 1, ..., n-1 for a sequence of n log
     * entries.
     *
     * @generated from protobuf field: int32 index = 2;
     */
    index: number;
    /**
     * The total number of log entries that the original LogEntry was split into.
     *
     * @generated from protobuf field: int32 total_splits = 3;
     */
    totalSplits: number;
}
declare class LogEntry$Type extends MessageType<LogEntry> {
    constructor();
    create(value?: PartialMessage<LogEntry>): LogEntry;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: LogEntry): LogEntry;
    private binaryReadMap11;
    internalBinaryWrite(message: LogEntry, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message google.logging.v2.LogEntry
 */
export declare const LogEntry: LogEntry$Type;
declare class LogEntryOperation$Type extends MessageType<LogEntryOperation> {
    constructor();
    create(value?: PartialMessage<LogEntryOperation>): LogEntryOperation;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: LogEntryOperation): LogEntryOperation;
    internalBinaryWrite(message: LogEntryOperation, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message google.logging.v2.LogEntryOperation
 */
export declare const LogEntryOperation: LogEntryOperation$Type;
declare class LogEntrySourceLocation$Type extends MessageType<LogEntrySourceLocation> {
    constructor();
    create(value?: PartialMessage<LogEntrySourceLocation>): LogEntrySourceLocation;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: LogEntrySourceLocation): LogEntrySourceLocation;
    internalBinaryWrite(message: LogEntrySourceLocation, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message google.logging.v2.LogEntrySourceLocation
 */
export declare const LogEntrySourceLocation: LogEntrySourceLocation$Type;
declare class LogSplit$Type extends MessageType<LogSplit> {
    constructor();
    create(value?: PartialMessage<LogSplit>): LogSplit;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: LogSplit): LogSplit;
    internalBinaryWrite(message: LogSplit, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message google.logging.v2.LogSplit
 */
export declare const LogSplit: LogSplit$Type;
export {};