@prismatic-io/components-google-cloud-bigquery 0.0.0-stage → 0.0.1

package/npm-dist/index.cjs

@@ -0,0 +1,3187 @@
+let _prismatic_io_spectral = require("@prismatic-io/spectral");
+let googleapis = require("googleapis");
+let _prismatic_io_spectral_http = require("@prismatic-io/spectral/http");
+//#region src/connections/index.ts
+const googleConnection = (0, _prismatic_io_spectral.oauth2Connection)({
+	key: "oauth2",
+	display: {
+		label: "OAuth 2.0",
+		description: "Authenticate using OAuth 2.0",
+		icons: { oauth2ConnectionIconPath: "oauth-button.png" }
+	},
+	oauth2Type: _prismatic_io_spectral.OAuth2Type.AuthorizationCode,
+	inputs: {
+		authorizeUrl: {
+			label: "Authorize URL",
+			placeholder: "Authorization URL",
+			type: "string",
+			required: true,
+			shown: false,
+			comments: "The Authorization URL for Google BigQuery.",
+			default: "https://accounts.google.com/o/oauth2/v2/auth?access_type=offline&prompt=consent"
+		},
+		tokenUrl: {
+			label: "Token URL",
+			placeholder: "Token URL",
+			type: "string",
+			required: true,
+			shown: false,
+			comments: "The Token URL for Google BigQuery.",
+			default: "https://oauth2.googleapis.com/token"
+		},
+		scopes: {
+			label: "Scopes",
+			placeholder: "Scopes",
+			type: "string",
+			required: true,
+			comments: "Space delimited listing of scopes. https://developers.google.com/identity/protocols/oauth2/scopes#bigquery",
+			default: "https://www.googleapis.com/auth/bigquery https://www.googleapis.com/auth/bigquery.insertdata https://www.googleapis.com/auth/cloud-platform https://www.googleapis.com/auth/cloud-platform.read-only https://www.googleapis.com/auth/devstorage.full_control	https://www.googleapis.com/auth/devstorage.read_only https://www.googleapis.com/auth/devstorage.read_write"
+		},
+		clientId: {
+			label: "Client ID",
+			placeholder: "Client Identifier",
+			type: "string",
+			required: true,
+			comments: "The Google BigQuery app's Client Identifier."
+		},
+		clientSecret: {
+			label: "Client Secret",
+			placeholder: "Client Secret",
+			type: "password",
+			required: true,
+			comments: "The Google BigQuery app's Client Secret."
+		}
+	}
+});
+const googleServiceAccount = (0, _prismatic_io_spectral.connection)({
+	key: "googleServiceAccount",
+	display: {
+		label: "Private Key",
+		description: "Authenticate using a private key"
+	},
+	inputs: {
+		clientEmail: {
+			label: "Client Email",
+			placeholder: "Client Email",
+			type: "string",
+			required: true,
+			example: "someone@example.com",
+			shown: true,
+			comments: "The email address of the client to connect."
+		},
+		privateKey: {
+			label: "Private Key",
+			placeholder: "Private Key",
+			type: "text",
+			required: true,
+			shown: true,
+			comments: "The private key of the client to connect."
+		},
+		scopes: {
+			label: "Scopes",
+			placeholder: "Scopes",
+			type: "string",
+			required: true,
+			example: "https://www.googleapis.com/auth/bigquery https://www.googleapis.com/auth/cloud-platform https://www.googleapis.com/auth/cloud-platform.read-only",
+			default: "https://www.googleapis.com/auth/bigquery https://www.googleapis.com/auth/cloud-platform https://www.googleapis.com/auth/cloud-platform.read-only",
+			shown: false,
+			comments: "Space delimited listing of scopes. https://developers.google.com/identity/protocols/oauth2/scopes#bigquery"
+		}
+	}
+});
+var connections_default = [googleConnection, googleServiceAccount];
+//#endregion
+//#region src/client.ts
+const validateConnection = (connection) => {
+	if (connection.key !== googleConnection.key && connection.key !== googleServiceAccount.key) throw new _prismatic_io_spectral.ConnectionError(connection, "Unknown Connection type provided.");
+	if (!connection.token?.access_token && !connection.fields.privateKey && !connection.fields.clientEmail && !connection.fields.scopes) throw new _prismatic_io_spectral.ConnectionError(connection, "Received valid Connection type but did not find valid access token.");
+};
+const generateAuthentication = (connection) => {
+	if (connection.key === googleServiceAccount.key) {
+		const { clientEmail, privateKey, scopes } = connection.fields;
+		const scopesArray = _prismatic_io_spectral.util.types.toString(scopes).split(" ");
+		return new googleapis.google.auth.GoogleAuth({
+			credentials: {
+				client_email: _prismatic_io_spectral.util.types.toString(clientEmail),
+				private_key: _prismatic_io_spectral.util.types.toString(privateKey).replace(/\\n/g, "\n")
+			},
+			scopes: scopesArray
+		});
+	} else if (connection.key === googleConnection.key) {
+		const oauth2Client = new googleapis.google.auth.OAuth2(_prismatic_io_spectral.util.types.toString(connection.fields.clientId), _prismatic_io_spectral.util.types.toString(connection.fields.clientSecret));
+		const token = _prismatic_io_spectral.util.types.toString(connection.token?.access_token);
+		oauth2Client.setCredentials({ access_token: token });
+		return oauth2Client;
+	}
+	throw new _prismatic_io_spectral.ConnectionError(connection, "Unknown Connection type provided.");
+};
+const createClient = (connection) => {
+	validateConnection(connection);
+	const auth = generateAuthentication(connection);
+	return googleapis.google.bigquery({
+		version: "v2",
+		auth
+	});
+};
+//#endregion
+//#region src/constants.ts
+const LOOK_BACK_DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+//#endregion
+//#region src/util/index.ts
+const cleanString = (value) => {
+	const str = _prismatic_io_spectral.util.types.toString(value);
+	return str ? str : void 0;
+};
+const jsonInputClean = (value) => {
+	if (typeof value === "string") {
+		if (value.trim() !== "") return JSON.parse(value);
+		return;
+	}
+	if (value !== null && value !== void 0) return value;
+};
+const valueListInputClean = (value) => {
+	if (Array.isArray(value) && value.length >= 1 && value[0] !== "000xxx") return value;
+};
+const lookBackDateClean = (value) => {
+	if (value === void 0 || value === null || typeof value === "string" && value.trim() === "") return "";
+	const raw = typeof value === "string" ? value.trim() : String(value);
+	const match = typeof value === "string" ? raw.match(LOOK_BACK_DATE_PATTERN) : null;
+	if (!match) throw new Error(`Look-back Date must be a date in YYYY-MM-DD format. Received: ${raw}`);
+	const [, yearStr, monthStr, dayStr] = match;
+	const year = Number(yearStr);
+	const month = Number(monthStr);
+	const day = Number(dayStr);
+	const parsed = new Date(Date.UTC(year, month - 1, day));
+	if (parsed.getUTCFullYear() !== year || parsed.getUTCMonth() !== month - 1 || parsed.getUTCDate() !== day) throw new Error(`Look-back Date must be a date in YYYY-MM-DD format. Received: ${raw}`);
+	if (parsed.getTime() > Date.now()) throw new Error(`Look-back Date cannot be a future date. Received: ${raw}`);
+	return parsed.toISOString();
+};
+//#endregion
+//#region src/inputs/common.ts
+const connectionInput = (0, _prismatic_io_spectral.input)({
+	label: "Connection",
+	type: "connection",
+	required: true,
+	comments: "The Google Cloud BigQuery connection to use."
+});
+const projectId = (0, _prismatic_io_spectral.input)({
+	label: "Project ID",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "The unique identifier for the Google Cloud project.",
+	example: "my-project-12345",
+	placeholder: "Enter project ID",
+	required: true,
+	dataSource: "projectsNames"
+});
+const datasetId = (0, _prismatic_io_spectral.input)({
+	label: "Dataset ID",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "The unique identifier for the dataset.",
+	example: "my_dataset",
+	placeholder: "Enter dataset ID",
+	required: true,
+	dataSource: "selectDataset"
+});
+const tableId = (0, _prismatic_io_spectral.input)({
+	label: "Table ID",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "The unique identifier for the table.",
+	example: "my_table",
+	placeholder: "Enter table ID",
+	required: true,
+	dataSource: "tablesNames"
+});
+const maxResults = (0, _prismatic_io_spectral.input)({
+	label: "Max Results",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toNumber,
+	comments: "The maximum number of results to return in a single response page. Leverage the page tokens to iterate through the entire collection.",
+	example: "100",
+	placeholder: "Enter maximum results",
+	required: false
+});
+const pageToken = (0, _prismatic_io_spectral.input)({
+	label: "Page Token",
+	type: "string",
+	clean: cleanString,
+	comments: "Page token returned by a previous call to request the next page of results.",
+	example: "CAESBAgCIAE",
+	placeholder: "Enter page token",
+	required: false
+});
+const filter = (0, _prismatic_io_spectral.input)({
+	label: "Filter",
+	type: "string",
+	clean: cleanString,
+	comments: "An expression for filtering the results of the request by label. The syntax is 'labels.<name>[:<value>]'. Multiple filters can be ANDed together by connecting with a space. Example: 'labels.department:receiving labels.active'. See [Filtering datasets](https://cloud.google.com/bigquery/docs/labeling-datasets#filtering_datasets_using_labels) using labels for details.",
+	example: "labels.department:receiving labels.active",
+	placeholder: "Enter filter expression",
+	required: false
+});
+const selectedFields = (0, _prismatic_io_spectral.input)({
+	label: "Selected Fields",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "tabledata.list of table schema fields to return (comma-separated). If unspecified, all fields are returned. A fieldMask cannot be used here because the fields will automatically be converted from camelCase to snake_case and the conversion will fail if there are underscores. Since these are fields in BigQuery table schemas, underscores are allowed.",
+	placeholder: "Enter selected fields",
+	required: false
+});
+const startIndex = (0, _prismatic_io_spectral.input)({
+	label: "Start Index",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Zero-based index of the starting row.",
+	example: "0",
+	placeholder: "Enter start index",
+	required: false
+});
+const kind = (0, _prismatic_io_spectral.input)({
+	label: "Kind",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Output only. The resource type.",
+	example: "bigquery#dataset",
+	placeholder: "Enter resource kind",
+	required: false
+});
+const etag = (0, _prismatic_io_spectral.input)({
+	label: "ETag",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Output only. A hash of the resource.",
+	example: "W/\"abc123def456\"",
+	placeholder: "Enter ETag",
+	required: false
+});
+const id = (0, _prismatic_io_spectral.input)({
+	label: "ID",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Output only. The fully-qualified unique name of the dataset in the format projectId:datasetId. The dataset name without the project name is given in the datasetId field. When creating a new dataset, leave this field blank, and instead specify the datasetId field.",
+	example: "my-project:my_dataset",
+	placeholder: "Enter ID",
+	required: false
+});
+const selfLink = (0, _prismatic_io_spectral.input)({
+	label: "Self Link",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Output only. A URL that can be used to access the resource again. You can use this URL in Get or Update requests to the resource.",
+	example: "https://bigquery.googleapis.com/bigquery/v2/projects/my-project/datasets/my_dataset",
+	placeholder: "Enter self link",
+	required: false
+});
+const friendlyName = (0, _prismatic_io_spectral.input)({
+	label: "Friendly Name",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Optional. A descriptive name for the dataset.",
+	example: "My Dataset",
+	placeholder: "Enter friendly name",
+	required: false
+});
+const description = (0, _prismatic_io_spectral.input)({
+	label: "Description",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Optional. A descriptive name for the dataset.",
+	example: "This dataset contains sales data",
+	placeholder: "Enter description",
+	required: false
+});
+const creationTime = (0, _prismatic_io_spectral.input)({
+	label: "Creation Time",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Output only. The time when this dataset was created, in milliseconds since the epoch.",
+	example: "1609459200000",
+	placeholder: "Enter creation time",
+	required: false
+});
+const lastModifiedTime = (0, _prismatic_io_spectral.input)({
+	label: "Last Modified Time",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Output only. The date when this dataset was last modified, in milliseconds since the epoch.",
+	example: "1640995200000",
+	placeholder: "Enter last modified time",
+	required: false
+});
+const location = (0, _prismatic_io_spectral.input)({
+	label: "Location",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "The geographic location where the dataset should reside. See https://cloud.google.com/bigquery/docs/locations for supported locations.",
+	example: "US",
+	placeholder: "Enter location",
+	required: false
+});
+const defaultCollation = (0, _prismatic_io_spectral.input)({
+	label: "Default Collation",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Optional. Defines the default collation specification of future tables created in the dataset. If a table is created in this dataset without table-level default collation, then the table inherits the dataset default collation, which is applied to the string fields that do not have explicit collation specified. A change to this field affects only tables created afterwards, and does not alter the existing tables. The following values are supported: 'und:ci': undetermined locale, case insensitive.'' empty string. Default to case-sensitive behavior.",
+	example: "und:ci",
+	placeholder: "Enter default collation",
+	required: false
+});
+const defaultRoundingMode = (0, _prismatic_io_spectral.input)({
+	label: "Default Rounding Mode",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	required: false,
+	comments: "Optional. Defines the default rounding mode specification of new tables created within this dataset. During table creation, if this field is specified, the table within this dataset will inherit the default rounding mode of the dataset. Setting the default rounding mode on a table overrides this option. Existing tables in the dataset are unaffected. If columns are defined during that table creation, they will immediately inherit the table's default rounding mode, unless otherwise specified.",
+	placeholder: "Select rounding mode",
+	model: [
+		{
+			label: "ROUNDING MODE UNSPECIFIED",
+			value: "ROUNDING_MODE_UNSPECIFIED"
+		},
+		{
+			label: "ROUND HALF AWAY FROM ZERO",
+			value: "ROUND_HALF_AWAY_FROM_ZERO"
+		},
+		{
+			label: "ROUND HALF EVEN",
+			value: "ROUND_HALF_EVEN"
+		}
+	]
+});
+const encryptionConfiguration = (0, _prismatic_io_spectral.input)({
+	label: "Encryption Configuration",
+	type: "code",
+	language: "json",
+	comments: "Custom encryption configuration (e.g., Cloud KMS keys). This shows the encryption configuration of the model data while stored in BigQuery storage. This field can be used with models.patch to update encryption key for an already encrypted model.",
+	example: JSON.stringify({ kmsKeyName: "string" }),
+	clean: jsonInputClean,
+	required: false
+});
+const expirationTime = (0, _prismatic_io_spectral.input)({
+	label: "Expiration Time",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Optional. The time when this model expires, in milliseconds since the epoch. If not present, the model will persist indefinitely. Expired models will be deleted and their storage reclaimed. The defaultTableExpirationMs property of the encapsulating dataset can be used to set a default expirationTime on newly created models.",
+	required: false
+});
+const fetchAll = (0, _prismatic_io_spectral.input)({
+	label: "Fetch All",
+	type: "boolean",
+	required: false,
+	default: "false",
+	comments: "When true, automatically fetches all pages of results using pagination.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const labels = (0, _prismatic_io_spectral.input)({
+	label: "Labels",
+	type: "code",
+	language: "json",
+	comments: "The labels associated with this dataset. You can use these to organize and group your datasets. You can set this property when inserting or updating a dataset. See Creating and Updating Dataset Labels for more information.",
+	example: JSON.stringify({
+		name: "wrench",
+		mass: "1.3kg",
+		count: "3"
+	}),
+	clean: jsonInputClean,
+	required: false
+});
+//#endregion
+//#region src/inputs/pagination.ts
+const paginationFields = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Pagination",
+	required: false,
+	comments: "Page navigation controls for the results.",
+	inputs: {
+		pageToken,
+		maxResults
+	}
+});
+const paginationFieldsWithStartIndex = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Pagination",
+	required: false,
+	comments: "Page navigation controls for the results.",
+	inputs: {
+		pageToken,
+		maxResults,
+		startIndex
+	}
+});
+const tableListPaginationFields = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Pagination",
+	required: false,
+	comments: "Page navigation controls for the results.",
+	inputs: {
+		pageToken,
+		maxResults: (0, _prismatic_io_spectral.input)({
+			...maxResults,
+			required: false,
+			clean: _prismatic_io_spectral.util.types.toString
+		})
+	}
+});
+//#endregion
+//#region src/inputs/datasets.ts
+const all = (0, _prismatic_io_spectral.input)({
+	label: "All",
+	type: "boolean",
+	clean: _prismatic_io_spectral.util.types.toBool,
+	comments: "When true, lists all datasets, including hidden ones.",
+	required: false
+});
+const storageBillingModel = (0, _prismatic_io_spectral.input)({
+	label: "Storage Billing Model",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Optional. Updates storageBillingModel for the dataset.",
+	placeholder: "Select storage billing model",
+	model: [
+		{
+			label: "STORAGE BILLING MODEL UNSPECIFIED",
+			value: "STORAGE_BILLING_MODEL_UNSPECIFIED"
+		},
+		{
+			label: "LOGICAL",
+			value: "LOGICAL"
+		},
+		{
+			label: "PHYSICAL",
+			value: "PHYSICAL"
+		}
+	]
+});
+const maxTimeTravelHours = (0, _prismatic_io_spectral.input)({
+	label: "Max Time Travel Hours",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Optional. Defines the time travel window in hours. The value can be from 48 to 168 hours (2 to 7 days). The default value is 168 hours if this is not set.",
+	example: "168",
+	placeholder: "Enter max time travel hours",
+	required: false
+});
+const defaultTableExpirationMs = (0, _prismatic_io_spectral.input)({
+	label: "Default Table Expiration (ms)",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Optional. The default lifetime of all tables in the dataset, in milliseconds. The minimum lifetime value is 3600000 milliseconds (one hour). To clear an existing default expiration with a PATCH request, set to 0. Once this property is set, all newly-created tables in the dataset will have an expirationTime property set to the creation time plus the value in this property, and changing the value will only affect new tables, not existing ones. When the expirationTime for a given table is reached, that table will be deleted automatically. If a table's expirationTime is modified or removed before the table expires, or if you provide an explicit expirationTime when creating a table, that value takes precedence over the default expiration time indicated by this property.",
+	example: "3600000",
+	placeholder: "Enter default table expiration in milliseconds",
+	required: false
+});
+const satisfiesPzs = (0, _prismatic_io_spectral.input)({
+	label: "Satisfies PZS",
+	type: "boolean",
+	clean: _prismatic_io_spectral.util.types.toBool,
+	comments: "Output only. Reserved for future use.",
+	required: false
+});
+const isCaseInsensitive = (0, _prismatic_io_spectral.input)({
+	label: "Is Case Insensitive",
+	type: "boolean",
+	clean: _prismatic_io_spectral.util.types.toBool,
+	comments: "Optional. TRUE if the dataset and its table names are case-insensitive, otherwise FALSE. By default, this is FALSE, which means the dataset and its table names are case-sensitive. This field does not affect routine references.",
+	required: false
+});
+const defaultPartitionExpirationMs = (0, _prismatic_io_spectral.input)({
+	label: "Default Partition Expiration (ms)",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "This default partition expiration, expressed in milliseconds. \nWhen new time-partitioned tables are created in a dataset where this property is set, the table will inherit this value, propagated as the TimePartitioning.expirationMs property on the new table. If you set TimePartitioning.expirationMs explicitly when creating a table, the defaultPartitionExpirationMs of the containing dataset is ignored. \nWhen creating a partitioned table, if defaultPartitionExpirationMs is set, the defaultTableExpirationMs value is ignored and the table will not be inherit a table expiration deadline.",
+	example: "86400000",
+	placeholder: "Enter default partition expiration in milliseconds",
+	required: false
+});
+const datasetReference = (0, _prismatic_io_spectral.input)({
+	label: "Dataset Reference",
+	type: "code",
+	language: "json",
+	comments: "A reference that identifies the dataset.",
+	example: JSON.stringify({
+		datasetId: "string",
+		projectId: "string"
+	}),
+	clean: jsonInputClean,
+	required: true
+});
+const access = (0, _prismatic_io_spectral.input)({
+	label: "Access",
+	type: "code",
+	language: "json",
+	comments: "Optional. An array of objects that define dataset access for one or more entities. You can set this property when inserting or updating a dataset in order to control who is allowed to access the data. If unspecified at dataset creation time, BigQuery adds default dataset access for the following entities: access.specialGroup: projectReaders; access.role: READER; access.specialGroup: projectWriters; access.role: WRITER; access.specialGroup: projectOwners; access.role: OWNER; access.userByEmail: [dataset creator email]; access.role: OWNER.",
+	example: JSON.stringify([{
+		role: "string",
+		userByEmail: "string",
+		groupByEmail: "string",
+		domain: "string",
+		specialGroup: "string",
+		iamMember: "string",
+		view: {
+			projectId: "string",
+			datasetId: "string",
+			tableId: "string"
+		},
+		routine: {
+			projectId: "string",
+			datasetId: "string",
+			routineId: "string"
+		},
+		dataset: {
+			dataset: {
+				datasetId: "string",
+				projectId: "string"
+			},
+			targetTypes: ["TARGET_TYPE_UNSPECIFIED", "VIEWS"]
+		}
+	}]),
+	clean: jsonInputClean,
+	required: false
+});
+const defaultEncryptionConfiguration = (0, _prismatic_io_spectral.input)({
+	label: "Default Encryption Configuration",
+	type: "code",
+	language: "json",
+	comments: "The default encryption key for all tables in the dataset. Once this property is set, all newly-created partitioned tables in the dataset will have encryption key set to this value, unless table creation request (or query) overrides the key.",
+	example: JSON.stringify({ kmsKeyName: "string" }),
+	clean: jsonInputClean,
+	required: false
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Linked Dataset Source",
+	type: "code",
+	language: "json",
+	comments: "Optional. The source dataset reference when the dataset is of type LINKED. For all other dataset types it is not set. This field cannot be updated once it is set. Any attempt to update this field using Update and Patch API Operations will be ignored.",
+	example: JSON.stringify({ sourceDataset: {
+		datasetId: "string",
+		projectId: "string"
+	} }),
+	clean: jsonInputClean,
+	required: false
+});
+const tags = (0, _prismatic_io_spectral.input)({
+	label: "Tags",
+	type: "code",
+	language: "json",
+	comments: "Output only. Tags for the Dataset.",
+	example: JSON.stringify([{
+		tagKey: "string",
+		tagValue: "string"
+	}]),
+	clean: jsonInputClean,
+	required: false
+});
+const datasetAdditionalFields = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Additional Fields",
+	required: false,
+	comments: "Additional optional fields.",
+	inputs: {
+		kind,
+		etag,
+		id,
+		selfLink,
+		friendlyName,
+		description,
+		defaultTableExpirationMs,
+		defaultPartitionExpirationMs,
+		labels,
+		access,
+		creationTime,
+		lastModifiedTime,
+		location,
+		defaultEncryptionConfiguration,
+		satisfiesPzs,
+		isCaseInsensitive,
+		defaultCollation,
+		defaultRoundingMode,
+		maxTimeTravelHours,
+		tags,
+		storageBillingModel
+	}
+});
+const createDatasetInputs = {
+	connectionInput,
+	projectId,
+	datasetReference,
+	additionalFields: datasetAdditionalFields
+};
+const deleteDatasetInputs = {
+	connectionInput,
+	projectId,
+	datasetId
+};
+const getDatasetInputs = {
+	connectionInput,
+	projectId,
+	datasetId
+};
+const listDatasetsInputs = {
+	connectionInput,
+	projectId,
+	fetchAll,
+	pagination: paginationFields,
+	all,
+	filter
+};
+const updateDatasetInputs = {
+	connectionInput,
+	projectId,
+	datasetId,
+	datasetReference,
+	additionalFields: datasetAdditionalFields
+};
+//#endregion
+//#region src/inputs/jobs.ts
+const jobId = (0, _prismatic_io_spectral.input)({
+	label: "Job ID",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "The unique identifier for the job.",
+	example: "job_abc123xyz",
+	placeholder: "Enter job ID",
+	required: true,
+	dataSource: "selectJob"
+});
+const allUsers = (0, _prismatic_io_spectral.input)({
+	label: "All Users",
+	type: "boolean",
+	clean: _prismatic_io_spectral.util.types.toBool,
+	comments: "When true, displays jobs owned by all users in the project. Default is false.",
+	required: false
+});
+const minCreationTime = (0, _prismatic_io_spectral.input)({
+	label: "Min Creation Time",
+	type: "string",
+	clean: cleanString,
+	comments: "Min value for job creation time, in milliseconds since the POSIX epoch. If set, only jobs created after or at this timestamp are returned.",
+	example: "1609459200000",
+	placeholder: "Enter minimum creation time (milliseconds)",
+	required: false
+});
+const maxCreationTime = (0, _prismatic_io_spectral.input)({
+	label: "Max Creation Time",
+	type: "string",
+	clean: cleanString,
+	comments: "Max value for job creation time, in milliseconds since the POSIX epoch. If set, only jobs created before or at this timestamp are returned.",
+	example: "1640995200000",
+	placeholder: "Enter maximum creation time (milliseconds)",
+	required: false
+});
+const parentJobId = (0, _prismatic_io_spectral.input)({
+	label: "Parent Job ID",
+	type: "string",
+	clean: cleanString,
+	comments: "If set, shows only child jobs of the specified parent. Otherwise, shows all top-level jobs.",
+	example: "parent_job_abc123",
+	placeholder: "Enter parent job ID",
+	required: false
+});
+const projection = (0, _prismatic_io_spectral.input)({
+	label: "Projection",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Restrict information returned to a set of selected fields",
+	placeholder: "Select projection",
+	model: [{
+		label: "MINIMAL",
+		value: "MINIMAL"
+	}, {
+		label: "FULL",
+		value: "FULL"
+	}]
+});
+const stateFilter = (0, _prismatic_io_spectral.input)({
+	label: "State Filter",
+	type: "string",
+	collection: "valuelist",
+	required: false,
+	comments: "Filter for job state. Valid values of this enum field are: DONE, PENDING, RUNNING.",
+	example: "[\"DONE\", \"RUNNING\"]",
+	placeholder: "Select job states",
+	clean: valueListInputClean
+});
+const timeoutMs = (0, _prismatic_io_spectral.input)({
+	label: "Timeout (ms)",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toNumber,
+	comments: "Specifies the maximum amount of time, in milliseconds, that the client is willing to wait for the query to complete. By default, this limit is 10 seconds (10,000 milliseconds). If the query is complete, the jobComplete field in the response is true. If the query has not yet completed, jobComplete is false. You can request a longer timeout period in the timeoutMs field. However, the call is not guaranteed to wait for the specified timeout; it typically returns after around 200 seconds (200,000 milliseconds), even if the query is not complete. If jobComplete is false, you can continue to wait for the query to complete by calling the getQueryResults method until the jobComplete field in the getQueryResults response is true.",
+	example: "10000",
+	placeholder: "Enter timeout in milliseconds",
+	required: false
+});
+const dryRun = (0, _prismatic_io_spectral.input)({
+	label: "Dry Run",
+	type: "boolean",
+	clean: _prismatic_io_spectral.util.types.toBool,
+	comments: "When true, BigQuery doesn't run the job. Instead, if the query is valid, BigQuery returns statistics about the job such as how many bytes would be processed. If the query is invalid, an error returns. The default value is false.",
+	required: false
+});
+const useQueryCache = (0, _prismatic_io_spectral.input)({
+	label: "Use Query Cache",
+	type: "boolean",
+	clean: _prismatic_io_spectral.util.types.toBool,
+	default: "true",
+	comments: "When true, looks for the result in the query cache. The query cache is a best-effort cache that will be flushed whenever tables in the query are modified. The default value is true.",
+	required: false
+});
+const useLegacySql = (0, _prismatic_io_spectral.input)({
+	label: "Use Legacy SQL",
+	type: "boolean",
+	clean: _prismatic_io_spectral.util.types.toBool,
+	default: "false",
+	comments: "Specifies whether to use BigQuery's legacy SQL dialect for this query. [BigQuery's GoogleSQL](https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax)",
+	required: false
+});
+const parameterMode = (0, _prismatic_io_spectral.input)({
+	label: "Parameter Mode",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "GoogleSQL only. Set to POSITIONAL to use positional (?) query parameters or to NAMED to use named (@myparam) query parameters in this query.",
+	example: "NAMED",
+	placeholder: "Enter parameter mode",
+	required: false
+});
+const userEmail = (0, _prismatic_io_spectral.input)({
+	label: "User Email",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Output only. Email address of the user who ran the job.",
+	example: "user@example.com",
+	placeholder: "Enter user email",
+	required: false
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Principal Subject",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Output only. [Full-projection-only] String representation of identity of requesting party. Populated for both first- and third-party identities. Only present for APIs that support third-party identities.",
+	example: "user:user@example.com",
+	placeholder: "Enter principal subject",
+	required: false
+});
+const maximumBytesBilled = (0, _prismatic_io_spectral.input)({
+	label: "Maximum Bytes Billed",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Optional. Limits the bytes billed for this query. Queries with bytes billed above this limit will fail (without incurring a charge). If unspecified, the project default is used.",
+	example: "1000000000",
+	placeholder: "Enter maximum bytes billed",
+	required: false
+});
+const requestId = (0, _prismatic_io_spectral.input)({
+	label: "Request ID",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Optional. A unique user provided identifier to ensure idempotent behavior for queries. Note that this is different from the jobId. It has the following properties: It is case-sensitive, limited to up to 36 ASCII characters. A UUID is recommended. Read only queries can ignore this token since they are nullipotent by definition. For the purposes of idempotency ensured by the requestId, a request is considered duplicate of another only if they have the same requestId and are actually duplicates. When determining whether a request is a duplicate of another request, all parameters in the request that may affect the result are considered. For example, query, connectionProperties, queryParameters, useLegacySql are parameters that affect the result and are considered when determining whether a request is a duplicate, but properties like timeoutMs don't affect the result and are thus not considered. Dry run query requests are never considered duplicate of another request. When a duplicate mutating query request is detected, it returns: a. the results of the mutation if it completes successfully within the timeout. b. the running operation if it is still in progress at the end of the timeout. Its lifetime is limited to 15 minutes. In other words, if two requests are sent with the same requestId, but more than 15 minutes apart, idempotency is not guaranteed.",
+	example: "550e8400-e29b-41d4-a716-446655440000",
+	placeholder: "Enter request ID",
+	required: false
+});
+const createSession = (0, _prismatic_io_spectral.input)({
+	label: "Create Session",
+	type: "boolean",
+	clean: _prismatic_io_spectral.util.types.toBool,
+	comments: "When true, creates a new session using a randomly generated sessionId. If false, runs query with an existing sessionId passed in ConnectionProperty, otherwise runs query in non-session mode. The session location will be set to QueryRequest.location if it is present, otherwise it's set to the default location based on existing routing logic.",
+	required: false
+});
+const query = (0, _prismatic_io_spectral.input)({
+	label: "Query",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Required. A query string to execute, using Google Standard SQL or legacy SQL syntax. Example: 'SELECT COUNT(f1) FROM myProjectId.myDatasetId.myTableId'.",
+	example: "SELECT COUNT(f1) FROM myProjectId.myDatasetId.myTableId",
+	placeholder: "Enter SQL query",
+	required: true
+});
+const configuration = (0, _prismatic_io_spectral.input)({
+	label: "Configuration",
+	type: "code",
+	language: "json",
+	comments: "Required. Describes the job configuration.",
+	example: "Reference to the Google docs for this input. https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#jobconfiguration",
+	clean: jsonInputClean,
+	required: true
+});
+const jobReference = (0, _prismatic_io_spectral.input)({
+	label: "Job Reference",
+	type: "code",
+	language: "json",
+	comments: "Optional. Reference describing the unique-per-user name of the job.",
+	example: JSON.stringify({
+		projectId: "string",
+		jobId: "string",
+		location: "string"
+	}),
+	clean: jsonInputClean,
+	required: false
+});
+const statistics = (0, _prismatic_io_spectral.input)({
+	label: "Statistics",
+	type: "code",
+	language: "json",
+	comments: "Output only. Information about the job, including starting time and ending time of the job.",
+	example: "Reference to the Google docs for this input. https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#jobstatistics",
+	clean: jsonInputClean,
+	required: false
+});
+const status = (0, _prismatic_io_spectral.input)({
+	label: "Status",
+	type: "code",
+	language: "json",
+	comments: "Output only. The status of this job. Examine this value when polling an asynchronous job to see if the job is complete.",
+	example: JSON.stringify({
+		errorResult: {
+			reason: "string",
+			location: "string",
+			debugInfo: "string",
+			message: "string"
+		},
+		errors: [{
+			reason: "string",
+			location: "string",
+			debugInfo: "string",
+			message: "string"
+		}],
+		state: "string"
+	}),
+	clean: jsonInputClean,
+	required: false
+});
+const defaultDataset = (0, _prismatic_io_spectral.input)({
+	label: "Default Dataset",
+	type: "code",
+	language: "json",
+	comments: "Optional. Specifies the default datasetId and projectId to assume for any unqualified table names in the query. If not set, all table names in the query string must be qualified in the format 'datasetId.tableId'.",
+	example: JSON.stringify({
+		datasetId: "string",
+		projectId: "string"
+	}),
+	clean: jsonInputClean,
+	required: false
+});
+const queryParameters = (0, _prismatic_io_spectral.input)({
+	label: "Query Parameters",
+	type: "code",
+	language: "json",
+	comments: "Optional. An array of query parameters for a query. Reference to the Google docs for this input. https://cloud.google.com/bigquery/docs/reference/rest/v2/QueryParameter",
+	example: JSON.stringify([{
+		name: "name",
+		parameterType: { type: "STRING" },
+		parameterValue: { value: "value" }
+	}]),
+	clean: jsonInputClean,
+	required: false
+});
+const connectionProperties = (0, _prismatic_io_spectral.input)({
+	label: "Connection Properties",
+	type: "code",
+	language: "json",
+	comments: "Optional. Connection properties which can modify the query behavior.",
+	example: JSON.stringify([{
+		key: "string",
+		value: "string"
+	}]),
+	clean: jsonInputClean,
+	required: false
+});
+const listJobsFilters = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Filters",
+	required: false,
+	comments: "Optional query controls to sort and refine the results.",
+	inputs: {
+		allUsers,
+		minCreationTime,
+		maxCreationTime,
+		projection,
+		parentJobId
+	}
+});
+const createJobAdditionalFields = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Additional Fields",
+	required: false,
+	comments: "Additional optional fields.",
+	inputs: {
+		kind,
+		etag,
+		id,
+		selfLink,
+		userEmail,
+		statistics,
+		status
+	}
+});
+const queryJobAdditionalFields = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Additional Fields",
+	required: false,
+	comments: "Additional optional fields.",
+	inputs: {
+		kind,
+		defaultDataset,
+		timeoutMs,
+		dryRun,
+		useQueryCache,
+		useLegacySql,
+		parameterMode,
+		queryParameters,
+		location,
+		connectionProperties,
+		labels,
+		maximumBytesBilled,
+		requestId,
+		createSession
+	}
+});
+const cancelJobInputs = {
+	connectionInput,
+	projectId,
+	jobId,
+	location
+};
+const createJobInputs = {
+	connectionInput,
+	projectId,
+	configuration,
+	jobReference,
+	additionalFields: createJobAdditionalFields
+};
+const deleteJobInputs = {
+	connectionInput,
+	projectId,
+	jobId,
+	location
+};
+const getJobInputs = {
+	connectionInput,
+	projectId,
+	jobId,
+	location
+};
+const getQueryJobResultInputs = {
+	connectionInput,
+	projectId,
+	jobId,
+	timeoutMs,
+	location,
+	pagination: paginationFieldsWithStartIndex
+};
+const listJobsInputs = {
+	connectionInput,
+	projectId,
+	fetchAll,
+	pagination: paginationFields,
+	filters: listJobsFilters,
+	stateFilter
+};
+const queryJobInputs = {
+	connectionInput,
+	projectId,
+	query,
+	maxResults,
+	additionalFields: queryJobAdditionalFields
+};
+//#endregion
+//#region src/inputs/misc.ts
+const version = (0, _prismatic_io_spectral.input)({
+	label: "API Version",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	default: "v2",
+	comments: "The API version to use. This is used to construct the base URL for the request.",
+	example: "v2",
+	placeholder: "Enter API version",
+	required: false
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Format Options",
+	type: "boolean",
+	clean: _prismatic_io_spectral.util.types.toBool,
+	comments: "When true, applies output format adjustments.",
+	required: false
+});
+//#endregion
+//#region src/inputs/models.ts
+const modelId = (0, _prismatic_io_spectral.input)({
+	label: "Model ID",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "The unique identifier for the model.",
+	example: "my_model",
+	placeholder: "Enter model ID",
+	required: true,
+	dataSource: "selectModel"
+});
+const defaultTrialId = (0, _prismatic_io_spectral.input)({
+	label: "Default Trial ID",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Output only. The default trialId to use in TVFs when the trialId is not passed in. For single-objective hyperparameter tuning models, this is the best trial ID. For multi-objective hyperparameter tuning models, this is the smallest trial ID among all Pareto optimal trials.",
+	required: false
+});
+const modelType = (0, _prismatic_io_spectral.input)({
+	label: "Model Type",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Output only. Type of the model resource.",
+	model: [
+		{
+			label: "MODEL_TYPE_UNSPECIFIED",
+			value: "MODEL_TYPE_UNSPECIFIED"
+		},
+		{
+			label: "LINEAR_REGRESSION",
+			value: "LINEAR_REGRESSION"
+		},
+		{
+			label: "LOGISTIC_REGRESSION",
+			value: "LOGISTIC_REGRESSION"
+		},
+		{
+			label: "KMEANS",
+			value: "KMEANS"
+		},
+		{
+			label: "MATRIX_FACTORIZATION",
+			value: "MATRIX_FACTORIZATION"
+		},
+		{
+			label: "DNN_CLASSIFIER",
+			value: "DNN_CLASSIFIER"
+		},
+		{
+			label: "TENSORFLOW",
+			value: "TENSORFLOW"
+		},
+		{
+			label: "DNN_REGRESSOR",
+			value: "DNN_REGRESSOR"
+		},
+		{
+			label: "XGBOOST",
+			value: "XGBOOST"
+		},
+		{
+			label: "BOOSTED_TREE_REGRESSOR",
+			value: "BOOSTED_TREE_REGRESSOR"
+		},
+		{
+			label: "BOOSTED_TREE_CLASSIFIER",
+			value: "BOOSTED_TREE_CLASSIFIER"
+		},
+		{
+			label: "ARIMA",
+			value: "ARIMA"
+		},
+		{
+			label: "AUTOML_REGRESSOR",
+			value: "AUTOML_REGRESSOR"
+		},
+		{
+			label: "AUTOML_CLASSIFIER",
+			value: "AUTOML_CLASSIFIER"
+		},
+		{
+			label: "PCA",
+			value: "PCA"
+		},
+		{
+			label: "DNN_LINEAR_COMBINED_CLASSIFIER",
+			value: "DNN_LINEAR_COMBINED_CLASSIFIER"
+		},
+		{
+			label: "DNN_LINEAR_COMBINED_REGRESSOR",
+			value: "DNN_LINEAR_COMBINED_REGRESSOR"
+		},
+		{
+			label: "AUTOENCODER",
+			value: "AUTOENCODER"
+		},
+		{
+			label: "ARIMA_PLUS",
+			value: "ARIMA_PLUS"
+		},
+		{
+			label: "ARIMA_PLUS_XREG",
+			value: "ARIMA_PLUS_XREG"
+		},
+		{
+			label: "RANDOM_FOREST_REGRESSOR",
+			value: "RANDOM_FOREST_REGRESSOR"
+		},
+		{
+			label: "RANDOM_FOREST_CLASSIFIER",
+			value: "RANDOM_FOREST_CLASSIFIER"
+		},
+		{
+			label: "TENSORFLOW_LITE",
+			value: "TENSORFLOW_LITE"
+		},
+		{
+			label: "ONNX",
+			value: "ONNX"
+		}
+	]
+});
+const optimalTrialIds = (0, _prismatic_io_spectral.input)({
+	label: "Optimal Trial IDs",
+	type: "string",
+	collection: "valuelist",
+	required: false,
+	comments: "Output only. For single-objective hyperparameter tuning models, it only contains the best trial. For multi-objective hyperparameter tuning models, it contains all Pareto optimal trials sorted by trialId.",
+	example: "[\"trial_1\", \"trial_2\"]",
+	placeholder: "Enter trial IDs",
+	clean: valueListInputClean
+});
+const modelReference = (0, _prismatic_io_spectral.input)({
+	label: "Model Reference",
+	type: "code",
+	language: "json",
+	comments: "Unique identifier for this model.",
+	example: JSON.stringify({
+		projectId: "string",
+		datasetId: "string",
+		modelId: "string"
+	}),
+	clean: jsonInputClean,
+	required: true
+});
+const trainingRuns = (0, _prismatic_io_spectral.input)({
+	label: "Training Runs",
+	type: "code",
+	language: "json",
+	comments: "Information for all training runs in increasing order of startTime.",
+	example: "Reference to the Google docs for this input. An array of https://cloud.google.com/bigquery/docs/reference/rest/v2/models#trainingrun",
+	clean: jsonInputClean,
+	required: false
+});
+const featureColumns = (0, _prismatic_io_spectral.input)({
+	label: "Feature Columns",
+	type: "code",
+	language: "json",
+	comments: "Output only. Input feature columns for the model inference. If the model is trained with TRANSFORM clause, these are the input of the TRANSFORM clause.",
+	example: "Reference to the Google docs for this input. An array of https://cloud.google.com/bigquery/docs/reference/rest/v2/StandardSqlField",
+	clean: jsonInputClean,
+	required: false
+});
+const labelColumns = (0, _prismatic_io_spectral.input)({
+	label: "Label Columns",
+	type: "code",
+	language: "json",
+	comments: "Output only. Label columns that were used to train this model. The output of the model will have a 'predicted_' prefix to these columns.",
+	example: "Reference to the Google docs for this input. An array of https://cloud.google.com/bigquery/docs/reference/rest/v2/StandardSqlField",
+	clean: jsonInputClean,
+	required: false
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Transform Columns",
+	type: "code",
+	language: "json",
+	comments: "Output only. This field will be populated if a TRANSFORM clause was used to train a model. TRANSFORM clause (if used) takes featureColumns as input and outputs transformColumns. transformColumns then are used to train the model.",
+	example: "Reference to the Google docs for this input. An array of https://cloud.google.com/bigquery/docs/reference/rest/v2/models#transformcolumn",
+	clean: jsonInputClean,
+	required: false
+});
+const hparamSearchSpaces = (0, _prismatic_io_spectral.input)({
+	label: "Hparam Search Spaces",
+	type: "code",
+	language: "json",
+	comments: "Output only. Trials of a hyperparameter tuning model sorted by trialId.",
+	example: "Reference to the Google docs for this input. https://cloud.google.com/bigquery/docs/reference/rest/v2/models#hparamsearchspaces",
+	clean: jsonInputClean,
+	required: false
+});
+const hparamTrials = (0, _prismatic_io_spectral.input)({
+	label: "Hparam Trials",
+	type: "code",
+	language: "json",
+	comments: "Output only. Trials of a hyperparameter tuning model sorted by trialId.",
+	example: "Reference to the Google docs for this input. An array of https://cloud.google.com/bigquery/docs/reference/rest/v2/models#hparamtuningtrial",
+	clean: jsonInputClean,
+	required: false
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Remote Model Info",
+	type: "code",
+	language: "json",
+	comments: "Output only. Remote model info",
+	example: JSON.stringify({
+		connection: "string",
+		maxBatchingRows: "string",
+		endpoint: "string",
+		remoteServiceType: "One of REMOTE_SERVICE_TYPE_UNSPECIFIED / CLOUD_AI_TRANSLATE_V3 / CLOUD_AI_VISION_V1 / CLOUD_AI_NATURAL_LANGUAGE_V1"
+	}),
+	clean: jsonInputClean,
+	required: false
+});
+const updateModelAdditionalFields = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Additional Fields",
+	required: false,
+	comments: "Additional optional fields.",
+	inputs: {
+		etag,
+		creationTime,
+		lastModifiedTime,
+		description,
+		friendlyName,
+		labels,
+		expirationTime,
+		location,
+		encryptionConfiguration,
+		modelType,
+		trainingRuns,
+		featureColumns,
+		labelColumns,
+		hparamSearchSpaces,
+		defaultTrialId,
+		hparamTrials,
+		optimalTrialIds
+	}
+});
+const deleteModelInputs = {
+	connectionInput,
+	projectId,
+	datasetId,
+	modelId
+};
+const getModelInputs = {
+	connectionInput,
+	projectId,
+	datasetId,
+	modelId
+};
+const listModelsInputs = {
+	connectionInput,
+	projectId,
+	datasetId,
+	fetchAll,
+	pagination: paginationFields
+};
+const updateModelInputs = {
+	connectionInput,
+	projectId,
+	datasetId,
+	modelId,
+	modelReference,
+	additionalFields: updateModelAdditionalFields
+};
+//#endregion
+//#region src/inputs/policies.ts
+const resource = (0, _prismatic_io_spectral.input)({
+	label: "Resource",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.",
+	example: "projects/my-project/datasets/my-dataset/tables/my-table",
+	placeholder: "Enter resource name",
+	required: true
+});
+const updateMask = (0, _prismatic_io_spectral.input)({
+	label: "Update Mask",
+	type: "string",
+	clean: cleanString,
+	comments: "OPTIONAL: A FieldMask specifying which fields of the policy to modify. Only the fields in the mask will be modified. If no mask is provided, the following default mask is used: paths: 'bindings, etag' \n This is a comma-separated list of fully qualified names of fields. Example: 'user.displayName,photo'.",
+	example: "user.displayName,photo",
+	placeholder: "Enter update mask",
+	required: false
+});
+const options = (0, _prismatic_io_spectral.input)({
+	label: "Options",
+	type: "code",
+	language: "json",
+	comments: "OPTIONAL: A GetPolicyOptions object for specifying options to tables.getIamPolicy.",
+	example: JSON.stringify({ requestedPolicyVersion: "integer" }),
+	clean: jsonInputClean,
+	required: false
+});
+const policy = (0, _prismatic_io_spectral.input)({
+	label: "Policy",
+	type: "code",
+	language: "json",
+	comments: "The complete policy to be applied to the resource. The size of the policy is limited to a few 10s of KB. An empty policy is a valid policy but certain Google Cloud services (such as Projects) might reject them.",
+	example: "Reference to the Google docs for this input. https://cloud.google.com/bigquery/docs/reference/rest/v2/Policy",
+	clean: jsonInputClean,
+	required: false
+});
+const getPolicyInputs = {
+	connectionInput,
+	resource,
+	options
+};
+const setPolicyInputs = {
+	connectionInput,
+	resource,
+	policy,
+	updateMask
+};
+const pollChangesInputs = {
+	connectionInput,
+	projectId,
+	lookBackDate: (0, _prismatic_io_spectral.input)({
+		label: "Look-back Date",
+		placeholder: "Enter look-back date (YYYY-MM-DD)",
+		type: "string",
+		required: false,
+		comments: "The date the initial sync starts from, in YYYY-MM-DD format. Cannot be a future date. Leave empty to start from the first recurrence with no backfill. When set, the initial sync seeds each job created on or after this date once.",
+		example: "2026-01-01",
+		clean: lookBackDateClean
+	})
+};
+//#endregion
+//#region src/inputs/projects.ts
+const getServiceAccountInputs = {
+	connectionInput,
+	projectId
+};
+const listProjectsInputs = {
+	connectionInput,
+	fetchAll,
+	pagination: paginationFields
+};
+//#endregion
+//#region src/inputs/routines.ts
+const routineId = (0, _prismatic_io_spectral.input)({
+	label: "Routine ID",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "The unique identifier for the routine.",
+	example: "my_routine",
+	placeholder: "Enter routine ID",
+	required: true,
+	dataSource: "selectRoutine"
+});
+const readMask = (0, _prismatic_io_spectral.input)({
+	label: "Read Mask",
+	type: "string",
+	clean: cleanString,
+	comments: "If set, only the Routine fields in the field mask are returned in the response. If unset, all Routine fields are returned. This is a comma-separated list of fully qualified names of fields. Example: 'user.displayName,photo'.",
+	example: "user.displayName,photo",
+	placeholder: "Enter read mask",
+	required: false
+});
+const routineType = (0, _prismatic_io_spectral.input)({
+	label: "Routine Type",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "The type of routine. One of ROUTINE_TYPE_UNSPECIFIED / SCALAR_FUNCTION / PROCEDURE / TABLE_VALUED_FUNCTION",
+	example: "SCALAR_FUNCTION",
+	placeholder: "Enter routine type",
+	required: true
+});
+const definitionBody = (0, _prismatic_io_spectral.input)({
+	label: "Definition Body",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Required. The body of the routine. For functions, this is the expression in the AS clause. If language=SQL, it is the substring inside (but excluding) the parentheses. For example, for the function created with the following statement: CREATE FUNCTION JoinLines(x string, y string) as (concat(x, '\\n', y)) The definitionBody is concat(x, '\\n', y) (\\n is not replaced with linebreak). If language=JAVASCRIPT, it is the evaluated string in the AS clause. For example, for the function created with the following statement: CREATE FUNCTION f() RETURNS STRING LANGUAGE js AS 'return '\\n';\\n'The definitionBody is return '\\n';\\n Note that both \\n are replaced with linebreaks.",
+	example: "concat(x, '\\n', y)",
+	placeholder: "Enter definition body",
+	required: true
+});
+const determinismLevel = (0, _prismatic_io_spectral.input)({
+	label: "Determinism Level",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Optional. The determinism level of the JavaScript UDF, if defined. One of DETERMINISM_LEVEL_UNSPECIFIED / DETERMINISTIC / NOT_DETERMINISTIC",
+	example: "DETERMINISTIC",
+	placeholder: "Enter determinism level",
+	required: false
+});
+const language = (0, _prismatic_io_spectral.input)({
+	label: "Language",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Optional. Defaults to 'SQL' if remoteFunctionOptions field is absent, not set otherwise. One of LANGUAGE_UNSPECIFIED / SQL / JAVASCRIPT / PYTHON / JAVA / SCALA",
+	example: "SQL",
+	placeholder: "Enter language",
+	required: false
+});
+const importedLibraries = (0, _prismatic_io_spectral.input)({
+	label: "Imported Libraries",
+	type: "string",
+	collection: "valuelist",
+	required: false,
+	comments: "Optional. If language = 'JAVASCRIPT', this field stores the path of the imported JAVASCRIPT libraries.",
+	example: "[\"gs://bucket/path/lib.js\"]",
+	placeholder: "Enter library paths",
+	clean: valueListInputClean
+});
+const routineReference = (0, _prismatic_io_spectral.input)({
+	label: "Routine Reference",
+	type: "code",
+	language: "json",
+	comments: "Reference describing the ID of this routine.",
+	example: JSON.stringify({
+		projectId: "string",
+		datasetId: "string",
+		routineId: "string"
+	}),
+	clean: jsonInputClean,
+	required: true
+});
+const argument = (0, _prismatic_io_spectral.input)({
+	label: "Arguments",
+	type: "code",
+	language: "json",
+	comments: "Input/output argument of a function or a stored procedure.",
+	example: "Reference to the Google docs for this input. An array of https://cloud.google.com/bigquery/docs/reference/rest/v2/routines#argument",
+	clean: jsonInputClean,
+	required: false
+});
+const returnType = (0, _prismatic_io_spectral.input)({
+	label: "Return Type",
+	type: "code",
+	language: "json",
+	comments: "Optional if language = 'SQL'; required otherwise. Cannot be set if routineType = 'TABLE_VALUED_FUNCTION'. If absent, the return type is inferred from definitionBody at query time in each query that references this routine. If present, then the evaluated result will be cast to the specified returned type at query time.",
+	example: "Reference to the Google docs for this input. https://cloud.google.com/bigquery/docs/reference/rest/v2/StandardSqlDataType",
+	clean: jsonInputClean,
+	required: false
+});
+const returnTableType = (0, _prismatic_io_spectral.input)({
+	label: "Return Table Type",
+	type: "code",
+	language: "json",
+	comments: "Optional. Can be set only if routineType = 'TABLE_VALUED_FUNCTION'. If absent, the return table type is inferred from definitionBody at query time in each query that references this routine. If present, then the columns in the evaluated table result will be cast to match the column types specified in return table type, at query time.",
+	example: "Reference to the Google docs for this input. https://cloud.google.com/bigquery/docs/reference/rest/v2/StandardSqlDataType",
+	clean: jsonInputClean,
+	required: false
+});
+const remoteFunctionOptions = (0, _prismatic_io_spectral.input)({
+	label: "Remote Function Options",
+	type: "code",
+	language: "json",
+	comments: "Optional. Remote function specific options.",
+	example: JSON.stringify({
+		endpoint: "string",
+		connection: "string",
+		userDefinedContext: {
+			string: "string",
+			string2: "string",
+			string3: "string"
+		},
+		maxBatchingRows: "string"
+	}),
+	clean: jsonInputClean,
+	required: false
+});
+const sparkOptions = (0, _prismatic_io_spectral.input)({
+	label: "Spark Options",
+	type: "code",
+	language: "json",
+	comments: "Optional. Spark specific options.",
+	example: JSON.stringify({
+		connection: "string",
+		runtimeVersion: "string",
+		containerImage: "string",
+		properties: {
+			string: "string",
+			string2: "string",
+			string3: "string"
+		},
+		mainFileUri: "string",
+		pyFileUris: ["string"],
+		jarUris: ["string"],
+		fileUris: ["string"],
+		archiveUris: ["string"],
+		mainClass: "string"
+	}),
+	clean: jsonInputClean,
+	required: false
+});
+const routineAdditionalFields = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Additional Fields",
+	required: false,
+	comments: "Additional optional fields.",
+	inputs: {
+		etag,
+		argument,
+		returnTableType,
+		returnType,
+		creationTime,
+		lastModifiedTime,
+		language,
+		importedLibraries,
+		description: {
+			...description,
+			comments: "Optional. The description of the routine, if defined."
+		},
+		determinismLevel,
+		remoteFunctionOptions,
+		sparkOptions
+	}
+});
+const createRoutineInputs = {
+	connectionInput,
+	datasetId,
+	projectId,
+	routineReference,
+	routineType,
+	definitionBody,
+	additionalFields: routineAdditionalFields
+};
+const deleteRoutineInputs = {
+	connectionInput,
+	datasetId,
+	projectId,
+	routineId
+};
+const getRoutineInputs = {
+	connectionInput,
+	datasetId,
+	projectId,
+	readMask,
+	routineId
+};
+const listRoutinesInputs = {
+	connectionInput,
+	projectId,
+	datasetId,
+	fetchAll,
+	pagination: paginationFields,
+	filter,
+	readMask
+};
+const updateRoutineInputs = {
+	connectionInput,
+	datasetId,
+	projectId,
+	routineReference,
+	routineType,
+	definitionBody,
+	additionalFields: routineAdditionalFields
+};
+//#endregion
+//#region src/inputs/tableData.ts
+const skipInvalidRows = (0, _prismatic_io_spectral.input)({
+	label: "Skip Invalid Rows",
+	type: "boolean",
+	clean: _prismatic_io_spectral.util.types.toBool,
+	comments: "When true, inserts all valid rows of a request even if invalid rows exist. Default is false, which causes the entire request to fail if any invalid rows exist.",
+	required: false
+});
+const ignoreUnknownValues = (0, _prismatic_io_spectral.input)({
+	label: "Ignore Unknown Values",
+	type: "boolean",
+	clean: _prismatic_io_spectral.util.types.toBool,
+	comments: "When true, accepts rows that contain values that do not match the schema. The unknown values are ignored. Default is false, which treats unknown values as errors.",
+	required: false
+});
+const templateSuffix = (0, _prismatic_io_spectral.input)({
+	label: "Template Suffix",
+	type: "string",
+	clean: cleanString,
+	comments: "Optional. If specified, treats the destination table as a base template, and inserts the rows into an instance table named '{destination}{templateSuffix}'. BigQuery will manage creation of the instance table, using the schema of the base template table. \nSee https://cloud.google.com/bigquery/streaming-data-into-bigquery#template-tables for considerations when working with templates tables.",
+	example: "_20240101",
+	placeholder: "Enter template suffix",
+	required: false
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Trace ID",
+	type: "string",
+	clean: cleanString,
+	comments: "Unique request trace ID. Used for debugging purposes only. It is case-sensitive, limited to up to 36 ASCII characters. A UUID is recommended.",
+	example: "550e8400-e29b-41d4-a716-446655440000",
+	placeholder: "Enter trace ID",
+	required: false
+});
+const tableDataInsertAllInputs = {
+	connectionInput,
+	datasetId,
+	projectId,
+	tableId,
+	rows: (0, _prismatic_io_spectral.input)({
+		label: "Rows",
+		type: "code",
+		language: "json",
+		comments: "The complete policy to be applied to the resource. The size of the policy is limited to a few 10s of KB. An empty policy is a valid policy but certain Google Cloud services (such as Projects) might reject them.",
+		example: JSON.stringify([{
+			insertId: "string",
+			json: "follow this structure: https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#google.protobuf.Struct"
+		}]),
+		clean: jsonInputClean,
+		required: false
+	}),
+	additionalFields: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Additional Fields",
+		required: false,
+		comments: "Additional optional fields.",
+		inputs: {
+			kind,
+			skipInvalidRows,
+			ignoreUnknownValues,
+			templateSuffix
+		}
+	})
+};
+//#endregion
+//#region src/inputs/tables.ts
+const requirePartitionFilter = (0, _prismatic_io_spectral.input)({
+	label: "Require Partition Filter",
+	type: "boolean",
+	clean: _prismatic_io_spectral.util.types.toBool,
+	comments: "When true, queries over this table require a partition filter that can be used for partition elimination to be specified.",
+	required: false
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Num Bytes",
+	type: "string",
+	clean: cleanString,
+	comments: "Output only. The size of this table in logical bytes, excluding any data in the streaming buffer.",
+	example: "1234567890",
+	placeholder: "Enter number of bytes",
+	required: false
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Num Long Term Bytes",
+	type: "string",
+	clean: cleanString,
+	comments: "Output only. The number of logical bytes in the table that are considered 'long-term storage'.",
+	example: "9876543210",
+	placeholder: "Enter number of long-term bytes",
+	required: false
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Num Rows",
+	type: "string",
+	clean: cleanString,
+	comments: "Output only. The number of rows of data in this table, excluding any data in the streaming buffer.",
+	example: "1000000",
+	placeholder: "Enter number of rows",
+	required: false
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Type",
+	type: "string",
+	clean: cleanString,
+	comments: "Output only. Describes the table type. The following values are supported:\n TABLE: A normal BigQuery table.\nVIEW: A virtual table defined by a SQL query. \nEXTERNAL: A table that references data stored in an external storage system, such as Google Cloud Storage. \nMATERIALIZED_VIEW: A precomputed view defined by a SQL query. \nSNAPSHOT: An immutable BigQuery table that preserves the contents of a base table at a particular time. See additional information on table snapshots. \nThe default value is TABLE.",
+	example: "TABLE",
+	placeholder: "Enter table type",
+	required: false
+});
+const maxStaleness = (0, _prismatic_io_spectral.input)({
+	label: "Max Staleness",
+	type: "string",
+	clean: _prismatic_io_spectral.util.types.toString,
+	comments: "Optional. The maximum staleness of data that could be returned when the table (or stale MV) is queried. Staleness encoded as a string encoding of sql IntervalValue type.",
+	example: "INTERVAL 1 DAY",
+	placeholder: "Enter max staleness",
+	required: false
+});
+const view = (0, _prismatic_io_spectral.input)({
+	label: "View",
+	type: "string",
+	clean: cleanString,
+	comments: "Optional. Specifies the view that determines which table information is returned. By default, basic table information and storage statistics (STORAGE_STATS) are returned. One of TABLE_METADATA_VIEW_UNSPECIFIED / BASIC / STORAGE_STATS / FULL",
+	example: "FULL",
+	placeholder: "Enter view type",
+	required: false
+});
+const schema = (0, _prismatic_io_spectral.input)({
+	label: "Schema",
+	type: "code",
+	language: "json",
+	comments: "Optional. Describes the schema of this table.",
+	example: "Reference to the Google docs for this input. https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#tableschema",
+	clean: jsonInputClean,
+	required: false
+});
+const timePartitioning = (0, _prismatic_io_spectral.input)({
+	label: "Time Partitioning",
+	type: "code",
+	language: "json",
+	comments: "If specified, configures time-based partitioning for this table.",
+	example: JSON.stringify({
+		type: "string",
+		expirationMs: "string",
+		field: "string",
+		requirePartitionFilter: false
+	}),
+	clean: jsonInputClean,
+	required: false
+});
+const rangePartitioning = (0, _prismatic_io_spectral.input)({
+	label: "Range Partitioning",
+	type: "code",
+	language: "json",
+	comments: "If specified, configures range partitioning for this table.",
+	example: JSON.stringify({
+		field: "string",
+		range: {
+			start: "string",
+			end: "string",
+			interval: "string"
+		}
+	}),
+	clean: jsonInputClean,
+	required: false
+});
+const clustering = (0, _prismatic_io_spectral.input)({
+	label: "Clustering",
+	type: "code",
+	language: "json",
+	comments: "Clustering specification for the table. Must be specified with time-based partitioning, data in the table will be first partitioned and subsequently clustered.",
+	example: JSON.stringify({ fields: [
+		"string",
+		"string",
+		"string"
+	] }),
+	clean: jsonInputClean,
+	required: false
+});
+const tableReference = (0, _prismatic_io_spectral.input)({
+	label: "Table Reference",
+	type: "code",
+	language: "json",
+	comments: "Reference describing the ID of this routine.",
+	example: JSON.stringify({
+		projectId: "string",
+		datasetId: "string",
+		tableId: "string"
+	}),
+	clean: jsonInputClean,
+	required: true
+});
+const tableView = (0, _prismatic_io_spectral.input)({
+	label: "View",
+	type: "code",
+	language: "json",
+	comments: "Optional. The view definition.",
+	example: JSON.stringify({
+		query: "string",
+		userDefinedFunctionResources: [{
+			resourceUri: "string",
+			inlineCode: "string"
+		}],
+		useLegacySql: false
+	}),
+	clean: jsonInputClean,
+	required: false
+});
+const materializedView = (0, _prismatic_io_spectral.input)({
+	label: "Materialized View",
+	type: "code",
+	language: "json",
+	comments: "Optional. The materialized view definition.",
+	example: JSON.stringify({
+		refreshWatermark: "string",
+		lastRefreshStatus: {
+			reason: "string",
+			location: "string",
+			debugInfo: "string",
+			message: "string"
+		}
+	}),
+	clean: jsonInputClean,
+	required: false
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Materialized View Status",
+	type: "code",
+	language: "json",
+	comments: "Optional. The materialized view status.",
+	example: JSON.stringify({
+		refreshWatermark: "string",
+		lastRefreshStatus: {
+			reason: "string",
+			location: "string",
+			debugInfo: "string",
+			message: "string"
+		}
+	}),
+	clean: jsonInputClean,
+	required: false
+});
+const externalDataConfiguration = (0, _prismatic_io_spectral.input)({
+	label: "External Data Configuration",
+	type: "code",
+	language: "json",
+	comments: "Optional. Describes the data format, location, and other properties of a table stored outside of BigQuery. By defining these properties, the data source can then be queried as if it were a standard BigQuery table.",
+	example: "Reference to the Google docs for this input. https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#externaldataconfiguration",
+	clean: jsonInputClean,
+	required: false
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Streaming Buffer",
+	type: "code",
+	language: "json",
+	comments: "Output only. Contains information regarding this table's streaming buffer, if one is present. This field will be absent if the table is not being streamed to or if there is no data in the streaming buffer.",
+	example: JSON.stringify({
+		estimatedBytes: "string",
+		estimatedRows: "string",
+		oldestEntryTime: "string"
+	}),
+	clean: jsonInputClean,
+	required: false
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Snapshot Definition",
+	type: "code",
+	language: "json",
+	comments: "Output only. Contains information about the snapshot. This value is set via snapshot creation.",
+	example: JSON.stringify({
+		baseTableReference: {
+			projectId: "string",
+			datasetId: "string",
+			tableId: "string"
+		},
+		snapshotTime: "string"
+	}),
+	clean: jsonInputClean,
+	required: false
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Clone Definition",
+	type: "code",
+	language: "json",
+	comments: "Output only. Contains information about the clone. This value is set via the clone operation.",
+	example: JSON.stringify({
+		baseTableReference: {
+			projectId: "string",
+			datasetId: "string",
+			tableId: "string"
+		},
+		cloneTime: "string"
+	}),
+	clean: jsonInputClean,
+	required: false
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Table Constraints",
+	type: "code",
+	language: "json",
+	comments: "Optional. Tables Primary Key and Foreign Key information",
+	example: JSON.stringify({
+		primaryKey: { columns: ["string"] },
+		foreignKeys: [{
+			name: "string",
+			referencedTable: {
+				projectId: "string",
+				datasetId: "string",
+				tableId: "string"
+			},
+			columnReferences: [{
+				referencingColumn: "string",
+				referencedColumn: "string"
+			}]
+		}]
+	}),
+	clean: jsonInputClean,
+	required: false
+});
+const tableAdditionalFields = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Additional Fields",
+	required: false,
+	comments: "Additional optional fields.",
+	inputs: {
+		kind,
+		friendlyName,
+		description,
+		labels,
+		schema,
+		timePartitioning,
+		rangePartitioning,
+		clustering,
+		requirePartitionFilter,
+		expirationTime,
+		view: tableView,
+		materializedView,
+		externalDataConfiguration,
+		encryptionConfiguration,
+		defaultCollation,
+		defaultRoundingMode,
+		maxStaleness
+	}
+});
+const createTableInputs = {
+	connectionInput,
+	tableReference,
+	datasetId: (0, _prismatic_io_spectral.input)({
+		...datasetId,
+		required: true,
+		comments: "Dataset ID of the table to update."
+	}),
+	projectId: (0, _prismatic_io_spectral.input)({
+		...projectId,
+		required: true,
+		comments: "Project ID of the table to update."
+	}),
+	additionalFields: tableAdditionalFields
+};
+const deleteTableInputs = {
+	connectionInput,
+	datasetId: (0, _prismatic_io_spectral.input)({
+		...datasetId,
+		required: true,
+		comments: "Dataset ID of the table to delete."
+	}),
+	projectId: (0, _prismatic_io_spectral.input)({
+		...projectId,
+		required: true,
+		comments: "Project ID of the table to delete."
+	}),
+	tableId: (0, _prismatic_io_spectral.input)({
+		...tableId,
+		required: true,
+		comments: "Table ID of the table to delete."
+	})
+};
+const getTableInputs = {
+	connectionInput,
+	datasetId: (0, _prismatic_io_spectral.input)({
+		...datasetId,
+		required: true,
+		comments: "Dataset ID of the requested table."
+	}),
+	projectId: (0, _prismatic_io_spectral.input)({
+		...projectId,
+		required: true,
+		comments: "Project ID of the requested table."
+	}),
+	tableId: (0, _prismatic_io_spectral.input)({
+		...tableId,
+		required: true,
+		comments: "Table ID of the requested table."
+	}),
+	selectedFields,
+	view
+};
+const listTablesInputs = {
+	connectionInput,
+	projectId: (0, _prismatic_io_spectral.input)({
+		...projectId,
+		required: true,
+		comments: "Project ID of the tables to list."
+	}),
+	datasetId: (0, _prismatic_io_spectral.input)({
+		...datasetId,
+		required: true,
+		comments: "Dataset ID of the tables to list."
+	}),
+	fetchAll,
+	pagination: tableListPaginationFields
+};
+const patchTableInputs = {
+	connectionInput,
+	datasetId: (0, _prismatic_io_spectral.input)({
+		...datasetId,
+		required: true,
+		comments: "Dataset ID of the table to patch."
+	}),
+	projectId: (0, _prismatic_io_spectral.input)({
+		...projectId,
+		required: true,
+		comments: "Project ID of the table to patch."
+	}),
+	tableId: (0, _prismatic_io_spectral.input)({
+		...tableId,
+		required: true,
+		comments: "Table ID of the table to patch."
+	}),
+	tableReference,
+	additionalFields: tableAdditionalFields
+};
+const updateTableInputs = {
+	connectionInput,
+	datasetId: (0, _prismatic_io_spectral.input)({
+		...datasetId,
+		required: true,
+		comments: "Dataset ID of the table to update."
+	}),
+	projectId: (0, _prismatic_io_spectral.input)({
+		...projectId,
+		required: true,
+		comments: "Project ID of the table to update."
+	}),
+	tableId: (0, _prismatic_io_spectral.input)({
+		...tableId,
+		required: true,
+		comments: "Table ID of the table to update."
+	}),
+	tableReference,
+	additionalFields: tableAdditionalFields
+};
+//#endregion
+//#region src/actions/datasets/createDataset.ts
+const createDataset = (0, _prismatic_io_spectral.action)({
+	display: {
+		description: "Creates a new empty dataset.",
+		label: "Create Dataset"
+	},
+	inputs: createDatasetInputs,
+	perform: async (_context, { connectionInput, projectId, datasetReference, additionalFields = {} }) => {
+		const { data } = await createClient(connectionInput).datasets.insert({
+			projectId: projectId || void 0,
+			requestBody: {
+				kind: additionalFields.kind || void 0,
+				etag: additionalFields.etag || void 0,
+				id: additionalFields.id || void 0,
+				selfLink: additionalFields.selfLink || void 0,
+				datasetReference: datasetReference || void 0,
+				friendlyName: additionalFields.friendlyName || void 0,
+				description: additionalFields.description || void 0,
+				defaultTableExpirationMs: additionalFields.defaultTableExpirationMs || void 0,
+				defaultPartitionExpirationMs: additionalFields.defaultPartitionExpirationMs || void 0,
+				labels: additionalFields.labels || void 0,
+				access: additionalFields.access || void 0,
+				creationTime: additionalFields.creationTime || void 0,
+				lastModifiedTime: additionalFields.lastModifiedTime || void 0,
+				location: additionalFields.location || void 0,
+				defaultEncryptionConfiguration: additionalFields.defaultEncryptionConfiguration || void 0,
+				satisfiesPzs: additionalFields.satisfiesPzs,
+				isCaseInsensitive: additionalFields.isCaseInsensitive,
+				defaultCollation: additionalFields.defaultCollation || void 0,
+				defaultRoundingMode: additionalFields.defaultRoundingMode || void 0,
+				maxTimeTravelHours: additionalFields.maxTimeTravelHours || void 0,
+				tags: additionalFields.tags || void 0,
+				storageBillingModel: additionalFields.storageBillingModel || void 0
+			}
+		});
+		return { data };
+	}
+});
+//#endregion
+//#region src/actions/datasets/deleteDataset.ts
+const deleteDataset = (0, _prismatic_io_spectral.action)({
+	display: {
+		description: "Deletes the dataset specified by the datasetId value. Before you can delete a dataset, you must delete all its tables, either manually or by specifying deleteContents. Immediately after deletion, you can create another dataset with the same name.",
+		label: "Delete Dataset"
+	},
+	inputs: deleteDatasetInputs,
+	perform: async (_context, { connectionInput, projectId, datasetId }) => {
+		const { data } = await createClient(connectionInput).datasets.delete({
+			datasetId: datasetId || void 0,
+			projectId: projectId || void 0
+		});
+		return { data };
+	}
+});
+//#endregion
+//#region src/actions/datasets/getDataset.ts
+const getDataset = (0, _prismatic_io_spectral.action)({
+	display: {
+		description: "Returns the dataset specified by datasetID.",
+		label: "Get Dataset"
+	},
+	inputs: getDatasetInputs,
+	perform: async (_context, { connectionInput, projectId, datasetId }) => {
+		const { data } = await createClient(connectionInput).datasets.get({
+			datasetId: datasetId || void 0,
+			projectId: projectId || void 0
+		});
+		return { data };
+	}
+});
+//#endregion
+//#region src/utils/pagination.ts
+const MAX_PAGES = 100;
+const paginateResults = async (listFn, params, fetchAll, dataField) => {
+	if (!fetchAll) {
+		const { data } = await listFn(params);
+		return { data };
+	}
+	const allResults = [];
+	let pagesFetched = 0;
+	let currentPageToken;
+	const { pageToken: _pt, ...otherParams } = params;
+	let hasMore = true;
+	while (hasMore && pagesFetched < MAX_PAGES) {
+		const requestParams = { ...otherParams };
+		if (currentPageToken) requestParams.pageToken = currentPageToken;
+		const { data } = await listFn(requestParams);
+		pagesFetched++;
+		const results = data?.[dataField];
+		if (Array.isArray(results)) allResults.push(...results);
+		const nextToken = data?.nextPageToken || data?.pageToken;
+		if (nextToken) currentPageToken = nextToken;
+		else hasMore = false;
+	}
+	return { data: { [dataField]: allResults } };
+};
+//#endregion
+//#region src/actions/datasets/listDatasets.ts
+const listDatasets = (0, _prismatic_io_spectral.action)({
+	display: {
+		description: "Lists all datasets in the specified project to which the user has been granted the READER dataset role.",
+		label: "List Datasets"
+	},
+	inputs: listDatasetsInputs,
+	perform: async (_context, { connectionInput, projectId, all, filter, pagination = {}, fetchAll }) => {
+		const client = createClient(connectionInput);
+		return await paginateResults((params) => client.datasets.list(params), {
+			projectId: projectId || void 0,
+			pageToken: pagination.pageToken || void 0,
+			all,
+			filter: filter || void 0,
+			maxResults: pagination.maxResults || void 0
+		}, fetchAll, "datasets");
+	}
+});
+//#endregion
+//#region src/actions/datasets/index.ts
+var datasets_default = {
+	createDataset,
+	updateDataset: (0, _prismatic_io_spectral.action)({
+		display: {
+			description: "Updates information in an existing dataset. The update method replaces the entire dataset resource, whereas the patch method only replaces fields that are provided in the submitted dataset resource.",
+			label: "Update Dataset"
+		},
+		inputs: updateDatasetInputs,
+		perform: async (_context, { connectionInput, projectId, datasetId, datasetReference, additionalFields = {} }) => {
+			const { data } = await createClient(connectionInput).datasets.update({
+				projectId: projectId || void 0,
+				datasetId: datasetId || void 0,
+				requestBody: {
+					kind: additionalFields.kind || void 0,
+					etag: additionalFields.etag || void 0,
+					id: additionalFields.id || void 0,
+					selfLink: additionalFields.selfLink || void 0,
+					datasetReference: datasetReference || void 0,
+					friendlyName: additionalFields.friendlyName || void 0,
+					description: additionalFields.description || void 0,
+					defaultTableExpirationMs: additionalFields.defaultTableExpirationMs || void 0,
+					defaultPartitionExpirationMs: additionalFields.defaultPartitionExpirationMs || void 0,
+					labels: additionalFields.labels || void 0,
+					access: additionalFields.access || void 0,
+					creationTime: additionalFields.creationTime || void 0,
+					lastModifiedTime: additionalFields.lastModifiedTime || void 0,
+					location: additionalFields.location || void 0,
+					defaultEncryptionConfiguration: additionalFields.defaultEncryptionConfiguration || void 0,
+					satisfiesPzs: additionalFields.satisfiesPzs,
+					isCaseInsensitive: additionalFields.isCaseInsensitive,
+					defaultCollation: additionalFields.defaultCollation || void 0,
+					defaultRoundingMode: additionalFields.defaultRoundingMode || void 0,
+					maxTimeTravelHours: additionalFields.maxTimeTravelHours || void 0,
+					tags: additionalFields.tags || void 0,
+					storageBillingModel: additionalFields.storageBillingModel || void 0
+				}
+			});
+			return { data };
+		}
+	}),
+	getDataset,
+	listDatasets,
+	deleteDataset
+};
+//#endregion
+//#region src/actions/jobs/index.ts
+var jobs_default = {
+	cancelJob: (0, _prismatic_io_spectral.action)({
+		display: {
+			description: "Requests that a job be cancelled.",
+			label: "Cancel Job"
+		},
+		inputs: cancelJobInputs,
+		perform: async (_context, { connectionInput, projectId, jobId, location }) => {
+			const { data } = await createClient(connectionInput).jobs.cancel({
+				projectId: projectId || void 0,
+				jobId: jobId || void 0,
+				location: location || void 0
+			});
+			return { data };
+		}
+	}),
+	createJob: (0, _prismatic_io_spectral.action)({
+		display: {
+			description: "Starts a new asynchronous job.",
+			label: "Create Job"
+		},
+		inputs: createJobInputs,
+		perform: async (_context, { connectionInput, projectId, configuration, jobReference, additionalFields = {} }) => {
+			const { data } = await createClient(connectionInput).jobs.insert({
+				projectId: projectId || void 0,
+				requestBody: {
+					kind: additionalFields.kind || void 0,
+					etag: additionalFields.etag || void 0,
+					id: additionalFields.id || void 0,
+					selfLink: additionalFields.selfLink || void 0,
+					user_email: additionalFields.userEmail || void 0,
+					configuration: configuration || void 0,
+					jobReference: jobReference || void 0,
+					statistics: additionalFields.statistics || void 0,
+					status: additionalFields.status || void 0
+				}
+			});
+			return { data };
+		}
+	}),
+	deleteJob: (0, _prismatic_io_spectral.action)({
+		display: {
+			description: "Requests the deletion of the metadata of a job.",
+			label: "Delete Job"
+		},
+		inputs: deleteJobInputs,
+		perform: async (_context, { connectionInput, projectId, jobId, location }) => {
+			const { data } = await createClient(connectionInput).jobs.delete({
+				projectId: projectId || void 0,
+				jobId: jobId || void 0,
+				location: location || void 0
+			});
+			return { data };
+		}
+	}),
+	getJob: (0, _prismatic_io_spectral.action)({
+		display: {
+			description: "Returns information about a specific job.",
+			label: "Get Job"
+		},
+		inputs: getJobInputs,
+		perform: async (_context, { connectionInput, projectId, jobId, location }) => {
+			const { data } = await createClient(connectionInput).jobs.get({
+				projectId: projectId || void 0,
+				jobId: jobId || void 0,
+				location: location || void 0
+			});
+			return { data };
+		}
+	}),
+	getQueryJobResult: (0, _prismatic_io_spectral.action)({
+		display: {
+			description: "Receives the results of a query job.",
+			label: "Get Query Job Results"
+		},
+		inputs: getQueryJobResultInputs,
+		perform: async (_context, { connectionInput, projectId, jobId, timeoutMs, location, pagination = {} }) => {
+			const { data } = await createClient(connectionInput).jobs.getQueryResults({
+				projectId: projectId || void 0,
+				jobId: jobId || void 0,
+				startIndex: pagination.startIndex || void 0,
+				pageToken: pagination.pageToken || void 0,
+				maxResults: pagination.maxResults || void 0,
+				timeoutMs: timeoutMs || void 0,
+				location: location || void 0
+			});
+			return { data };
+		}
+	}),
+	listJobs: (0, _prismatic_io_spectral.action)({
+		display: {
+			description: "Lists all jobs that you started in the specified project.",
+			label: "List Jobs"
+		},
+		inputs: listJobsInputs,
+		perform: async (_context, { connectionInput, projectId, filters = {}, stateFilter, pagination = {}, fetchAll }) => {
+			const client = createClient(connectionInput);
+			return await paginateResults((params) => client.jobs.list(params), {
+				projectId: projectId || void 0,
+				pageToken: pagination.pageToken || void 0,
+				allUsers: filters.allUsers,
+				maxResults: pagination.maxResults || void 0,
+				minCreationTime: filters.minCreationTime || void 0,
+				maxCreationTime: filters.maxCreationTime || void 0,
+				projection: filters.projection || void 0,
+				stateFilter: stateFilter || void 0,
+				parentJobId: filters.parentJobId || void 0
+			}, fetchAll, "jobs");
+		}
+	}),
+	queryJob: (0, _prismatic_io_spectral.action)({
+		display: {
+			description: "Runs a BigQuery SQL query synchronously and returns query results if the query completes within a specified timeout.",
+			label: "Query Job"
+		},
+		inputs: queryJobInputs,
+		perform: async (_context, { connectionInput, projectId, query, maxResults, additionalFields = {} }) => {
+			const { data } = await createClient(connectionInput).jobs.query({
+				projectId: projectId || void 0,
+				requestBody: {
+					kind: additionalFields.kind || void 0,
+					query: query || void 0,
+					maxResults: maxResults || void 0,
+					defaultDataset: additionalFields.defaultDataset || void 0,
+					timeoutMs: additionalFields.timeoutMs || void 0,
+					dryRun: additionalFields.dryRun,
+					useQueryCache: additionalFields.useQueryCache,
+					useLegacySql: additionalFields.useLegacySql,
+					parameterMode: additionalFields.parameterMode || void 0,
+					queryParameters: additionalFields.queryParameters || void 0,
+					location: additionalFields.location || void 0,
+					connectionProperties: additionalFields.connectionProperties || void 0,
+					labels: additionalFields.labels || void 0,
+					maximumBytesBilled: additionalFields.maximumBytesBilled || void 0,
+					requestId: additionalFields.requestId || void 0,
+					createSession: additionalFields.createSession
+				}
+			});
+			return { data };
+		}
+	})
+};
+//#endregion
+//#region src/actions/misc/rawRequest.ts
+const { debugRequest: _, ...rawRequestInputs } = _prismatic_io_spectral_http.inputs;
+//#endregion
+//#region src/actions/misc/index.ts
+var misc_default = { rawRequest: (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Raw Request",
+		description: "Send raw HTTP request to Google Cloud BigQuery"
+	},
+	inputs: {
+		connection: connectionInput,
+		version,
+		...rawRequestInputs,
+		url: {
+			...rawRequestInputs.url,
+			comments: "Input the path only (/projects/{projectId}/jobs), The base URL is already included (https://bigquery.googleapis.com/bigquery/{version}). For example, to connect to https://bigquery.googleapis.com/bigquery/v2/projects/{projectId}/jobs, only /projects/{projectId}/jobs is entered in this field.",
+			example: "/projects/{projectId}/jobs"
+		}
+	},
+	perform: async (context, { connection, version, ...rawRequestInputs }) => {
+		const url = `https://bigquery.googleapis.com/bigquery/${version}`;
+		const token = _prismatic_io_spectral.util.types.toString(connection.token?.access_token);
+		const { data } = await (0, _prismatic_io_spectral_http.sendRawRequest)(url, {
+			...rawRequestInputs,
+			debugRequest: context.debug.enabled
+		}, { Authorization: `Bearer ${token}` });
+		return { data };
+	}
+}) };
+//#endregion
+//#region src/actions/models/deleteModel.ts
+const deleteModel = (0, _prismatic_io_spectral.action)({
+	display: {
+		description: "Deletes the model specified by model ID from the dataset.",
+		label: "Delete Model"
+	},
+	inputs: deleteModelInputs,
+	perform: async (_context, { connectionInput, projectId, datasetId, modelId }) => {
+		const { data } = await createClient(connectionInput).models.delete({
+			datasetId: datasetId || void 0,
+			projectId: projectId || void 0,
+			modelId: modelId || void 0
+		});
+		return { data };
+	}
+});
+//#endregion
+//#region src/actions/models/index.ts
+var models_default = {
+	getModel: (0, _prismatic_io_spectral.action)({
+		display: {
+			description: "Gets the specified model resource by model ID.",
+			label: "Get Model"
+		},
+		inputs: getModelInputs,
+		perform: async (_context, { connectionInput, projectId, datasetId, modelId }) => {
+			const { data } = await createClient(connectionInput).models.get({
+				datasetId: datasetId || void 0,
+				projectId: projectId || void 0,
+				modelId: modelId || void 0
+			});
+			return { data };
+		}
+	}),
+	listModels: (0, _prismatic_io_spectral.action)({
+		display: {
+			description: "Lists all models in the specified dataset. Requires the READER dataset role. After retrieving the list of models, you can get information about a particular model by calling the models.get method.",
+			label: "List Models"
+		},
+		inputs: listModelsInputs,
+		perform: async (_context, { connectionInput, projectId, datasetId, pagination = {}, fetchAll }) => {
+			const client = createClient(connectionInput);
+			return await paginateResults((params) => client.models.list(params), {
+				projectId: projectId || void 0,
+				datasetId: datasetId || void 0,
+				maxResults: pagination.maxResults || void 0,
+				pageToken: pagination.pageToken || void 0
+			}, fetchAll, "models");
+		}
+	}),
+	deleteModel,
+	updateModel: (0, _prismatic_io_spectral.action)({
+		display: {
+			description: "Patch specific fields in the specified model.",
+			label: "Update Model"
+		},
+		inputs: updateModelInputs,
+		perform: async (_context, { connectionInput, projectId, datasetId, modelId, modelReference, additionalFields = {} }) => {
+			const { data } = await createClient(connectionInput).models.patch({
+				projectId: projectId || void 0,
+				datasetId: datasetId || void 0,
+				modelId: modelId || void 0,
+				requestBody: {
+					etag: additionalFields.etag || void 0,
+					modelReference: modelReference || void 0,
+					creationTime: additionalFields.creationTime || void 0,
+					lastModifiedTime: additionalFields.lastModifiedTime || void 0,
+					description: additionalFields.description || void 0,
+					friendlyName: additionalFields.friendlyName || void 0,
+					labels: additionalFields.labels || void 0,
+					expirationTime: additionalFields.expirationTime || void 0,
+					location: additionalFields.location || void 0,
+					encryptionConfiguration: additionalFields.encryptionConfiguration || void 0,
+					modelType: additionalFields.modelType || void 0,
+					trainingRuns: additionalFields.trainingRuns || void 0,
+					featureColumns: additionalFields.featureColumns || void 0,
+					labelColumns: additionalFields.labelColumns || void 0,
+					hparamSearchSpaces: additionalFields.hparamSearchSpaces || void 0,
+					defaultTrialId: additionalFields.defaultTrialId || void 0,
+					hparamTrials: additionalFields.hparamTrials || void 0,
+					optimalTrialIds: additionalFields.optimalTrialIds || void 0
+				}
+			});
+			return { data };
+		}
+	})
+};
+//#endregion
+//#region src/actions/policies/getPolicy.ts
+const getPolicy = (0, _prismatic_io_spectral.action)({
+	display: {
+		description: "Gets the access control policy for a resource.",
+		label: "Get Policy"
+	},
+	inputs: getPolicyInputs,
+	perform: async (_context, { connectionInput, resource, options }) => {
+		const { data } = await createClient(connectionInput).tables.getIamPolicy({
+			resource,
+			requestBody: { options }
+		});
+		return { data };
+	}
+});
+//#endregion
+//#region src/actions/policies/index.ts
+var policies_default = {
+	setPolicy: (0, _prismatic_io_spectral.action)({
+		display: {
+			description: "Sets the access control policy on the specified resource.",
+			label: "Set Policy"
+		},
+		inputs: setPolicyInputs,
+		perform: async (_context, { connectionInput, resource, policy, updateMask }) => {
+			const { data } = await createClient(connectionInput).tables.setIamPolicy({
+				resource,
+				requestBody: {
+					policy,
+					updateMask
+				}
+			});
+			return { data };
+		}
+	}),
+	getPolicy
+};
+//#endregion
+//#region src/actions/projects/index.ts
+var projects_default = {
+	getServiceAccount: (0, _prismatic_io_spectral.action)({
+		display: {
+			description: "Receives the service account for a project used for interactions with Google Cloud KMS",
+			label: "Get Service Account"
+		},
+		inputs: getServiceAccountInputs,
+		perform: async (_context, { connectionInput, projectId }) => {
+			const { data } = await createClient(connectionInput).projects.getServiceAccount({ projectId: projectId || void 0 });
+			return { data };
+		}
+	}),
+	listProjects: (0, _prismatic_io_spectral.action)({
+		display: {
+			description: "Lists projects to which the user has been granted any project role.",
+			label: "List Projects"
+		},
+		inputs: listProjectsInputs,
+		perform: async (_context, { connectionInput, pagination = {}, fetchAll }) => {
+			const client = createClient(connectionInput);
+			return await paginateResults((params) => client.projects.list(params), {
+				maxResults: pagination.maxResults || void 0,
+				pageToken: pagination.pageToken || void 0
+			}, fetchAll, "projects");
+		}
+	})
+};
+//#endregion
+//#region src/actions/routines/createRoutine.ts
+const createRoutine = (0, _prismatic_io_spectral.action)({
+	display: {
+		description: "Creates a new routine in the dataset.",
+		label: "Create Routine"
+	},
+	inputs: createRoutineInputs,
+	perform: async (_context, { connectionInput, datasetId, projectId, routineReference, routineType, definitionBody, additionalFields = {} }) => {
+		const { data } = await createClient(connectionInput).routines.insert({
+			datasetId: datasetId || void 0,
+			projectId: projectId || void 0,
+			requestBody: {
+				routineReference: routineReference || void 0,
+				routineType: routineType || void 0,
+				definitionBody: definitionBody || void 0,
+				etag: additionalFields.etag || void 0,
+				arguments: additionalFields.argument || void 0,
+				returnTableType: additionalFields.returnTableType || void 0,
+				returnType: additionalFields.returnType || void 0,
+				creationTime: additionalFields.creationTime || void 0,
+				lastModifiedTime: additionalFields.lastModifiedTime || void 0,
+				language: additionalFields.language || void 0,
+				importedLibraries: additionalFields.importedLibraries || void 0,
+				description: additionalFields.description || void 0,
+				determinismLevel: additionalFields.determinismLevel || void 0,
+				remoteFunctionOptions: additionalFields.remoteFunctionOptions || void 0,
+				sparkOptions: additionalFields.sparkOptions || void 0
+			}
+		});
+		return { data };
+	}
+});
+//#endregion
+//#region src/actions/routines/deleteRoutine.ts
+const deleteRoutine = (0, _prismatic_io_spectral.action)({
+	display: {
+		description: "Deletes the routine specified by routine ID from the dataset.",
+		label: "Delete Routine"
+	},
+	inputs: deleteRoutineInputs,
+	perform: async (_context, { connectionInput, datasetId, projectId, routineId }) => {
+		const { data } = await createClient(connectionInput).routines.delete({
+			datasetId: datasetId || void 0,
+			projectId: projectId || void 0,
+			routineId: routineId || void 0
+		});
+		return { data };
+	}
+});
+//#endregion
+//#region src/actions/routines/getRoutine.ts
+const getRoutine = (0, _prismatic_io_spectral.action)({
+	display: {
+		description: "Gets the specified routine resource by routine ID.",
+		label: "Get Routine"
+	},
+	inputs: getRoutineInputs,
+	perform: async (_context, { connectionInput, datasetId, projectId, readMask, routineId }) => {
+		const { data } = await createClient(connectionInput).routines.get({
+			datasetId: datasetId || void 0,
+			projectId: projectId || void 0,
+			routineId: routineId || void 0,
+			readMask: readMask || void 0
+		});
+		return { data };
+	}
+});
+//#endregion
+//#region src/actions/routines/index.ts
+var routines_default = {
+	createRoutine,
+	listRoutines: (0, _prismatic_io_spectral.action)({
+		display: {
+			description: "Lists all routines in the specified dataset.",
+			label: "List Routines"
+		},
+		inputs: listRoutinesInputs,
+		perform: async (_context, { connectionInput, datasetId, projectId, filter, readMask, pagination = {}, fetchAll }) => {
+			const client = createClient(connectionInput);
+			return await paginateResults((params) => client.routines.list(params), {
+				datasetId: datasetId || void 0,
+				projectId: projectId || void 0,
+				filter: filter || void 0,
+				pageToken: pagination.pageToken || void 0,
+				maxResults: pagination.maxResults || void 0,
+				readMask: readMask || void 0
+			}, fetchAll, "routines");
+		}
+	}),
+	getRoutine,
+	updateRoutine: (0, _prismatic_io_spectral.action)({
+		display: {
+			description: "Updates information in an existing routine.",
+			label: "Update Routine"
+		},
+		inputs: updateRoutineInputs,
+		perform: async (_context, { connectionInput, datasetId, projectId, routineReference, routineType, definitionBody, additionalFields = {} }) => {
+			const { data } = await createClient(connectionInput).routines.update({
+				datasetId: datasetId || void 0,
+				projectId: projectId || void 0,
+				requestBody: {
+					routineReference: routineReference || void 0,
+					routineType: routineType || void 0,
+					definitionBody: definitionBody || void 0,
+					etag: additionalFields.etag || void 0,
+					arguments: additionalFields.argument || void 0,
+					returnTableType: additionalFields.returnTableType || void 0,
+					returnType: additionalFields.returnType || void 0,
+					creationTime: additionalFields.creationTime || void 0,
+					lastModifiedTime: additionalFields.lastModifiedTime || void 0,
+					language: additionalFields.language || void 0,
+					importedLibraries: additionalFields.importedLibraries || void 0,
+					description: additionalFields.description || void 0,
+					determinismLevel: additionalFields.determinismLevel || void 0,
+					remoteFunctionOptions: additionalFields.remoteFunctionOptions || void 0,
+					sparkOptions: additionalFields.sparkOptions || void 0
+				}
+			});
+			return { data };
+		}
+	}),
+	deleteRoutine
+};
+//#endregion
+//#region src/actions/tableData/index.ts
+var tableData_default = { tableDataInsertAll: (0, _prismatic_io_spectral.action)({
+	display: {
+		description: "Streams data into BigQuery one record at a time without needing to run a load job.",
+		label: "Table Data Insert All"
+	},
+	inputs: tableDataInsertAllInputs,
+	perform: async (_context, { connectionInput, datasetId, projectId, tableId, rows, additionalFields = {} }) => {
+		const { data } = await createClient(connectionInput).tabledata.insertAll({
+			datasetId: datasetId || void 0,
+			projectId: projectId || void 0,
+			tableId: tableId || void 0,
+			requestBody: {
+				kind: additionalFields.kind || void 0,
+				skipInvalidRows: additionalFields.skipInvalidRows,
+				ignoreUnknownValues: additionalFields.ignoreUnknownValues,
+				templateSuffix: additionalFields.templateSuffix || void 0,
+				rows: rows || void 0
+			}
+		});
+		return { data };
+	}
+}) };
+//#endregion
+//#region src/actions/tables/createTable.ts
+const createTable = (0, _prismatic_io_spectral.action)({
+	display: {
+		description: "Creates a new, empty table in the dataset.",
+		label: "Create Table"
+	},
+	inputs: createTableInputs,
+	perform: async (_context, { connectionInput, datasetId, projectId, tableReference, additionalFields = {} }) => {
+		const { data } = await createClient(connectionInput).tables.insert({
+			datasetId: datasetId || void 0,
+			projectId: projectId || void 0,
+			requestBody: {
+				kind: additionalFields.kind || void 0,
+				tableReference: tableReference || void 0,
+				friendlyName: additionalFields.friendlyName || void 0,
+				description: additionalFields.description || void 0,
+				labels: additionalFields.labels || void 0,
+				schema: additionalFields.schema || void 0,
+				timePartitioning: additionalFields.timePartitioning || void 0,
+				rangePartitioning: additionalFields.rangePartitioning || void 0,
+				clustering: additionalFields.clustering || void 0,
+				requirePartitionFilter: additionalFields.requirePartitionFilter,
+				expirationTime: additionalFields.expirationTime || void 0,
+				view: additionalFields.view || void 0,
+				materializedView: additionalFields.materializedView || void 0,
+				externalDataConfiguration: additionalFields.externalDataConfiguration || void 0,
+				encryptionConfiguration: additionalFields.encryptionConfiguration || void 0,
+				defaultCollation: additionalFields.defaultCollation || void 0,
+				defaultRoundingMode: additionalFields.defaultRoundingMode || void 0,
+				maxStaleness: additionalFields.maxStaleness || void 0
+			}
+		});
+		return { data };
+	}
+});
+//#endregion
+//#region src/actions/tables/deleteTable.ts
+const deleteTable = (0, _prismatic_io_spectral.action)({
+	display: {
+		description: "Deletes the table specified by table ID from the dataset.",
+		label: "Delete Table"
+	},
+	inputs: deleteTableInputs,
+	perform: async (_context, { connectionInput, datasetId, projectId, tableId }) => {
+		const { data } = await createClient(connectionInput).tables.delete({
+			datasetId,
+			projectId,
+			tableId
+		});
+		return { data };
+	}
+});
+//#endregion
+//#region src/actions/tables/getTable.ts
+const getTable = (0, _prismatic_io_spectral.action)({
+	display: {
+		description: "Gets the specified table resource by table ID.",
+		label: "Get Table"
+	},
+	inputs: getTableInputs,
+	perform: async (_context, { connectionInput, datasetId, projectId, tableId, selectedFields, view }) => {
+		const { data } = await createClient(connectionInput).tables.get({
+			datasetId,
+			projectId,
+			tableId,
+			selectedFields: selectedFields || void 0,
+			view: view || void 0
+		});
+		return { data };
+	}
+});
+//#endregion
+//#region src/actions/tables/listTables.ts
+const listTables = (0, _prismatic_io_spectral.action)({
+	display: {
+		description: "Lists all tables in the specified dataset.",
+		label: "List Tables"
+	},
+	inputs: listTablesInputs,
+	perform: async (_context, { connectionInput, datasetId, projectId, pagination = {}, fetchAll }) => {
+		const client = createClient(connectionInput);
+		return await paginateResults((params) => client.tables.list(params), {
+			datasetId,
+			projectId,
+			...pagination.maxResults && { maxResults: _prismatic_io_spectral.util.types.toNumber(pagination.maxResults) },
+			...pagination.pageToken && { pageToken: pagination.pageToken }
+		}, fetchAll, "tables");
+	}
+});
+//#endregion
+//#region src/actions/tables/patchTable.ts
+const patchTable = (0, _prismatic_io_spectral.action)({
+	display: {
+		description: "Patch information in an existing table.",
+		label: "Patch Table"
+	},
+	inputs: patchTableInputs,
+	perform: async (_context, { connectionInput, datasetId, projectId, tableId, tableReference, additionalFields = {} }) => {
+		const { data } = await createClient(connectionInput).tables.patch({
+			datasetId,
+			projectId,
+			tableId,
+			requestBody: {
+				kind: additionalFields.kind || void 0,
+				tableReference: tableReference || void 0,
+				friendlyName: additionalFields.friendlyName || void 0,
+				description: additionalFields.description || void 0,
+				labels: additionalFields.labels || void 0,
+				schema: additionalFields.schema || void 0,
+				timePartitioning: additionalFields.timePartitioning || void 0,
+				rangePartitioning: additionalFields.rangePartitioning || void 0,
+				clustering: additionalFields.clustering || void 0,
+				requirePartitionFilter: additionalFields.requirePartitionFilter,
+				expirationTime: additionalFields.expirationTime || void 0,
+				view: additionalFields.view || void 0,
+				materializedView: additionalFields.materializedView || void 0,
+				externalDataConfiguration: additionalFields.externalDataConfiguration || void 0,
+				encryptionConfiguration: additionalFields.encryptionConfiguration || void 0,
+				defaultCollation: additionalFields.defaultCollation || void 0,
+				defaultRoundingMode: additionalFields.defaultRoundingMode || void 0,
+				maxStaleness: additionalFields.maxStaleness || void 0
+			}
+		});
+		return { data };
+	}
+});
+//#endregion
+//#region src/actions/tables/index.ts
+var tables_default = {
+	createTable,
+	listTables,
+	getTable,
+	updateTable: (0, _prismatic_io_spectral.action)({
+		display: {
+			description: "Updates information in an existing table.",
+			label: "Update Table"
+		},
+		inputs: updateTableInputs,
+		perform: async (_context, { connectionInput, datasetId, projectId, tableId, tableReference, additionalFields = {} }) => {
+			const { data } = await createClient(connectionInput).tables.update({
+				datasetId,
+				projectId,
+				tableId,
+				requestBody: {
+					kind: additionalFields.kind || void 0,
+					tableReference: tableReference || void 0,
+					friendlyName: additionalFields.friendlyName || void 0,
+					description: additionalFields.description || void 0,
+					labels: additionalFields.labels || void 0,
+					schema: additionalFields.schema || void 0,
+					timePartitioning: additionalFields.timePartitioning || void 0,
+					rangePartitioning: additionalFields.rangePartitioning || void 0,
+					clustering: additionalFields.clustering || void 0,
+					requirePartitionFilter: additionalFields.requirePartitionFilter,
+					expirationTime: additionalFields.expirationTime || void 0,
+					view: additionalFields.view || void 0,
+					materializedView: additionalFields.materializedView || void 0,
+					externalDataConfiguration: additionalFields.externalDataConfiguration || void 0,
+					encryptionConfiguration: additionalFields.encryptionConfiguration || void 0,
+					defaultCollation: additionalFields.defaultCollation || void 0,
+					defaultRoundingMode: additionalFields.defaultRoundingMode || void 0,
+					maxStaleness: additionalFields.maxStaleness || void 0
+				}
+			});
+			return { data };
+		}
+	}),
+	deleteTable,
+	patchTable
+};
+//#endregion
+//#region src/actions/index.ts
+var actions_default = {
+	...datasets_default,
+	...jobs_default,
+	...misc_default,
+	...models_default,
+	...policies_default,
+	...projects_default,
+	...routines_default,
+	...tableData_default,
+	...tables_default
+};
+//#endregion
+//#region src/datasources/index.ts
+var datasources_default = {
+	projectsNames: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Project",
+			description: "A picklist of projects in your Google Cloud account."
+		},
+		inputs: { connection: connectionInput },
+		perform: async (_context, { connection }) => {
+			const { data } = await createClient(connection).projects.list();
+			if (data.projects) return { result: data.projects?.map((project) => ({
+				label: project?.friendlyName || project?.projectReference?.projectId || project.id,
+				key: project.id ? project.id.toString() : ""
+			})) };
+			return Promise.resolve({ result: [] });
+		},
+		dataSourceType: "picklist",
+		examplePayload: { result: [{
+			label: "John Locke",
+			key: "650"
+		}, {
+			label: "John Doe",
+			key: "47012"
+		}] }
+	}),
+	selectDataset: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Dataset",
+			description: "A picklist of datasets in the specified project."
+		},
+		inputs: {
+			connection: connectionInput,
+			projectId: {
+				...projectId,
+				dataSource: void 0
+			}
+		},
+		perform: async (_context, { connection, projectId }) => {
+			const { data } = await createClient(connection).datasets.list({ projectId: projectId || void 0 });
+			if (data.datasets) return { result: data.datasets.map((dataset) => ({
+				label: dataset?.friendlyName || dataset?.datasetReference?.datasetId || dataset.id,
+				key: dataset.id ? dataset.id.toString() : ""
+			})).sort((a, b) => (a.label ?? "") < (b.label ?? "") ? -1 : 1) };
+			return Promise.resolve({ result: [] });
+		},
+		dataSourceType: "picklist",
+		examplePayload: { result: [{
+			label: "Analytics Dataset",
+			key: "my-project:analytics_dataset"
+		}, {
+			label: "Sales Dataset",
+			key: "my-project:sales_dataset"
+		}] }
+	}),
+	selectJob: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Job",
+			description: "A picklist of jobs in the specified project."
+		},
+		inputs: {
+			connection: connectionInput,
+			projectId: {
+				...projectId,
+				dataSource: void 0
+			}
+		},
+		perform: async (_context, { connection, projectId }) => {
+			const { data } = await createClient(connection).jobs.list({ projectId: projectId || void 0 });
+			if (data.jobs) return { result: data.jobs.map((job) => ({
+				label: job?.jobReference?.jobId ? `${job.jobReference.jobId} (${job?.status?.state || "Unknown"})` : job?.id || "Unknown Job",
+				key: job?.jobReference?.jobId ? job.jobReference.jobId.toString() : ""
+			})).sort((a, b) => (a.label ?? "") < (b.label ?? "") ? -1 : 1) };
+			return Promise.resolve({ result: [] });
+		},
+		dataSourceType: "picklist",
+		examplePayload: { result: [{
+			label: "job_abc123 (DONE)",
+			key: "job_abc123"
+		}, {
+			label: "job_xyz789 (RUNNING)",
+			key: "job_xyz789"
+		}] }
+	}),
+	selectModel: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Model",
+			description: "A picklist of models in the specified dataset."
+		},
+		inputs: {
+			connection: connectionInput,
+			projectId: {
+				...projectId,
+				dataSource: void 0
+			},
+			datasetId: {
+				...datasetId,
+				dataSource: void 0
+			}
+		},
+		perform: async (_context, { connection, projectId, datasetId }) => {
+			const { data } = await createClient(connection).models.list({
+				projectId: projectId || void 0,
+				datasetId: datasetId || void 0
+			});
+			if (data.models) return { result: data.models.map((model) => ({
+				label: model?.friendlyName || model?.modelReference?.modelId || model?.modelType || "Unknown Model",
+				key: model?.modelReference?.modelId ? model.modelReference.modelId.toString() : ""
+			})).sort((a, b) => (a.label ?? "") < (b.label ?? "") ? -1 : 1) };
+			return Promise.resolve({ result: [] });
+		},
+		dataSourceType: "picklist",
+		examplePayload: { result: [{
+			label: "Prediction Model",
+			key: "prediction_model"
+		}, {
+			label: "Recommendation Model",
+			key: "recommendation_model"
+		}] }
+	}),
+	selectRoutine: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Routine",
+			description: "A picklist of routines in the specified dataset."
+		},
+		inputs: {
+			connection: connectionInput,
+			projectId: {
+				...projectId,
+				dataSource: void 0
+			},
+			datasetId: {
+				...datasetId,
+				dataSource: void 0
+			}
+		},
+		perform: async (_context, { connection, projectId, datasetId }) => {
+			const { data } = await createClient(connection).routines.list({
+				projectId: projectId || void 0,
+				datasetId: datasetId || void 0
+			});
+			if (data.routines) return { result: data.routines.map((routine) => ({
+				label: routine?.routineReference?.routineId || routine?.routineType || "Unknown Routine",
+				key: routine?.routineReference?.routineId ? routine.routineReference.routineId.toString() : ""
+			})).sort((a, b) => (a.label ?? "") < (b.label ?? "") ? -1 : 1) };
+			return Promise.resolve({ result: [] });
+		},
+		dataSourceType: "picklist",
+		examplePayload: { result: [{
+			label: "calculate_totals",
+			key: "calculate_totals"
+		}, {
+			label: "transform_data",
+			key: "transform_data"
+		}] }
+	}),
+	tablesNames: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Table",
+			description: "A picklist of tables in the specified dataset."
+		},
+		inputs: {
+			connection: connectionInput,
+			projectId: {
+				...projectId,
+				dataSource: void 0
+			},
+			datasetId: {
+				...datasetId,
+				dataSource: void 0
+			}
+		},
+		perform: async (_context, { connection, projectId, datasetId }) => {
+			const { data } = await createClient(connection).tables.list({
+				projectId: projectId || void 0,
+				datasetId: datasetId || void 0
+			});
+			if (data.tables) return { result: data.tables?.map((table) => ({
+				label: table?.friendlyName || table?.tableReference?.tableId || table.id,
+				key: table.id ? table.id.toString() : ""
+			})) };
+			return Promise.resolve({ result: [] });
+		},
+		dataSourceType: "picklist",
+		examplePayload: { result: [{
+			label: "John Locke",
+			key: "650"
+		}, {
+			label: "John Doe",
+			key: "47012"
+		}] }
+	})
+};
+//#endregion
+//#region src/examplePayloads.ts
+const pollChangesExamplePayload = {
+	payload: {
+		headers: {},
+		queryParameters: {},
+		rawBody: {
+			data: "",
+			contentType: "application/json"
+		},
+		body: { data: { created: [{
+			kind: "bigquery#job",
+			id: "my-project:US.job_abc123def456",
+			jobReference: {
+				projectId: "my-project",
+				jobId: "job_abc123def456",
+				location: "US"
+			},
+			status: { state: "DONE" },
+			statistics: {
+				creationTime: "1640995200000",
+				startTime: "1640995205000",
+				endTime: "1640995210000"
+			},
+			user_email: "user@example.com"
+		}] } },
+		pathFragment: "",
+		webhookUrls: { "Polling Flow": "https://hooks.example.com/trigger/EXAMPLE" },
+		webhookApiKeys: { "Polling Flow": ["example-api-key"] },
+		invokeUrl: "https://hooks.example.com/trigger/EXAMPLE",
+		executionId: "SW5zdGFuY2VFeGVjdXRpb246MTIzNDU=",
+		customer: {
+			id: "Q3VzdG9tZXI6MTIzNDU=",
+			externalId: "example-customer-external-id",
+			name: "Example Customer"
+		},
+		instance: {
+			id: "SW5zdGFuY2U6MTIzNDU=",
+			name: "Example Instance"
+		},
+		user: {
+			id: "VXNlcjoxMjM0NQ==",
+			externalId: "example-user-external-id",
+			name: "Example User",
+			email: "user@example.com"
+		}
+	},
+	polledNoChanges: false
+};
+//#endregion
+//#region src/utils/polling.ts
+const fetchJobsSince = async (client, projectId, minCreationTime, maxCreationTime) => {
+	const jobs = [];
+	let pageToken;
+	let page = 0;
+	while (page < 100) {
+		page += 1;
+		const { data } = await client.jobs.list({
+			projectId,
+			allUsers: true,
+			minCreationTime: String(minCreationTime),
+			maxCreationTime: maxCreationTime !== void 0 ? String(maxCreationTime) : void 0,
+			pageToken
+		});
+		jobs.push(...data?.jobs ?? []);
+		const nextToken = data?.nextPageToken ?? void 0;
+		if (!nextToken) return {
+			jobs,
+			truncated: false
+		};
+		pageToken = nextToken;
+	}
+	return {
+		jobs,
+		truncated: true
+	};
+};
+const getJobCreationMs = (job) => {
+	const raw = job.statistics?.creationTime;
+	if (typeof raw !== "string") return null;
+	const ms = Number(raw);
+	return Number.isFinite(ms) ? ms : null;
+};
+const resolvePollingRecordChanges = (data) => {
+	return [...((data ?? { created: [] }).created ?? []).map((record) => ({
+		changeType: "created",
+		record
+	}))];
+};
+//#endregion
+//#region src/triggers/pollChangesTrigger.ts
+const pollChangesTrigger = (0, _prismatic_io_spectral.pollingTrigger)({
+	display: {
+		label: "New Jobs",
+		description: "Retrieves existing and ongoing jobs in a specified BigQuery project. Load history once, check for new jobs on a schedule, or both."
+	},
+	inputs: pollChangesInputs,
+	examplePayload: pollChangesExamplePayload,
+	triggerResolverSupport: "valid",
+	batchConfig: { batchSize: 50 },
+	triggerResolver: { resolveItems: (_context, { payload }) => resolvePollingRecordChanges(payload.body.data) },
+	perform: async (context, payload, params) => {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const state = context.polling.getState();
+		const lookBackIso = params.lookBackDate;
+		const seedTime = lookBackIso && lookBackIso !== "" ? new Date(lookBackIso).toISOString() : now;
+		const lastPolledAt = state?.lastPolledAt ?? seedTime;
+		const { jobs, truncated } = await fetchJobsSince(createClient(params.connectionInput), params.projectId, new Date(lastPolledAt).getTime(), state?.drainUntil);
+		if (truncated) {
+			const oldestMs = jobs.reduce((min, job) => {
+				const ms = getJobCreationMs(job);
+				return ms !== null && (min === null || ms < min) ? ms : min;
+			}, null);
+			context.polling.setState({
+				lastPolledAt,
+				drainUntil: oldestMs ?? state?.drainUntil,
+				highWater: state?.highWater ?? now
+			});
+			context.logger.warn(`BigQuery jobs poll truncated at the page cap. Draining the backlog older than ${oldestMs} on the next poll.`);
+		} else context.polling.setState({ lastPolledAt: state?.highWater ?? now });
+		if (context.debug.enabled) context.logger.debug(`Polled BigQuery jobs: ${jobs.length} fetched, truncated=${truncated}`);
+		return {
+			payload: {
+				...payload,
+				body: { data: { created: jobs } }
+			},
+			polledNoChanges: jobs.length === 0
+		};
+	}
+});
+var triggers_default = {
+	myTrigger: (0, _prismatic_io_spectral.trigger)({
+		display: {
+			label: "PubSub Notification",
+			description: "Receive PubSub notifications from Google Cloud when events occur."
+		},
+		perform: async (_context, payload) => {
+			return Promise.resolve({
+				payload,
+				response: {
+					statusCode: 200,
+					contentType: "application/json"
+				}
+			});
+		},
+		inputs: {},
+		synchronousResponseSupport: "valid",
+		scheduleSupport: "valid"
+	}),
+	pollChangesTrigger
+};
+//#endregion
+//#region src/index.ts
+var src_default = (0, _prismatic_io_spectral.component)({
+	key: "google-cloud-bigquery",
+	public: true,
+	documentationUrl: "https://prismatic.io/docs/components/google-cloud-bigquery/",
+	display: {
+		label: "Google Cloud BigQuery",
+		description: "BigQuery is Google Cloud's fully managed, petabyte-scale, and cost-effective analytics data warehouse that lets you run analytics over vast amounts of data in near real time.",
+		iconPath: "icon.png",
+		category: "Application Connectors"
+	},
+	actions: actions_default,
+	triggers: triggers_default,
+	connections: connections_default,
+	dataSources: datasources_default
+});
+//#endregion
+//#region npm-dist/.entry.ts
+var _entry_default = (0, _prismatic_io_spectral.callableComponent)(src_default);
+//#endregion
+module.exports = _entry_default;