@metabase/client 0.0.0-stage → 0.1.1

package/dist/resources/transform-python.js

@@ -0,0 +1,57 @@
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { PythonLibrary, PythonTestRunError, PythonTestRunOutput, pythonTestRunBody } from "../domain/transform-python.js";
+import { z } from "zod";
+//#region src/resources/transform-python.ts
+const PythonApiTestRun = z.union([z.object({
+	logs: z.string(),
+	output: PythonTestRunOutput
+}).transform(({ logs, output }) => ({
+	outcome: "succeeded",
+	logs,
+	output
+})), z.object({
+	logs: z.string(),
+	error: PythonTestRunError
+}).transform(({ logs, error }) => ({
+	outcome: "failed",
+	logs,
+	error
+}))]);
+function libraryPath(path) {
+	return `/api/ee/transforms-python/library/${encodeURIComponent(path)}`;
+}
+function transformPythonResource(transport) {
+	const { explain } = explainer(transport, "transformPython");
+	/** Get the Python library at a path, the user module every Python transform can import. */
+	async function getLibrary(path, options = {}) {
+		return transport.requestParsed(PythonLibrary, libraryPath(path), { ...options });
+	}
+	/** Replace the source of the Python library at a path, creating the library when none exists. */
+	async function updateLibrary(path, params, options = {}) {
+		return transport.requestParsed(PythonLibrary, libraryPath(path), {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/**
+	* Evaluate an ad-hoc Python transform on a sample of its source tables, without a target table.
+	* Meant for early feedback on short runs: input, output and time limits apply, and the sample
+	* sizes are capped at 100 rows.
+	*/
+	async function testRun(params, options = {}) {
+		const { features } = await transport.server(options);
+		return transport.requestParsed(PythonApiTestRun, "/api/ee/transforms-python/test-run", {
+			...options,
+			method: "POST",
+			body: pythonTestRunBody(params, features)
+		});
+	}
+	return {
+		getLibrary: explain("getLibrary", getLibrary),
+		updateLibrary: explain("updateLibrary", updateLibrary),
+		testRun: explain("testRun", testRun)
+	};
+}
+//#endregion
+export { transformPythonResource };

package/dist/resources/transform-tag.d.ts

@@ -0,0 +1,35 @@
+import { f as RequestOptions, h as Transport } from "../transport-BsXqRujn.js";
+import { t as ListResult } from "../list-BT_bBm9Z.js";
+//#region src/resources/transform-tag.d.ts
+declare function transformTagResource(transport: Transport): {
+  list: (options?: RequestOptions | undefined) => Promise<ListResult<{
+    [x: string]: unknown;
+    id: number;
+    name: string;
+    entity_id: string | null;
+    built_in_type: string | null;
+  }>>;
+  create: (params: {
+    [x: string]: unknown;
+    name: string;
+  }, options?: RequestOptions | undefined) => Promise<{
+    [x: string]: unknown;
+    id: number;
+    name: string;
+    entity_id: string | null;
+    built_in_type: string | null;
+  }>;
+  update: (id: number, params: {
+    [x: string]: unknown;
+    name: string;
+  }, options?: RequestOptions | undefined) => Promise<{
+    [x: string]: unknown;
+    id: number;
+    name: string;
+    entity_id: string | null;
+    built_in_type: string | null;
+  }>;
+  delete: (id: number, options?: RequestOptions | undefined) => Promise<void>;
+};
+//#endregion
+export { transformTagResource };

package/dist/resources/transform-tag.js

@@ -0,0 +1,47 @@
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { TransformTag } from "../domain/transform-tag.js";
+import { z } from "zod";
+//#region src/resources/transform-tag.ts
+const TransformTagApiList = z.array(TransformTag);
+function transformTagResource(transport) {
+	const { explain } = explainer(transport, "transformTag");
+	/** List every transform tag the caller can see, built-in tags included. */
+	async function list(options = {}) {
+		return {
+			data: await transport.requestParsed(TransformTagApiList, "/api/transform-tag", { ...options }),
+			total: null
+		};
+	}
+	/** Create a transform tag, the label a transform job matches transforms on. */
+	async function create(params, options = {}) {
+		return transport.requestParsed(TransformTag, "/api/transform-tag", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/** Rename a transform tag by id. */
+	async function update(id, params, options = {}) {
+		return transport.requestParsed(TransformTag, `/api/transform-tag/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** Delete a transform tag by id, detaching it from every transform and job carrying it. */
+	async function remove(id, options = {}) {
+		await transport.requestRaw(`/api/transform-tag/${id}`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	return {
+		list: explain("list", list),
+		create: explain("create", create),
+		update: explain("update", update),
+		delete: explain("delete", remove)
+	};
+}
+//#endregion
+export { transformTagResource };

package/dist/resources/transform-test.d.ts

@@ -0,0 +1,2 @@
+import { n as transformTestResource, t as TransformTestListParams } from "../transform-test-CR_i54IV.js";
+export { TransformTestListParams, transformTestResource };

package/dist/resources/transform-test.js

@@ -0,0 +1,75 @@
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { TransformTest, TransformTestRunResult } from "../domain/transform-test.js";
+import { z } from "zod";
+//#region src/resources/transform-test.ts
+const TransformTestApiList = z.array(TransformTest);
+function transformTestResource(transport) {
+	const { explain } = explainer(transport, "transformTest");
+	/** List the transform tests, optionally only those of one transform. */
+	async function list(params = {}, options = {}) {
+		return {
+			data: await transport.requestParsed(TransformTestApiList, "/api/ee/transform-test", {
+				...options,
+				query: { "transform-id": params["transform-id"] }
+			}),
+			total: null
+		};
+	}
+	/** Get a transform test by id. */
+	async function get(id, options = {}) {
+		return transport.requestParsed(TransformTest, `/api/ee/transform-test/${id}`, { ...options });
+	}
+	/**
+	* Create a transform test. The server validates the inputs and expectations against the
+	* transform before saving, and refuses with an `HttpError` whose `errorCode` is a
+	* `TransformTestRefusalCode` when they cannot run.
+	*/
+	async function create(params, options = {}) {
+		return transport.requestParsed(TransformTest, "/api/ee/transform-test", {
+			...options,
+			method: "POST",
+			body: params
+		});
+	}
+	/**
+	* Update a transform test by id, leaving omitted fields unchanged. A body that touches the
+	* transform, inputs or expectations is validated as on create, with the same refusal.
+	*/
+	async function update(id, params, options = {}) {
+		return transport.requestParsed(TransformTest, `/api/ee/transform-test/${id}`, {
+			...options,
+			method: "PUT",
+			body: params
+		});
+	}
+	/** Delete a transform test by id. */
+	async function remove(id, options = {}) {
+		await transport.requestRaw(`/api/ee/transform-test/${id}`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	/**
+	* Run a transform test by id. A result means the run happened: `status` is `passed` or `failed`
+	* and every expectation reports what it found, one that could not be evaluated as its own
+	* `error`. An `HttpError` whose `errorCode` is a `TransformTestRefusalCode` means the run was
+	* refused and nothing meaningful ran.
+	*/
+	async function run(id, options = {}) {
+		return transport.requestParsed(TransformTestRunResult, `/api/ee/transform-test/${id}/run`, {
+			...options,
+			method: "POST"
+		});
+	}
+	return {
+		list: explain("list", list),
+		get: explain("get", get),
+		create: explain("create", create),
+		update: explain("update", update),
+		delete: explain("delete", remove),
+		run: explain("run", run)
+	};
+}
+//#endregion
+export { transformTestResource };

package/dist/resources/transform.d.ts

@@ -0,0 +1,2 @@
+import { a as TransformRunSummaryPageParams, i as TransformRunParams, n as TransformRunPageOptions, o as transformResource, r as TransformRunPageParams, t as TransformDagParams } from "../transform-WASQAXeA.js";
+export { TransformDagParams, TransformRunPageOptions, TransformRunPageParams, TransformRunParams, TransformRunSummaryPageParams, transformResource };

package/dist/resources/transform.js

@@ -0,0 +1,227 @@
+import { TimeoutError } from "../errors.js";
+import { paginatePages } from "../paginate.js";
+import { t as explainer } from "../refusal-B9aeHMc9.js";
+import { pollUntil } from "../poll.js";
+import { TransformDagRunResult, TransformDagTransform, TransformRun, TransformRunSummary, isTransformRunFailed, isTransformRunTerminal, transformDetailSchema, transformRowSchema, transformSourceBody } from "../domain/transform.js";
+import { z } from "zod";
+//#region src/resources/transform.ts
+function transformListSchema(features) {
+	return z.array(transformRowSchema(features));
+}
+const TransformRunKickoff = z.object({
+	message: z.string(),
+	run_id: z.number().int().positive().nullable()
+});
+const TransformDagTransformList = z.array(TransformDagTransform);
+function transformResource(transport) {
+	const { explain, explainWalk } = explainer(transport, "transform");
+	async function requestTransformList(path, opts) {
+		const { features } = await transport.server(opts);
+		return {
+			data: await transport.requestParsed(transformListSchema(features), path, opts),
+			total: null
+		};
+	}
+	async function requestTransform(path, opts) {
+		const { features } = await transport.server(opts);
+		return transport.requestParsed(transformRowSchema(features), path, opts);
+	}
+	/** List every transform the caller can see. */
+	async function list(options = {}) {
+		return requestTransformList("/api/transform", { ...options });
+	}
+	/** Get one transform by id. */
+	async function get(id, options = {}) {
+		const { features } = await transport.server(options);
+		return transport.requestParsed(transformDetailSchema(features), `/api/transform/${id}`, { ...options });
+	}
+	async function writeBody(params, options) {
+		if (params.source === void 0) return params;
+		const { features } = await transport.server(options);
+		return {
+			...params,
+			source: transformSourceBody(params.source, features)
+		};
+	}
+	/** Create a transform — a query plus the warehouse table it writes — from a full body. */
+	async function create(params, options = {}) {
+		const body = await writeBody(params, options);
+		return requestTransform("/api/transform", {
+			...options,
+			method: "POST",
+			body
+		});
+	}
+	/** Update a transform by id, patching only the fields the body carries. */
+	async function update(id, params, options = {}) {
+		const body = await writeBody(params, options);
+		return requestTransform(`/api/transform/${id}`, {
+			...options,
+			method: "PUT",
+			body
+		});
+	}
+	/** Delete a transform by id, leaving any table it already materialized in place. */
+	async function remove(id, options = {}) {
+		await transport.requestRaw(`/api/transform/${id}`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	/** Drop a transform's materialized output table, keeping the transform definition. */
+	async function deleteTable(id, options = {}) {
+		await transport.requestRaw(`/api/transform/${id}/table`, {
+			...options,
+			method: "DELETE",
+			expectContentType: "binary"
+		});
+	}
+	/** List the upstream transforms a transform depends on. */
+	async function dependencies(id, options = {}) {
+		return requestTransformList(`/api/transform/${id}/dependencies`, { ...options });
+	}
+	/** Request cancellation of a transform's current run. */
+	async function cancel(id, options = {}) {
+		await transport.requestRaw(`/api/transform/${id}/cancel`, {
+			...options,
+			method: "POST",
+			expectContentType: "binary"
+		});
+	}
+	/** Get one transform run by run id — not by the id of the transform that produced it. */
+	async function getRun(runId, options = {}) {
+		return transport.requestParsed(TransformRun, `/api/transform/run/${runId}`, { ...options });
+	}
+	/** Walk the run history, newest first, optionally narrowed to a single transform. */
+	async function* runPages(params = {}, options = {}) {
+		yield* paginatePages(transport, "/api/transform/run", TransformRun, {
+			query: { "transform-ids": params["transform-ids"] },
+			...options.offset !== void 0 && { offset: options.offset },
+			...options.max !== void 0 && { max: options.max },
+			...options.pageSize !== void 0 && { pageSize: options.pageSize },
+			...options.signal !== void 0 && { signal: options.signal }
+		});
+	}
+	/**
+	* Walk the unified run history, newest first by default: every row is a root run — a job run, a
+	* DAG reprocess run, or a standalone transform run — and never a member run of a job or DAG.
+	*/
+	async function* runSummaryPages(params = {}, options = {}) {
+		yield* paginatePages(transport, "/api/transform/runs", TransformRunSummary, {
+			query: {
+				types: params.types,
+				statuses: params.statuses,
+				"run-methods": params["run-methods"],
+				"start-time": params["start-time"],
+				"end-time": params["end-time"],
+				"transform-ids": params["transform-ids"],
+				"sort-column": params["sort-column"],
+				"sort-direction": params["sort-direction"]
+			},
+			...options.offset !== void 0 && { offset: options.offset },
+			...options.max !== void 0 && { max: options.max },
+			...options.pageSize !== void 0 && { pageSize: options.pageSize },
+			...options.signal !== void 0 && { signal: options.signal }
+		});
+	}
+	/**
+	* Reset the stored checkpoint of an incremental transform, so its next run reprocesses the whole
+	* source rather than the rows past the last checkpoint.
+	*/
+	async function resetCheckpoint(id, options = {}) {
+		await transport.requestRaw(`/api/transform/${id}/reset-checkpoint`, {
+			...options,
+			method: "POST",
+			expectContentType: "binary"
+		});
+	}
+	/**
+	* Start a DAG reprocess run seeded at a transform: the transform plus, by `direction`, every
+	* transform it transitively depends on or every transform that transitively depends on it. The
+	* server answers at once with the run's id, or null when it ran nothing because a DAG run for
+	* this transform is already in progress or the closure is empty. Progress is read off
+	* `runSummaryPages` with `types: ["dag"]`, and the member runs off `transformDagRun.transformRuns`.
+	*/
+	async function runDag(id, params, options = {}) {
+		return transport.requestParsed(TransformDagRunResult, `/api/transform/${id}/run-dag`, {
+			...options,
+			method: "POST",
+			body: { direction: params.direction }
+		});
+	}
+	/** Preview the transforms a DAG reprocess seeded at a transform would run, in execution order. */
+	async function dagTransforms(id, params, options = {}) {
+		return {
+			data: await transport.requestParsed(TransformDagTransformList, `/api/transform/${id}/dag-transforms`, {
+				...options,
+				query: { direction: params.direction }
+			}),
+			total: null
+		};
+	}
+	/**
+	* Start a run of a transform by id. The server queues the run and answers at once; `wait` polls
+	* it to a terminal status, and `syncTarget` follows that with the output table's registration.
+	* A server that answers no run id started nothing, and there is then nothing to poll.
+	*/
+	async function run(id, params = {}, options = {}) {
+		const kickoff = await transport.requestParsed(TransformRunKickoff, `/api/transform/${id}/run`, {
+			...options,
+			method: "POST"
+		});
+		const schedule = params.syncTarget === true ? params.wait ?? {} : params.wait;
+		if (schedule === void 0 || kickoff.run_id === null) return {
+			message: kickoff.message,
+			run_id: kickoff.run_id,
+			final: null
+		};
+		const runId = kickoff.run_id;
+		const final = await pollUntil(async (signal) => getRun(runId, {
+			...options,
+			signal
+		}), (candidate) => isTransformRunTerminal(candidate.status), schedule);
+		if (params.syncTarget !== true) return {
+			message: kickoff.message,
+			run_id: runId,
+			final
+		};
+		const targetTableId = isTransformRunFailed(final.status) ? null : await awaitTargetTableId(id, schedule, options);
+		return {
+			message: kickoff.message,
+			run_id: runId,
+			final,
+			target_table_id: targetTableId
+		};
+	}
+	async function awaitTargetTableId(id, wait, options) {
+		try {
+			return (await pollUntil(async (signal) => get(id, {
+				...options,
+				signal
+			}), (transform) => transform.target_table_id !== null, wait)).target_table_id;
+		} catch (error) {
+			if (error instanceof TimeoutError) return null;
+			throw error;
+		}
+	}
+	return {
+		list: explain("list", list),
+		get: explain("get", get),
+		create: explain("create", create),
+		update: explain("update", update),
+		delete: explain("delete", remove),
+		deleteTable: explain("deleteTable", deleteTable),
+		dependencies: explain("dependencies", dependencies),
+		cancel: explain("cancel", cancel),
+		getRun: explain("getRun", getRun),
+		runPages: explainWalk("runPages", runPages),
+		runSummaryPages: explainWalk("runSummaryPages", runSummaryPages),
+		resetCheckpoint: explain("resetCheckpoint", resetCheckpoint),
+		runDag: explain("runDag", runDag),
+		dagTransforms: explain("dagTransforms", dagTransforms),
+		run: explain("run", run)
+	};
+}
+//#endregion
+export { transformResource };

package/dist/resources/upload.d.ts

@@ -0,0 +1,2 @@
+import { n as uploadResource, t as UploadCsvParams } from "../upload-B5YjVkSW.js";
+export { UploadCsvParams, uploadResource };

package/dist/resources/upload.js

@@ -0,0 +1,48 @@
+import { ResponseShapeError } from "../errors.js";
+import { buildCsvFormData } from "./csv-upload.js";
+import { UploadResult } from "../domain/upload.js";
+//#region src/resources/upload.ts
+const UPLOAD_TABLE_ID_HEADER = "metabase-table-id";
+function uploadResource(transport) {
+	/**
+	* Create a table and model populated with the values from the attached CSV. Returns the model ID
+	* if successful.
+	*
+	* The file may be at most 50 MB; larger uploads are rejected with a 413 response.
+	*/
+	async function createFromCsv(file, params, options = {}) {
+		const form = buildCsvFormData(file);
+		form.append("collection_id", params.collection_id);
+		const response = await transport.requestRaw("/api/upload/csv", {
+			...options,
+			method: "POST",
+			body: form,
+			expectContentType: "binary"
+		});
+		return parseCreateUploadResult(await response.text(), response.headers);
+	}
+	return { createFromCsv };
+}
+function parseCreateUploadResult(bodyText, headers) {
+	return UploadResult.parse({
+		model_id: parseResponseInteger(bodyText, "response body"),
+		table_id: parseResponseInteger(headers.get(UPLOAD_TABLE_ID_HEADER), `${UPLOAD_TABLE_ID_HEADER} header`)
+	});
+}
+function parseResponseInteger(value, source) {
+	const trimmed = value?.trim() ?? "";
+	if (trimmed === "") throw new ResponseShapeError(`upload succeeded but the ${source} was empty`, {
+		kind: "decoded",
+		source,
+		value
+	});
+	const parsed = Number(trimmed);
+	if (!Number.isInteger(parsed)) throw new ResponseShapeError(`upload succeeded but the ${source} was not an integer: ${JSON.stringify(trimmed)}`, {
+		kind: "decoded",
+		source,
+		value
+	});
+	return parsed;
+}
+//#endregion
+export { uploadResource };

package/dist/resources/user.d.ts

@@ -0,0 +1,8 @@
+import { f as RequestOptions, h as Transport } from "../transport-BsXqRujn.js";
+import { t as CurrentUser } from "../user-Sqqv7rqh.js";
+//#region src/resources/user.d.ts
+declare function userResource(transport: Transport): {
+  current: (options?: RequestOptions) => Promise<CurrentUser>;
+};
+//#endregion
+export { userResource };

package/dist/resources/user.js

@@ -0,0 +1,11 @@
+import { CurrentUser } from "../domain/user.js";
+//#region src/resources/user.ts
+function userResource(transport) {
+	/** Get the user the request's credentials authenticate as. */
+	async function current(options = {}) {
+		return transport.requestParsed(CurrentUser, "/api/user/current", { ...options });
+	}
+	return { current };
+}
+//#endregion
+export { userResource };

package/dist/revision-Dyl-8p7d.d.ts

@@ -0,0 +1,106 @@
+import { r as InputGate } from "./input-gates-DwKoTJVQ.js";
+import { z } from "zod";
+//#region src/domain/revision.d.ts
+declare const RevisionEntity: z.ZodEnum<{
+  transform: "transform";
+  card: "card";
+  dashboard: "dashboard";
+  document: "document";
+  measure: "measure";
+  segment: "segment";
+  "transform-test": "transform-test";
+}>;
+type RevisionEntity = z.infer<typeof RevisionEntity>;
+declare const Revision: z.ZodObject<{
+  id: z.ZodNumber;
+  timestamp: z.ZodString;
+  is_creation: z.ZodBoolean;
+  is_reversion: z.ZodBoolean;
+  most_recent: z.ZodBoolean;
+  diff: z.ZodNullable<z.ZodObject<{}, z.core.$loose>>;
+  description: z.ZodString;
+  has_multiple_changes: z.ZodBoolean;
+  user: z.ZodObject<{
+    id: z.ZodNumber;
+    first_name: z.ZodNullable<z.ZodString>;
+    last_name: z.ZodNullable<z.ZodString>;
+    common_name: z.ZodString;
+  }, z.core.$loose>;
+}, z.core.$loose>;
+type Revision = z.infer<typeof Revision>;
+declare const RevisionCompact: z.ZodObject<{
+  id: z.ZodNumber;
+  description: z.ZodString;
+  timestamp: z.ZodString;
+  user: z.ZodObject<{
+    id: z.ZodNumber;
+    first_name: z.ZodNullable<z.ZodString>;
+    last_name: z.ZodNullable<z.ZodString>;
+    common_name: z.ZodString;
+  }, z.core.$loose>;
+  is_creation: z.ZodBoolean;
+  is_reversion: z.ZodBoolean;
+}, z.core.$strip>;
+type RevisionCompact = z.infer<typeof RevisionCompact>;
+declare const RevisionRow: z.ZodObject<{
+  id: z.ZodNumber;
+  model: z.ZodString;
+  model_id: z.ZodNumber;
+  user_id: z.ZodNumber;
+  object: z.ZodObject<{}, z.core.$loose>;
+  timestamp: z.ZodString;
+  is_creation: z.ZodBoolean;
+  is_reversion: z.ZodBoolean;
+  most_recent: z.ZodBoolean;
+}, z.core.$loose>;
+type RevisionRow = z.infer<typeof RevisionRow>;
+declare const REVISION_ENTITY_GATES: readonly InputGate[];
+declare const RevisionRevertInput: z.ZodObject<{
+  entity: z.ZodEnum<{
+    transform: "transform";
+    card: "card";
+    dashboard: "dashboard";
+    document: "document";
+    measure: "measure";
+    segment: "segment";
+    "transform-test": "transform-test";
+  }>;
+  id: z.ZodNumber;
+  revision_id: z.ZodNumber;
+}, z.core.$strict>;
+type RevisionRevertInput = z.infer<typeof RevisionRevertInput>;
+declare const RevisionRevert: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  outcome: z.ZodLiteral<"reverted">;
+  revision: z.ZodObject<{
+    id: z.ZodNumber;
+    timestamp: z.ZodString;
+    is_creation: z.ZodBoolean;
+    is_reversion: z.ZodBoolean;
+    most_recent: z.ZodBoolean;
+    diff: z.ZodNullable<z.ZodObject<{}, z.core.$loose>>;
+    description: z.ZodString;
+    has_multiple_changes: z.ZodBoolean;
+    user: z.ZodObject<{
+      id: z.ZodNumber;
+      first_name: z.ZodNullable<z.ZodString>;
+      last_name: z.ZodNullable<z.ZodString>;
+      common_name: z.ZodString;
+    }, z.core.$loose>;
+  }, z.core.$loose>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"unchanged">;
+  revision: z.ZodObject<{
+    id: z.ZodNumber;
+    model: z.ZodString;
+    model_id: z.ZodNumber;
+    user_id: z.ZodNumber;
+    object: z.ZodObject<{}, z.core.$loose>;
+    timestamp: z.ZodString;
+    is_creation: z.ZodBoolean;
+    is_reversion: z.ZodBoolean;
+    most_recent: z.ZodBoolean;
+  }, z.core.$loose>;
+}, z.core.$strip>], "outcome">;
+type RevisionRevert = z.infer<typeof RevisionRevert>;
+//#endregion
+export { RevisionRevert as a, RevisionEntity as i, Revision as n, RevisionRevertInput as o, RevisionCompact as r, RevisionRow as s, REVISION_ENTITY_GATES as t };