@keboola/api-client 49.0.0 → 51.0.0

package/dist/sdk/configurations/index.cjs

@@ -1,3 +1,635 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_configurations = require("../../configurations-Dkxsa3Uf.cjs");
-exports.createConfigurationSdk = require_configurations.createConfigurationSdk;
+const require_schemaGuidedMerge = require("../../schemaGuidedMerge-C8CqrNGe.cjs");
+const require_componentId = require("../../componentId-C8ZTXXDo.cjs");
+const require_configurations = require("../../configurations-WI8H4zLk.cjs");
+let zod = require("zod");
+// src/sdks/configurations/schemas/appDataGatewaySchema.ts
+/**
+* `keboola.app-data-gateway` — the Data Gateway provisions and manages its own Snowflake
+* workspace, so the config carries no credentials: just the id of the workspace it runs
+* against, stored at `parameters.db.workspaceId`.
+*/
+const appDataGatewaySchema = zod.z.object({ parameters: zod.z.object({ db: zod.z.object({ workspaceId: zod.z.number() }) }) });
+// src/sdks/configurations/schemas/common/dbConfig.ts
+/** Wrap a `parameters.db` credential schema into the full component config shape. */
+const dbConfig = (db) => zod.z.object({ parameters: zod.z.object({ db }) });
+// src/sdks/configurations/schemas/common/dbConnection.ts
+/**
+* The credential fields shared by virtually every DB writer, stored at `parameters.db`.
+* Components extend this with driver-specific fields (`schema`, `warehouse`, `ssh`, …) and
+* override where they differ (e.g. Snowflake makes `#password` optional). Secret leaves use
+* the `#` prefix the encryption service recognizes.
+*/
+const dbConnectionSchema = zod.z.object({
+	host: zod.z.string().describe("Hostname"),
+	port: zod.z.number().describe("Port"),
+	user: zod.z.string().describe("Username"),
+	"#password": zod.z.string().describe("Password"),
+	database: zod.z.string().describe("Database Name")
+});
+// src/sdks/configurations/schemas/common/forbidden.ts
+/**
+* Marks a field as "must be absent" in one arm of a mutually-exclusive union: `z.undefined()`
+* rejects any value while `.optional()` lets the key be omitted entirely. Pairing it with a
+* required field in the sibling arm (e.g. `#password` XOR `#privateKey`) is what makes an
+* "exactly one of" union reject configs that set both keys — or neither — at runtime and in
+* the inferred type. Without it the arms would be open objects that silently strip the extra key.
+*/
+const forbidden = zod.z.undefined().optional();
+// src/sdks/configurations/schemas/common/oauthAuthorization.ts
+/**
+* The OAuth credential reference components store under a top-level `authorization` key. `id`
+* points at the vault-stored credential; `version` is the OAuth-API version (3 on modern stacks).
+* Shared by every OAuth-backed component (Google family, Facebook, …).
+*/
+const oauthAuthorizationSchema = zod.z.object({ oauth_api: zod.z.object({
+	id: zod.z.string(),
+	version: zod.z.number().optional()
+}) });
+// src/sdks/configurations/schemas/common/sshTunnelSchema.ts
+const sshTunnelSchema = zod.z.object({
+	enabled: zod.z.boolean(),
+	sshHost: zod.z.string().optional(),
+	user: zod.z.string().optional(),
+	sshPort: zod.z.number().optional(),
+	/** FTP passive-mode port range (e.g. `10000:10005`); only relevant to FTP extractors. */
+	passivePortRange: zod.z.string().optional(),
+	keys: zod.z.object({
+		public: zod.z.string().optional(),
+		"#private": zod.z.string().optional()
+	}).optional()
+});
+// src/sdks/configurations/schemas/common/sslSchema.ts
+/** SSL options nested at `parameters.db.ssl` (drivers that support it, e.g. MySQL, Hive). */
+const sslSchema = zod.z.object({
+	enabled: zod.z.boolean(),
+	cert: zod.z.string().optional(),
+	"#key": zod.z.string().optional(),
+	ca: zod.z.string().optional(),
+	cipher: zod.z.string().optional(),
+	verifyServerCert: zod.z.boolean().optional()
+});
+// src/sdks/configurations/schemas/appSnowflakeDwhManagerSchema.ts
+/**
+* `keboola.app-snowflake-dwh-manager` — master Snowflake connection. Auth is a password OR a
+* key-pair (exactly one). The common fields are shared; each variant requires its own secret and
+* *forbids the other* (`forbidden`), so a config carrying both — or neither — is rejected at
+* runtime and at the type level, matching the `wr-db-snowflake` XOR pattern.
+*/
+const dwhMasterBase = zod.z.object({
+	master_host: zod.z.string(),
+	master_user: zod.z.string(),
+	master_database: zod.z.string(),
+	warehouse: zod.z.string()
+});
+const appSnowflakeDwhManagerSchema = zod.z.object({ parameters: zod.z.union([dwhMasterBase.extend({
+	"#master_password": zod.z.string(),
+	"#master_private_key": forbidden
+}), dwhMasterBase.extend({
+	"#master_private_key": zod.z.string(),
+	"#master_password": forbidden
+})]) });
+// src/sdks/configurations/schemas/ex/exAwsS3Schema.ts
+/** Access-key credentials — forbids the IAM-role fields so the variants stay exclusive. */
+const awsCredentialsAuth = zod.z.object({
+	loginType: zod.z.literal("credentials"),
+	accessKeyId: zod.z.string(),
+	"#secretAccessKey": zod.z.string(),
+	accountId: forbidden,
+	roleName: forbidden
+}).loose();
+/** IAM-role auth — forbids the access-key fields so the variants stay exclusive. */
+const awsRoleAuth = zod.z.object({
+	loginType: zod.z.literal("role"),
+	accountId: zod.z.string(),
+	roleName: zod.z.string(),
+	accessKeyId: forbidden,
+	"#secretAccessKey": forbidden
+}).loose();
+/**
+* `keboola.ex-aws-s3` — access-key credentials OR IAM-role auth (exactly one). `loginType` is the
+* discriminant, and each arm *forbids the other* variant's fields (`z.undefined()`) so a config
+* mixing both — e.g. credentials + a stale `roleName` — is rejected rather than silently stripped.
+* The outer object is `.loose()` so top-level component-managed keys (`storage`, `processors`)
+* pass through.
+*/
+const exAwsS3Schema = zod.z.object({ parameters: zod.z.union([awsCredentialsAuth, awsRoleAuth]) }).loose();
+// src/sdks/configurations/schemas/ex/exAzureBlobStorageSchema.ts
+/**
+* `kds-team.ex-azure-blob-storage-v2` — account name + key + container. Both levels are `.loose()`:
+* the connection block is validated, but component-managed `parameters` and top-level keys
+* (`storage`, `processors`) pass through rather than being stripped on create/update.
+*/
+const exAzureBlobSchema = zod.z.object({ parameters: zod.z.object({
+	account_name: zod.z.string(),
+	"#account_key": zod.z.string(),
+	container_name: zod.z.string()
+}).loose() }).loose();
+// src/sdks/configurations/schemas/ex/exAzureDataLakeSchema.ts
+/**
+* `kds-team.ex-azure-data-lake-gen2` — like Blob, but a `file_system` instead of a container. Both
+* levels are `.loose()`: the connection block is validated, but component-managed `parameters` and
+* top-level keys (`storage`, `processors`) pass through rather than being stripped on create/update.
+*/
+const exAzureDataLakeSchema = zod.z.object({ parameters: zod.z.object({
+	account_name: zod.z.string(),
+	"#account_key": zod.z.string(),
+	file_system: zod.z.string()
+}).loose() }).loose();
+// src/sdks/configurations/schemas/ex/exFtpSchema.ts
+/** Connection fields shared by both auth variants. */
+const ftpConnection = zod.z.object({
+	host: zod.z.string(),
+	port: zod.z.number(),
+	connectionType: zod.z.enum([
+		"FTP",
+		"FTPS",
+		"SFTP"
+	]),
+	username: zod.z.string(),
+	ignorePassiveAddress: zod.z.boolean().optional(),
+	ssh: sshTunnelSchema.optional(),
+	path: zod.z.string().optional(),
+	onlyNewFiles: zod.z.boolean().optional()
+});
+/** Password auth — forbids the private key so the variants stay exclusive. */
+const ftpPasswordAuth = ftpConnection.extend({
+	"#password": zod.z.string(),
+	"#privateKey": forbidden
+}).loose();
+/** Private-key auth — forbids the password so the variants stay exclusive. */
+const ftpPrivateKeyAuth = ftpConnection.extend({
+	"#privateKey": zod.z.string(),
+	"#password": forbidden
+}).loose();
+/**
+* `keboola.ex-ftp` / `keboola.ex-ftp-csas` — FTP/FTPS/SFTP server connection. Auth is a password
+* OR a private key (exactly one): each variant requires its secret and *forbids the other*
+* (`z.undefined()`), so a config with both — or neither — is rejected, and switching variants via
+* an update drops the abandoned secret (the whole `parameters` union subtree is replaced wholesale
+* by `schemaGuidedMerge`, so a partial patch must carry the complete connection block). The outer
+* object is `.loose()` so top-level component-managed keys (`storage`, `processors`) pass through.
+*/
+const exFtpSchema = zod.z.object({ parameters: zod.z.union([ftpPasswordAuth, ftpPrivateKeyAuth]) }).loose();
+// src/sdks/configurations/schemas/ex/exHttpSchema.ts
+/**
+* `keboola.ex-http` — only the connection block is stable here. The request/job definitions are
+* component-managed and left unvalidated, so both levels are `.loose()`: extra `parameters` keys
+* and top-level keys (`storage`, `processors`) pass through `schema`/`inputSchema` unchanged rather
+* than being stripped on create/update.
+*/
+const exHttpSchema = zod.z.object({ parameters: zod.z.object({
+	baseUrl: zod.z.string(),
+	maxRedirects: zod.z.number().optional()
+}).loose() }).loose();
+// src/sdks/configurations/schemas/exDb/exDbDefaultSchema.ts
+/**
+* Default extractor credentials with an optional SSH tunnel, for the generic SSH-only drivers.
+*
+* - Keep in sync with kbc-ui's `hasSshTunnel` / `hasSsl` (`ex-db-generic/helpers.ts`).
+* - SSL-capable, tunnel-less and extra-field drivers get their own schema.
+*/
+const exDbDefaultSchema = dbConfig(dbConnectionSchema.extend({ ssh: sshTunnelSchema.optional() }));
+// src/sdks/configurations/schemas/exDb/exDbPgsqlSchema.ts
+/** `keboola.ex-db-pgsql` — generic credentials that also accept SSL. */
+const exDbPgsqlSchema = dbConfig(dbConnectionSchema.extend({
+	ssh: sshTunnelSchema.optional(),
+	ssl: sslSchema.optional()
+}));
+// src/sdks/configurations/schemas/exDb/exDbProgressSchema.ts
+/** `kds-team.ex-progress-db` — generic credentials, no SSH tunnel or SSL. */
+const exDbProgressSchema = dbConfig(dbConnectionSchema);
+// src/sdks/configurations/schemas/exDb/exDbMysqlSchema.ts
+/** `keboola.ex-db-mysql` — `database` optional + transaction-isolation / network-compression. */
+const exDbMysqlSchema = dbConfig(dbConnectionSchema.extend({
+	database: zod.z.string().optional(),
+	transactionIsolationLevel: zod.z.enum([
+		"REPEATABLE READ",
+		"READ COMMITTED",
+		"READ UNCOMMITTED",
+		"SERIALIZABLE"
+	]).optional(),
+	networkCompression: zod.z.boolean().optional(),
+	ssh: sshTunnelSchema.optional(),
+	ssl: sslSchema.optional()
+}));
+// src/sdks/configurations/schemas/exDb/exDbMssqlSchema.ts
+/** `keboola.ex-db-mssql` — `port` optional, otherwise the shared base. */
+const exDbMssqlSchema = dbConfig(dbConnectionSchema.extend({
+	port: zod.z.number().optional(),
+	ssh: sshTunnelSchema.optional(),
+	ssl: sslSchema.optional()
+}));
+// src/sdks/configurations/schemas/exDb/exDbOracleSchema.ts
+/** `keboola.ex-db-oracle` — host/port/database all optional (tnsnames is the alternative). */
+const exDbOracleSchema = dbConfig(dbConnectionSchema.omit({
+	host: true,
+	port: true,
+	database: true
+}).extend({
+	host: zod.z.string().optional(),
+	port: zod.z.number().optional(),
+	database: zod.z.string().optional(),
+	tnsnames: zod.z.string().optional(),
+	connectThrough: zod.z.boolean().optional(),
+	ssh: sshTunnelSchema.optional()
+}));
+// src/sdks/configurations/schemas/exDb/exDbFirebirdSchema.ts
+/** `keboola.ex-db-firebird` — `dbname` + user/#password only (no host/port/database fields). */
+const exDbFirebirdSchema = dbConfig(zod.z.object({
+	dbname: zod.z.string(),
+	user: zod.z.string(),
+	"#password": zod.z.string()
+}));
+// src/sdks/configurations/schemas/exDb/exTeradataSchema.ts
+/** `keboola.ex-teradata` — shared base with optional `database`. */
+const exTeradataSchema = dbConfig(dbConnectionSchema.extend({ database: zod.z.string().optional() }));
+// src/sdks/configurations/schemas/exDb/exDbInformixSchema.ts
+/** `keboola.ex-db-informix` — Informix server name + protocol + optional locale. */
+const exDbInformixSchema = dbConfig(dbConnectionSchema.extend({
+	serverName: zod.z.string(),
+	protocol: zod.z.enum(["onsoctcp", "onsocssl"]),
+	dbLocale: zod.z.string().optional()
+}));
+// src/sdks/configurations/schemas/exDb/exDbSnowflakeSchema.ts
+/**
+* `keboola.ex-db-snowflake` — auth is a union: password OR key-pair (exactly one). The common
+* fields (host/port/user/database + optional schema/warehouse) are shared; each variant requires
+* its own secret and forbids the other, so a config carrying both — or neither — is rejected at
+* runtime and at the type level.
+*/
+const snowflakeCommon$1 = dbConnectionSchema.omit({ "#password": true }).extend({
+	schema: zod.z.string().optional(),
+	warehouse: zod.z.string().optional()
+});
+const exDbSnowflakeSchema = dbConfig(zod.z.union([snowflakeCommon$1.extend({
+	"#password": zod.z.string(),
+	"#privateKey": forbidden
+}), snowflakeCommon$1.extend({
+	"#privateKey": zod.z.string(),
+	"#password": forbidden
+})]));
+// src/sdks/configurations/schemas/exDb/exDbNetsuiteSchema.ts
+/** `keboola.ex-db-netsuite` — SuiteAnalytics account/role + user/#password (no host/port/db). */
+const exDbNetsuiteSchema = dbConfig(zod.z.object({
+	accountId: zod.z.string(),
+	roleId: zod.z.string(),
+	user: zod.z.string(),
+	"#password": zod.z.string()
+}));
+/** `kds-team.ex-netsuite` — Connect host/port + server data source + account/role. */
+const exKdsNetsuiteSchema = dbConfig(zod.z.object({
+	host: zod.z.string(),
+	port: zod.z.number(),
+	server_data_source: zod.z.enum(["NetSuite.com", "NetSuite2.com"]),
+	account_id: zod.z.string(),
+	role_id: zod.z.string(),
+	user: zod.z.string(),
+	"#password": zod.z.string()
+}));
+// src/sdks/configurations/schemas/gooddataWriterSchema.ts
+/**
+* A single exported column. `type` is always present and drives which of the other fields the
+* UI shows (and persists): `dataType`/`dataTypeSize` for the base types + LABEL, `reference` for
+* LABEL/HYPERLINK, `schemaReference` for REFERENCE, `format`/`dateDimension` for DATE, and
+* `sortLabel`/`sortOrder` + the `identifier*` fields for ATTRIBUTE. They're optional here since a
+* given column only carries the subset relevant to its type. Mirrors the kbc-ui column adapter
+* (`apps/kbc-ui/src/scripts/modules/gooddata-writer-v3/helpers/makeColumnDefinition.ts`).
+*/
+const gooddataColumn = zod.z.object({
+	type: zod.z.enum([
+		"ATTRIBUTE",
+		"CONNECTION_POINT",
+		"DATE",
+		"FACT",
+		"HYPERLINK",
+		"LABEL",
+		"REFERENCE",
+		"IGNORE"
+	]),
+	id: zod.z.string().optional(),
+	title: zod.z.string().optional(),
+	dataType: zod.z.enum([
+		"BIGINT",
+		"DATE",
+		"DECIMAL",
+		"INT",
+		"VARCHAR"
+	]).optional(),
+	dataTypeSize: zod.z.string().optional(),
+	reference: zod.z.string().optional(),
+	schemaReference: zod.z.string().optional(),
+	sortLabel: zod.z.string().optional(),
+	sortOrder: zod.z.enum(["ASC", "DESC"]).optional(),
+	format: zod.z.string().optional(),
+	dateDimension: zod.z.string().optional(),
+	identifier: zod.z.string().optional(),
+	identifierLabel: zod.z.string().optional(),
+	identifierSortLabel: zod.z.string().optional()
+});
+/** One exported table: a GoodData `title`, its `columns` keyed by source column name, and an
+*  optional `disabled` flag toggled when export is switched off. */
+const gooddataTable = zod.z.object({
+	title: zod.z.string(),
+	disabled: zod.z.boolean().optional(),
+	identifier: zod.z.string().optional(),
+	columns: zod.z.record(zod.z.string(), gooddataColumn)
+});
+/** One date dimension; `template` selects the date-dimension template (`gooddata` / `keboola` /
+*  a custom template id). */
+const gooddataDimension = zod.z.object({
+	template: zod.z.string(),
+	includeTime: zod.z.boolean().optional(),
+	identifier: zod.z.string().optional()
+});
+/**
+* `keboola.gooddata-writer` — GoodData project + login credentials plus the exported model:
+* `tables` (keyed by source table id) and `dimensions` (keyed by dimension name). Both are
+* optional — a fresh config has credentials before any table/dimension is mapped — and must be
+* declared: the registry validates create/update input with a deep-partial that strips keys
+* absent from this shape, so an undeclared `tables`/`dimensions` payload would be dropped before
+* it's stored.
+*/
+const gooddataWriterSchema = zod.z.object({ parameters: zod.z.object({
+	project: zod.z.object({
+		pid: zod.z.string(),
+		backendUrl: zod.z.string().optional()
+	}),
+	user: zod.z.object({
+		login: zod.z.string(),
+		"#password": zod.z.string()
+	}),
+	loadOnly: zod.z.boolean().optional(),
+	multiLoad: zod.z.boolean().optional(),
+	tables: zod.z.record(zod.z.string(), gooddataTable).optional(),
+	dimensions: zod.z.record(zod.z.string(), gooddataDimension).optional()
+}) });
+// src/sdks/configurations/schemas/googleAdsSchema.ts
+/** `keboola.ex-google-ads` — OAuth credential reference + account selection. */
+const exGoogleAdsSchema = zod.z.object({
+	authorization: oauthAuthorizationSchema,
+	parameters: zod.z.object({
+		customerId: zod.z.array(zod.z.string()),
+		onlyEnabledCustomers: zod.z.boolean().optional(),
+		continueOnFailure: zod.z.boolean().optional(),
+		getAccountChildren: zod.z.boolean().optional()
+	})
+});
+// src/sdks/configurations/schemas/schedulerSchema.ts
+/**
+* `keboola.scheduler` — drives a target component config on a cron schedule. Unlike the
+* writer configs, scheduler state lives at the top level (no `parameters` wrapper):
+* `schedule` holds the cron expression + timezone + enabled/disabled state, `target`
+* identifies which component configuration to run.
+*/
+const schedulerSchema = zod.z.object({
+	schedule: zod.z.object({
+		cronTab: zod.z.string(),
+		timezone: zod.z.string().optional(),
+		state: zod.z.enum(["enabled", "disabled"])
+	}),
+	target: zod.z.object({
+		componentId: zod.z.string(),
+		configurationId: zod.z.string(),
+		mode: zod.z.literal("run")
+	})
+});
+// src/sdks/configurations/schemas/wrDb/wrDbDefaultSchema.ts
+/**
+* Default writer credentials — host/port/user/#password/database + optional SSH and SSL tunnels.
+* Shared by the writers that add no extra fields (`keboola.wr-db-mysql`, `keboola.wr-db-hive`);
+* writers that add or rename fields get their own schema.
+*/
+const wrDbDefaultSchema = dbConfig(dbConnectionSchema.extend({
+	ssh: sshTunnelSchema.optional(),
+	ssl: sslSchema.optional()
+}));
+// src/sdks/configurations/schemas/wrDb/wrDbPgsqlSchema.ts
+/** `keboola.wr-db-pgsql` — adds a required `schema`, optional SSH. */
+const wrDbPgsqlSchema = dbConfig(dbConnectionSchema.extend({
+	schema: zod.z.string(),
+	ssh: sshTunnelSchema.optional()
+}));
+// src/sdks/configurations/schemas/wrDb/wrDbOracleSchema.ts
+/** `keboola.wr-db-oracle` — optional `schema`, optional SSH. */
+const wrDbOracleSchema = dbConfig(dbConnectionSchema.extend({
+	schema: zod.z.string().optional(),
+	ssh: sshTunnelSchema.optional()
+}));
+// src/sdks/configurations/schemas/wrDb/wrSynapseSchema.ts
+/** `keboola.wr-synapse` — optional `schema` (defaults to `dbo` in the UI). */
+const wrSynapseSchema = dbConfig(dbConnectionSchema.extend({ schema: zod.z.string().optional() }));
+// src/sdks/configurations/schemas/wrDb/wrRedshiftSchema.ts
+/** `keboola.wr-redshift-v2` — required `schema`, optional SSH. */
+const wrRedshiftSchema = dbConfig(dbConnectionSchema.extend({
+	schema: zod.z.string(),
+	ssh: sshTunnelSchema.optional()
+}));
+// src/sdks/configurations/schemas/wrDb/wrDbMssqlSchema.ts
+/** `keboola.wr-db-mssql-v2` — optional `instance`, required `tdsVersion`, optional SSH. */
+const wrDbMssqlSchema = dbConfig(dbConnectionSchema.extend({
+	instance: zod.z.string().optional(),
+	tdsVersion: zod.z.enum([
+		"7.0",
+		"7.1",
+		"7.2",
+		"7.3",
+		"7.4"
+	]),
+	ssh: sshTunnelSchema.optional()
+}));
+// src/sdks/configurations/schemas/wrDb/wrDbImpalaSchema.ts
+/** `keboola.wr-db-impala` — adds `auth_mech`, optional SSH. */
+const wrDbImpalaSchema = dbConfig(dbConnectionSchema.extend({
+	auth_mech: zod.z.number(),
+	ssh: sshTunnelSchema.optional()
+}));
+// src/sdks/configurations/schemas/wrDb/wrExasolSchema.ts
+/**
+* `kds-team.wr-exasol` — no `database`; auth is password OR SaaS personal-access-token
+* (`#refresh_token`), at least one required (both may coexist). Mirrors kbc-ui's
+* `apps/kbc-ui/src/scripts/modules/wr-db/templates/hasValidCredentials.ts`, which drops the
+* `#password` requirement once a `#refresh_token` is present.
+*/
+const exasolBase = zod.z.object({
+	host: zod.z.string(),
+	port: zod.z.number(),
+	user: zod.z.string(),
+	schema: zod.z.string()
+});
+const wrExasolSchema = dbConfig(zod.z.union([exasolBase.extend({
+	"#password": zod.z.string(),
+	"#refresh_token": zod.z.string().optional()
+}), exasolBase.extend({
+	"#refresh_token": zod.z.string(),
+	"#password": zod.z.string().optional()
+})]));
+// src/sdks/configurations/schemas/wrDb/wrFireboltSchema.ts
+/** `kds-team.wr-firebolt` — no host/port; engine + AWS staging credentials. */
+const wrFireboltSchema = dbConfig(zod.z.object({
+	user: zod.z.string(),
+	"#password": zod.z.string(),
+	database: zod.z.string(),
+	aws_api_key_id: zod.z.string(),
+	"#aws_api_key_secret": zod.z.string(),
+	staging_bucket: zod.z.string(),
+	engine_name: zod.z.string().optional()
+}));
+// src/sdks/configurations/schemas/wrDb/wrHiveCsasSchema.ts
+/** `kds-team.wr-hive-csas` — Hive base + Kerberos auth. */
+const wrHiveCsasSchema = dbConfig(dbConnectionSchema.extend({
+	kinitPrincipal: zod.z.string(),
+	servicePrincipal: zod.z.string(),
+	config: zod.z.string(),
+	"#keytab": zod.z.string(),
+	ssh: sshTunnelSchema.optional()
+}));
+// src/sdks/configurations/schemas/wrDb/wrThoughtspotSchema.ts
+/** `keboola.wr-thoughtspot` — SSH tunnel creds carried as top-level fields, not nested. */
+const wrThoughtspotSchema = dbConfig(dbConnectionSchema.extend({
+	schema: zod.z.string().optional(),
+	sshUser: zod.z.string(),
+	"#sshPassword": zod.z.string()
+}));
+// src/sdks/configurations/schemas/wrDb/wrSisenseSchema.ts
+/** `keboola.wr-sisense` — uses `username` (not `user`). */
+const wrSisenseSchema = dbConfig(zod.z.object({
+	host: zod.z.string(),
+	port: zod.z.number(),
+	username: zod.z.string(),
+	"#password": zod.z.string(),
+	database: zod.z.string()
+}));
+// src/sdks/configurations/schemas/wrDb/wrDbSnowflakeSchema.ts
+/**
+* `keboola.wr-db-snowflake` — auth is a union: password OR key-pair (exactly one). The common
+* fields (host/port/user/database/schema/warehouse) are shared; each variant requires its own
+* secret and *forbids the other* (`z.undefined()`), so a config carrying both — or neither —
+* is rejected at runtime and at the type level. Without the `forbidden` half, the variants
+* would be open objects: the extra key is excess (TS allows it) and stripped (Zod accepts it).
+*/
+const snowflakeCommon = dbConnectionSchema.omit({ "#password": true }).extend({
+	schema: zod.z.string(),
+	warehouse: zod.z.string().optional()
+});
+const wrDbSnowflakeSchema = dbConfig(zod.z.union([snowflakeCommon.extend({
+	"#password": zod.z.string(),
+	"#privateKey": forbidden
+}), snowflakeCommon.extend({
+	"#privateKey": zod.z.string(),
+	"#password": forbidden
+})]));
+// src/sdks/configurations/createRegistry/createRegistry.ts
+/** Deep-partial any schema: objects → keys optional (recursing), unions → each member
+*  deep-partialed, anything else left as-is. Lets a union schema (e.g. Snowflake's
+*  password | key-pair auth) still produce a partial input schema. */
+const partialize = (schema) => {
+	if (schema instanceof zod.z.ZodObject) return deepPartial(schema);
+	if (schema instanceof zod.z.ZodUnion) {
+		const options = schema.options.map(partialize);
+		return zod.z.union(options);
+	}
+	return schema;
+};
+const deepPartial = (schema) => {
+	const shape = {};
+	for (const [key, value] of Object.entries(schema.shape)) {
+		const field = value;
+		const inner = field instanceof zod.z.ZodOptional ? field.unwrap() : field;
+		shape[key] = partialize(inner);
+	}
+	const partial = zod.z.object(shape).partial();
+	return schema.def.catchall ? partial.catchall(schema.def.catchall) : partial;
+};
+const createRegistry = () => {
+	const map = /* @__PURE__ */ new Map();
+	const registry = {
+		add(componentId, schema) {
+			map.set(componentId, schema);
+			return registry;
+		},
+		get(componentId) {
+			const schema = map.get(componentId);
+			if (!schema) throw new Error(`No configuration registered for component "${componentId}".`);
+			return {
+				schema,
+				inputSchema: deepPartial(schema)
+			};
+		},
+		has: (componentId) => map.has(componentId)
+	};
+	return registry;
+};
+// src/sdks/configurations/registry.ts
+const registry = createRegistry().add(require_componentId.ComponentId.WR_DB_MYSQL, wrDbDefaultSchema).add(require_componentId.ComponentId.WR_DB_PGSQL, wrDbPgsqlSchema).add(require_componentId.ComponentId.WR_PAIRITY, wrDbPgsqlSchema).add(require_componentId.ComponentId.WR_DB_ORACLE, wrDbOracleSchema).add(require_componentId.ComponentId.WR_DB_SNOWFLAKE, wrDbSnowflakeSchema).add(require_componentId.ComponentId.WR_DB_SNOWFLAKE_GCS, wrDbSnowflakeSchema).add(require_componentId.ComponentId.WR_DB_SNOWFLAKE_GCS_S3, wrDbSnowflakeSchema).add(require_componentId.ComponentId.WR_SNOWFLAKE_BLOB_STORAGE, wrDbSnowflakeSchema).add(require_componentId.ComponentId.WR_LOOKER_V2, wrDbSnowflakeSchema).add(require_componentId.ComponentId.WR_SYNAPSE, wrSynapseSchema).add(require_componentId.ComponentId.WR_REDSHIFT, wrRedshiftSchema).add(require_componentId.ComponentId.WR_DB_MSSQL, wrDbMssqlSchema).add(require_componentId.ComponentId.WR_DB_HIVE, wrDbDefaultSchema).add(require_componentId.ComponentId.WR_DB_IMPALA, wrDbImpalaSchema).add(require_componentId.ComponentId.WR_HIVE_CSAS, wrHiveCsasSchema).add(require_componentId.ComponentId.WR_THOUGHTSPOT, wrThoughtspotSchema).add(require_componentId.ComponentId.WR_EXASOL, wrExasolSchema).add(require_componentId.ComponentId.WR_FIREBOLT, wrFireboltSchema).add(require_componentId.ComponentId.WR_SISENSE, wrSisenseSchema).add(require_componentId.ComponentId.APP_DATA_GATEWAY, appDataGatewaySchema).add(require_componentId.ComponentId.SCHEDULER, schedulerSchema).add(require_componentId.ComponentId.APP_SNOWFLAKE_DWH_MANAGER, appSnowflakeDwhManagerSchema).add(require_componentId.ComponentId.GOODDATA_WRITER, gooddataWriterSchema).add(require_componentId.ComponentId.EX_DB_REDSHIFT, exDbDefaultSchema).add(require_componentId.ComponentId.EX_DB_DB2, exDbDefaultSchema).add(require_componentId.ComponentId.EX_DB_DB2_BATA, exDbDefaultSchema).add(require_componentId.ComponentId.EX_DB_MSSQL_CDATA, exDbDefaultSchema).add(require_componentId.ComponentId.EX_DB_IMPALA, exDbDefaultSchema).add(require_componentId.ComponentId.EX_DB_HIVE, exDbDefaultSchema).add(require_componentId.ComponentId.EX_DB_HIVE_CSAS, exDbDefaultSchema).add(require_componentId.ComponentId.EX_DB_HIVE_CSAS_TEST, exDbDefaultSchema).add(require_componentId.ComponentId.EX_DB_PGSQL, exDbPgsqlSchema).add(require_componentId.ComponentId.EX_DB_MYSQL, exDbMysqlSchema).add(require_componentId.ComponentId.EX_DB_MSSQL, exDbMssqlSchema).add(require_componentId.ComponentId.EX_DB_ORACLE, exDbOracleSchema).add(require_componentId.ComponentId.EX_DB_SNOWFLAKE, exDbSnowflakeSchema).add(require_componentId.ComponentId.EX_DB_FIREBIRD, exDbFirebirdSchema).add(require_componentId.ComponentId.EX_DB_NETSUITE, exDbNetsuiteSchema).add(require_componentId.ComponentId.EX_DB_INFORMIX, exDbInformixSchema).add(require_componentId.ComponentId.EX_TERADATA, exTeradataSchema).add(require_componentId.ComponentId.KDS_EX_NETSUITE, exKdsNetsuiteSchema).add(require_componentId.ComponentId.KDS_EX_PROGRESS_DB, exDbProgressSchema).add(require_componentId.ComponentId.EX_GOOGLE_ADS, exGoogleAdsSchema).add(require_componentId.ComponentId.EX_HTTP, exHttpSchema).add(require_componentId.ComponentId.EX_FTP, exFtpSchema).add(require_componentId.ComponentId.EX_FTP_CSAS, exFtpSchema).add(require_componentId.ComponentId.EX_AWS_S3, exAwsS3Schema).add(require_componentId.ComponentId.KDS_EX_AZURE_BLOB_STORAGE_V2, exAzureBlobSchema).add(require_componentId.ComponentId.KDS_EX_AZURE_DATA_LAKE_GEN2, exAzureDataLakeSchema);
+// src/sdks/configurations/configurationsSdk.ts
+const toConfigResult = (data, schema) => {
+	const result = schema.safeParse(data.configuration);
+	return {
+		data,
+		runnable: result.success,
+		error: result.error
+	};
+};
+const createConfigurationSdk = ({ storageClient, encryptionClient, context }) => {
+	const _encrypt = async (componentId, data) => {
+		if (require_schemaGuidedMerge.isEmptyDeep(data)) return data;
+		return encryptionClient.encryptScopedSecrets({
+			scope: "ProjectSecure",
+			componentId,
+			projectId: context.project.sapiToken.owner.id,
+			data
+		});
+	};
+	const getConfiguration = async (path) => {
+		const data = await storageClient.configurations.getConfiguration(path);
+		const def = registry.get(path.componentId);
+		return toConfigResult(data, def.schema);
+	};
+	const createConfiguration = async (input) => {
+		const { componentId, branchId, configuration, ...rest } = input;
+		require_configurations.assertCanCreateConfiguration(context.project.sapiToken, { isDevModeActive: context.defaultBranch.isDev(branchId) });
+		const def = registry.get(componentId);
+		const validated = def.inputSchema.parse(configuration);
+		const encrypted = await _encrypt(componentId, validated);
+		const data = await storageClient.configurations.createConfiguration({
+			...rest,
+			branchId,
+			componentId,
+			configuration: encrypted
+		});
+		return toConfigResult(data, def.schema);
+	};
+	const updateConfiguration = async (input) => {
+		const { componentId, branchId, configId, configuration, mode = "merge", ...rest } = input;
+		require_configurations.assertCanUpdateConfiguration(context.project.sapiToken, { isDevModeActive: context.defaultBranch.isDev(branchId) });
+		const def = registry.get(componentId);
+		const validated = def.inputSchema.parse(configuration);
+		const encrypted = await _encrypt(componentId, validated);
+		let newConfiguration = encrypted;
+		if (mode === "merge") {
+			const original = await storageClient.configurations.getConfiguration({
+				componentId,
+				branchId,
+				configId
+			});
+			newConfiguration = require_schemaGuidedMerge.schemaGuidedMerge(def.schema, original.configuration ?? {}, encrypted);
+		}
+		const { configuration: data } = await storageClient.configurations.updateConfiguration({
+			...rest,
+			branchId,
+			componentId,
+			configId,
+			configuration: newConfiguration
+		});
+		return toConfigResult(data, def.schema);
+	};
+	return {
+		getConfiguration,
+		createConfiguration,
+		updateConfiguration
+	};
+};
+exports.createConfigurationSdk = createConfigurationSdk;
+
+//# sourceMappingURL=index.cjs.map