azquery

type AggregationType string

type BatchQueryRequest struct {
	// REQUIRED; The Analytics query. Learn more about the Analytics query syntax [https://azure.microsoft.com/documentation/articles/app-insights-analytics-reference/]
	Body *Body

	// REQUIRED; Unique ID corresponding to each request in the batch.
	CorrelationID *string

	// REQUIRED; Primary Workspace ID of the query. This is the Workspace ID from the Properties blade in the Azure portal.
	WorkspaceID *string

	// Headers of the request. Can use prefer header to set server timeout and to query statistics and visualization information.
	Headers map[string]*string

	// The method of a single request in a batch, defaults to POST
	Method *BatchQueryRequestMethod

	// The query path of a single request in a batch, defaults to /query
	Path *BatchQueryRequestPath
}

type BatchQueryRequestMethod string

type BatchQueryRequestPath string

type BatchQueryResponse struct {
	// Contains the tables, columns & rows resulting from a query.
	Body          *BatchQueryResults
	CorrelationID *string

	// Dictionary of
	Headers map[string]*string
	Status  *int32
}

type BatchQueryResults struct {
	// The code and message for an error.
	Error *ErrorInfo

	// Statistics represented in JSON format.
	Statistics []byte

	// The results of the query in tabular format.
	Tables []*Table

	// Visualization data in JSON format.
	Visualization []byte
}

type BatchRequest struct {
	// REQUIRED; An single request in a batch.
	Requests []*BatchQueryRequest
}

type BatchResponse struct {
	// An array of responses corresponding to each individual request in a batch.
	Responses []*BatchQueryResponse
}

type Body struct {
	// REQUIRED; The query to execute.
	Query *string

	// A list of workspaces to query in addition to the primary workspace.
	AdditionalWorkspaces []*string

	// Optional. The timespan over which to query data. This is an ISO8601 time period value. This timespan is applied in addition
	// to any that are specified in the query expression.
	Timespan *TimeInterval
}

type Column struct {
	// The name of this column.
	Name *string

	// The data type of this column.
	Type *LogsColumnType
}

type ErrorInfo struct {
	// REQUIRED; A machine readable error code.
	Code string
	// contains filtered or unexported fields
}

type LocalizableString struct {
	// REQUIRED; The invariant value.
	Value *string

	// The display name.
	LocalizedValue *string
}

type LogsClient struct {
	// contains filtered or unexported fields
}

type LogsClientOptions struct {
	azcore.ClientOptions
}

type LogsClientQueryBatchOptions struct {
}

type LogsClientQueryBatchResponse struct {
	// Response to a batch query.
	BatchResponse
}

type LogsClientQueryResourceOptions struct {
	// Optional. The prefer header to set server timeout, query statistics and visualization information.
	Options *LogsQueryOptions
}

type LogsClientQueryResourceResponse struct {
	// Contains the tables, columns & rows resulting from a query.
	Results
}

type LogsClientQueryWorkspaceOptions struct {
	// Optional. The prefer header to set server timeout, query statistics and visualization information.
	Options *LogsQueryOptions
}

type LogsClientQueryWorkspaceResponse struct {
	// Contains the tables, columns & rows resulting from a query.
	Results
}

type LogsColumnType string

type LogsQueryOptions struct {
	// Set Statistics to true to get logs query execution statistics,
	// such as CPU and memory consumption. Defaults to false.
	Statistics *bool

	// Set Visualization to true to get visualization
	// data for logs queries. Defaults to false.
	Visualization *bool

	// By default, the Azure Monitor Query service will run your
	// query for up to three minutes. To increase the default timeout,
	// set Wait to desired number of seconds.
	// Max wait time the service will allow is ten minutes (600 seconds).
	Wait *int
}

type MetadataValue struct {
	// The name of the metadata.
	Name *LocalizableString

	// The value of the metadata.
	Value *string
}

type Metric struct {
	// REQUIRED; the metric Id.
	ID *string

	// REQUIRED; the name and the display name of the metric, i.e. it is localizable string.
	Name *LocalizableString

	// REQUIRED; the time series returned when a data query is performed.
	TimeSeries []*TimeSeriesElement

	// REQUIRED; the resource type of the metric resource.
	Type *string

	// REQUIRED; The unit of the metric.
	Unit *MetricUnit

	// Detailed description of this metric.
	DisplayDescription *string

	// 'Success' or the error details on query failures for this metric.
	ErrorCode *string

	// Error message encountered querying this specific metric.
	ErrorMessage *string
}

type MetricAvailability struct {
	// the retention period for the metric at the specified timegrain. Expressed as a duration 'PT1M', 'P1D', etc.
	Retention *string

	// the time grain specifies the aggregation interval for the metric. Expressed as a duration 'PT1M', 'P1D', etc.
	TimeGrain *string
}

type MetricClass string

