@keboola/api-client 41.0.0 → 42.0.0

package/dist/syncActions-DyxNmbUR.cjs

@@ -0,0 +1,1216 @@
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+const require_createFetchClient = require("./createFetchClient-BgihytBn.cjs");
+const require_SyncActionError = require("./SyncActionError-BG0zwchi.cjs");
+const require_ValidationError = require("./ValidationError-D65QU0uq.cjs");
+const require_createGenericFetchClient = require("./createGenericFetchClient-C7Y0YVfc.cjs");
+const require_createOpenapiFetchClient = require("./createOpenapiFetchClient-DY5s-aH6.cjs");
+const require_auth = require("./auth-zfI04oj7.cjs");
+const require_componentId = require("./componentId-D4jp6a13.cjs");
+let zod = require("zod");
+zod = require_rolldown_runtime.__toESM(zod, 1);
+//#region src/clients/syncActions/utils/response.ts
+const asErrorBody = (data) => typeof data === "object" && data !== null ? data : null;
+const asString = (value) => typeof value === "string" && value ? value : void 0;
+const asNumber = (value) => typeof value === "number" ? value : void 0;
+/**
+* Fails a sync action on a non-2xx, or on a 2xx whose body has `status: 'error'`.
+*
+* - Throws: `coreFetch` only rethrows a returned `ApiError`.
+* - `SyncActionError` is not an `ApiError`, so retry / network-error handling skips it.
+*/
+const syncActionValidateStatus = (apiResponse) => {
+	const body = asErrorBody(apiResponse.data);
+	if (body?.status === "error") throw new require_SyncActionError.SyncActionError(asString(body.message) ?? asString(body.error) ?? apiResponse.response.statusText, {
+		exceptionId: asString(body.exceptionId),
+		code: asNumber(body.code),
+		data: apiResponse.data
+	});
+	return require_createFetchClient.defaultValidateStatus(apiResponse);
+};
+//#endregion
+//#region src/clients/syncActions/constants.ts
+const SyncAction = {
+	PREPARE_ROWS: "prepareRows",
+	TEST_CONNECTION: "testConnection",
+	DB_EXTRACTOR_GET_TABLES: "getTables",
+	DB_WRITER_GET_TABLES_INFO: "getTablesInfo",
+	DBT_COMPILE: "dbtCompile",
+	DBT_DOCS: "dbtDocs",
+	DBT_GIT_REPOSITORY: "gitRepository",
+	DBT_RUN_RESULTS: "dbtRunResults",
+	CODE_PATTERN_GENERATE: "generate",
+	APIFY_LIST_ACTORS: "listActors",
+	APIFY_LIST_TASKS: "listTasks",
+	AWS_S3_GET_EXTERNAL_ID: "getExternalId",
+	CONFIGURATION_MIGRATION_STATUS: "status",
+	DATA_APP_ENTRYPOINTS: "data-app-entrypoints",
+	DATA_APP_GIT_REPOSITORY: "git-repository",
+	EMAIL_ATTACHMENTS_GET: "get",
+	FACEBOOK_ADS_ACCOUNTS: "adaccounts",
+	FACEBOOK_PAGES_ACCOUNTS: "accounts",
+	FLOW_MIGRATION_PREVIEW: "preview",
+	FLOW_MIGRATION_VALIDATE: "validate",
+	GENERIC_EXTRACTOR_INFER_MAPPING: "infer_mapping",
+	GENERIC_EXTRACTOR_LOAD_FROM_CURL: "load_from_curl",
+	GENERIC_EXTRACTOR_PERFORM_FUNCTION: "perform_function",
+	GENERIC_EXTRACTOR_TEST_REQUEST: "test_request",
+	GOOGLE_ADS_LIST_ACCOUNTS: "listAccounts",
+	GOOGLE_ANALYTICS_GET_PROFILES_PROPERTIES: "getProfilesProperties",
+	GOOGLE_ANALYTICS_GET_PROPERTIES_METADATA: "getPropertiesMetadata",
+	BIGQUERY_GET_CLUSTERING: "getClustering",
+	BIGQUERY_GET_COLUMNS: "getColumns",
+	BIGQUERY_GET_PARTITIONING: "getPartitioning",
+	GOOGLE_DRIVE_CREATE_FILE: "createFile",
+	GOOGLE_SHEETS_ADD_SHEET: "addSheet",
+	GOOGLE_SHEETS_CREATE_SPREADSHEET: "createSpreadsheet",
+	INSTAGRAM_ACCOUNTS: "igaccounts",
+	LOOKER_TEST_CREDENTIALS: "testLookerCredentials",
+	ONEDRIVE_CREATE_WORKBOOK: "createWorkbook",
+	ONEDRIVE_CREATE_WORKSHEET: "createWorksheet",
+	ONEDRIVE_GET_WORKSHEETS: "getWorksheets",
+	ONEDRIVE_SEARCH: "search",
+	SNOWFLAKE_DWH_MANAGER_ENROLL_MFA: "enrollMFA",
+	SNOWFLAKE_DWH_MANAGER_RESET_PASSWORD: "resetPassword",
+	SSH_KEYS_GENERATE: "generate",
+	STORAGE_EXTRACTOR_SOURCE_INFO: "sourceInfo",
+	STORAGE_WRITER_INFO: "info"
+};
+//#endregion
+//#region src/clients/syncActions/schemas.ts
+/** The Keboola-side context every sync action carries; namespaces extend it with their own fields. */
+const syncActionContextSchema = zod.object({
+	/** A numeric id or `"default"`; required so requests are self-describing. */
+	branchId: zod.string().min(1, "Required"),
+	/** Leave undefined to run the published version (not Docker `latest`); set only to pin a build. */
+	tag: zod.string().optional(),
+	mode: zod.enum(["run", "debug"]).optional()
+});
+/** The `/actions` body; each namespace validates its own `configData` shape. */
+const syncActionBodySchema = syncActionContextSchema.extend({
+	componentId: zod.string().min(1, "Required"),
+	action: zod.string().min(1, "Required"),
+	configData: zod.record(zod.string(), zod.unknown())
+});
+//#endregion
+//#region src/clients/syncActions/apify/schemas.ts
+const apifyObjectsInputSchema = syncActionContextSchema.extend({ "#token": zod.string().min(1, "Required") });
+const apifyObjectsSchema = zod.array(zod.object({
+	id: zod.string(),
+	name: zod.string()
+}));
+//#endregion
+//#region src/clients/syncActions/apify/utils.ts
+/**
+* A slow Apify account makes the component answer `{ timeout: true }` on a 200 instead of the list —
+* a failure only this action knows how to spot, so it is checked before deferring to the shared
+* validation.
+*/
+const apifyValidateStatus = (apiResponse) => {
+	const data = apiResponse.data;
+	if (typeof data === "object" && data !== null && "timeout" in data && data.timeout) throw new require_SyncActionError.SyncActionError("Timed out while loading data from Apify.", { data });
+	return syncActionValidateStatus(apiResponse);
+};
+//#endregion
+//#region src/clients/syncActions/apify/apify.ts
+const createApify = (sendSyncAction) => {
+	const _getObjects = async (action, input, signal) => {
+		const { "#token": token, ...context } = require_ValidationError.parseOrThrow(apifyObjectsInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action,
+			componentId: require_componentId.ComponentId.APIFY,
+			configData: { parameters: { "#token": token } }
+		}, {
+			signal,
+			validateStatus: apifyValidateStatus
+		});
+		return require_ValidationError.parseOrThrow(apifyObjectsSchema, data);
+	};
+	const getActors = (input, signal) => {
+		return _getObjects(SyncAction.APIFY_LIST_ACTORS, input, signal);
+	};
+	const getTasks = (input, signal) => {
+		return _getObjects(SyncAction.APIFY_LIST_TASKS, input, signal);
+	};
+	return {
+		getActors,
+		getTasks
+	};
+};
+//#endregion
+//#region src/clients/syncActions/codePattern/schemas.ts
+const codePatternGenerateInputSchema = syncActionContextSchema.extend({
+	/** The code pattern component; any pattern answers the same `generate` contract. */
+	componentId: zod.string().min(1, "Required"),
+	/** The transformation's input and output mapping. */
+	storage: zod.record(zod.string(), zod.unknown()),
+	/** The pattern's form values, plus the target transformation component as `_componentId`. */
+	parameters: zod.looseObject({ _componentId: zod.string().min(1, "Required") })
+});
+/** `storage` is optional; without it the transformation keeps its mapping. */
+const codePatternGenerateResultSchema = zod.object({ result: zod.object({
+	parameters: zod.record(zod.string(), zod.unknown()),
+	storage: zod.record(zod.string(), zod.unknown()).optional()
+}) }).transform(({ result }) => result);
+//#endregion
+//#region src/clients/syncActions/codePattern/codePattern.ts
+const createCodePattern = (sendSyncAction) => {
+	/** The transformation configuration the pattern generates from its form values and mapping. */
+	const generate = async (input, signal) => {
+		const { componentId, storage, parameters, ...context } = require_ValidationError.parseOrThrow(codePatternGenerateInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			componentId,
+			action: SyncAction.CODE_PATTERN_GENERATE,
+			configData: {
+				storage,
+				parameters
+			}
+		}, { signal });
+		return require_ValidationError.parseOrThrow(codePatternGenerateResultSchema, data);
+	};
+	return { generate };
+};
+//#endregion
+//#region src/clients/syncActions/common/schemas.ts
+/** Actions any component may implement, so the id selects nothing and `configData` is its own. */
+const commonActionInputSchema = syncActionContextSchema.extend({
+	componentId: zod.string().min(1, "Required"),
+	configData: zod.record(zod.string(), zod.unknown())
+});
+/** A failed test answers `status: 'error'`, which throws `SyncActionError`. */
+const testConnectionResultSchema = zod.object({ message: zod.string().optional() });
+/** The rows the configuration's create-row form describes; they exist only once created. */
+const preparedRowsSchema = zod.array(zod.object({
+	name: zod.string(),
+	description: zod.string().optional(),
+	configuration: zod.record(zod.string(), zod.unknown())
+}));
+//#endregion
+//#region src/clients/syncActions/common/common.ts
+const createCommon = (sendSyncAction) => {
+	const sendCommonAction = (action, input, signal) => {
+		const { componentId, configData, ...context } = require_ValidationError.parseOrThrow(commonActionInputSchema, input);
+		return sendSyncAction({
+			...context,
+			componentId,
+			action,
+			configData
+		}, { signal });
+	};
+	const testConnection = async (input, signal) => {
+		const data = await sendCommonAction(SyncAction.TEST_CONNECTION, input, signal);
+		return require_ValidationError.parseOrThrow(testConnectionResultSchema, data);
+	};
+	const prepareRows = async (input, signal) => {
+		const data = await sendCommonAction(SyncAction.PREPARE_ROWS, input, signal);
+		return require_ValidationError.parseOrThrow(preparedRowsSchema, data);
+	};
+	return {
+		prepareRows,
+		testConnection
+	};
+};
+//#endregion
+//#region src/clients/syncActions/configurationMigration/schemas.ts
+const getConfigurationMigrationStatusInputSchema = syncActionContextSchema.extend({
+	origin: zod.string().min(1, "Required"),
+	/** When omitted, the tool uses the destination it has registered for `origin`. */
+	destination: zod.string().optional()
+});
+const configurationMigrationStatusSchema = zod.object({
+	componentId: zod.string(),
+	configId: zod.string(),
+	configName: zod.string(),
+	/** The config's `runtime.migrationStatus`: `success`, `error: <message>`, or `n/a` before a run. */
+	status: zod.string()
+});
+const getConfigurationMigrationStatusResultSchema = zod.object({ configurations: zod.array(configurationMigrationStatusSchema) });
+//#endregion
+//#region src/clients/syncActions/configurationMigration/configurationMigration.ts
+const createConfigurationMigration = (sendSyncAction) => {
+	/** Throws `SyncActionError` when the component has no migration registered for `origin`. */
+	const getStatus = async (input, signal) => {
+		const { origin, destination, ...context } = require_ValidationError.parseOrThrow(getConfigurationMigrationStatusInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.CONFIGURATION_MIGRATION_STATUS,
+			componentId: require_componentId.ComponentId.APP_CONFIGURATION_MIGRATION_TOOL,
+			configData: { parameters: {
+				origin,
+				destination
+			} }
+		}, { signal });
+		return require_ValidationError.parseOrThrow(getConfigurationMigrationStatusResultSchema, data).configurations;
+	};
+	return { getStatus };
+};
+//#endregion
+//#region src/clients/syncActions/dbt/schemas.ts
+/** `componentId` is a plain string: every dbt transformation serves the same actions, so it selects nothing. */
+const dbtActionInputSchema = syncActionContextSchema.extend({
+	componentId: zod.string().min(1, "Required"),
+	configId: zod.string().min(1, "Required"),
+	artifacts: zod.record(zod.string(), zod.unknown()).optional()
+});
+/**
+* Model file name (`orders.sql`) → compiled SQL, in the component's key order.
+*
+* - A never-run configuration fails with a `SyncActionError`, not an empty payload.
+* - A missing key defaults to empty; a present key of the wrong shape still fails.
+*/
+const dbtCompiledSchema = zod.object({ compiled: zod.record(zod.string(), zod.string()).default({}) }).transform(({ compiled }) => compiled);
+/** `"Thread-1"` → `1`; an unparseable value falls back to `0` rather than failing the timeline. */
+const dbtThreadSchema = zod.string().transform((thread) => Number.parseInt(thread.replace(/^Thread-/, ""), 10)).pipe(zod.number().int().nonnegative()).catch(0);
+/** Omits `status` and `dependsOn`. */
+const dbtModelTimingSchema = zod.object({
+	id: zod.string(),
+	name: zod.string(),
+	thread: dbtThreadSchema,
+	/** ISO timestamps, left unparsed. */
+	timeStarted: zod.string(),
+	timeCompleted: zod.string()
+});
+/** A missing key defaults to empty, as in `dbtCompiledSchema`. */
+const dbtRunResultsSchema = zod.object({ modelTiming: zod.array(dbtModelTimingSchema).default([]) }).transform(({ modelTiming }) => modelTiming);
+const dbtDocsSchema = zod.object({ html: zod.string() }).transform(({ html }) => html);
+//#endregion
+//#region src/clients/syncActions/dbt/utils.ts
+/**
+* The dbt artifact actions read the *stored* configuration — `configId` is what they resolve it by,
+* so the payload carries no settings of its own. `artifacts` is the configuration's own artifacts
+* section, passed through untouched: it selects which run's artifacts the component picks up, and
+* omitting it leaves the component on its default (the latest run).
+*/
+const buildDbtActionConfigData = ({ configId, artifacts }) => ({
+	parameters: { configId },
+	...artifacts && { artifacts }
+});
+//#endregion
+//#region src/clients/syncActions/dbt/dbt.ts
+/** The dbt transformations' artifact actions — each reads what the *last run* left behind. */
+const createDbt = (sendSyncAction) => {
+	const sendDbtAction = (action, input, signal) => {
+		const { componentId, configId, artifacts, ...context } = require_ValidationError.parseOrThrow(dbtActionInputSchema, input);
+		return sendSyncAction({
+			...context,
+			componentId,
+			action,
+			configData: buildDbtActionConfigData({
+				configId,
+				artifacts
+			})
+		}, { signal });
+	};
+	/** The compiled SQL of every model in the configuration. */
+	const compile = async (input, signal) => {
+		const data = await sendDbtAction(SyncAction.DBT_COMPILE, input, signal);
+		return require_ValidationError.parseOrThrow(dbtCompiledSchema, data);
+	};
+	/** When each model of the last run started and finished, and on which worker. */
+	const runResults = async (input, signal) => {
+		const data = await sendDbtAction(SyncAction.DBT_RUN_RESULTS, input, signal);
+		return require_ValidationError.parseOrThrow(dbtRunResultsSchema, data);
+	};
+	/** The docs site the last run generated. */
+	const getDocs = async (input, signal) => {
+		const data = await sendDbtAction(SyncAction.DBT_DOCS, input, signal);
+		return require_ValidationError.parseOrThrow(dbtDocsSchema, data);
+	};
+	return {
+		compile,
+		getDocs,
+		runResults
+	};
+};
+//#endregion
+//#region src/clients/syncActions/emailAttachments/schemas.ts
+const getEmailAttachmentsEmailInputSchema = syncActionContextSchema.extend({ 
+/** The configuration id — keys the stored address and is embedded in a newly generated one. */
+config: zod.string().min(1, "Required") });
+const emailAttachmentsEmailSchema = zod.object({ email: zod.string() });
+//#endregion
+//#region src/clients/syncActions/emailAttachments/emailAttachments.ts
+const createEmailAttachments = (sendSyncAction) => {
+	/** The configuration's inbound address; the component generates and stores it on first call. */
+	const getEmail = async (input, signal) => {
+		const { config, ...context } = require_ValidationError.parseOrThrow(getEmailAttachmentsEmailInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.EMAIL_ATTACHMENTS_GET,
+			componentId: require_componentId.ComponentId.EX_EMAIL_ATTACHMENTS,
+			configData: { parameters: { config } }
+		}, { signal });
+		return require_ValidationError.parseOrThrow(emailAttachmentsEmailSchema, data).email;
+	};
+	return { getEmail };
+};
+//#endregion
+//#region src/clients/syncActions/facebook/constants.ts
+const FACEBOOK_FAMILY = [
+	require_componentId.ComponentId.EX_FACEBOOK,
+	require_componentId.ComponentId.EX_FACEBOOK_PAGES,
+	require_componentId.ComponentId.EX_FACEBOOK_ADS,
+	require_componentId.ComponentId.EX_FACEBOOK_ADS_V2,
+	require_componentId.ComponentId.EX_INSTAGRAM,
+	require_componentId.ComponentId.EX_INSTAGRAM_V2
+];
+/** Pages list Pages, Ads lists ad accounts, Instagram lists the business accounts behind Pages. */
+const FACEBOOK_ACCOUNTS_ACTION = {
+	[require_componentId.ComponentId.EX_FACEBOOK]: SyncAction.FACEBOOK_PAGES_ACCOUNTS,
+	[require_componentId.ComponentId.EX_FACEBOOK_PAGES]: SyncAction.FACEBOOK_PAGES_ACCOUNTS,
+	[require_componentId.ComponentId.EX_FACEBOOK_ADS]: SyncAction.FACEBOOK_ADS_ACCOUNTS,
+	[require_componentId.ComponentId.EX_FACEBOOK_ADS_V2]: SyncAction.FACEBOOK_ADS_ACCOUNTS,
+	[require_componentId.ComponentId.EX_INSTAGRAM]: SyncAction.INSTAGRAM_ACCOUNTS,
+	[require_componentId.ComponentId.EX_INSTAGRAM_V2]: SyncAction.INSTAGRAM_ACCOUNTS
+};
+const facebookIds = new Set(FACEBOOK_FAMILY);
+const isFacebookComponentId = (componentId) => facebookIds.has(componentId);
+//#endregion
+//#region src/clients/syncActions/facebook/schemas.ts
+const facebookGetAccountsInputSchema = syncActionContextSchema.extend({
+	componentId: zod.enum(FACEBOOK_FAMILY),
+	/** The stored configuration; the component reads its `authorization` and `parameters['api-version']`. */
+	configuration: zod.record(zod.string(), zod.unknown())
+});
+/** Kept whole: a configuration stores the accounts as the Graph API returned them. */
+const facebookAccountsSchema = zod.array(zod.looseObject({
+	id: zod.string(),
+	name: zod.string().optional()
+}));
+//#endregion
+//#region src/clients/syncActions/facebook/utils.ts
+/**
+* The message of the Graph API error body the component passed on as `error`.
+*
+* - JSON-encoded: its `error.message`.
+* - Plain text: the text itself.
+*/
+const getGraphApiErrorMessage = (error) => {
+	if (typeof error !== "string") return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(error);
+	} catch {
+		return error || void 0;
+	}
+	if (typeof parsed !== "object" || parsed === null || !("error" in parsed)) return void 0;
+	const { error: graphError } = parsed;
+	return typeof graphError === "object" && graphError !== null && "message" in graphError && typeof graphError.message === "string" ? graphError.message : void 0;
+};
+/**
+* The first-generation components answer a failed Graph API call with `{ code, error }` on a 200.
+*
+* - `error` is the Graph API's own error body, JSON-encoded; `code` is its HTTP status.
+* - A `status: 'error'` body is left to the shared validation.
+*/
+const facebookValidateStatus = (apiResponse) => {
+	const data = apiResponse.data;
+	if (typeof data === "object" && data !== null && !Array.isArray(data) && "error" in data && !("status" in data)) throw new require_SyncActionError.SyncActionError(getGraphApiErrorMessage(data.error) ?? "Failed to load the accounts.", {
+		code: "code" in data && typeof data.code === "number" ? data.code : void 0,
+		data
+	});
+	return syncActionValidateStatus(apiResponse);
+};
+//#endregion
+//#region src/clients/syncActions/facebook/facebook.ts
+const createFacebook = (sendSyncAction) => {
+	/** The accounts the configuration's authorization can extract from; which kind depends on `componentId`. */
+	const getAccounts = async (input, signal) => {
+		const { componentId, configuration, ...context } = require_ValidationError.parseOrThrow(facebookGetAccountsInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			componentId,
+			action: FACEBOOK_ACCOUNTS_ACTION[componentId],
+			configData: configuration
+		}, {
+			signal,
+			validateStatus: facebookValidateStatus
+		});
+		return require_ValidationError.parseOrThrow(facebookAccountsSchema, data);
+	};
+	return { getAccounts };
+};
+//#endregion
+//#region src/clients/syncActions/flowMigration/schemas.ts
+const flowMigrationInputSchema = syncActionContextSchema.extend({ orchestrationIds: zod.array(zod.string().min(1, "Required")) });
+const flowMigrationValidationResultSchema = zod.object({
+	orchestrationId: zod.string(),
+	orchestrationName: zod.string(),
+	valid: zod.boolean(),
+	issues: zod.array(zod.string())
+});
+/** The orchestration's configuration as the flow it would become; extra keys pass through. */
+const flowMigrationMigratedConfigurationSchema = zod.looseObject({
+	phases: zod.array(zod.unknown()).optional(),
+	tasks: zod.array(zod.unknown()).optional(),
+	parameters: zod.unknown().optional()
+});
+/**
+* One orchestration's dry-run outcome.
+*
+* - `skipped`: it failed validation; `issues` says why.
+* - `failed`: building the flow threw; `error` carries the message.
+*/
+const flowMigrationPreviewResultSchema = zod.object({
+	orchestrationId: zod.string(),
+	orchestrationName: zod.string(),
+	status: zod.enum([
+		"dry-run",
+		"skipped",
+		"failed"
+	]),
+	issues: zod.array(zod.string()),
+	changes: zod.array(zod.string()),
+	error: zod.string().optional(),
+	migratedConfiguration: flowMigrationMigratedConfigurationSchema.optional()
+});
+const flowMigrationValidationResultsSchema = zod.array(flowMigrationValidationResultSchema);
+const flowMigrationPreviewResultsSchema = zod.array(flowMigrationPreviewResultSchema);
+//#endregion
+//#region src/clients/syncActions/flowMigration/flowMigration.ts
+/** Orchestration → flow migration checks; one result per requested orchestration. */
+const createFlowMigration = (sendSyncAction) => {
+	const validate = async (input, signal) => {
+		const { orchestrationIds, ...context } = require_ValidationError.parseOrThrow(flowMigrationInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.FLOW_MIGRATION_VALIDATE,
+			componentId: require_componentId.ComponentId.FLOW_MIGRATION_TOOL,
+			configData: { parameters: { orchestrationIds } }
+		}, { signal });
+		return require_ValidationError.parseOrThrow(flowMigrationValidationResultsSchema, data);
+	};
+	/** A dry run: nothing is written, and invalid orchestrations come back `skipped`. */
+	const preview = async (input, signal) => {
+		const { orchestrationIds, ...context } = require_ValidationError.parseOrThrow(flowMigrationInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.FLOW_MIGRATION_PREVIEW,
+			componentId: require_componentId.ComponentId.FLOW_MIGRATION_TOOL,
+			configData: { parameters: {
+				mode: "config",
+				orchestrationIds
+			} }
+		}, { signal });
+		return require_ValidationError.parseOrThrow(flowMigrationPreviewResultsSchema, data);
+	};
+	return {
+		validate,
+		preview
+	};
+};
+//#endregion
+//#region src/clients/syncActions/genericExtractor/schemas.ts
+/** The endpoint's position in the jobs tree, its indexes joined with `_` (`"0_1"`). */
+const selectedJobSchema = zod.string().min(1, "Required");
+/**
+* Every action's `parameters` are the configuration's whole `parameters`.
+*
+* - `api`, `config` with its jobs, and the secrets, as stored.
+* - Plus the `__`-prefixed keys that action reads.
+*/
+const genericExtractorTestRequestInputSchema = syncActionContextSchema.extend({
+	parameters: zod.looseObject({ __SELECTED_JOB: selectedJobSchema }),
+	variables_id: zod.string().optional(),
+	variables_values_id: zod.string().optional()
+});
+/** `response.status_code` is `null` when the request never left — a configuration error. */
+const genericExtractorTestRequestResultSchema = zod.object({
+	response: zod.looseObject({ status_code: zod.number().nullable() }),
+	request: zod.record(zod.string(), zod.unknown()),
+	records: zod.array(zod.unknown()),
+	debug_log: zod.string()
+});
+const genericExtractorLoadFromCurlInputSchema = syncActionContextSchema.extend({ parameters: zod.looseObject({ __CURL_COMMAND: zod.string().min(1, "Required") }) });
+/** The job the command describes, ready to add to `config.jobs`. */
+const genericExtractorJobSchema = zod.looseObject({ endpoint: zod.string() });
+const genericExtractorPerformFunctionInputSchema = syncActionContextSchema.extend({ parameters: zod.looseObject({ __FUNCTION_CFG: zod.unknown() }) });
+const genericExtractorPerformFunctionResultSchema = zod.object({ result: zod.unknown() }).transform(({ result }) => result);
+/** The component defaults `__PRIMARY_KEY` to `[]` and `__NESTING_LEVEL` to `2`. */
+const genericExtractorInferMappingInputSchema = syncActionContextSchema.extend({ parameters: zod.looseObject({
+	__SELECTED_JOB: selectedJobSchema,
+	__PRIMARY_KEY: zod.array(zod.string()).optional(),
+	__NESTING_LEVEL: zod.number().int().positive().optional()
+}) });
+const genericExtractorMappingSchema = zod.record(zod.string(), zod.unknown());
+//#endregion
+//#region src/clients/syncActions/genericExtractor/genericExtractor.ts
+const createGenericExtractor = (sendSyncAction) => {
+	const send = (action, context, configData, signal) => sendSyncAction({
+		...context,
+		action,
+		componentId: require_componentId.ComponentId.EX_GENERIC_V2,
+		configData
+	}, { signal });
+	/** Calls the selected endpoint once and reports the request, the response and the records. */
+	const testRequest = async (input, signal) => {
+		const { parameters, variables_id, variables_values_id, ...context } = require_ValidationError.parseOrThrow(genericExtractorTestRequestInputSchema, input);
+		const data = await send(SyncAction.GENERIC_EXTRACTOR_TEST_REQUEST, context, {
+			parameters,
+			variables_id,
+			variables_values_id
+		}, signal);
+		return require_ValidationError.parseOrThrow(genericExtractorTestRequestResultSchema, data);
+	};
+	const loadFromCurl = async (input, signal) => {
+		const { parameters, ...context } = require_ValidationError.parseOrThrow(genericExtractorLoadFromCurlInputSchema, input);
+		const data = await send(SyncAction.GENERIC_EXTRACTOR_LOAD_FROM_CURL, context, { parameters }, signal);
+		return require_ValidationError.parseOrThrow(genericExtractorJobSchema, data);
+	};
+	const performFunction = async (input, signal) => {
+		const { parameters, ...context } = require_ValidationError.parseOrThrow(genericExtractorPerformFunctionInputSchema, input);
+		const data = await send(SyncAction.GENERIC_EXTRACTOR_PERFORM_FUNCTION, context, { parameters }, signal);
+		return require_ValidationError.parseOrThrow(genericExtractorPerformFunctionResultSchema, data);
+	};
+	/** Derives the endpoint's output mapping from the records one test call returns. */
+	const inferMapping = async (input, signal) => {
+		const { parameters, ...context } = require_ValidationError.parseOrThrow(genericExtractorInferMappingInputSchema, input);
+		const data = await send(SyncAction.GENERIC_EXTRACTOR_INFER_MAPPING, context, { parameters }, signal);
+		return require_ValidationError.parseOrThrow(genericExtractorMappingSchema, data);
+	};
+	return {
+		inferMapping,
+		loadFromCurl,
+		performFunction,
+		testRequest
+	};
+};
+//#endregion
+//#region src/clients/syncActions/git/constants.ts
+/**
+* Components whose git repository lives under `parameters.dataApp.git.repository` and that answer to
+* the `git-repository` action. They are the only ones serving `data-app-entrypoints`, and the only
+* ones accepting an SSH key.
+*/
+const DATA_APP_FAMILY = [require_componentId.ComponentId.DATA_APPS, require_componentId.ComponentId.SANDBOXES];
+/**
+* Components whose git repository lives under `parameters.git.repo` and that answer to the
+* `gitRepository` action. They authenticate over HTTPS with a username and password only.
+*
+* Deliberately a list rather than "everything else": `listBranches` / `list_branches` /
+* `checkBranches` also exist on unrelated third-party components (`kds-team.app-custom-python`,
+* `keboola.app-transformation-migration`, `kds-team.app-sox-migration-checker`) under a different
+* contract. Those stay on the generic `sendSyncAction` escape hatch.
+*/
+const DBT_FAMILY = [
+	require_componentId.ComponentId.DBT_TEST_CORE_KEY_PAIR,
+	require_componentId.ComponentId.DBT_TEST_REMOTE_SNOWFLAKE,
+	require_componentId.ComponentId.DBT_TRANSFORMATION,
+	require_componentId.ComponentId.DBT_TRANSFORMATION_LOCAL_BIGQUERY,
+	require_componentId.ComponentId.DBT_TRANSFORMATION_REMOTE_BIGQUERY,
+	require_componentId.ComponentId.DBT_TRANSFORMATION_REMOTE_MSSQL,
+	require_componentId.ComponentId.DBT_TRANSFORMATION_REMOTE_POSTGRESQL,
+	require_componentId.ComponentId.DBT_TRANSFORMATION_REMOTE_REDSHIFT,
+	require_componentId.ComponentId.DBT_TRANSFORMATION_REMOTE_SNOWFLAKE
+];
+const GIT_FAMILY = [...DATA_APP_FAMILY, ...DBT_FAMILY];
+const dataAppIds = new Set(DATA_APP_FAMILY);
+const isDataAppFamily = (componentId) => dataAppIds.has(componentId);
+//#endregion
+//#region src/clients/syncActions/git/schemas.ts
+const gitAuthSchema = zod.discriminatedUnion("type", [
+	zod.object({ type: zod.literal("public") }),
+	zod.object({
+		type: zod.literal("password"),
+		username: zod.string().min(1, "Required"),
+		"#password": zod.string().min(1, "Required")
+	}),
+	zod.object({
+		type: zod.literal("sshKey"),
+		/** Ignored by the component: over SSH the user is always `git`. */
+		username: zod.string().min(1, "Required").optional(),
+		"#sshKey": zod.string().min(1, "Required")
+	})
+]);
+const gitInputSchema = syncActionContextSchema.extend({
+	repositoryUrl: zod.string().min(1, "Required"),
+	auth: gitAuthSchema.default({ type: "public" })
+});
+/**
+* **Takes no `branch` — do not add one.** The component clones with `-b <branch>`, so a stale one
+* would fail the branch listing. Zod strips it.
+*/
+const getBranchesInputSchema = gitInputSchema.extend({ componentId: zod.enum(GIT_FAMILY) }).check((ctx) => {
+	const { componentId, auth } = ctx.value;
+	if (auth.type !== "sshKey" || isDataAppFamily(componentId)) return;
+	ctx.issues.push({
+		code: "custom",
+		input: auth,
+		path: ["auth"],
+		message: `Component "${componentId}" authenticates with a password, not an SSH key.`
+	});
+});
+/** Only the data-app family serves `data-app-entrypoints`. */
+const getEntrypointsInputSchema = gitInputSchema.extend({
+	componentId: zod.enum(DATA_APP_FAMILY),
+	/** The *git* branch (not `branchId`); omit for the repository default. `""` normalises to omitted. */
+	branch: zod.string().optional().transform((branch) => branch || void 0)
+});
+/** Only `branch` is load-bearing; the rest falls back to `''` so one bad field can't fail the list. */
+const gitBranchSchema = zod.object({
+	branch: zod.string(),
+	sha: zod.string().catch(""),
+	date: zod.string().catch(""),
+	comment: zod.string().catch(""),
+	author: zod.object({
+		name: zod.string().catch(""),
+		email: zod.string().catch("")
+	}).catch({
+		name: "",
+		email: ""
+	})
+});
+/** An array, or an index-keyed object with gaps (a server-filtered PHP array). */
+const gitBranchListSchema = zod.union([zod.array(gitBranchSchema), zod.record(zod.string(), gitBranchSchema)]).transform((branches) => Array.isArray(branches) ? branches : Object.values(branches));
+/**
+* - `repository.branches` is confirmed; the top-level position is accepted but unverified.
+* - A response with neither list is rejected, not read as no branches.
+*/
+const gitBranchesSchema = zod.object({
+	repository: zod.object({ branches: gitBranchListSchema.optional() }).optional(),
+	branches: gitBranchListSchema.optional()
+}).check((ctx) => {
+	if (ctx.value.branches ?? ctx.value.repository?.branches) return;
+	ctx.issues.push({
+		code: "custom",
+		input: ctx.value,
+		message: "The response carried no branch list."
+	});
+}).transform(({ repository, branches }) => branches ?? repository?.branches ?? []);
+const gitEntrypointsSchema = zod.object({ entrypoints: zod.array(zod.string()) });
+//#endregion
+//#region src/clients/syncActions/git/utils.ts
+/** Every variant is already the shape the components read, minus the discriminator. */
+const toCredentials = (auth) => {
+	const { type: _type, ...credentials } = auth;
+	return credentials;
+};
+const toRevision = (rev) => rev.revision === "branch" ? { branch: rev.branch } : {};
+/** Data apps nest their repository a level deeper, and call the URL `repository`. */
+const buildDataAppConfigData = ({ repositoryUrl, auth, ...rev }) => ({ parameters: { dataApp: { git: {
+	repository: repositoryUrl,
+	...toCredentials(auth),
+	...toRevision(rev)
+} } } });
+/** dbt transformations keep the same settings at the top of `parameters`, under `repo`. */
+const buildDbtConfigData = ({ repositoryUrl, auth, ...rev }) => ({ parameters: { git: {
+	repo: repositoryUrl,
+	...toCredentials(auth),
+	...toRevision(rev)
+} } });
+//#endregion
+//#region src/clients/syncActions/git/git.ts
+/**
+* Git repository actions, across both component families that serve them — the data apps
+* (`git-repository`) and the dbt transformations (`gitRepository`). Which action name and which
+* `configData` shape a call uses is resolved from `componentId`; see `./constants`.
+*/
+const createGit = (sendSyncAction) => {
+	const getBranches = async (input, signal) => {
+		const { componentId, repositoryUrl, auth, ...context } = require_ValidationError.parseOrThrow(getBranchesInputSchema, input);
+		const isDataApp = isDataAppFamily(componentId);
+		const action = isDataApp ? SyncAction.DATA_APP_GIT_REPOSITORY : SyncAction.DBT_GIT_REPOSITORY;
+		const buildConfigData = isDataApp ? buildDataAppConfigData : buildDbtConfigData;
+		const data = await sendSyncAction({
+			...context,
+			componentId,
+			action,
+			configData: buildConfigData({
+				repositoryUrl,
+				auth,
+				revision: "default"
+			})
+		}, { signal });
+		return require_ValidationError.parseOrThrow(gitBranchesSchema, data);
+	};
+	const getEntrypoints = async (input, signal) => {
+		const { componentId, repositoryUrl, auth, branch, ...context } = require_ValidationError.parseOrThrow(getEntrypointsInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			componentId,
+			action: SyncAction.DATA_APP_ENTRYPOINTS,
+			configData: buildDataAppConfigData({
+				repositoryUrl,
+				auth,
+				...branch ? {
+					revision: "branch",
+					branch
+				} : { revision: "default" }
+			})
+		}, { signal });
+		return require_ValidationError.parseOrThrow(gitEntrypointsSchema, data);
+	};
+	return {
+		getBranches,
+		getEntrypoints
+	};
+};
+//#endregion
+//#region src/clients/syncActions/utils/oauth.ts
+/** The OAuth broker's credentials for one configuration, under the keys the components read. */
+const oauthCredentialsSchema = zod.object({
+	appKey: zod.string().min(1, "Required"),
+	"#data": zod.string().min(1, "Required"),
+	"#appSecret": zod.string().min(1, "Required")
+});
+/** The `configData.authorization` block every OAuth-backed component expects. */
+const buildOauthAuthorization = (credentials) => ({ oauth_api: { credentials } });
+//#endregion
+//#region src/clients/syncActions/googleAnalytics/schemas.ts
+/** A GA4 Data API property, under the keys the component both returns and requires back. */
+const googleAnalyticsPropertySchema = zod.object({
+	accountKey: zod.string(),
+	accountName: zod.string(),
+	propertyKey: zod.string(),
+	propertyName: zod.string()
+});
+/** A Universal Analytics view; the names are joined in only when Google lists the account and web property. */
+const googleAnalyticsProfileSchema = zod.object({
+	id: zod.string().optional(),
+	name: zod.string().optional(),
+	webPropertyId: zod.string().optional(),
+	webPropertyName: zod.string().optional(),
+	accountId: zod.string().optional(),
+	accountName: zod.string().optional(),
+	eCommerceTracking: zod.boolean().optional()
+});
+const googleAnalyticsGetProfilesPropertiesInputSchema = syncActionContextSchema.extend({ credentials: oauthCredentialsSchema });
+/** `messages` carries a failed listing of either kind; the other list still comes back. */
+const googleAnalyticsGetProfilesPropertiesResultSchema = zod.object({
+	messages: zod.array(zod.string()),
+	properties: zod.array(googleAnalyticsPropertySchema),
+	profiles: zod.array(googleAnalyticsProfileSchema)
+});
+const googleAnalyticsGetPropertiesMetadataInputSchema = syncActionContextSchema.extend({
+	credentials: oauthCredentialsSchema,
+	properties: zod.array(googleAnalyticsPropertySchema)
+});
+const googleAnalyticsMetadataItemSchema = zod.object({
+	apiName: zod.string(),
+	uiName: zod.string().optional(),
+	description: zod.string().optional()
+});
+/** Merged across `properties`, one entry per `apiName`. */
+const googleAnalyticsGetPropertiesMetadataResultSchema = zod.object({
+	metrics: zod.array(googleAnalyticsMetadataItemSchema),
+	dimensions: zod.array(googleAnalyticsMetadataItemSchema)
+});
+//#endregion
+//#region src/clients/syncActions/googleAnalytics/googleAnalytics.ts
+const createGoogleAnalytics = (sendSyncAction) => {
+	const getPropertiesMetadata = async (input, signal) => {
+		const { credentials, properties, ...context } = require_ValidationError.parseOrThrow(googleAnalyticsGetPropertiesMetadataInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.GOOGLE_ANALYTICS_GET_PROPERTIES_METADATA,
+			componentId: require_componentId.ComponentId.EX_GOOGLE_ANALYTICS_V4,
+			configData: {
+				authorization: buildOauthAuthorization(credentials),
+				parameters: { properties }
+			}
+		}, { signal });
+		return require_ValidationError.parseOrThrow(googleAnalyticsGetPropertiesMetadataResultSchema, data);
+	};
+	const getProfilesProperties = async (input, signal) => {
+		const { credentials, ...context } = require_ValidationError.parseOrThrow(googleAnalyticsGetProfilesPropertiesInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.GOOGLE_ANALYTICS_GET_PROFILES_PROPERTIES,
+			componentId: require_componentId.ComponentId.EX_GOOGLE_ANALYTICS_V4,
+			configData: { authorization: buildOauthAuthorization(credentials) }
+		}, { signal });
+		return require_ValidationError.parseOrThrow(googleAnalyticsGetProfilesPropertiesResultSchema, data);
+	};
+	return {
+		getPropertiesMetadata,
+		getProfilesProperties
+	};
+};
+//#endregion
+//#region src/clients/syncActions/googleDrive/schemas.ts
+/** The writer's `parameters.tables` entry; its config definition rejects any other key. */
+const googleDriveTableSchema = zod.object({
+	id: zod.number().int().nonnegative(),
+	tableId: zod.string().optional(),
+	fileId: zod.string().optional(),
+	title: zod.string().min(1, "Required"),
+	folder: zod.object({
+		id: zod.string().optional(),
+		title: zod.string().optional()
+	}).optional(),
+	action: zod.enum(["create", "update"]).optional(),
+	enabled: zod.boolean().optional(),
+	convert: zod.boolean().optional()
+});
+const googleDriveCreateFileInputSchema = syncActionContextSchema.extend({
+	/** The stored configuration without `storage`; the writer reads its `authorization` and `parameters`. */
+	configuration: zod.looseObject({ parameters: zod.record(zod.string(), zod.unknown()).default({}) }),
+	table: googleDriveTableSchema
+});
+/** `folder` is the table's folder, or `{ id: 'root', title: '' }` when it has none. */
+const googleDriveCreateFileResultSchema = zod.object({ file: zod.object({
+	id: zod.string(),
+	folder: zod.object({
+		id: zod.string(),
+		title: zod.string().optional()
+	})
+}) }).transform(({ file }) => file);
+//#endregion
+//#region src/clients/syncActions/googleDrive/googleDrive.ts
+const createGoogleDrive = (sendSyncAction) => {
+	/** Creates the Drive file a table will be written to, without writing any data. */
+	const createFile = async (input, signal) => {
+		const { configuration, table, ...context } = require_ValidationError.parseOrThrow(googleDriveCreateFileInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.GOOGLE_DRIVE_CREATE_FILE,
+			componentId: require_componentId.ComponentId.WR_GOOGLE_DRIVE,
+			configData: {
+				...configuration,
+				parameters: {
+					...configuration.parameters,
+					tables: [table]
+				}
+			}
+		}, { signal });
+		return require_ValidationError.parseOrThrow(googleDriveCreateFileResultSchema, data);
+	};
+	return { createFile };
+};
+//#endregion
+//#region src/clients/syncActions/googleSheets/schemas.ts
+/** The writer's `parameters.tables` entry; its config definition rejects any other key. */
+const googleSheetsTableSchema = zod.object({
+	id: zod.number().int().nonnegative(),
+	tableId: zod.string().optional(),
+	fileId: zod.string().optional(),
+	title: zod.string().optional(),
+	folder: zod.object({
+		id: zod.string().optional(),
+		title: zod.string().optional()
+	}).optional(),
+	action: zod.enum([
+		"create",
+		"update",
+		"append"
+	]).optional(),
+	enabled: zod.boolean().optional(),
+	sheetId: zod.union([zod.string(), zod.number()]).optional(),
+	sheetTitle: zod.string().optional(),
+	sheetMode: zod.enum(["replace", "add"]).optional()
+});
+const googleSheetsTableActionInputSchema = syncActionContextSchema.extend({
+	/** The stored configuration without `storage`; the writer reads its `authorization` and `parameters`. */
+	configuration: zod.looseObject({ parameters: zod.record(zod.string(), zod.unknown()).default({}) }),
+	table: googleSheetsTableSchema
+});
+const googleSheetPropertiesSchema = zod.object({ sheetId: zod.number() });
+const googleSheetsCreateSpreadsheetResultSchema = zod.object({ spreadsheet: zod.object({
+	spreadsheetId: zod.string(),
+	sheets: zod.array(zod.object({ properties: googleSheetPropertiesSchema })).min(1)
+}) }).transform(({ spreadsheet }) => spreadsheet);
+/** The sheet named `sheetTitle` when the spreadsheet already has one, else the sheet it added. */
+const googleSheetsAddSheetResultSchema = zod.object({ sheet: googleSheetPropertiesSchema }).transform(({ sheet }) => sheet);
+//#endregion
+//#region src/clients/syncActions/googleSheets/googleSheets.ts
+const createGoogleSheets = (sendSyncAction) => {
+	const sendTableAction = (action, input, signal) => {
+		const { configuration, table, ...context } = require_ValidationError.parseOrThrow(googleSheetsTableActionInputSchema, input);
+		return sendSyncAction({
+			...context,
+			action,
+			componentId: require_componentId.ComponentId.WR_GOOGLE_SHEETS,
+			configData: {
+				...configuration,
+				parameters: {
+					...configuration.parameters,
+					tables: [table]
+				}
+			}
+		}, { signal });
+	};
+	/** Creates the spreadsheet a table will be written to, without writing any data. */
+	const createSpreadsheet = async (input, signal) => {
+		const data = await sendTableAction(SyncAction.GOOGLE_SHEETS_CREATE_SPREADSHEET, input, signal);
+		return require_ValidationError.parseOrThrow(googleSheetsCreateSpreadsheetResultSchema, data);
+	};
+	/** Adds the table's `sheetTitle` sheet to its existing spreadsheet (`fileId`). */
+	const addSheet = async (input, signal) => {
+		const data = await sendTableAction(SyncAction.GOOGLE_SHEETS_ADD_SHEET, input, signal);
+		return require_ValidationError.parseOrThrow(googleSheetsAddSheetResultSchema, data);
+	};
+	return {
+		addSheet,
+		createSpreadsheet
+	};
+};
+//#endregion
+//#region src/clients/syncActions/looker/schemas.ts
+const testLookerCredentialsInputSchema = syncActionContextSchema.extend({
+	credentialsId: zod.string().min(1, "Required"),
+	"#token": zod.string().min(1, "Required"),
+	host: zod.string().min(1, "Required")
+});
+/** The component answers with a status envelope only — there is no payload to model. */
+const lookerCredentialsResultSchema = zod.object({
+	status: zod.string().optional(),
+	message: zod.string().optional()
+});
+//#endregion
+//#region src/clients/syncActions/looker/looker.ts
+const createLooker = (sendSyncAction) => {
+	/** Registers the project's Looker credentials; throws `SyncActionError` when Looker rejects them. */
+	const testCredentials = async (input, signal) => {
+		const { credentialsId, "#token": token, host, ...context } = require_ValidationError.parseOrThrow(testLookerCredentialsInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.LOOKER_TEST_CREDENTIALS,
+			componentId: require_componentId.ComponentId.WR_LOOKER_V2,
+			configData: { parameters: { looker: {
+				credentialsId,
+				"#token": token,
+				host
+			} } }
+		}, { signal });
+		return require_ValidationError.parseOrThrow(lookerCredentialsResultSchema, data);
+	};
+	return { testCredentials };
+};
+//#endregion
+//#region src/clients/syncActions/oneDrive/schemas.ts
+const oneDriveInputSchema = syncActionContextSchema.extend({ credentials: oauthCredentialsSchema });
+const oneDriveSearchFilesInputSchema = oneDriveInputSchema.extend({ search: zod.string().min(1, "Required") });
+const oneDriveGetWorksheetsInputSchema = oneDriveInputSchema.extend({
+	componentId: zod.enum([require_componentId.ComponentId.EX_ONEDRIVE, require_componentId.ComponentId.WR_ONEDRIVE]),
+	driveId: zod.string().min(1, "Required"),
+	fileId: zod.string().min(1, "Required")
+});
+const oneDriveCreateWorkbookInputSchema = oneDriveInputSchema.extend({ path: zod.string().min(1, "Required") });
+const oneDriveCreateWorksheetInputSchema = oneDriveInputSchema.extend({
+	driveId: zod.string().min(1, "Required"),
+	fileId: zod.string().min(1, "Required"),
+	name: zod.string().min(1, "Required")
+});
+const oneDriveFileSchema = zod.object({
+	driveId: zod.string(),
+	fileId: zod.string(),
+	name: zod.string(),
+	/** `null` when the component resolved no folder for the file. */
+	path: zod.string().nullable()
+});
+const oneDriveWorksheetSchema = zod.object({
+	driveId: zod.string(),
+	fileId: zod.string(),
+	worksheetId: zod.string(),
+	name: zod.string(),
+	/** `name`, suffixed with ` (hidden)` for a hidden worksheet. */
+	title: zod.string(),
+	position: zod.number(),
+	visible: zod.boolean()
+});
+const oneDriveSearchFilesResultSchema = zod.object({ files: zod.array(oneDriveFileSchema) });
+const oneDriveGetWorksheetsResultSchema = zod.object({ worksheets: zod.array(oneDriveWorksheetSchema) });
+const oneDriveCreateWorkbookResultSchema = zod.object({ file: zod.object({
+	driveId: zod.string(),
+	fileId: zod.string()
+}) });
+const oneDriveCreateWorksheetResultSchema = zod.object({ worksheet: zod.object({
+	driveId: zod.string(),
+	fileId: zod.string(),
+	worksheetId: zod.string()
+}) });
+//#endregion
+//#region src/clients/syncActions/oneDrive/oneDrive.ts
+const createOneDrive = (sendSyncAction) => {
+	const searchFiles = async (input, signal) => {
+		const { credentials, search, ...context } = require_ValidationError.parseOrThrow(oneDriveSearchFilesInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.ONEDRIVE_SEARCH,
+			componentId: require_componentId.ComponentId.EX_ONEDRIVE,
+			configData: {
+				parameters: { workbook: { search } },
+				authorization: buildOauthAuthorization(credentials)
+			}
+		}, { signal });
+		return require_ValidationError.parseOrThrow(oneDriveSearchFilesResultSchema, data).files;
+	};
+	const getWorksheets = async (input, signal) => {
+		const { credentials, driveId, fileId, ...context } = require_ValidationError.parseOrThrow(oneDriveGetWorksheetsInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.ONEDRIVE_GET_WORKSHEETS,
+			configData: {
+				parameters: { workbook: {
+					driveId,
+					fileId
+				} },
+				authorization: buildOauthAuthorization(credentials)
+			}
+		}, { signal });
+		return require_ValidationError.parseOrThrow(oneDriveGetWorksheetsResultSchema, data).worksheets;
+	};
+	/** Throws `SyncActionError` when a workbook already exists at `path`. */
+	const createWorkbook = async (input, signal) => {
+		const { credentials, path, ...context } = require_ValidationError.parseOrThrow(oneDriveCreateWorkbookInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.ONEDRIVE_CREATE_WORKBOOK,
+			componentId: require_componentId.ComponentId.WR_ONEDRIVE,
+			configData: {
+				parameters: { workbook: { path } },
+				authorization: buildOauthAuthorization(credentials)
+			}
+		}, { signal });
+		return require_ValidationError.parseOrThrow(oneDriveCreateWorkbookResultSchema, data).file;
+	};
+	/** Throws `SyncActionError` when the workbook already has a worksheet called `name`. */
+	const createWorksheet = async (input, signal) => {
+		const { credentials, driveId, fileId, name, ...context } = require_ValidationError.parseOrThrow(oneDriveCreateWorksheetInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.ONEDRIVE_CREATE_WORKSHEET,
+			componentId: require_componentId.ComponentId.WR_ONEDRIVE,
+			configData: {
+				parameters: {
+					workbook: {
+						driveId,
+						fileId
+					},
+					worksheet: { name }
+				},
+				authorization: buildOauthAuthorization(credentials)
+			}
+		}, { signal });
+		return require_ValidationError.parseOrThrow(oneDriveCreateWorksheetResultSchema, data).worksheet;
+	};
+	return {
+		searchFiles,
+		getWorksheets,
+		createWorkbook,
+		createWorksheet
+	};
+};
+//#endregion
+//#region src/clients/syncActions/snowflakeDwhManager/schemas.ts
+const snowflakeDwhManagerUserActionInputSchema = syncActionContextSchema.extend({ 
+/** The configuration's master connection merged with the one user row the action applies to. */
+parameters: zod.record(zod.string(), zod.unknown()) });
+const snowflakeDwhManagerUserActionResultSchema = zod.object({ message: zod.string() }).transform(({ message }) => message);
+//#endregion
+//#region src/clients/syncActions/snowflakeDwhManager/snowflakeDwhManager.ts
+const createSnowflakeDwhManager = (sendSyncAction) => {
+	const sendUserAction = async (action, input, signal) => {
+		const { parameters, ...context } = require_ValidationError.parseOrThrow(snowflakeDwhManagerUserActionInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action,
+			componentId: require_componentId.ComponentId.APP_SNOWFLAKE_DWH_MANAGER,
+			configData: { parameters }
+		}, { signal });
+		return require_ValidationError.parseOrThrow(snowflakeDwhManagerUserActionResultSchema, data);
+	};
+	/** Resolves with the component's message, which carries the one-time reset URL. */
+	const resetPassword = (input, signal) => sendUserAction(SyncAction.SNOWFLAKE_DWH_MANAGER_RESET_PASSWORD, input, signal);
+	const enrollMfa = (input, signal) => sendUserAction(SyncAction.SNOWFLAKE_DWH_MANAGER_ENROLL_MFA, input, signal);
+	return {
+		enrollMfa,
+		resetPassword
+	};
+};
+//#endregion
+//#region src/clients/syncActions/sshKeys/schemas.ts
+const sshKeyPairSchema = zod.object({
+	status: zod.literal("success"),
+	public: zod.string(),
+	private: zod.string()
+});
+//#endregion
+//#region src/clients/syncActions/sshKeys/sshKeys.ts
+const createSshKeys = (sendSyncAction) => {
+	/** Generates a new 4096-bit RSA key pair; the component keeps no copy. */
+	const generate = async (input, signal) => {
+		const data = await sendSyncAction({
+			...require_ValidationError.parseOrThrow(syncActionContextSchema, input),
+			action: SyncAction.SSH_KEYS_GENERATE,
+			componentId: require_componentId.ComponentId.SSH_KEYGEN_V2,
+			configData: {}
+		}, { signal });
+		return require_ValidationError.parseOrThrow(sshKeyPairSchema, data);
+	};
+	return { generate };
+};
+//#endregion
+//#region src/clients/syncActions/syncActionsClient.ts
+const createSendSyncAction = (client) => {
+	return async (body, options = {}) => {
+		const { data } = await client.post("/actions", { body: require_ValidationError.parseOrThrow(syncActionBodySchema, body) }, options);
+		return data;
+	};
+};
+const createSyncActionsClient = ({ baseUrl, middlewares, auth }) => {
+	const client = require_createOpenapiFetchClient.createOpenapiFetchClient({
+		baseUrl,
+		middlewares,
+		headers: require_auth.createAuthHeaders(auth),
+		validateStatus: syncActionValidateStatus
+	});
+	const genericClient = require_createGenericFetchClient.createGenericFetchClient({
+		baseUrl,
+		middlewares
+	});
+	const sendSyncAction = createSendSyncAction(client);
+	const healthCheck = async (signal) => {
+		const { data } = await genericClient.get("/health-check", {}, { signal });
+		return data;
+	};
+	return {
+		healthCheck,
+		sendSyncAction,
+		apify: createApify(sendSyncAction),
+		codePattern: createCodePattern(sendSyncAction),
+		common: createCommon(sendSyncAction),
+		configurationMigration: createConfigurationMigration(sendSyncAction),
+		dbt: createDbt(sendSyncAction),
+		emailAttachments: createEmailAttachments(sendSyncAction),
+		facebook: createFacebook(sendSyncAction),
+		flowMigration: createFlowMigration(sendSyncAction),
+		genericExtractor: createGenericExtractor(sendSyncAction),
+		git: createGit(sendSyncAction),
+		googleAnalytics: createGoogleAnalytics(sendSyncAction),
+		googleDrive: createGoogleDrive(sendSyncAction),
+		googleSheets: createGoogleSheets(sendSyncAction),
+		looker: createLooker(sendSyncAction),
+		oneDrive: createOneDrive(sendSyncAction),
+		snowflakeDwhManager: createSnowflakeDwhManager(sendSyncAction),
+		sshKeys: createSshKeys(sendSyncAction)
+	};
+};
+//#endregion
+Object.defineProperty(exports, "FACEBOOK_FAMILY", {
+	enumerable: true,
+	get: function() {
+		return FACEBOOK_FAMILY;
+	}
+});
+Object.defineProperty(exports, "SyncAction", {
+	enumerable: true,
+	get: function() {
+		return SyncAction;
+	}
+});
+Object.defineProperty(exports, "createSyncActionsClient", {
+	enumerable: true,
+	get: function() {
+		return createSyncActionsClient;
+	}
+});
+Object.defineProperty(exports, "isFacebookComponentId", {
+	enumerable: true,
+	get: function() {
+		return isFacebookComponentId;
+	}
+});
+
+//# sourceMappingURL=syncActions-DyxNmbUR.cjs.map