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

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

@@ -1,186 +0,0 @@
-var $schema$w = "../schema.json";
-var schemaVersion$w = "v1";
-var pluginType$w = "grafana-oracle-datasource";
-var pluginName$w = "Oracle Database";
-var fields$w = [
-	{
-		id: "root.url",
-		key: "url",
-		label: "URL",
-		description: "Oracle connection string (host:port/service_name or TNS name).",
-		valueType: "string",
-		semanticType: "url",
-		target: "root",
-		required: true
-	},
-	{
-		id: "jsonData.database",
-		key: "database",
-		label: "Database",
-		description: "Database or service name.",
-		valueType: "string",
-		target: "jsonData"
-	},
-	{
-		id: "jsonData.user",
-		key: "user",
-		label: "User",
-		description: "Oracle database user.",
-		valueType: "string",
-		target: "jsonData"
-	},
-	{
-		id: "jsonData.useTNSNamesBasedConnection",
-		key: "useTNSNamesBasedConnection",
-		label: "Use TNS Names",
-		description: "Use TNS names for connection instead of host:port.",
-		valueType: "boolean",
-		target: "jsonData",
-		ui: {
-			component: "switch"
-		}
-	},
-	{
-		id: "jsonData.tnsNamesEntry",
-		key: "tnsNamesEntry",
-		label: "TNS Names Entry",
-		description: "TNS names entry to use for the connection.",
-		valueType: "string",
-		target: "jsonData",
-		dependsOn: "jsonData.useTNSNamesBasedConnection == true"
-	},
-	{
-		id: "jsonData.timezone_name",
-		key: "timezone_name",
-		label: "Timezone",
-		description: "Oracle session timezone name.",
-		valueType: "string",
-		target: "jsonData"
-	},
-	{
-		id: "jsonData.use_dst",
-		key: "use_dst",
-		label: "Use DST",
-		description: "Enable daylight saving time adjustment.",
-		valueType: "boolean",
-		target: "jsonData",
-		ui: {
-			component: "switch"
-		}
-	},
-	{
-		id: "jsonData.useKerberosAuthentication",
-		key: "useKerberosAuthentication",
-		label: "Kerberos Authentication",
-		description: "Use Kerberos for authentication.",
-		valueType: "boolean",
-		target: "jsonData",
-		ui: {
-			component: "switch"
-		}
-	},
-	{
-		id: "jsonData.connectionPoolSize",
-		key: "connectionPoolSize",
-		label: "Connection Pool Size",
-		description: "Maximum number of connections in the pool.",
-		valueType: "number",
-		target: "jsonData"
-	},
-	{
-		id: "jsonData.dataProxyTimeout",
-		key: "dataProxyTimeout",
-		label: "Data Proxy Timeout",
-		description: "Timeout for data proxy requests in seconds.",
-		valueType: "number",
-		target: "jsonData"
-	},
-	{
-		id: "jsonData.prefetchRowsCount",
-		key: "prefetchRowsCount",
-		label: "Prefetch Rows Count",
-		description: "Number of rows to prefetch from Oracle.",
-		valueType: "number",
-		target: "jsonData"
-	},
-	{
-		id: "jsonData.rowLimit",
-		key: "rowLimit",
-		label: "Row Limit",
-		description: "Maximum number of rows returned per query.",
-		valueType: "number",
-		target: "jsonData"
-	},
-	{
-		id: "jsonData.enableSecureSocksProxy",
-		key: "enableSecureSocksProxy",
-		label: "Secure Socks Proxy",
-		description: "Enable secure SOCKS proxy.",
-		valueType: "boolean",
-		target: "jsonData",
-		ui: {
-			component: "switch"
-		}
-	},
-	{
-		id: "secureJsonData.password",
-		key: "password",
-		label: "Password",
-		description: "Oracle database password.",
-		valueType: "string",
-		target: "secureJsonData",
-		required: true,
-		semanticType: "password"
-	}
-];
-var groups$w = [
-	{
-		id: "connection",
-		title: "Connection",
-		fieldRefs: [
-			"root.url",
-			"jsonData.database",
-			"jsonData.useTNSNamesBasedConnection",
-			"jsonData.tnsNamesEntry"
-		]
-	},
-	{
-		id: "auth",
-		title: "Authentication",
-		fieldRefs: [
-			"jsonData.user",
-			"secureJsonData.password",
-			"jsonData.useKerberosAuthentication"
-		]
-	},
-	{
-		id: "settings",
-		title: "Settings",
-		fieldRefs: [
-			"jsonData.timezone_name",
-			"jsonData.use_dst"
-		]
-	},
-	{
-		id: "advanced",
-		title: "Advanced",
-		fieldRefs: [
-			"jsonData.connectionPoolSize",
-			"jsonData.dataProxyTimeout",
-			"jsonData.prefetchRowsCount",
-			"jsonData.rowLimit",
-			"jsonData.enableSecureSocksProxy"
-		]
-	}
-];
-var grafanaOracleDatasourceSchema = {
-	$schema: $schema$w,
-	schemaVersion: schemaVersion$w,
-	pluginType: pluginType$w,
-	pluginName: pluginName$w,
-	fields: fields$w,
-	groups: groups$w
-};
-
-export { $schema$w as $schema, grafanaOracleDatasourceSchema as default, fields$w as fields, groups$w as groups, pluginName$w as pluginName, pluginType$w as pluginType, schemaVersion$w as schemaVersion };
-//# sourceMappingURL=grafana-oracle-datasource.schema.json.js.map

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

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

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