type MetricDefinition struct {
	// Custom category name for this metric.
	Category *string

	// the name and the display name of the dimension, i.e. it is a localizable string.
	Dimensions []*LocalizableString

	// Detailed description of this metric.
	DisplayDescription *string

	// the resource identifier of the metric definition.
	ID *string

	// Flag to indicate whether the dimension is required.
	IsDimensionRequired *bool

	// the collection of what aggregation intervals are available to be queried.
	MetricAvailabilities []*MetricAvailability

	// The class of the metric.
	MetricClass *MetricClass

	// the name and the display name of the metric, i.e. it is a localizable string.
	Name *LocalizableString

	// the namespace the metric belongs to.
	Namespace *string

	// the primary aggregation type value defining how to use the values for display.
	PrimaryAggregationType *AggregationType

	// the resource identifier of the resource that emitted the metric.
	ResourceID *string

	// the collection of what aggregation types are supported.
	SupportedAggregationTypes []*AggregationType

	// The unit of the metric.
	Unit *MetricUnit
}

type MetricDefinitionCollection struct {
	// REQUIRED; the values for the metric definitions.
	Value []*MetricDefinition
}

type MetricNamespace struct {
	// Kind of namespace
	Classification *NamespaceClassification

	// The ID of the metric namespace.
	ID *string

	// The escaped name of the namespace.
	Name *string

	// Properties which include the fully qualified namespace name.
	Properties *MetricNamespaceName

	// The type of the namespace.
	Type *string
}

type MetricNamespaceCollection struct {
	// REQUIRED; The values for the metric namespaces.
	Value []*MetricNamespace
}

type MetricNamespaceName struct {
	// The metric namespace name.
	MetricNamespaceName *string
}

type MetricResults struct {
	// The collection of metric data responses per resource, per metric.
	Values []*MetricValues
}

type MetricUnit string

type MetricValue struct {
	// REQUIRED; The timestamp for the metric value in ISO 8601 format.
	TimeStamp *time.Time

	// The average value in the time range.
	Average *float64

	// The number of samples in the time range. Can be used to determine the number of values that contributed to the average
	// value.
	Count *float64

	// The greatest value in the time range.
	Maximum *float64

	// The least value in the time range.
	Minimum *float64

	// The sum of all of the values in the time range.
	Total *float64
}

type MetricValues struct {
	// REQUIRED; The end time, in datetime format, for which the data was retrieved.
	EndTime *string

	// REQUIRED; The start time, in datetime format, for which the data was retrieved.
	StartTime *string

	// REQUIRED; The value of the collection.
	Values []*Metric

	// The interval (window size) for which the metric data was returned in. Follows the IS8601/RFC3339 duration format (e.g.
	// 'P1D' for 1 day). This may be adjusted in the future and returned back from what
	// was originally requested. This is not present if a metadata request was made.
	Interval *string

	// The namespace of the metrics been queried
	Namespace *string

	// The resource that has been queried for metrics.
	ResourceID *string

	// The region of the resource been queried for metrics.
	ResourceRegion *string
}

type MetricsBatchClient struct {
	// contains filtered or unexported fields
}

type MetricsBatchClientOptions struct {
	azcore.ClientOptions
}

type MetricsBatchClientQueryBatchOptions struct {
	// The list of aggregation types to retrieve
	Aggregation []*AggregationType

	// The end time of the query. It is a string in the format 'yyyy-MM-ddTHH:mm:ss.fffZ'.
	EndTime *string

	// The filter is used to reduce the set of metric data returned.
	// Example:
	// Metric contains metadata A, B and C.
	// - Return all time series of C where A = a1 and B = b1 or b2
	// filter=A eq ‘a1’ and B eq ‘b1’ or B eq ‘b2’ and C eq ‘’
	// - Invalid variant:
	// filter=A eq ‘a1’ and B eq ‘b1’ and C eq ‘’ or B = ‘b2’
	// This is invalid because the logical or operator cannot separate two different metadata names.
	// - Return all time series where A = a1, B = b1 and C = c1:
	// filter=A eq ‘a1’ and B eq ‘b1’ and C eq ‘c1’
	// - Return all time series where A = a1
	// filter=A eq ‘a1’ and B eq ‘’ and C eq ‘’.
	Filter *string

	// The interval (i.e. timegrain) of the query.Examples: PT15M, PT1H, P1D
	Interval *string

	// The aggregation to use for sorting results and the direction of the sort. Only one order can be specified.Examples: sum
	// asc
	OrderBy *string

	// The start time of the query. It is a string in the format 'yyyy-MM-ddTHH:mm:ss.fffZ'. If you have specified the endtime
	// parameter, then this parameter is required. If only starttime is specified, then
	// endtime defaults to the current time. If no time interval is specified, the default is 1 hour.
	StartTime *string

	// The maximum number of records to retrieve per resource ID in the request. Valid only if filter is specified. Defaults to
	// 10.
	Top *int32
}

type MetricsBatchClientQueryBatchResponse struct {
	// The metrics result for a resource.
	MetricResults
}

