@grafana/plugin-ui 0.14.1-dsconfig.f952c80 → 0.15.0

package/dist/esm/schema/registry/elasticsearch.schema.json.js

@@ -1,597 +0,0 @@
-var $schema$Z = "../schema.json";
-var schemaVersion$Z = "v1";
-var pluginType$Z = "elasticsearch";
-var pluginName$Z = "Elasticsearch";
-var docURL$w = "https://grafana.com/docs/grafana/latest/datasources/elasticsearch/configure/";
-var fields$Z = [
-	{
-		id: "root.url",
-		key: "url",
-		label: "URL",
-		description: "HTTP URL of the Elasticsearch server.",
-		valueType: "string",
-		semanticType: "url",
-		target: "root",
-		required: true,
-		ui: {
-			component: "input",
-			placeholder: "http://localhost:9200"
-		}
-	},
-	{
-		id: "auth.method",
-		key: "authMethod",
-		label: "Authentication method",
-		description: "Choose an authentication method to access the data source.",
-		valueType: "string",
-		kind: "virtual",
-		defaultValue: "no-auth",
-		ui: {
-			component: "select",
-			options: [
-				{
-					label: "No Authentication",
-					value: "no-auth"
-				},
-				{
-					label: "Basic authentication",
-					value: "basic-auth"
-				},
-				{
-					label: "Forward OAuth Identity",
-					value: "forward-oauth"
-				},
-				{
-					label: "Cross-site credentials",
-					value: "cross-site"
-				},
-				{
-					label: "API Key",
-					value: "api-key"
-				},
-				{
-					label: "SigV4 auth",
-					value: "sigv4",
-					description: "AWS Signature Version 4 authentication"
-				}
-			]
-		},
-		storage: {
-			type: "computed",
-			read: "jsonData.sigV4Auth == true ? 'sigv4' : (jsonData.apiKeyAuth == true ? 'api-key' : (root.basicAuth == true ? 'basic-auth' : (jsonData.oauthPassThru == true ? 'forward-oauth' : (root.withCredentials == true ? 'cross-site' : 'no-auth'))))"
-		},
-		effects: [
-			{
-				when: "value == 'no-auth'",
-				set: {
-					"root.basicAuth": false,
-					"jsonData.oauthPassThru": false,
-					"root.withCredentials": false,
-					"jsonData.apiKeyAuth": false,
-					"jsonData.sigV4Auth": false
-				}
-			},
-			{
-				when: "value == 'basic-auth'",
-				set: {
-					"root.basicAuth": true,
-					"jsonData.oauthPassThru": false,
-					"root.withCredentials": false,
-					"jsonData.apiKeyAuth": false,
-					"jsonData.sigV4Auth": false
-				}
-			},
-			{
-				when: "value == 'forward-oauth'",
-				set: {
-					"root.basicAuth": false,
-					"jsonData.oauthPassThru": true,
-					"root.withCredentials": false,
-					"jsonData.apiKeyAuth": false,
-					"jsonData.sigV4Auth": false
-				}
-			},
-			{
-				when: "value == 'cross-site'",
-				set: {
-					"root.basicAuth": false,
-					"jsonData.oauthPassThru": false,
-					"root.withCredentials": true,
-					"jsonData.apiKeyAuth": false,
-					"jsonData.sigV4Auth": false
-				}
-			},
-			{
-				when: "value == 'api-key'",
-				set: {
-					"root.basicAuth": false,
-					"jsonData.oauthPassThru": false,
-					"root.withCredentials": false,
-					"jsonData.apiKeyAuth": true,
-					"jsonData.sigV4Auth": false
-				}
-			},
-			{
-				when: "value == 'sigv4'",
-				set: {
-					"root.basicAuth": false,
-					"jsonData.oauthPassThru": false,
-					"root.withCredentials": false,
-					"jsonData.apiKeyAuth": false,
-					"jsonData.sigV4Auth": true
-				}
-			}
-		]
-	},
-	{
-		id: "root.basicAuth",
-		key: "basicAuth",
-		label: "Basic Auth",
-		valueType: "boolean",
-		target: "root",
-		tags: [
-			"managed-by:auth.method"
-		]
-	},
-	{
-		id: "root.withCredentials",
-		key: "withCredentials",
-		label: "Cross-site credentials",
-		valueType: "boolean",
-		target: "root",
-		tags: [
-			"managed-by:auth.method"
-		]
-	},
-	{
-		id: "root.basicAuthUser",
-		key: "basicAuthUser",
-		label: "Username",
-		description: "Username for basic HTTP authentication.",
-		valueType: "string",
-		target: "root",
-		dependsOn: "auth.method == 'basic-auth'"
-	},
-	{
-		id: "secureJsonData.basicAuthPassword",
-		key: "basicAuthPassword",
-		label: "Password",
-		description: "Password for basic HTTP authentication.",
-		valueType: "string",
-		semanticType: "password",
-		target: "secureJsonData",
-		dependsOn: "auth.method == 'basic-auth'"
-	},
-	{
-		id: "jsonData.oauthPassThru",
-		key: "oauthPassThru",
-		label: "Forward OAuth Identity",
-		description: "Forward the user's OAuth token to Elasticsearch.",
-		valueType: "boolean",
-		target: "jsonData",
-		tags: [
-			"managed-by:auth.method"
-		]
-	},
-	{
-		id: "jsonData.apiKeyAuth",
-		key: "apiKeyAuth",
-		label: "API key auth",
-		description: "Enable API key authentication.",
-		valueType: "boolean",
-		target: "jsonData",
-		tags: [
-			"managed-by:auth.method"
-		]
-	},
-	{
-		id: "secureJsonData.apiKey",
-		key: "apiKey",
-		label: "API Key",
-		description: "Elasticsearch API key for authentication.",
-		valueType: "string",
-		semanticType: "token",
-		target: "secureJsonData",
-		dependsOn: "auth.method == 'api-key'"
-	},
-	{
-		id: "jsonData.sigV4Auth",
-		key: "sigV4Auth",
-		label: "SigV4 auth",
-		description: "Enable AWS Signature Version 4 authentication.",
-		valueType: "boolean",
-		target: "jsonData",
-		tags: [
-			"managed-by:auth.method"
-		]
-	},
-	{
-		id: "jsonData.tlsAuthWithCACert",
-		key: "tlsAuthWithCACert",
-		label: "Add self-signed certificate",
-		description: "Add a self-signed CA certificate for TLS verification.",
-		valueType: "boolean",
-		target: "jsonData",
-		ui: {
-			component: "switch"
-		}
-	},
-	{
-		id: "secureJsonData.tlsCACert",
-		key: "tlsCACert",
-		label: "CA Cert",
-		description: "PEM-encoded CA certificate.",
-		valueType: "string",
-		target: "secureJsonData",
-		dependsOn: "jsonData.tlsAuthWithCACert == true",
-		ui: {
-			component: "textarea",
-			rows: 7
-		}
-	},
-	{
-		id: "jsonData.tlsAuth",
-		key: "tlsAuth",
-		label: "TLS Client Authentication",
-		description: "Enable TLS client certificate authentication.",
-		valueType: "boolean",
-		target: "jsonData",
-		ui: {
-			component: "switch"
-		}
-	},
-	{
-		id: "jsonData.serverName",
-		key: "serverName",
-		label: "Server name",
-		description: "Server name for SNI in TLS handshake.",
-		valueType: "string",
-		target: "jsonData",
-		dependsOn: "jsonData.tlsAuth == true"
-	},
-	{
-		id: "secureJsonData.tlsClientCert",
-		key: "tlsClientCert",
-		label: "Client Cert",
-		description: "PEM-encoded client certificate.",
-		valueType: "string",
-		target: "secureJsonData",
-		dependsOn: "jsonData.tlsAuth == true",
-		ui: {
-			component: "textarea",
-			rows: 7
-		}
-	},
-	{
-		id: "secureJsonData.tlsClientKey",
-		key: "tlsClientKey",
-		label: "Client Key",
-		description: "PEM-encoded client private key.",
-		valueType: "string",
-		semanticType: "token",
-		target: "secureJsonData",
-		dependsOn: "jsonData.tlsAuth == true",
-		ui: {
-			component: "textarea",
-			rows: 7
-		}
-	},
-	{
-		id: "jsonData.tlsSkipVerify",
-		key: "tlsSkipVerify",
-		label: "Skip TLS certificate validation",
-		description: "Skip server certificate verification.",
-		valueType: "boolean",
-		target: "jsonData",
-		ui: {
-			component: "switch"
-		}
-	},
-	{
-		id: "httpHeaders",
-		key: "httpHeaders",
-		label: "HTTP headers",
-		description: "Pass along additional context and metadata about the request/response.",
-		valueType: "array",
-		target: "jsonData",
-		storage: {
-			type: "indexedPair",
-			key: {
-				pattern: "httpHeaderName{index}",
-				target: "jsonData"
-			},
-			value: {
-				pattern: "httpHeaderValue{index}",
-				target: "secureJsonData"
-			},
-			startIndex: 1
-		},
-		item: {
-			valueType: "object"
-		}
-	},
-	{
-		id: "jsonData.keepCookies",
-		key: "keepCookies",
-		label: "Allowed cookies",
-		description: "Grafana proxy deletes forwarded cookies by default. Specify cookies by name that should be forwarded.",
-		valueType: "array",
-		target: "jsonData",
-		item: {
-			valueType: "string"
-		}
-	},
-	{
-		id: "jsonData.timeout",
-		key: "timeout",
-		label: "Timeout",
-		description: "HTTP request timeout in seconds.",
-		valueType: "number",
-		target: "jsonData",
-		ui: {
-			component: "input",
-			placeholder: "Timeout in seconds"
-		}
-	},
-	{
-		id: "jsonData.timeField",
-		key: "timeField",
-		label: "Time field name",
-		description: "Name of the time field. Default is @timestamp.",
-		valueType: "string",
-		target: "jsonData",
-		required: true,
-		defaultValue: "@timestamp",
-		ui: {
-			component: "input",
-			placeholder: "@timestamp"
-		}
-	},
-	{
-		id: "jsonData.interval",
-		key: "interval",
-		label: "Index date pattern",
-		description: "Index date time format for pattern-based indices.",
-		valueType: "string",
-		target: "jsonData",
-		validations: [
-			{
-				type: "allowedValues",
-				values: [
-					"Hourly",
-					"Daily",
-					"Weekly",
-					"Monthly",
-					"Yearly"
-				]
-			}
-		],
-		ui: {
-			component: "select",
-			options: [
-				{
-					label: "No pattern",
-					value: ""
-				},
-				{
-					label: "Hourly",
-					value: "Hourly"
-				},
-				{
-					label: "Daily",
-					value: "Daily"
-				},
-				{
-					label: "Weekly",
-					value: "Weekly"
-				},
-				{
-					label: "Monthly",
-					value: "Monthly"
-				},
-				{
-					label: "Yearly",
-					value: "Yearly"
-				}
-			]
-		}
-	},
-	{
-		id: "jsonData.timeInterval",
-		key: "timeInterval",
-		label: "Min time interval",
-		description: "Lower limit for the auto group-by time interval. Recommended to match your write frequency (e.g. 1m). Default is 10s.",
-		valueType: "string",
-		semanticType: "duration",
-		target: "jsonData",
-		defaultValue: "10s",
-		ui: {
-			component: "input",
-			placeholder: "10s"
-		}
-	},
-	{
-		id: "jsonData.maxConcurrentShardRequests",
-		key: "maxConcurrentShardRequests",
-		label: "Max concurrent shard requests",
-		description: "Number of shards queried simultaneously. Default is 5.",
-		valueType: "number",
-		target: "jsonData",
-		defaultValue: 5
-	},
-	{
-		id: "jsonData.logMessageField",
-		key: "logMessageField",
-		label: "Message field name",
-		description: "Which field should be used as the log message.",
-		valueType: "string",
-		target: "jsonData"
-	},
-	{
-		id: "jsonData.logLevelField",
-		key: "logLevelField",
-		label: "Level field name",
-		description: "Which field should indicate the priority of the log message.",
-		valueType: "string",
-		target: "jsonData"
-	},
-	{
-		id: "jsonData.dataLinks",
-		key: "dataLinks",
-		label: "Data links",
-		description: "Create links from specified fields, accessible in the logs view.",
-		valueType: "array",
-		target: "jsonData",
-		item: {
-			valueType: "object",
-			fields: [
-				{
-					id: "dataLinks.item.field",
-					key: "field",
-					label: "Field",
-					description: "Name of the field used by the data link.",
-					valueType: "string",
-					isItemField: true,
-					required: true
-				},
-				{
-					id: "dataLinks.item.url",
-					key: "url",
-					label: "URL/query",
-					description: "Full link URL or query. Interpolate with ${__value.raw}.",
-					valueType: "string",
-					isItemField: true
-				},
-				{
-					id: "dataLinks.item.urlDisplayLabel",
-					key: "urlDisplayLabel",
-					label: "URL Label",
-					description: "Custom display label for the link.",
-					valueType: "string",
-					isItemField: true
-				},
-				{
-					id: "dataLinks.item.datasourceUid",
-					key: "datasourceUid",
-					label: "Internal link",
-					description: "Data source UID for internal link. Supports tracing data sources.",
-					valueType: "string",
-					semanticType: "datasourceUid",
-					isItemField: true
-				}
-			]
-		}
-	},
-	{
-		id: "jsonData.includeFrozen",
-		key: "includeFrozen",
-		label: "Include frozen indices",
-		description: "Include frozen indices in searches. Requires X-Pack.",
-		valueType: "boolean",
-		target: "jsonData",
-		ui: {
-			component: "switch"
-		}
-	},
-	{
-		id: "jsonData.index",
-		key: "index",
-		label: "Index name",
-		description: "Name of the Elasticsearch index.",
-		valueType: "string",
-		target: "jsonData",
-		ui: {
-			component: "input"
-		}
-	},
-	{
-		id: "jsonData.defaultQueryMode",
-		key: "defaultQueryMode",
-		label: "Default query mode",
-		description: "Default query editor mode for new queries.",
-		valueType: "string",
-		target: "jsonData"
-	}
-];
-var groups$Z = [
-	{
-		id: "connection",
-		title: "Connection",
-		fieldRefs: [
-			"root.url"
-		]
-	},
-	{
-		id: "auth",
-		title: "Authentication",
-		fieldRefs: [
-			"auth.method",
-			"root.basicAuthUser",
-			"secureJsonData.basicAuthPassword",
-			"secureJsonData.apiKey"
-		]
-	},
-	{
-		id: "tls",
-		title: "TLS settings",
-		description: "Additional security measures that can be applied on top of authentication.",
-		fieldRefs: [
-			"jsonData.tlsAuthWithCACert",
-			"secureJsonData.tlsCACert",
-			"jsonData.tlsAuth",
-			"jsonData.serverName",
-			"secureJsonData.tlsClientCert",
-			"secureJsonData.tlsClientKey",
-			"jsonData.tlsSkipVerify"
-		]
-	},
-	{
-		id: "http",
-		title: "HTTP settings",
-		fieldRefs: [
-			"httpHeaders",
-			"jsonData.keepCookies",
-			"jsonData.timeout"
-		]
-	},
-	{
-		id: "elasticsearch-details",
-		title: "Elasticsearch details",
-		fieldRefs: [
-			"jsonData.index",
-			"jsonData.timeField",
-			"jsonData.interval",
-			"jsonData.timeInterval",
-			"jsonData.maxConcurrentShardRequests",
-			"jsonData.includeFrozen",
-			"jsonData.defaultQueryMode"
-		]
-	},
-	{
-		id: "logs",
-		title: "Logs",
-		fieldRefs: [
-			"jsonData.logMessageField",
-			"jsonData.logLevelField"
-		]
-	},
-	{
-		id: "data-links",
-		title: "Data links",
-		fieldRefs: [
-			"jsonData.dataLinks"
-		]
-	}
-];
-var elasticsearchSchema = {
-	$schema: $schema$Z,
-	schemaVersion: schemaVersion$Z,
-	pluginType: pluginType$Z,
-	pluginName: pluginName$Z,
-	docURL: docURL$w,
-	fields: fields$Z,
-	groups: groups$Z
-};
-
-export { $schema$Z as $schema, elasticsearchSchema as default, docURL$w as docURL, fields$Z as fields, groups$Z as groups, pluginName$Z as pluginName, pluginType$Z as pluginType, schemaVersion$Z as schemaVersion };
-//# sourceMappingURL=elasticsearch.schema.json.js.map