@@ -1,85 +0,0 @@
-var $schema$v = "../schema.json";
-var schemaVersion$v = "v1";
-var pluginType$v = "grafana-pagerduty-datasource";
-var pluginName$v = "PagerDuty";
-var fields$v = [
-	{
-		id: "jsonData.servers.url",
-		key: "url",
-		label: "Server URL",
-		description: "PagerDuty API server URL.",
-		valueType: "string",
-		semanticType: "url",
-		target: "jsonData",
-		section: "servers",
-		required: true
-	},
-	{
-		id: "jsonData.servers.variables",
-		key: "variables",
-		label: "Server Variables",
-		description: "Server URL template variables.",
-		valueType: "map",
-		target: "jsonData",
-		section: "servers",
-		item: {
-			valueType: "string"
-		}
-	},
-	{
-		id: "jsonData.auth.id",
-		key: "id",
-		label: "API Token",
-		description: "PagerDuty API authentication token.",
-		valueType: "string",
-		target: "jsonData",
-		section: "auth",
-		required: true
-	},
-	{
-		id: "jsonData.enableSecureSocksProxy",
-		key: "enableSecureSocksProxy",
-		label: "Secure Socks Proxy",
-		description: "Enable secure SOCKS proxy.",
-		valueType: "boolean",
-		target: "jsonData",
-		ui: {
-			component: "switch"
-		}
-	}
-];
-var groups$v = [
-	{
-		id: "connection",
-		title: "Connection",
-		fieldRefs: [
-			"jsonData.servers.url",
-			"jsonData.servers.variables"
-		]
-	},
-	{
-		id: "auth",
-		title: "Authentication",
-		fieldRefs: [
-			"jsonData.auth.id"
-		]
-	},
-	{
-		id: "advanced",
-		title: "Advanced",
-		fieldRefs: [
-			"jsonData.enableSecureSocksProxy"
-		]
-	}
-];
-var grafanaPagerdutyDatasourceSchema = {
-	$schema: $schema$v,
-	schemaVersion: schemaVersion$v,
-	pluginType: pluginType$v,
-	pluginName: pluginName$v,
-	fields: fields$v,
-	groups: groups$v
-};
-
-export { $schema$v as $schema, grafanaPagerdutyDatasourceSchema as default, fields$v as fields, groups$v as groups, pluginName$v as pluginName, pluginType$v as pluginType, schemaVersion$v as schemaVersion };
-//# sourceMappingURL=grafana-pagerduty-datasource.schema.json.js.map

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

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

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