type MetricsClient struct {
	// contains filtered or unexported fields
}

type MetricsClientListDefinitionsOptions struct {
	// Metric namespace to query metric definitions for.
	MetricNamespace *string
}

type MetricsClientListDefinitionsResponse struct {
	// Represents collection of metric definitions.
	MetricDefinitionCollection
}

type MetricsClientListNamespacesOptions struct {
	// The ISO 8601 conform Date start time from which to query for metric namespaces.
	StartTime *string
}

type MetricsClientListNamespacesResponse struct {
	// Represents collection of metric namespaces.
	MetricNamespaceCollection
}

type MetricsClientOptions struct {
	azcore.ClientOptions
}

type MetricsClientQueryResourceOptions struct {
	// The list of aggregation types to retrieve
	Aggregation []*AggregationType

	// The $filter is used to reduce the set of metric data returned. Example: Metric contains metadata A, B and C. - Return all
	// time series of C where A = a1 and B = b1 or b2 $filter=A eq 'a1' and B eq 'b1'
	// or B eq 'b2' and C eq ” - Invalid variant: $filter=A eq 'a1' and B eq 'b1' and C eq ” or B = 'b2' This is invalid because
	// the logical or operator cannot separate two different metadata names. -
	// Return all time series where A = a1, B = b1 and C = c1: $filter=A eq 'a1' and B eq 'b1' and C eq 'c1' - Return all time
	// series where A = a1 $filter=A eq 'a1' and B eq ” and C eq ”. Special case:
	// When dimension name or dimension value uses round brackets. Eg: When dimension name is dim (test) 1 Instead of using $filter=
	// "dim (test) 1 eq ” " use $filter= "dim %2528test%2529 1 eq ” " When
	// dimension name is dim (test) 3 and dimension value is dim3 (test) val Instead of using $filter= "dim (test) 3 eq 'dim3
	// (test) val' " use $filter= "dim %2528test%2529 3 eq 'dim3 %2528test%2529 val' "
	Filter *string

	// The interval (i.e. timegrain) of the query in ISO 8601 duration format. Defaults to PT1M. Special case for 'FULL' value
	// that returns single datapoint for entire time span requested.Examples: PT15M,
	// PT1H, P1D, FULL
	Interval *string

	// The names of the metrics (comma separated) to retrieve. Special case: If a metricname itself has a comma in it then use
	// %2 to indicate it. Eg: 'Metric,Name1' should be 'Metric%2Name1'
	MetricNames *string

	// Metric namespace to query metric definitions for.
	MetricNamespace *string

	// The aggregation to use for sorting results and the direction of the sort. Only one order can be specified. Examples: sum
	// asc.
	OrderBy *string

	// Reduces the set of data collected. The syntax allowed depends on the operation. See the operation's description for details.
	ResultType *ResultType

	// The timespan of the query. It is a string with the following format 'startDateTimeISO/endDateTimeISO'.
	Timespan *TimeInterval

	// The maximum number of records to retrieve. Valid only if $filter is specified. Defaults to 10.
	Top *int32
}

type MetricsClientQueryResourceResponse struct {
	// The response to a metrics query.
	Response
}

type NamespaceClassification string

type ResourceIDList struct {
	// The list of resource IDs to query metrics for.
	ResourceIDs []*string
}

type Response struct {
	// REQUIRED; The timespan for which the data was retrieved. Its value consists of two datetimes concatenated, separated by
	// '/'. This may be adjusted in the future and returned back from what was originally
	// requested.
	Timespan *TimeInterval

	// REQUIRED; the value of the collection.
	Value []*Metric

	// The integer value representing the relative cost of the query.
	Cost *int32

	// The interval (window size) for which the metric data was returned in ISO 8601 duration format with a special case for 'FULL'
	// value that returns single datapoint for entire time span requested (
	// Examples: PT15M, PT1H, P1D, FULL). This may be adjusted and different from what was originally requested if AutoAdjustTimegrain=true
	// is specified. This is not present if a metadata request was made.
	Interval *string

	// The namespace of the metrics being queried
	Namespace *string

	// The region of the resource being queried for metrics.
	ResourceRegion *string
}

type ResultType string

type Results struct {
	// REQUIRED; The results of the query in tabular format.
	Tables []*Table

	// The code and message for an error.
	Error *ErrorInfo

	// Statistics represented in JSON format.
	Statistics []byte

	// Visualization data in JSON format.
	Visualization []byte
}

type Row []any

type Table struct {
	// REQUIRED; The list of columns in this table.
	Columns []*Column

	// REQUIRED; The name of the table.
	Name *string

	// REQUIRED; The resulting rows from this query.
	Rows []Row
}

type TimeInterval string

type TimeSeriesElement struct {
	// An array of data points representing the metric values. This is only returned if a result type of data is specified.
	Data []*MetricValue

	// the metadata values returned if $filter was specified in the call.
	MetadataValues []*MetadataValue
}