@grafana/plugin-ui 0.14.0-dev.1 → 0.14.1-dsconfig.4bdebf6

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

@@ -0,0 +1,464 @@
+var $schema$u = "../schema.json";
+var schemaVersion$u = "v1";
+var pluginType$u = "grafana-postgresql-datasource";
+var pluginName$u = "PostgreSQL";
+var docURL$j = "https://grafana.com/docs/grafana/latest/datasources/postgres/";
+var fields$u = [
+	{
+		id: "root.url",
+		key: "url",
+		label: "Host",
+		description: "PostgreSQL host:port. Example: localhost:5432.",
+		valueType: "string",
+		target: "root",
+		required: true,
+		ui: {
+			component: "input",
+			placeholder: "localhost:5432"
+		}
+	},
+	{
+		id: "root.user",
+		key: "user",
+		label: "Username",
+		description: "Database username.",
+		valueType: "string",
+		target: "root",
+		required: true,
+		ui: {
+			component: "input",
+			placeholder: "Username"
+		}
+	},
+	{
+		id: "jsonData.database",
+		key: "database",
+		label: "Database",
+		description: "PostgreSQL database name.",
+		valueType: "string",
+		target: "jsonData",
+		required: true,
+		storage: {
+			type: "computed",
+			read: "root.database"
+		}
+	},
+	{
+		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: "disable",
+		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 configuration method",
+		description: "How to provide TLS certificates.",
+		valueType: "string",
+		target: "jsonData",
+		validations: [
+			{
+				type: "allowedValues",
+				values: [
+					"file-path",
+					"file-content"
+				]
+			}
+		],
+		ui: {
+			component: "select",
+			options: [
+				{
+					label: "File 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 on the server.",
+		valueType: "string",
+		target: "jsonData",
+		dependsOn: "jsonData.tlsConfigurationMethod == 'file-path'"
+	},
+	{
+		id: "jsonData.sslCertFile",
+		key: "sslCertFile",
+		label: "TLS/SSL Client Certificate",
+		description: "Path to the client certificate file on the server.",
+		valueType: "string",
+		target: "jsonData",
+		dependsOn: "jsonData.tlsConfigurationMethod == 'file-path'"
+	},
+	{
+		id: "jsonData.sslKeyFile",
+		key: "sslKeyFile",
+		label: "TLS/SSL Client Key",
+		description: "Path to the client key file on the server.",
+		valueType: "string",
+		target: "jsonData",
+		dependsOn: "jsonData.tlsConfigurationMethod == 'file-path'"
+	},
+	{
+		id: "jsonData.tlsSkipVerify",
+		key: "tlsSkipVerify",
+		label: "Skip TLS Verify",
+		description: "Skip server certificate verification.",
+		valueType: "boolean",
+		target: "jsonData",
+		ui: {
+			component: "switch"
+		}
+	},
+	{
+		id: "jsonData.postgresVersion",
+		key: "postgresVersion",
+		label: "PostgreSQL version",
+		description: "PostgreSQL server version. Affects available query features.",
+		valueType: "number",
+		target: "jsonData"
+	},
+	{
+		id: "jsonData.timescaledb",
+		key: "timescaledb",
+		label: "TimescaleDB",
+		description: "Enable TimescaleDB features like time_bucket for time grouping.",
+		valueType: "boolean",
+		target: "jsonData",
+		ui: {
+			component: "switch"
+		}
+	},
+	{
+		id: "jsonData.timeInterval",
+		key: "timeInterval",
+		label: "Min time interval",
+		description: "A lower limit for the auto group-by time interval.",
+		valueType: "string",
+		semanticType: "duration",
+		target: "jsonData",
+		ui: {
+			component: "input",
+			placeholder: "1m"
+		}
+	},
+	{
+		id: "jsonData.maxOpenConns",
+		key: "maxOpenConns",
+		label: "Max open connections",
+		description: "Maximum number of open connections to the database.",
+		valueType: "number",
+		target: "jsonData",
+		validations: [
+			{
+				type: "range",
+				min: 0
+			}
+		]
+	},
+	{
+		id: "jsonData.maxIdleConns",
+		key: "maxIdleConns",
+		label: "Max idle connections",
+		description: "Maximum number of idle connections in the pool.",
+		valueType: "number",
+		target: "jsonData",
+		defaultValue: 2,
+		validations: [
+			{
+				type: "range",
+				min: 0
+			}
+		]
+	},
+	{
+		id: "jsonData.maxIdleConnsAuto",
+		key: "maxIdleConnsAuto",
+		label: "Auto max idle connections",
+		description: "Let Grafana automatically manage the idle connection pool.",
+		valueType: "boolean",
+		target: "jsonData",
+		ui: {
+			component: "switch"
+		}
+	},
+	{
+		id: "jsonData.connMaxLifetime",
+		key: "connMaxLifetime",
+		label: "Max connection lifetime",
+		description: "Maximum lifetime of a connection in seconds.",
+		valueType: "number",
+		target: "jsonData",
+		defaultValue: 14400,
+		validations: [
+			{
+				type: "range",
+				min: 0
+			}
+		]
+	},
+	{
+		id: "jsonData.connectionTimeout",
+		key: "connectionTimeout",
+		label: "Connection timeout",
+		description: "Connection timeout in seconds.",
+		valueType: "number",
+		target: "jsonData",
+		validations: [
+			{
+				type: "range",
+				min: 0
+			}
+		]
+	},
+	{
+		id: "jsonData.timezone",
+		key: "timezone",
+		label: "Session timezone",
+		description: "Specify the timezone used in the database session (e.g. Europe/Berlin).",
+		valueType: "string",
+		target: "jsonData"
+	},
+	{
+		id: "jsonData.servername",
+		key: "servername",
+		label: "TLS server name",
+		description: "TLS server name for certificate verification.",
+		valueType: "string",
+		semanticType: "hostname",
+		target: "jsonData"
+	},
+	{
+		id: "jsonData.encrypt",
+		key: "encrypt",
+		label: "Encrypt",
+		description: "Encryption mode.",
+		valueType: "string",
+		target: "jsonData"
+	},
+	{
+		id: "jsonData.authenticationType",
+		key: "authenticationType",
+		label: "Authentication type",
+		description: "Authentication mechanism used for the PostgreSQL connection.",
+		valueType: "string",
+		target: "jsonData"
+	},
+	{
+		id: "jsonData.allowCleartextPasswords",
+		key: "allowCleartextPasswords",
+		label: "Allow cleartext passwords",
+		description: "Allow sending passwords in cleartext.",
+		valueType: "boolean",
+		target: "jsonData",
+		ui: {
+			component: "switch"
+		}
+	},
+	{
+		id: "jsonData.enableSecureSocksProxy",
+		key: "enableSecureSocksProxy",
+		label: "Secure Socks Proxy",
+		description: "Enable secure SOCKS proxy.",
+		valueType: "boolean",
+		target: "jsonData",
+		ui: {
+			component: "switch"
+		}
+	},
+	{
+		id: "jsonData.secureSocksProxyUsername",
+		key: "secureSocksProxyUsername",
+		label: "Secure Socks Proxy Username",
+		description: "Username for the secure SOCKS proxy.",
+		valueType: "boolean",
+		target: "jsonData"
+	},
+	{
+		id: "secureJsonData.password",
+		key: "password",
+		label: "Password",
+		description: "Database password.",
+		valueType: "string",
+		semanticType: "password",
+		target: "secureJsonData"
+	},
+	{
+		id: "secureJsonData.tlsCACert",
+		key: "tlsCACert",
+		label: "TLS/SSL Root Certificate",
+		description: "PEM-encoded root CA certificate content.",
+		valueType: "string",
+		target: "secureJsonData",
+		dependsOn: "jsonData.tlsConfigurationMethod == 'file-content'",
+		ui: {
+			component: "textarea",
+			rows: 7
+		}
+	},
+	{
+		id: "secureJsonData.tlsClientCert",
+		key: "tlsClientCert",
+		label: "TLS/SSL Client Certificate",
+		description: "PEM-encoded client certificate content.",
+		valueType: "string",
+		target: "secureJsonData",
+		dependsOn: "jsonData.tlsConfigurationMethod == 'file-content'",
+		ui: {
+			component: "textarea",
+			rows: 7
+		}
+	},
+	{
+		id: "secureJsonData.tlsClientKey",
+		key: "tlsClientKey",
+		label: "TLS/SSL Client Key",
+		description: "PEM-encoded client key content.",
+		valueType: "string",
+		semanticType: "token",
+		target: "secureJsonData",
+		dependsOn: "jsonData.tlsConfigurationMethod == 'file-content'",
+		ui: {
+			component: "textarea",
+			rows: 7
+		}
+	}
+];
+var groups$u = [
+	{
+		id: "connection",
+		title: "PostgreSQL Connection",
+		fieldRefs: [
+			"root.url",
+			"jsonData.database"
+		]
+	},
+	{
+		id: "auth",
+		title: "Authentication",
+		fieldRefs: [
+			"root.user",
+			"secureJsonData.password",
+			"jsonData.authenticationType",
+			"jsonData.allowCleartextPasswords"
+		]
+	},
+	{
+		id: "tls",
+		title: "TLS / SSL",
+		fieldRefs: [
+			"jsonData.sslmode",
+			"jsonData.tlsConfigurationMethod",
+			"jsonData.sslRootCertFile",
+			"jsonData.sslCertFile",
+			"jsonData.sslKeyFile",
+			"jsonData.tlsSkipVerify",
+			"jsonData.servername",
+			"secureJsonData.tlsCACert",
+			"secureJsonData.tlsClientCert",
+			"secureJsonData.tlsClientKey"
+		]
+	},
+	{
+		id: "postgres-details",
+		title: "PostgreSQL details",
+		fieldRefs: [
+			"jsonData.postgresVersion",
+			"jsonData.timescaledb",
+			"jsonData.timeInterval",
+			"jsonData.timezone"
+		]
+	},
+	{
+		id: "connection-limits",
+		title: "Connection Limits",
+		fieldRefs: [
+			"jsonData.maxOpenConns",
+			"jsonData.maxIdleConns",
+			"jsonData.maxIdleConnsAuto",
+			"jsonData.connMaxLifetime",
+			"jsonData.connectionTimeout"
+		]
+	},
+	{
+		id: "network",
+		title: "Network",
+		fieldRefs: [
+			"jsonData.enableSecureSocksProxy",
+			"jsonData.secureSocksProxyUsername"
+		]
+	}
+];
+var relationships$4 = [
+	{
+		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$j,
+	fields: fields$u,
+	groups: groups$u,
+	relationships: relationships$4
+};
+
+export { $schema$u as $schema, grafanaPostgresqlDatasourceSchema as default, docURL$j as docURL, fields$u as fields, groups$u as groups, pluginName$u as pluginName, pluginType$u as pluginType, relationships$4 as relationships, schemaVersion$u as schemaVersion };
+//# sourceMappingURL=grafana-postgresql-datasource.schema.json.js.map

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

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

package/dist/esm/datasource/schema/datasources/grafana-pyroscope-datasource.schema.json.js

@@ -0,0 +1,41 @@
+var $schema$t = "../schema.json";
+var schemaVersion$t = "v1";
+var pluginType$t = "grafana-pyroscope-datasource";
+var pluginName$t = "Pyroscope";
+var docURL$i = "https://grafana.com/docs/grafana/latest/datasources/pyroscope/";
+var fields$t = [
+	{
+		id: "jsonData.minStep",
+		key: "minStep",
+		label: "Minimal step",
+		description: "Minimal step used for metric query. Should be the same or higher as the scrape interval setting in the Pyroscope database.",
+		valueType: "string",
+		semanticType: "duration",
+		target: "jsonData",
+		ui: {
+			component: "input",
+			placeholder: "15s"
+		}
+	}
+];
+var groups$t = [
+	{
+		id: "querying",
+		title: "Querying",
+		fieldRefs: [
+			"jsonData.minStep"
+		]
+	}
+];
+var grafanaPyroscopeDatasourceSchema = {
+	$schema: $schema$t,
+	schemaVersion: schemaVersion$t,
+	pluginType: pluginType$t,
+	pluginName: pluginName$t,
+	docURL: docURL$i,
+	fields: fields$t,
+	groups: groups$t
+};
+
+export { $schema$t as $schema, grafanaPyroscopeDatasourceSchema as default, docURL$i as docURL, fields$t as fields, groups$t as groups, pluginName$t as pluginName, pluginType$t as pluginType, schemaVersion$t as schemaVersion };
+//# sourceMappingURL=grafana-pyroscope-datasource.schema.json.js.map

package/dist/esm/datasource/schema/datasources/grafana-pyroscope-datasource.schema.json.js.map

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

package/dist/esm/datasource/schema/datasources/grafana-redshift-datasource.schema.json.js

@@ -0,0 +1,201 @@
+var $schema$s = "../schema.json";
+var schemaVersion$s = "v1";
+var pluginType$s = "grafana-redshift-datasource";
+var pluginName$s = "Amazon Redshift";
+var docURL$h = "https://grafana.com/grafana/plugins/grafana-redshift-datasource/";
+var fields$s = [
+	{
+		id: "jsonData.authType",
+		key: "authType",
+		label: "Authentication Provider",
+		description: "AWS authentication method.",
+		valueType: "string",
+		target: "jsonData",
+		defaultValue: "default"
+	},
+	{
+		id: "jsonData.defaultRegion",
+		key: "defaultRegion",
+		label: "Default Region",
+		description: "AWS region.",
+		valueType: "string",
+		target: "jsonData"
+	},
+	{
+		id: "jsonData.assumeRoleArn",
+		key: "assumeRoleArn",
+		label: "Assume Role ARN",
+		description: "ARN of the IAM role to assume.",
+		valueType: "string",
+		target: "jsonData"
+	},
+	{
+		id: "jsonData.externalId",
+		key: "externalId",
+		label: "External ID",
+		description: "External ID for cross-account role assumption.",
+		valueType: "string",
+		target: "jsonData"
+	},
+	{
+		id: "jsonData.profile",
+		key: "profile",
+		label: "Credentials Profile Name",
+		description: "AWS credentials profile name.",
+		valueType: "string",
+		target: "jsonData"
+	},
+	{
+		id: "jsonData.endpoint",
+		key: "endpoint",
+		label: "Endpoint",
+		description: "Optional custom endpoint.",
+		valueType: "string",
+		target: "jsonData"
+	},
+	{
+		id: "jsonData.withEvent",
+		key: "withEvent",
+		label: "With Event",
+		description: "Include events in query results.",
+		valueType: "boolean",
+		target: "jsonData",
+		ui: {
+			component: "switch"
+		}
+	},
+	{
+		id: "jsonData.useManagedSecret",
+		key: "useManagedSecret",
+		label: "Use Managed Secret",
+		description: "Use AWS Secrets Manager for authentication.",
+		valueType: "boolean",
+		target: "jsonData",
+		ui: {
+			component: "switch"
+		}
+	},
+	{
+		id: "jsonData.useServerless",
+		key: "useServerless",
+		label: "Use Serverless",
+		description: "Connect to Redshift Serverless.",
+		valueType: "boolean",
+		target: "jsonData",
+		ui: {
+			component: "switch"
+		}
+	},
+	{
+		id: "jsonData.workgroupName",
+		key: "workgroupName",
+		label: "Workgroup Name",
+		description: "Redshift Serverless workgroup name.",
+		valueType: "string",
+		target: "jsonData",
+		dependsOn: "jsonData.useServerless == true"
+	},
+	{
+		id: "jsonData.clusterIdentifier",
+		key: "clusterIdentifier",
+		label: "Cluster Identifier",
+		description: "Redshift cluster identifier.",
+		valueType: "string",
+		target: "jsonData"
+	},
+	{
+		id: "jsonData.database",
+		key: "database",
+		label: "Database",
+		description: "Redshift database name.",
+		valueType: "string",
+		target: "jsonData"
+	},
+	{
+		id: "jsonData.dbUser",
+		key: "dbUser",
+		label: "Database User",
+		description: "Database user for temporary credentials.",
+		valueType: "string",
+		target: "jsonData"
+	},
+	{
+		id: "jsonData.managedSecret",
+		key: "managedSecret",
+		label: "Managed Secret",
+		description: "AWS Secrets Manager secret for authentication.",
+		valueType: "object",
+		target: "jsonData",
+		dependsOn: "jsonData.useManagedSecret == true"
+	},
+	{
+		id: "secureJsonData.accessKey",
+		key: "accessKey",
+		label: "Access Key ID",
+		description: "AWS access key ID.",
+		valueType: "string",
+		semanticType: "token",
+		target: "secureJsonData"
+	},
+	{
+		id: "secureJsonData.secretKey",
+		key: "secretKey",
+		label: "Secret Access Key",
+		description: "AWS secret access key.",
+		valueType: "string",
+		semanticType: "token",
+		target: "secureJsonData"
+	},
+	{
+		id: "secureJsonData.sessionToken",
+		key: "sessionToken",
+		label: "Session Token",
+		description: "AWS temporary session token.",
+		valueType: "string",
+		semanticType: "token",
+		target: "secureJsonData"
+	}
+];
+var groups$s = [
+	{
+		id: "auth",
+		title: "Authentication",
+		fieldRefs: [
+			"jsonData.authType",
+			"jsonData.defaultRegion",
+			"jsonData.profile",
+			"jsonData.assumeRoleArn",
+			"jsonData.externalId",
+			"jsonData.endpoint",
+			"secureJsonData.accessKey",
+			"secureJsonData.secretKey",
+			"secureJsonData.sessionToken"
+		]
+	},
+	{
+		id: "redshift-details",
+		title: "Redshift details",
+		fieldRefs: [
+			"jsonData.clusterIdentifier",
+			"jsonData.database",
+			"jsonData.dbUser",
+			"jsonData.useServerless",
+			"jsonData.workgroupName",
+			"jsonData.useManagedSecret",
+			"jsonData.managedSecret",
+			"jsonData.withEvent"
+		]
+	}
+];
+var grafanaRedshiftDatasourceSchema = {
+	$schema: $schema$s,
+	schemaVersion: schemaVersion$s,
+	pluginType: pluginType$s,
+	pluginName: pluginName$s,
+	docURL: docURL$h,
+	fields: fields$s,
+	groups: groups$s
+};
+
+export { $schema$s as $schema, grafanaRedshiftDatasourceSchema as default, docURL$h as docURL, fields$s as fields, groups$s as groups, pluginName$s as pluginName, pluginType$s as pluginType, schemaVersion$s as schemaVersion };
+//# sourceMappingURL=grafana-redshift-datasource.schema.json.js.map

package/dist/esm/datasource/schema/datasources/grafana-redshift-datasource.schema.json.js.map

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