@keboola/api-client 40.0.0 → 42.0.0

package/dist/syncActions-BQ8kMgL6.js

@@ -0,0 +1,1191 @@
+import { c as defaultValidateStatus } from "./createFetchClient-cgWkwgAQ.js";
+import { t as SyncActionError } from "./SyncActionError-CoZFsdUk.js";
+import { i as parseOrThrow } from "./ValidationError-DjhtNMfZ.js";
+import { t as createGenericFetchClient } from "./createGenericFetchClient-CX9Hn3Aq.js";
+import { t as createOpenapiFetchClient } from "./createOpenapiFetchClient-BxcLLU_N.js";
+import { t as createAuthHeaders } from "./auth-DUHTJTwS.js";
+import { t as ComponentId } from "./componentId-DmHwHG5V.js";
+import * as z$1 from "zod";
+//#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 SyncActionError(asString(body.message) ?? asString(body.error) ?? apiResponse.response.statusText, {
+		exceptionId: asString(body.exceptionId),
+		code: asNumber(body.code),
+		data: apiResponse.data
+	});
+	return 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 = z$1.object({
+	/** A numeric id or `"default"`; required so requests are self-describing. */
+	branchId: z$1.string().min(1, "Required"),
+	/** Leave undefined to run the published version (not Docker `latest`); set only to pin a build. */
+	tag: z$1.string().optional(),
+	mode: z$1.enum(["run", "debug"]).optional()
+});
+/** The `/actions` body; each namespace validates its own `configData` shape. */
+const syncActionBodySchema = syncActionContextSchema.extend({
+	componentId: z$1.string().min(1, "Required"),
+	action: z$1.string().min(1, "Required"),
+	configData: z$1.record(z$1.string(), z$1.unknown())
+});
+//#endregion
+//#region src/clients/syncActions/apify/schemas.ts
+const apifyObjectsInputSchema = syncActionContextSchema.extend({ "#token": z$1.string().min(1, "Required") });
+const apifyObjectsSchema = z$1.array(z$1.object({
+	id: z$1.string(),
+	name: z$1.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 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 } = parseOrThrow(apifyObjectsInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action,
+			componentId: ComponentId.APIFY,
+			configData: { parameters: { "#token": token } }
+		}, {
+			signal,
+			validateStatus: apifyValidateStatus
+		});
+		return 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: z$1.string().min(1, "Required"),
+	/** The transformation's input and output mapping. */
+	storage: z$1.record(z$1.string(), z$1.unknown()),
+	/** The pattern's form values, plus the target transformation component as `_componentId`. */
+	parameters: z$1.looseObject({ _componentId: z$1.string().min(1, "Required") })
+});
+/** `storage` is optional; without it the transformation keeps its mapping. */
+const codePatternGenerateResultSchema = z$1.object({ result: z$1.object({
+	parameters: z$1.record(z$1.string(), z$1.unknown()),
+	storage: z$1.record(z$1.string(), z$1.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 } = parseOrThrow(codePatternGenerateInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			componentId,
+			action: SyncAction.CODE_PATTERN_GENERATE,
+			configData: {
+				storage,
+				parameters
+			}
+		}, { signal });
+		return 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: z$1.string().min(1, "Required"),
+	configData: z$1.record(z$1.string(), z$1.unknown())
+});
+/** A failed test answers `status: 'error'`, which throws `SyncActionError`. */
+const testConnectionResultSchema = z$1.object({ message: z$1.string().optional() });
+/** The rows the configuration's create-row form describes; they exist only once created. */
+const preparedRowsSchema = z$1.array(z$1.object({
+	name: z$1.string(),
+	description: z$1.string().optional(),
+	configuration: z$1.record(z$1.string(), z$1.unknown())
+}));
+//#endregion
+//#region src/clients/syncActions/common/common.ts
+const createCommon = (sendSyncAction) => {
+	const sendCommonAction = (action, input, signal) => {
+		const { componentId, configData, ...context } = 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 parseOrThrow(testConnectionResultSchema, data);
+	};
+	const prepareRows = async (input, signal) => {
+		const data = await sendCommonAction(SyncAction.PREPARE_ROWS, input, signal);
+		return parseOrThrow(preparedRowsSchema, data);
+	};
+	return {
+		prepareRows,
+		testConnection
+	};
+};
+//#endregion
+//#region src/clients/syncActions/configurationMigration/schemas.ts
+const getConfigurationMigrationStatusInputSchema = syncActionContextSchema.extend({
+	origin: z$1.string().min(1, "Required"),
+	/** When omitted, the tool uses the destination it has registered for `origin`. */
+	destination: z$1.string().optional()
+});
+const configurationMigrationStatusSchema = z$1.object({
+	componentId: z$1.string(),
+	configId: z$1.string(),
+	configName: z$1.string(),
+	/** The config's `runtime.migrationStatus`: `success`, `error: <message>`, or `n/a` before a run. */
+	status: z$1.string()
+});
+const getConfigurationMigrationStatusResultSchema = z$1.object({ configurations: z$1.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 } = parseOrThrow(getConfigurationMigrationStatusInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.CONFIGURATION_MIGRATION_STATUS,
+			componentId: ComponentId.APP_CONFIGURATION_MIGRATION_TOOL,
+			configData: { parameters: {
+				origin,
+				destination
+			} }
+		}, { signal });
+		return 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: z$1.string().min(1, "Required"),
+	configId: z$1.string().min(1, "Required"),
+	artifacts: z$1.record(z$1.string(), z$1.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 = z$1.object({ compiled: z$1.record(z$1.string(), z$1.string()).default({}) }).transform(({ compiled }) => compiled);
+/** `"Thread-1"` → `1`; an unparseable value falls back to `0` rather than failing the timeline. */
+const dbtThreadSchema = z$1.string().transform((thread) => Number.parseInt(thread.replace(/^Thread-/, ""), 10)).pipe(z$1.number().int().nonnegative()).catch(0);
+/** Omits `status` and `dependsOn`. */
+const dbtModelTimingSchema = z$1.object({
+	id: z$1.string(),
+	name: z$1.string(),
+	thread: dbtThreadSchema,
+	/** ISO timestamps, left unparsed. */
+	timeStarted: z$1.string(),
+	timeCompleted: z$1.string()
+});
+/** A missing key defaults to empty, as in `dbtCompiledSchema`. */
+const dbtRunResultsSchema = z$1.object({ modelTiming: z$1.array(dbtModelTimingSchema).default([]) }).transform(({ modelTiming }) => modelTiming);
+const dbtDocsSchema = z$1.object({ html: z$1.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 } = 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 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 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 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: z$1.string().min(1, "Required") });
+const emailAttachmentsEmailSchema = z$1.object({ email: z$1.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 } = parseOrThrow(getEmailAttachmentsEmailInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.EMAIL_ATTACHMENTS_GET,
+			componentId: ComponentId.EX_EMAIL_ATTACHMENTS,
+			configData: { parameters: { config } }
+		}, { signal });
+		return parseOrThrow(emailAttachmentsEmailSchema, data).email;
+	};
+	return { getEmail };
+};
+//#endregion
+//#region src/clients/syncActions/facebook/constants.ts
+const FACEBOOK_FAMILY = [
+	ComponentId.EX_FACEBOOK,
+	ComponentId.EX_FACEBOOK_PAGES,
+	ComponentId.EX_FACEBOOK_ADS,
+	ComponentId.EX_FACEBOOK_ADS_V2,
+	ComponentId.EX_INSTAGRAM,
+	ComponentId.EX_INSTAGRAM_V2
+];
+/** Pages list Pages, Ads lists ad accounts, Instagram lists the business accounts behind Pages. */
+const FACEBOOK_ACCOUNTS_ACTION = {
+	[ComponentId.EX_FACEBOOK]: SyncAction.FACEBOOK_PAGES_ACCOUNTS,
+	[ComponentId.EX_FACEBOOK_PAGES]: SyncAction.FACEBOOK_PAGES_ACCOUNTS,
+	[ComponentId.EX_FACEBOOK_ADS]: SyncAction.FACEBOOK_ADS_ACCOUNTS,
+	[ComponentId.EX_FACEBOOK_ADS_V2]: SyncAction.FACEBOOK_ADS_ACCOUNTS,
+	[ComponentId.EX_INSTAGRAM]: SyncAction.INSTAGRAM_ACCOUNTS,
+	[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: z$1.enum(FACEBOOK_FAMILY),
+	/** The stored configuration; the component reads its `authorization` and `parameters['api-version']`. */
+	configuration: z$1.record(z$1.string(), z$1.unknown())
+});
+/** Kept whole: a configuration stores the accounts as the Graph API returned them. */
+const facebookAccountsSchema = z$1.array(z$1.looseObject({
+	id: z$1.string(),
+	name: z$1.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 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 } = parseOrThrow(facebookGetAccountsInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			componentId,
+			action: FACEBOOK_ACCOUNTS_ACTION[componentId],
+			configData: configuration
+		}, {
+			signal,
+			validateStatus: facebookValidateStatus
+		});
+		return parseOrThrow(facebookAccountsSchema, data);
+	};
+	return { getAccounts };
+};
+//#endregion
+//#region src/clients/syncActions/flowMigration/schemas.ts
+const flowMigrationInputSchema = syncActionContextSchema.extend({ orchestrationIds: z$1.array(z$1.string().min(1, "Required")) });
+const flowMigrationValidationResultSchema = z$1.object({
+	orchestrationId: z$1.string(),
+	orchestrationName: z$1.string(),
+	valid: z$1.boolean(),
+	issues: z$1.array(z$1.string())
+});
+/** The orchestration's configuration as the flow it would become; extra keys pass through. */
+const flowMigrationMigratedConfigurationSchema = z$1.looseObject({
+	phases: z$1.array(z$1.unknown()).optional(),
+	tasks: z$1.array(z$1.unknown()).optional(),
+	parameters: z$1.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 = z$1.object({
+	orchestrationId: z$1.string(),
+	orchestrationName: z$1.string(),
+	status: z$1.enum([
+		"dry-run",
+		"skipped",
+		"failed"
+	]),
+	issues: z$1.array(z$1.string()),
+	changes: z$1.array(z$1.string()),
+	error: z$1.string().optional(),
+	migratedConfiguration: flowMigrationMigratedConfigurationSchema.optional()
+});
+const flowMigrationValidationResultsSchema = z$1.array(flowMigrationValidationResultSchema);
+const flowMigrationPreviewResultsSchema = z$1.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 } = parseOrThrow(flowMigrationInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.FLOW_MIGRATION_VALIDATE,
+			componentId: ComponentId.FLOW_MIGRATION_TOOL,
+			configData: { parameters: { orchestrationIds } }
+		}, { signal });
+		return parseOrThrow(flowMigrationValidationResultsSchema, data);
+	};
+	/** A dry run: nothing is written, and invalid orchestrations come back `skipped`. */
+	const preview = async (input, signal) => {
+		const { orchestrationIds, ...context } = parseOrThrow(flowMigrationInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.FLOW_MIGRATION_PREVIEW,
+			componentId: ComponentId.FLOW_MIGRATION_TOOL,
+			configData: { parameters: {
+				mode: "config",
+				orchestrationIds
+			} }
+		}, { signal });
+		return 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 = z$1.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: z$1.looseObject({ __SELECTED_JOB: selectedJobSchema }),
+	variables_id: z$1.string().optional(),
+	variables_values_id: z$1.string().optional()
+});
+/** `response.status_code` is `null` when the request never left — a configuration error. */
+const genericExtractorTestRequestResultSchema = z$1.object({
+	response: z$1.looseObject({ status_code: z$1.number().nullable() }),
+	request: z$1.record(z$1.string(), z$1.unknown()),
+	records: z$1.array(z$1.unknown()),
+	debug_log: z$1.string()
+});
+const genericExtractorLoadFromCurlInputSchema = syncActionContextSchema.extend({ parameters: z$1.looseObject({ __CURL_COMMAND: z$1.string().min(1, "Required") }) });
+/** The job the command describes, ready to add to `config.jobs`. */
+const genericExtractorJobSchema = z$1.looseObject({ endpoint: z$1.string() });
+const genericExtractorPerformFunctionInputSchema = syncActionContextSchema.extend({ parameters: z$1.looseObject({ __FUNCTION_CFG: z$1.unknown() }) });
+const genericExtractorPerformFunctionResultSchema = z$1.object({ result: z$1.unknown() }).transform(({ result }) => result);
+/** The component defaults `__PRIMARY_KEY` to `[]` and `__NESTING_LEVEL` to `2`. */
+const genericExtractorInferMappingInputSchema = syncActionContextSchema.extend({ parameters: z$1.looseObject({
+	__SELECTED_JOB: selectedJobSchema,
+	__PRIMARY_KEY: z$1.array(z$1.string()).optional(),
+	__NESTING_LEVEL: z$1.number().int().positive().optional()
+}) });
+const genericExtractorMappingSchema = z$1.record(z$1.string(), z$1.unknown());
+//#endregion
+//#region src/clients/syncActions/genericExtractor/genericExtractor.ts
+const createGenericExtractor = (sendSyncAction) => {
+	const send = (action, context, configData, signal) => sendSyncAction({
+		...context,
+		action,
+		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 } = parseOrThrow(genericExtractorTestRequestInputSchema, input);
+		const data = await send(SyncAction.GENERIC_EXTRACTOR_TEST_REQUEST, context, {
+			parameters,
+			variables_id,
+			variables_values_id
+		}, signal);
+		return parseOrThrow(genericExtractorTestRequestResultSchema, data);
+	};
+	const loadFromCurl = async (input, signal) => {
+		const { parameters, ...context } = parseOrThrow(genericExtractorLoadFromCurlInputSchema, input);
+		const data = await send(SyncAction.GENERIC_EXTRACTOR_LOAD_FROM_CURL, context, { parameters }, signal);
+		return parseOrThrow(genericExtractorJobSchema, data);
+	};
+	const performFunction = async (input, signal) => {
+		const { parameters, ...context } = parseOrThrow(genericExtractorPerformFunctionInputSchema, input);
+		const data = await send(SyncAction.GENERIC_EXTRACTOR_PERFORM_FUNCTION, context, { parameters }, signal);
+		return parseOrThrow(genericExtractorPerformFunctionResultSchema, data);
+	};
+	/** Derives the endpoint's output mapping from the records one test call returns. */
+	const inferMapping = async (input, signal) => {
+		const { parameters, ...context } = parseOrThrow(genericExtractorInferMappingInputSchema, input);
+		const data = await send(SyncAction.GENERIC_EXTRACTOR_INFER_MAPPING, context, { parameters }, signal);
+		return 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 = [ComponentId.DATA_APPS, 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 = [
+	ComponentId.DBT_TEST_CORE_KEY_PAIR,
+	ComponentId.DBT_TEST_REMOTE_SNOWFLAKE,
+	ComponentId.DBT_TRANSFORMATION,
+	ComponentId.DBT_TRANSFORMATION_LOCAL_BIGQUERY,
+	ComponentId.DBT_TRANSFORMATION_REMOTE_BIGQUERY,
+	ComponentId.DBT_TRANSFORMATION_REMOTE_MSSQL,
+	ComponentId.DBT_TRANSFORMATION_REMOTE_POSTGRESQL,
+	ComponentId.DBT_TRANSFORMATION_REMOTE_REDSHIFT,
+	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 = z$1.discriminatedUnion("type", [
+	z$1.object({ type: z$1.literal("public") }),
+	z$1.object({
+		type: z$1.literal("password"),
+		username: z$1.string().min(1, "Required"),
+		"#password": z$1.string().min(1, "Required")
+	}),
+	z$1.object({
+		type: z$1.literal("sshKey"),
+		/** Ignored by the component: over SSH the user is always `git`. */
+		username: z$1.string().min(1, "Required").optional(),
+		"#sshKey": z$1.string().min(1, "Required")
+	})
+]);
+const gitInputSchema = syncActionContextSchema.extend({
+	repositoryUrl: z$1.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: z$1.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: z$1.enum(DATA_APP_FAMILY),
+	/** The *git* branch (not `branchId`); omit for the repository default. `""` normalises to omitted. */
+	branch: z$1.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 = z$1.object({
+	branch: z$1.string(),
+	sha: z$1.string().catch(""),
+	date: z$1.string().catch(""),
+	comment: z$1.string().catch(""),
+	author: z$1.object({
+		name: z$1.string().catch(""),
+		email: z$1.string().catch("")
+	}).catch({
+		name: "",
+		email: ""
+	})
+});
+/** An array, or an index-keyed object with gaps (a server-filtered PHP array). */
+const gitBranchListSchema = z$1.union([z$1.array(gitBranchSchema), z$1.record(z$1.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 = z$1.object({
+	repository: z$1.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 = z$1.object({ entrypoints: z$1.array(z$1.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 } = 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 parseOrThrow(gitBranchesSchema, data);
+	};
+	const getEntrypoints = async (input, signal) => {
+		const { componentId, repositoryUrl, auth, branch, ...context } = 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 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 = z$1.object({
+	appKey: z$1.string().min(1, "Required"),
+	"#data": z$1.string().min(1, "Required"),
+	"#appSecret": z$1.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 = z$1.object({
+	accountKey: z$1.string(),
+	accountName: z$1.string(),
+	propertyKey: z$1.string(),
+	propertyName: z$1.string()
+});
+/** A Universal Analytics view; the names are joined in only when Google lists the account and web property. */
+const googleAnalyticsProfileSchema = z$1.object({
+	id: z$1.string().optional(),
+	name: z$1.string().optional(),
+	webPropertyId: z$1.string().optional(),
+	webPropertyName: z$1.string().optional(),
+	accountId: z$1.string().optional(),
+	accountName: z$1.string().optional(),
+	eCommerceTracking: z$1.boolean().optional()
+});
+const googleAnalyticsGetProfilesPropertiesInputSchema = syncActionContextSchema.extend({ credentials: oauthCredentialsSchema });
+/** `messages` carries a failed listing of either kind; the other list still comes back. */
+const googleAnalyticsGetProfilesPropertiesResultSchema = z$1.object({
+	messages: z$1.array(z$1.string()),
+	properties: z$1.array(googleAnalyticsPropertySchema),
+	profiles: z$1.array(googleAnalyticsProfileSchema)
+});
+const googleAnalyticsGetPropertiesMetadataInputSchema = syncActionContextSchema.extend({
+	credentials: oauthCredentialsSchema,
+	properties: z$1.array(googleAnalyticsPropertySchema)
+});
+const googleAnalyticsMetadataItemSchema = z$1.object({
+	apiName: z$1.string(),
+	uiName: z$1.string().optional(),
+	description: z$1.string().optional()
+});
+/** Merged across `properties`, one entry per `apiName`. */
+const googleAnalyticsGetPropertiesMetadataResultSchema = z$1.object({
+	metrics: z$1.array(googleAnalyticsMetadataItemSchema),
+	dimensions: z$1.array(googleAnalyticsMetadataItemSchema)
+});
+//#endregion
+//#region src/clients/syncActions/googleAnalytics/googleAnalytics.ts
+const createGoogleAnalytics = (sendSyncAction) => {
+	const getPropertiesMetadata = async (input, signal) => {
+		const { credentials, properties, ...context } = parseOrThrow(googleAnalyticsGetPropertiesMetadataInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.GOOGLE_ANALYTICS_GET_PROPERTIES_METADATA,
+			componentId: ComponentId.EX_GOOGLE_ANALYTICS_V4,
+			configData: {
+				authorization: buildOauthAuthorization(credentials),
+				parameters: { properties }
+			}
+		}, { signal });
+		return parseOrThrow(googleAnalyticsGetPropertiesMetadataResultSchema, data);
+	};
+	const getProfilesProperties = async (input, signal) => {
+		const { credentials, ...context } = parseOrThrow(googleAnalyticsGetProfilesPropertiesInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.GOOGLE_ANALYTICS_GET_PROFILES_PROPERTIES,
+			componentId: ComponentId.EX_GOOGLE_ANALYTICS_V4,
+			configData: { authorization: buildOauthAuthorization(credentials) }
+		}, { signal });
+		return 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 = z$1.object({
+	id: z$1.number().int().nonnegative(),
+	tableId: z$1.string().optional(),
+	fileId: z$1.string().optional(),
+	title: z$1.string().min(1, "Required"),
+	folder: z$1.object({
+		id: z$1.string().optional(),
+		title: z$1.string().optional()
+	}).optional(),
+	action: z$1.enum(["create", "update"]).optional(),
+	enabled: z$1.boolean().optional(),
+	convert: z$1.boolean().optional()
+});
+const googleDriveCreateFileInputSchema = syncActionContextSchema.extend({
+	/** The stored configuration without `storage`; the writer reads its `authorization` and `parameters`. */
+	configuration: z$1.looseObject({ parameters: z$1.record(z$1.string(), z$1.unknown()).default({}) }),
+	table: googleDriveTableSchema
+});
+/** `folder` is the table's folder, or `{ id: 'root', title: '' }` when it has none. */
+const googleDriveCreateFileResultSchema = z$1.object({ file: z$1.object({
+	id: z$1.string(),
+	folder: z$1.object({
+		id: z$1.string(),
+		title: z$1.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 } = parseOrThrow(googleDriveCreateFileInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.GOOGLE_DRIVE_CREATE_FILE,
+			componentId: ComponentId.WR_GOOGLE_DRIVE,
+			configData: {
+				...configuration,
+				parameters: {
+					...configuration.parameters,
+					tables: [table]
+				}
+			}
+		}, { signal });
+		return 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 = z$1.object({
+	id: z$1.number().int().nonnegative(),
+	tableId: z$1.string().optional(),
+	fileId: z$1.string().optional(),
+	title: z$1.string().optional(),
+	folder: z$1.object({
+		id: z$1.string().optional(),
+		title: z$1.string().optional()
+	}).optional(),
+	action: z$1.enum([
+		"create",
+		"update",
+		"append"
+	]).optional(),
+	enabled: z$1.boolean().optional(),
+	sheetId: z$1.union([z$1.string(), z$1.number()]).optional(),
+	sheetTitle: z$1.string().optional(),
+	sheetMode: z$1.enum(["replace", "add"]).optional()
+});
+const googleSheetsTableActionInputSchema = syncActionContextSchema.extend({
+	/** The stored configuration without `storage`; the writer reads its `authorization` and `parameters`. */
+	configuration: z$1.looseObject({ parameters: z$1.record(z$1.string(), z$1.unknown()).default({}) }),
+	table: googleSheetsTableSchema
+});
+const googleSheetPropertiesSchema = z$1.object({ sheetId: z$1.number() });
+const googleSheetsCreateSpreadsheetResultSchema = z$1.object({ spreadsheet: z$1.object({
+	spreadsheetId: z$1.string(),
+	sheets: z$1.array(z$1.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 = z$1.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 } = parseOrThrow(googleSheetsTableActionInputSchema, input);
+		return sendSyncAction({
+			...context,
+			action,
+			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 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 parseOrThrow(googleSheetsAddSheetResultSchema, data);
+	};
+	return {
+		addSheet,
+		createSpreadsheet
+	};
+};
+//#endregion
+//#region src/clients/syncActions/looker/schemas.ts
+const testLookerCredentialsInputSchema = syncActionContextSchema.extend({
+	credentialsId: z$1.string().min(1, "Required"),
+	"#token": z$1.string().min(1, "Required"),
+	host: z$1.string().min(1, "Required")
+});
+/** The component answers with a status envelope only — there is no payload to model. */
+const lookerCredentialsResultSchema = z$1.object({
+	status: z$1.string().optional(),
+	message: z$1.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 } = parseOrThrow(testLookerCredentialsInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.LOOKER_TEST_CREDENTIALS,
+			componentId: ComponentId.WR_LOOKER_V2,
+			configData: { parameters: { looker: {
+				credentialsId,
+				"#token": token,
+				host
+			} } }
+		}, { signal });
+		return parseOrThrow(lookerCredentialsResultSchema, data);
+	};
+	return { testCredentials };
+};
+//#endregion
+//#region src/clients/syncActions/oneDrive/schemas.ts
+const oneDriveInputSchema = syncActionContextSchema.extend({ credentials: oauthCredentialsSchema });
+const oneDriveSearchFilesInputSchema = oneDriveInputSchema.extend({ search: z$1.string().min(1, "Required") });
+const oneDriveGetWorksheetsInputSchema = oneDriveInputSchema.extend({
+	componentId: z$1.enum([ComponentId.EX_ONEDRIVE, ComponentId.WR_ONEDRIVE]),
+	driveId: z$1.string().min(1, "Required"),
+	fileId: z$1.string().min(1, "Required")
+});
+const oneDriveCreateWorkbookInputSchema = oneDriveInputSchema.extend({ path: z$1.string().min(1, "Required") });
+const oneDriveCreateWorksheetInputSchema = oneDriveInputSchema.extend({
+	driveId: z$1.string().min(1, "Required"),
+	fileId: z$1.string().min(1, "Required"),
+	name: z$1.string().min(1, "Required")
+});
+const oneDriveFileSchema = z$1.object({
+	driveId: z$1.string(),
+	fileId: z$1.string(),
+	name: z$1.string(),
+	/** `null` when the component resolved no folder for the file. */
+	path: z$1.string().nullable()
+});
+const oneDriveWorksheetSchema = z$1.object({
+	driveId: z$1.string(),
+	fileId: z$1.string(),
+	worksheetId: z$1.string(),
+	name: z$1.string(),
+	/** `name`, suffixed with ` (hidden)` for a hidden worksheet. */
+	title: z$1.string(),
+	position: z$1.number(),
+	visible: z$1.boolean()
+});
+const oneDriveSearchFilesResultSchema = z$1.object({ files: z$1.array(oneDriveFileSchema) });
+const oneDriveGetWorksheetsResultSchema = z$1.object({ worksheets: z$1.array(oneDriveWorksheetSchema) });
+const oneDriveCreateWorkbookResultSchema = z$1.object({ file: z$1.object({
+	driveId: z$1.string(),
+	fileId: z$1.string()
+}) });
+const oneDriveCreateWorksheetResultSchema = z$1.object({ worksheet: z$1.object({
+	driveId: z$1.string(),
+	fileId: z$1.string(),
+	worksheetId: z$1.string()
+}) });
+//#endregion
+//#region src/clients/syncActions/oneDrive/oneDrive.ts
+const createOneDrive = (sendSyncAction) => {
+	const searchFiles = async (input, signal) => {
+		const { credentials, search, ...context } = parseOrThrow(oneDriveSearchFilesInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.ONEDRIVE_SEARCH,
+			componentId: ComponentId.EX_ONEDRIVE,
+			configData: {
+				parameters: { workbook: { search } },
+				authorization: buildOauthAuthorization(credentials)
+			}
+		}, { signal });
+		return parseOrThrow(oneDriveSearchFilesResultSchema, data).files;
+	};
+	const getWorksheets = async (input, signal) => {
+		const { credentials, driveId, fileId, ...context } = parseOrThrow(oneDriveGetWorksheetsInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.ONEDRIVE_GET_WORKSHEETS,
+			configData: {
+				parameters: { workbook: {
+					driveId,
+					fileId
+				} },
+				authorization: buildOauthAuthorization(credentials)
+			}
+		}, { signal });
+		return parseOrThrow(oneDriveGetWorksheetsResultSchema, data).worksheets;
+	};
+	/** Throws `SyncActionError` when a workbook already exists at `path`. */
+	const createWorkbook = async (input, signal) => {
+		const { credentials, path, ...context } = parseOrThrow(oneDriveCreateWorkbookInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.ONEDRIVE_CREATE_WORKBOOK,
+			componentId: ComponentId.WR_ONEDRIVE,
+			configData: {
+				parameters: { workbook: { path } },
+				authorization: buildOauthAuthorization(credentials)
+			}
+		}, { signal });
+		return 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 } = parseOrThrow(oneDriveCreateWorksheetInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action: SyncAction.ONEDRIVE_CREATE_WORKSHEET,
+			componentId: ComponentId.WR_ONEDRIVE,
+			configData: {
+				parameters: {
+					workbook: {
+						driveId,
+						fileId
+					},
+					worksheet: { name }
+				},
+				authorization: buildOauthAuthorization(credentials)
+			}
+		}, { signal });
+		return 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: z$1.record(z$1.string(), z$1.unknown()) });
+const snowflakeDwhManagerUserActionResultSchema = z$1.object({ message: z$1.string() }).transform(({ message }) => message);
+//#endregion
+//#region src/clients/syncActions/snowflakeDwhManager/snowflakeDwhManager.ts
+const createSnowflakeDwhManager = (sendSyncAction) => {
+	const sendUserAction = async (action, input, signal) => {
+		const { parameters, ...context } = parseOrThrow(snowflakeDwhManagerUserActionInputSchema, input);
+		const data = await sendSyncAction({
+			...context,
+			action,
+			componentId: ComponentId.APP_SNOWFLAKE_DWH_MANAGER,
+			configData: { parameters }
+		}, { signal });
+		return 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 = z$1.object({
+	status: z$1.literal("success"),
+	public: z$1.string(),
+	private: z$1.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({
+			...parseOrThrow(syncActionContextSchema, input),
+			action: SyncAction.SSH_KEYS_GENERATE,
+			componentId: ComponentId.SSH_KEYGEN_V2,
+			configData: {}
+		}, { signal });
+		return 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: parseOrThrow(syncActionBodySchema, body) }, options);
+		return data;
+	};
+};
+const createSyncActionsClient = ({ baseUrl, middlewares, auth }) => {
+	const client = createOpenapiFetchClient({
+		baseUrl,
+		middlewares,
+		headers: createAuthHeaders(auth),
+		validateStatus: syncActionValidateStatus
+	});
+	const genericClient = 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
+export { SyncAction as i, FACEBOOK_FAMILY as n, isFacebookComponentId as r, createSyncActionsClient as t };
+
+//# sourceMappingURL=syncActions-BQ8kMgL6.js.map