@@ -1,411 +0,0 @@
-var $schema$u = "../schema.json";
-var schemaVersion$u = "v1";
-var pluginType$u = "grafana-postgresql-datasource";
-var pluginName$u = "PostgreSQL";
-var docURL$k = "https://grafana.com/docs/grafana/latest/datasources/postgres/";
-var fields$u = [
-	{
-		id: "root.url",
-		key: "url",
-		label: "Host URL",
-		description: "PostgreSQL host and port.",
-		valueType: "string",
-		target: "root",
-		required: true,
-		ui: {
-			component: "input",
-			placeholder: "localhost:5432"
-		}
-	},
-	{
-		id: "jsonData.database",
-		key: "database",
-		label: "Database name",
-		description: "PostgreSQL database name.",
-		valueType: "string",
-		target: "jsonData",
-		required: true,
-		storage: {
-			type: "computed",
-			read: "root.database"
-		},
-		ui: {
-			component: "input",
-			placeholder: "Database"
-		}
-	},
-	{
-		id: "root.user",
-		key: "user",
-		label: "Username",
-		description: "Database username.",
-		valueType: "string",
-		target: "root",
-		required: true,
-		ui: {
-			component: "input",
-			placeholder: "Username"
-		}
-	},
-	{
-		id: "secureJsonData.password",
-		key: "password",
-		label: "Password",
-		description: "Database password.",
-		valueType: "string",
-		semanticType: "password",
-		target: "secureJsonData"
-	},
-	{
-		id: "jsonData.sslmode",
-		key: "sslmode",
-		label: "TLS/SSL Mode",
-		description: "Determines whether or with what priority a secure TLS/SSL TCP/IP connection will be negotiated with the server.",
-		valueType: "string",
-		target: "jsonData",
-		defaultValue: "require",
-		validations: [
-			{
-				type: "allowedValues",
-				values: [
-					"disable",
-					"require",
-					"verify-ca",
-					"verify-full"
-				]
-			}
-		],
-		ui: {
-			component: "select",
-			options: [
-				{
-					label: "disable",
-					value: "disable"
-				},
-				{
-					label: "require",
-					value: "require"
-				},
-				{
-					label: "verify-ca",
-					value: "verify-ca"
-				},
-				{
-					label: "verify-full",
-					value: "verify-full"
-				}
-			]
-		}
-	},
-	{
-		id: "jsonData.tlsConfigurationMethod",
-		key: "tlsConfigurationMethod",
-		label: "TLS/SSL Method",
-		description: "How TLS/SSL certificates are configured. File system path specifies paths to certificates on the local file system. Certificate content stores certificate data encrypted in Grafana's database.",
-		valueType: "string",
-		target: "jsonData",
-		defaultValue: "file-path",
-		dependsOn: "jsonData.sslmode != 'disable'",
-		validations: [
-			{
-				type: "allowedValues",
-				values: [
-					"file-path",
-					"file-content"
-				]
-			}
-		],
-		ui: {
-			component: "select",
-			options: [
-				{
-					label: "File system path",
-					value: "file-path"
-				},
-				{
-					label: "Certificate content",
-					value: "file-content"
-				}
-			]
-		}
-	},
-	{
-		id: "jsonData.sslRootCertFile",
-		key: "sslRootCertFile",
-		label: "TLS/SSL Root Certificate",
-		description: "Path to the root certificate file. Required if TLS/SSL mode is verify-ca or verify-full.",
-		valueType: "string",
-		target: "jsonData",
-		dependsOn: "jsonData.sslmode != 'disable' && jsonData.tlsConfigurationMethod != 'file-content'",
-		ui: {
-			component: "input",
-			placeholder: "TLS/SSL root cert file"
-		}
-	},
-	{
-		id: "jsonData.sslCertFile",
-		key: "sslCertFile",
-		label: "TLS/SSL Client Certificate",
-		description: "Path to the client certificate file for TLS/SSL client authentication.",
-		valueType: "string",
-		target: "jsonData",
-		dependsOn: "jsonData.sslmode != 'disable' && jsonData.tlsConfigurationMethod != 'file-content'",
-		ui: {
-			component: "input",
-			placeholder: "TLS/SSL client cert file"
-		}
-	},
-	{
-		id: "jsonData.sslKeyFile",
-		key: "sslKeyFile",
-		label: "TLS/SSL Client Key",
-		description: "Path to the client key file for TLS/SSL client authentication.",
-		valueType: "string",
-		target: "jsonData",
-		dependsOn: "jsonData.sslmode != 'disable' && jsonData.tlsConfigurationMethod != 'file-content'",
-		ui: {
-			component: "input",
-			placeholder: "TLS/SSL client key file"
-		}
-	},
-	{
-		id: "secureJsonData.tlsClientCert",
-		key: "tlsClientCert",
-		label: "TLS/SSL Client Certificate",
-		description: "PEM-encoded client certificate content.",
-		valueType: "string",
-		target: "secureJsonData",
-		dependsOn: "jsonData.sslmode != 'disable' && jsonData.tlsConfigurationMethod == 'file-content'",
-		ui: {
-			component: "textarea",
-			rows: 7
-		}
-	},
-	{
-		id: "secureJsonData.tlsCACert",
-		key: "tlsCACert",
-		label: "TLS/SSL Root Certificate",
-		description: "PEM-encoded root CA certificate content. Required for verify-ca and verify-full modes.",
-		valueType: "string",
-		target: "secureJsonData",
-		dependsOn: "jsonData.sslmode != 'disable' && jsonData.tlsConfigurationMethod == 'file-content'",
-		ui: {
-			component: "textarea",
-			rows: 7
-		}
-	},
-	{
-		id: "secureJsonData.tlsClientKey",
-		key: "tlsClientKey",
-		label: "TLS/SSL Client Key",
-		description: "PEM-encoded client private key content.",
-		valueType: "string",
-		semanticType: "token",
-		target: "secureJsonData",
-		dependsOn: "jsonData.sslmode != 'disable' && jsonData.tlsConfigurationMethod == 'file-content'",
-		ui: {
-			component: "textarea",
-			rows: 7
-		}
-	},
-	{
-		id: "jsonData.postgresVersion",
-		key: "postgresVersion",
-		label: "Version",
-		description: "PostgreSQL server version. Controls what functions are available in the query builder.",
-		valueType: "number",
-		target: "jsonData",
-		defaultValue: 903,
-		ui: {
-			component: "select",
-			options: [
-				{
-					label: "9.0",
-					value: 900
-				},
-				{
-					label: "9.1",
-					value: 901
-				},
-				{
-					label: "9.2",
-					value: 902
-				},
-				{
-					label: "9.3",
-					value: 903
-				},
-				{
-					label: "9.4",
-					value: 904
-				},
-				{
-					label: "9.5",
-					value: 905
-				},
-				{
-					label: "9.6",
-					value: 906
-				},
-				{
-					label: "10",
-					value: 1000
-				},
-				{
-					label: "11",
-					value: 1100
-				},
-				{
-					label: "12",
-					value: 1200
-				},
-				{
-					label: "13",
-					value: 1300
-				},
-				{
-					label: "14",
-					value: 1400
-				},
-				{
-					label: "15",
-					value: 1500
-				}
-			]
-		}
-	},
-	{
-		id: "jsonData.timeInterval",
-		key: "timeInterval",
-		label: "Min time interval",
-		description: "A lower limit for the auto group-by time interval. Recommended to be set to write frequency, for example 1m if your data is written every minute.",
-		valueType: "string",
-		semanticType: "duration",
-		target: "jsonData",
-		ui: {
-			component: "input",
-			placeholder: "1m"
-		}
-	},
-	{
-		id: "jsonData.timescaledb",
-		key: "timescaledb",
-		label: "TimescaleDB",
-		description: "TimescaleDB is a time-series database built as a PostgreSQL extension. If enabled, Grafana will use time_bucket in the $__timeGroup macro and display TimescaleDB specific aggregate functions in the query builder.",
-		valueType: "boolean",
-		target: "jsonData",
-		ui: {
-			component: "switch"
-		}
-	},
-	{
-		id: "jsonData.maxOpenConns",
-		key: "maxOpenConns",
-		label: "Max open",
-		description: "Maximum number of open connections to the database. Default is 100.",
-		valueType: "number",
-		target: "jsonData",
-		defaultValue: 100,
-		validations: [
-			{
-				type: "range",
-				min: 0
-			}
-		]
-	},
-	{
-		id: "jsonData.connMaxLifetime",
-		key: "connMaxLifetime",
-		label: "Max lifetime",
-		description: "Maximum lifetime of a connection in seconds. Default is 14400 (4 hours). Set to 0 to reuse connections forever.",
-		valueType: "number",
-		target: "jsonData",
-		defaultValue: 14400,
-		validations: [
-			{
-				type: "range",
-				min: 0
-			}
-		]
-	}
-];
-var groups$u = [
-	{
-		id: "connection",
-		title: "Connection",
-		fieldRefs: [
-			"root.url",
-			"jsonData.database"
-		]
-	},
-	{
-		id: "auth",
-		title: "Authentication",
-		fieldRefs: [
-			"root.user",
-			"secureJsonData.password"
-		]
-	},
-	{
-		id: "tls",
-		title: "TLS/SSL Settings",
-		fieldRefs: [
-			"jsonData.sslmode",
-			"jsonData.tlsConfigurationMethod",
-			"jsonData.sslRootCertFile",
-			"jsonData.sslCertFile",
-			"jsonData.sslKeyFile",
-			"secureJsonData.tlsClientCert",
-			"secureJsonData.tlsCACert",
-			"secureJsonData.tlsClientKey"
-		]
-	},
-	{
-		id: "postgres-options",
-		title: "PostgreSQL Options",
-		fieldRefs: [
-			"jsonData.postgresVersion",
-			"jsonData.timeInterval",
-			"jsonData.timescaledb"
-		]
-	},
-	{
-		id: "connection-limits",
-		title: "Connection limits",
-		fieldRefs: [
-			"jsonData.maxOpenConns",
-			"jsonData.connMaxLifetime"
-		]
-	}
-];
-var relationships$6 = [
-	{
-		type: "pair",
-		fields: [
-			"root.user",
-			"secureJsonData.password"
-		],
-		description: "Database credentials"
-	},
-	{
-		type: "pair",
-		fields: [
-			"secureJsonData.tlsClientCert",
-			"secureJsonData.tlsClientKey"
-		],
-		description: "TLS client certificate and key"
-	}
-];
-var grafanaPostgresqlDatasourceSchema = {
-	$schema: $schema$u,
-	schemaVersion: schemaVersion$u,
-	pluginType: pluginType$u,
-	pluginName: pluginName$u,
-	docURL: docURL$k,
-	fields: fields$u,
-	groups: groups$u,
-	relationships: relationships$6
-};
-
-export { $schema$u as $schema, grafanaPostgresqlDatasourceSchema as default, docURL$k as docURL, fields$u as fields, groups$u as groups, pluginName$u as pluginName, pluginType$u as pluginType, relationships$6 as relationships, schemaVersion$u as schemaVersion };
-//# sourceMappingURL=grafana-postgresql-datasource.schema.json.js.map

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

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