package/dist/esm/schema/registry/elasticsearch.schema.json.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"elasticsearch.schema.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/schema/registry/grafana-adobeanalytics-datasource.schema.json.js

@@ -1,95 +0,0 @@
-var $schema$X = "../schema.json";
-var schemaVersion$X = "v1";
-var pluginType$X = "grafana-adobeanalytics-datasource";
-var pluginName$X = "Adobe Analytics";
-var docURL$v = "https://grafana.com/docs/plugins/grafana-adobeanalytics-datasource";
-var fields$X = [
-	{
-		id: "jsonData.variables.global_company_id",
-		key: "global_company_id",
-		label: "Global Company ID",
-		description: "Refer to [plugin documentation](http://grafana.com/docs/plugins/grafana-adobeanalytics-datasource/#connection) for more information on where to find your Global Company ID in Adobe portal.",
-		valueType: "string",
-		target: "jsonData",
-		section: "variables",
-		required: true,
-		ui: {
-			placeholder: ""
-		}
-	},
-	{
-		id: "jsonData.services.adobe_analytics.auth.clientId",
-		key: "services.adobe_analytics.auth.clientId",
-		label: "Client ID",
-		description: "OAuth2 Client ID for Adobe Analytics server-to-server authentication.",
-		valueType: "string",
-		target: "jsonData",
-		required: true,
-		ui: {
-			placeholder: "Client ID"
-		}
-	},
-	{
-		id: "secureJsonData.adobe_analytics.clientSecret",
-		key: "adobe_analytics.clientSecret",
-		label: "Client Secret",
-		description: "OAuth2 Client Secret for Adobe Analytics server-to-server authentication.",
-		valueType: "string",
-		target: "secureJsonData",
-		semanticType: "token",
-		required: true,
-		ui: {
-			placeholder: "Client Secret"
-		}
-	},
-	{
-		id: "jsonData.enableSecureSocksProxy",
-		key: "enableSecureSocksProxy",
-		label: "Enable Secure Socks Proxy",
-		description: "Enable proxying the datasource connection through the secure socks proxy to a different network.",
-		valueType: "boolean",
-		target: "jsonData",
-		ui: {
-			component: "switch"
-		}
-	}
-];
-var groups$X = [
-	{
-		id: "connection",
-		title: "Connection",
-		description: "Provide information to connect to the Adobe Analytics API.",
-		fieldRefs: [
-			"jsonData.variables.global_company_id"
-		]
-	},
-	{
-		id: "auth",
-		title: "Authentication",
-		description: "OAuth server to server authentication via https://ims-na1.adobelogin.com/ims/token/v3.",
-		fieldRefs: [
-			"jsonData.services.adobe_analytics.auth.clientId",
-			"secureJsonData.adobe_analytics.clientSecret"
-		]
-	},
-	{
-		id: "advanced",
-		title: "Advanced",
-		fieldRefs: [
-			"jsonData.enableSecureSocksProxy"
-		],
-		optional: true
-	}
-];
-var grafanaAdobeanalyticsDatasourceSchema = {
-	$schema: $schema$X,
-	schemaVersion: schemaVersion$X,
-	pluginType: pluginType$X,
-	pluginName: pluginName$X,
-	docURL: docURL$v,
-	fields: fields$X,
-	groups: groups$X
-};
-
-export { $schema$X as $schema, grafanaAdobeanalyticsDatasourceSchema as default, docURL$v as docURL, fields$X as fields, groups$X as groups, pluginName$X as pluginName, pluginType$X as pluginType, schemaVersion$X as schemaVersion };
-//# sourceMappingURL=grafana-adobeanalytics-datasource.schema.json.js.map

package/dist/esm/schema/registry/grafana-adobeanalytics-datasource.schema.json.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"grafana-adobeanalytics-datasource.schema.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}