redash

type Client struct {
	// PollInterval is the delay between job status checks.
	PollInterval time.Duration
	// contains filtered or unexported fields
}

type Column struct {
	Name         string `json:"name"`
	FriendlyName string `json:"friendly_name"`
	Type         string `json:"type"`
}

type DataSource struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

type Job struct {
	ID            string `json:"id"`
	Status        int    `json:"status"`
	Error         string `json:"error"`
	QueryResultID int    `json:"query_result_id"`
}

type NewQuery struct {
	Name         string `json:"name"`
	Query        string `json:"query"`
	DataSourceID int    `json:"data_source_id"`
	Description  string `json:"description,omitempty"`
	// Options carries the parameter definitions the new query is saved
	// with. Redash recomputes the query hash as it saves, so defaults set
	// here link an existing result to the query at creation time; nil
	// leaves the options key out.
	Options *QueryOptions `json:"options,omitempty"`
}

type NewVisualization struct {
	QueryID int                        `json:"query_id"`
	Type    string                     `json:"type"`
	Name    string                     `json:"name"`
	Options map[string]json.RawMessage `json:"options"`
}

type Query struct {
	ID           int    `json:"id"`
	Name         string `json:"name"`
	Description  string `json:"description"`
	Query        string `json:"query"`
	DataSourceID int    `json:"data_source_id"`
	IsDraft      bool   `json:"is_draft"`
	// Version is what an update sends back to prove it was composed
	// against the query as it stands; Redash refuses one carrying a stale
	// value.
	Version int `json:"version"`
	// LatestQueryDataID is the result Redash shows on the query page, and
	// draws every chart on it from. Zero means the query has none, which is
	// what a query nobody has executed reads back as.
	LatestQueryDataID int `json:"latest_query_data_id"`
	// Options carries the settings the query holds beside its SQL. An
	// update replaces the whole object, so it is decoded in a form that
	// survives being written back: see QueryOptions.
	Options QueryOptions `json:"options"`
	// Visualizations is the charts attached to the query. Only reading one
	// query carries them — the listing endpoints leave the key out — and
	// they are the only way to reach a visualization at all, since Redash
	// has no endpoint that reads one by its ID.
	Visualizations []Visualization `json:"visualizations"`
}

type QueryListOptions struct {
	// Search is the API's q full-text search. Empty means no filtering.
	Search string
	// Mine lists only the caller's own queries.
	Mine bool
	// Limit caps how many queries are returned. It must be at least 1;
	// the server refuses the page size a smaller one would ask for.
	Limit int
}

type QueryOptions struct {
	// Parameters is the parameter definitions, in the order they are
	// stored. Nil means the object had no parameters key, which is left
	// out again on the way back rather than written as an empty list.
	Parameters []QueryParameter
	// Extra is every other key of the object, kept as it arrived.
	Extra map[string]json.RawMessage
}

type QueryParameter struct {
	Name  string
	Title string
	Type  string
	// Value is the stored default, decoded as it came: numbers stay
	// json.Number, so sending one back reproduces the text Redash hashed
	// the query with. A parameter defined without a default is nil.
	Value any
	// Regex is the pattern a text-pattern parameter's value must match in
	// full. Empty on every other type.
	Regex string
	Extra map[string]json.RawMessage
}

type QueryResult struct {
	Columns []Column
	Rows    []map[string]any
}

type QueryUpdate struct {
	Name        *string `json:"name,omitempty"`
	Description *string `json:"description,omitempty"`
	Query       *string `json:"query,omitempty"`
	IsDraft     *bool   `json:"is_draft,omitempty"`
	// Options replaces the query's whole options object, so it has to be
	// composed from one that was just read rather than from nothing. Nil
	// leaves the key out, which is what keeps an update of the query's
	// metadata alone from clearing its parameter definitions.
	Options *QueryOptions `json:"options,omitempty"`
	// Version opts into the server's conflict check: set it to the version
	// of the query this update was composed from and a competing edit fails
	// the update instead of being silently overwritten. Left nil, the
	// server applies the update as a last write.
	Version *int `json:"version,omitempty"`
}

type Visualization struct {
	ID   int    `json:"id"`
	Type string `json:"type"`
	Name string `json:"name"`
	// Options is the settings blob the front end renders from, kept key by
	// key as it arrived rather than decoded into fields. Redash stores it
	// without validating it and an update replaces every key the request
	// carries, so an edit has to be able to send back what it never meant
	// to touch — the same problem QueryOptions.Extra solves, over a schema
	// with far more keys and no field here worth naming.
	Options map[string]json.RawMessage `json:"options"`
}

type VisualizationUpdate struct {
	Type *string `json:"type,omitempty"`
	Name *string `json:"name,omitempty"`
	// Options is a pointer for the same reason Type and Name are: an empty
	// object is a value — it resets the visualization to the front end's own
	// defaults — and a plain map with omitempty could not tell that apart
	// from an edit that leaves the options alone.
	Options *map[string]json.RawMessage `json:"options,omitempty"`
}