@hiro5409/attio-cli 0.0.0-stage → 0.1.0

package/dist/cli-CLfvqLdQ.mjs

@@ -0,0 +1,4747 @@
+import { cli, define } from "gunshi";
+import { renderHeader } from "gunshi/renderer";
+import ky, { isHTTPError } from "ky";
+import * as v from "valibot";
+//#region src/errors.ts
+var CliError = class extends Error {
+	options;
+	constructor(message, options) {
+		super(message);
+		this.name = "CliError";
+		this.options = options;
+	}
+};
+const AttioErrorBody = v.object({
+	code: v.optional(v.string()),
+	message: v.optional(v.string()),
+	type: v.optional(v.string())
+});
+const HTTP_FAILURES = {
+	400: {
+		code: "BAD_REQUEST",
+		exitCode: 2,
+		hint: "Correct the options or the body against the operation's page in Attio's API reference."
+	},
+	401: {
+		code: "UNAUTHORIZED",
+		exitCode: 2,
+		hint: "Set ATTIO_ACCESS_TOKEN to a valid Attio access token."
+	},
+	403: {
+		code: "FORBIDDEN",
+		exitCode: 3,
+		hint: "Attio's message names what is missing: a scope on the token, access to the resource, or a plan that allows the operation."
+	},
+	404: {
+		code: "NOT_FOUND",
+		exitCode: 1
+	},
+	429: {
+		code: "RATE_LIMITED",
+		exitCode: 4,
+		hint: "Wait before running the command again."
+	}
+};
+/** Turns an HTTP failure and the body Attio sent with it into a CLI error. */
+function httpError(status, body) {
+	const parsed = v.safeParse(AttioErrorBody, body);
+	const { code, message, type } = parsed.success ? parsed.output : {};
+	return new CliError(message || `Attio returned HTTP ${status}.`, {
+		...HTTP_FAILURES[status] ?? {
+			code: "API_ERROR",
+			exitCode: 1
+		},
+		attio: {
+			code,
+			type
+		},
+		status
+	});
+}
+/** Describes a command line that the CLI cannot act on. */
+function usageError(message) {
+	return new CliError(message, {
+		code: "INVALID_ARGUMENT",
+		exitCode: 2
+	});
+}
+/** Describes a request that never produced a response from Attio. */
+function networkError(cause) {
+	return new CliError(`Could not reach Attio${cause instanceof Error && cause.message ? ` (${cause.message})` : ""}.`, {
+		code: "NETWORK_ERROR",
+		exitCode: 1,
+		hint: "Check the network connection. A write may have reached Attio, so check before retrying."
+	});
+}
+/** Writes the failure to stderr as JSON and returns the process exit code. */
+function reportError(error) {
+	if (error instanceof AggregateError) return reportError(usageError(error.errors.map((item) => item instanceof Error ? item.message : String(item)).filter(Boolean).join("; ") || "Invalid command arguments."));
+	if (error instanceof CliError) {
+		const { exitCode, ...details } = error.options;
+		console.error(JSON.stringify({ error: {
+			...details,
+			message: error.message
+		} }, null, 2));
+		return exitCode;
+	}
+	const message = error instanceof Error ? error.message : String(error);
+	console.error(JSON.stringify({ error: {
+		code: "UNEXPECTED",
+		message
+	} }, null, 2));
+	return 1;
+}
+//#endregion
+//#region src/types/attio/core/bodySerializer.gen.ts
+const jsonBodySerializer = { bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value) };
+Object.entries({
+	$body_: "body",
+	$headers_: "headers",
+	$path_: "path",
+	$query_: "query"
+});
+//#endregion
+//#region src/types/attio/core/serverSentEvents.gen.ts
+function createSseClient({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) {
+	let lastEventId;
+	const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const createStream = async function* () {
+		let retryDelay = sseDefaultRetryDelay ?? 3e3;
+		let attempt = 0;
+		const signal = options.signal ?? new AbortController().signal;
+		while (true) {
+			if (signal.aborted) break;
+			attempt++;
+			const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+			if (lastEventId !== void 0) headers.set("Last-Event-ID", lastEventId);
+			try {
+				const requestInit = {
+					redirect: "follow",
+					...options,
+					body: options.serializedBody,
+					headers,
+					signal
+				};
+				let request = new Request(url, requestInit);
+				if (onRequest) request = await onRequest(url, requestInit);
+				const response = await (options.fetch ?? globalThis.fetch)(request);
+				if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+				if (!response.body) throw new Error("No body in SSE response");
+				const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+				let buffer = "";
+				const abortHandler = () => {
+					try {
+						reader.cancel();
+					} catch {}
+				};
+				signal.addEventListener("abort", abortHandler);
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						buffer += value;
+						buffer = buffer.replace(/\r\n?/g, "\n");
+						const chunks = buffer.split("\n\n");
+						buffer = chunks.pop() ?? "";
+						for (const chunk of chunks) {
+							const lines = chunk.split("\n");
+							const dataLines = [];
+							let eventName;
+							for (const line of lines) if (line.startsWith("data:")) dataLines.push(line.replace(/^data:\s*/, ""));
+							else if (line.startsWith("event:")) eventName = line.replace(/^event:\s*/, "");
+							else if (line.startsWith("id:")) lastEventId = line.replace(/^id:\s*/, "");
+							else if (line.startsWith("retry:")) {
+								const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+								if (!Number.isNaN(parsed)) retryDelay = parsed;
+							}
+							let data;
+							let parsedJson = false;
+							if (dataLines.length) {
+								const rawData = dataLines.join("\n");
+								try {
+									data = JSON.parse(rawData);
+									parsedJson = true;
+								} catch {
+									data = rawData;
+								}
+							}
+							if (parsedJson) {
+								if (responseValidator) await responseValidator(data);
+								if (responseTransformer) data = await responseTransformer(data);
+							}
+							onSseEvent?.({
+								data,
+								event: eventName,
+								id: lastEventId,
+								retry: retryDelay
+							});
+							if (dataLines.length) yield data;
+						}
+					}
+				} finally {
+					signal.removeEventListener("abort", abortHandler);
+					reader.releaseLock();
+				}
+				break;
+			} catch (error) {
+				onSseError?.(error);
+				if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) break;
+				const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4);
+				await sleep(backoff);
+			}
+		}
+	};
+	return { stream: createStream() };
+}
+//#endregion
+//#region src/types/attio/core/pathSerializer.gen.ts
+const separatorArrayExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const separatorArrayNoExplode = (style) => {
+	switch (style) {
+		case "form": return ",";
+		case "pipeDelimited": return "|";
+		case "spaceDelimited": return "%20";
+		default: return ",";
+	}
+};
+const separatorObjectExplode = (style) => {
+	switch (style) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+};
+const serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
+	if (!explode) {
+		const joinedValues = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+		switch (style) {
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			case "simple": return joinedValues;
+			default: return `${name}=${joinedValues}`;
+		}
+	}
+	const separator = separatorArrayExplode(style);
+	const joinedValues = value.map((v) => {
+		if (style === "label" || style === "simple") return allowReserved ? v : encodeURIComponent(v);
+		return serializePrimitiveParam({
+			allowReserved,
+			name,
+			value: v
+		});
+	}).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+const serializePrimitiveParam = ({ allowReserved, name, value }) => {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "object") throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+	return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+const serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly }) => {
+	if (value instanceof Date) return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+	if (style !== "deepObject" && !explode) {
+		let values = [];
+		Object.entries(value).forEach(([key, v]) => {
+			values = [
+				...values,
+				key,
+				allowReserved ? v : encodeURIComponent(v)
+			];
+		});
+		const joinedValues = values.join(",");
+		switch (style) {
+			case "form": return `${name}=${joinedValues}`;
+			case "label": return `.${joinedValues}`;
+			case "matrix": return `;${name}=${joinedValues}`;
+			default: return joinedValues;
+		}
+	}
+	const separator = separatorObjectExplode(style);
+	const joinedValues = Object.entries(value).map(([key, v]) => serializePrimitiveParam({
+		allowReserved,
+		name: style === "deepObject" ? `${name}[${key}]` : key,
+		value: v
+	})).join(separator);
+	return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+//#endregion
+//#region src/types/attio/core/utils.gen.ts
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+const defaultPathSerializer = ({ path, url: _url }) => {
+	let url = _url;
+	const matches = _url.match(PATH_PARAM_RE);
+	if (matches) for (const match of matches) {
+		let explode = false;
+		let name = match.substring(1, match.length - 1);
+		let style = "simple";
+		if (name.endsWith("*")) {
+			explode = true;
+			name = name.substring(0, name.length - 1);
+		}
+		if (name.startsWith(".")) {
+			name = name.substring(1);
+			style = "label";
+		} else if (name.startsWith(";")) {
+			name = name.substring(1);
+			style = "matrix";
+		}
+		const value = path[name];
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) {
+			url = url.replace(match, serializeArrayParam({
+				explode,
+				name,
+				style,
+				value
+			}));
+			continue;
+		}
+		if (typeof value === "object") {
+			url = url.replace(match, serializeObjectParam({
+				explode,
+				name,
+				style,
+				value,
+				valueOnly: true
+			}));
+			continue;
+		}
+		if (style === "matrix") {
+			url = url.replace(match, `;${serializePrimitiveParam({
+				name,
+				value
+			})}`);
+			continue;
+		}
+		const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
+		url = url.replace(match, replaceValue);
+	}
+	return url;
+};
+const getUrl = ({ baseUrl, path, query, querySerializer, url: _url }) => {
+	const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+	let url = (baseUrl ?? "") + pathUrl;
+	if (path) url = defaultPathSerializer({
+		path,
+		url
+	});
+	let search = query ? querySerializer(query) : "";
+	if (search.startsWith("?")) search = search.substring(1);
+	if (search) url += `?${search}`;
+	return url;
+};
+function getValidRequestBody(options) {
+	const hasBody = options.body !== void 0;
+	if (hasBody && options.bodySerializer) {
+		if ("serializedBody" in options) return options.serializedBody !== void 0 && options.serializedBody !== "" ? options.serializedBody : null;
+		return options.body !== "" ? options.body : null;
+	}
+	if (hasBody) return options.body;
+}
+//#endregion
+//#region src/types/attio/core/auth.gen.ts
+const getAuthToken = async (auth, callback) => {
+	const token = typeof callback === "function" ? await callback(auth) : callback;
+	if (!token) return;
+	if (auth.scheme === "bearer") return `Bearer ${token}`;
+	if (auth.scheme === "basic") return `Basic ${btoa(token)}`;
+	return token;
+};
+//#endregion
+//#region src/types/attio/client/utils.gen.ts
+const createQuerySerializer = ({ parameters = {}, ...args } = {}) => {
+	const querySerializer = (queryParams) => {
+		const search = [];
+		if (queryParams && typeof queryParams === "object") for (const name in queryParams) {
+			const value = queryParams[name];
+			if (value === void 0 || value === null) continue;
+			const options = parameters[name] || args;
+			if (Array.isArray(value)) {
+				const serializedArray = serializeArrayParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "form",
+					value,
+					...options.array
+				});
+				if (serializedArray) search.push(serializedArray);
+			} else if (typeof value === "object") {
+				const serializedObject = serializeObjectParam({
+					allowReserved: options.allowReserved,
+					explode: true,
+					name,
+					style: "deepObject",
+					value,
+					...options.object
+				});
+				if (serializedObject) search.push(serializedObject);
+			} else {
+				const serializedPrimitive = serializePrimitiveParam({
+					allowReserved: options.allowReserved,
+					name,
+					value
+				});
+				if (serializedPrimitive) search.push(serializedPrimitive);
+			}
+		}
+		return search.join("&");
+	};
+	return querySerializer;
+};
+/**
+* Infers parseAs value from provided Content-Type header.
+*/
+const getParseAs = (contentType) => {
+	if (!contentType) return "stream";
+	const cleanContent = contentType.split(";")[0]?.trim();
+	if (!cleanContent) return;
+	if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) return "json";
+	if (cleanContent === "multipart/form-data") return "formData";
+	if ([
+		"application/",
+		"audio/",
+		"image/",
+		"video/"
+	].some((type) => cleanContent.startsWith(type))) return "blob";
+	if (cleanContent.startsWith("text/")) return "text";
+};
+const checkForExistence = (options, name) => {
+	if (!name) return false;
+	if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) return true;
+	return false;
+};
+async function setAuthParams(options) {
+	for (const auth of options.security ?? []) {
+		if (checkForExistence(options, auth.name)) continue;
+		const token = await getAuthToken(auth, options.auth);
+		if (!token) continue;
+		const name = auth.name ?? "Authorization";
+		switch (auth.in) {
+			case "query":
+				if (!options.query) options.query = {};
+				options.query[name] = token;
+				break;
+			case "cookie":
+				options.headers.append("Cookie", `${name}=${token}`);
+				break;
+			default: options.headers.set(name, token);
+		}
+	}
+}
+const buildUrl = (options) => getUrl({
+	baseUrl: options.baseUrl,
+	path: options.path,
+	query: options.query,
+	querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+	url: options.url
+});
+const mergeConfigs = (a, b) => {
+	const config = {
+		...a,
+		...b
+	};
+	if (config.baseUrl?.endsWith("/")) config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+	config.headers = mergeHeaders(a.headers, b.headers);
+	return config;
+};
+const headersEntries = (headers) => {
+	const entries = [];
+	headers.forEach((value, key) => {
+		entries.push([key, value]);
+	});
+	return entries;
+};
+const mergeHeaders = (...headers) => {
+	const mergedHeaders = new Headers();
+	for (const header of headers) {
+		if (!header) continue;
+		const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+		for (const [key, value] of iterator) if (value === null) mergedHeaders.delete(key);
+		else if (Array.isArray(value)) for (const v of value) mergedHeaders.append(key, v);
+		else if (value !== void 0) mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
+	}
+	return mergedHeaders;
+};
+var Interceptors = class {
+	fns = [];
+	clear() {
+		this.fns = [];
+	}
+	eject(id) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) this.fns[index] = null;
+	}
+	exists(id) {
+		const index = this.getInterceptorIndex(id);
+		return Boolean(this.fns[index]);
+	}
+	getInterceptorIndex(id) {
+		if (typeof id === "number") return this.fns[id] ? id : -1;
+		return this.fns.indexOf(id);
+	}
+	update(id, fn) {
+		const index = this.getInterceptorIndex(id);
+		if (this.fns[index]) {
+			this.fns[index] = fn;
+			return id;
+		}
+		return false;
+	}
+	use(fn) {
+		this.fns.push(fn);
+		return this.fns.length - 1;
+	}
+};
+const createInterceptors = () => ({
+	error: new Interceptors(),
+	request: new Interceptors(),
+	response: new Interceptors()
+});
+const defaultQuerySerializer = createQuerySerializer({
+	allowReserved: false,
+	array: {
+		explode: true,
+		style: "form"
+	},
+	object: {
+		explode: true,
+		style: "deepObject"
+	}
+});
+const defaultHeaders = { "Content-Type": "application/json" };
+const createConfig = (override = {}) => ({
+	...jsonBodySerializer,
+	headers: defaultHeaders,
+	parseAs: "auto",
+	querySerializer: defaultQuerySerializer,
+	...override
+});
+//#endregion
+//#region src/types/attio/client/client.gen.ts
+const createClient = (config = {}) => {
+	let _config = mergeConfigs(createConfig(), config);
+	const getConfig = () => ({ ..._config });
+	const setConfig = (config) => {
+		_config = mergeConfigs(_config, config);
+		return getConfig();
+	};
+	const interceptors = createInterceptors();
+	const beforeRequest = async (options) => {
+		const opts = {
+			..._config,
+			...options,
+			fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+			headers: mergeHeaders(_config.headers, options.headers),
+			serializedBody: void 0
+		};
+		if (opts.security) await setAuthParams(opts);
+		if (opts.requestValidator) await opts.requestValidator(opts);
+		if (opts.body !== void 0 && opts.bodySerializer) opts.serializedBody = opts.bodySerializer(opts.body);
+		if (opts.body === void 0 || opts.serializedBody === "") opts.headers.delete("Content-Type");
+		const resolvedOpts = opts;
+		return {
+			opts: resolvedOpts,
+			url: buildUrl(resolvedOpts)
+		};
+	};
+	const request = async (options) => {
+		const throwOnError = options.throwOnError ?? _config.throwOnError;
+		const responseStyle = options.responseStyle ?? _config.responseStyle;
+		let request;
+		let response;
+		try {
+			const { opts, url } = await beforeRequest(options);
+			const requestInit = {
+				redirect: "follow",
+				...opts,
+				body: getValidRequestBody(opts)
+			};
+			request = new Request(url, requestInit);
+			for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+			const _fetch = opts.fetch;
+			response = await _fetch(request);
+			for (const fn of interceptors.response.fns) if (fn) response = await fn(response, request, opts);
+			const result = {
+				request,
+				response
+			};
+			if (response.ok) {
+				const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+				if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+					let emptyData;
+					switch (parseAs) {
+						case "arrayBuffer":
+						case "blob":
+						case "text":
+							emptyData = await response[parseAs]();
+							break;
+						case "formData":
+							emptyData = new FormData();
+							break;
+						case "stream":
+							emptyData = response.body;
+							break;
+						default: emptyData = {};
+					}
+					return opts.responseStyle === "data" ? emptyData : {
+						data: emptyData,
+						...result
+					};
+				}
+				let data;
+				switch (parseAs) {
+					case "arrayBuffer":
+					case "blob":
+					case "formData":
+					case "text":
+						data = await response[parseAs]();
+						break;
+					case "json": {
+						const text = await response.text();
+						data = text ? JSON.parse(text) : {};
+						break;
+					}
+					case "stream": return opts.responseStyle === "data" ? response.body : {
+						data: response.body,
+						...result
+					};
+				}
+				if (parseAs === "json") {
+					if (opts.responseValidator) await opts.responseValidator(data);
+					if (opts.responseTransformer) data = await opts.responseTransformer(data);
+				}
+				return opts.responseStyle === "data" ? data : {
+					data,
+					...result
+				};
+			}
+			const textError = await response.text();
+			let jsonError;
+			try {
+				jsonError = JSON.parse(textError);
+			} catch {}
+			throw jsonError ?? textError;
+		} catch (error) {
+			let finalError = error;
+			for (const fn of interceptors.error.fns) if (fn) finalError = await fn(finalError, response, request, options);
+			finalError = finalError || {};
+			if (throwOnError) throw finalError;
+			return responseStyle === "data" ? void 0 : {
+				error: finalError,
+				request,
+				response
+			};
+		}
+	};
+	const makeMethodFn = (method) => (options) => request({
+		...options,
+		method
+	});
+	const makeSseFn = (method) => async (options) => {
+		const { opts, url } = await beforeRequest(options);
+		return createSseClient({
+			...opts,
+			body: opts.body,
+			method,
+			onRequest: async (url, init) => {
+				let request = new Request(url, init);
+				for (const fn of interceptors.request.fns) if (fn) request = await fn(request, opts);
+				return request;
+			},
+			serializedBody: getValidRequestBody(opts),
+			url
+		});
+	};
+	const _buildUrl = (options) => buildUrl({
+		..._config,
+		...options
+	});
+	return {
+		buildUrl: _buildUrl,
+		connect: makeMethodFn("CONNECT"),
+		delete: makeMethodFn("DELETE"),
+		get: makeMethodFn("GET"),
+		getConfig,
+		head: makeMethodFn("HEAD"),
+		interceptors,
+		options: makeMethodFn("OPTIONS"),
+		patch: makeMethodFn("PATCH"),
+		post: makeMethodFn("POST"),
+		put: makeMethodFn("PUT"),
+		request,
+		setConfig,
+		sse: {
+			connect: makeSseFn("CONNECT"),
+			delete: makeSseFn("DELETE"),
+			get: makeSseFn("GET"),
+			head: makeSseFn("HEAD"),
+			options: makeSseFn("OPTIONS"),
+			patch: makeSseFn("PATCH"),
+			post: makeSseFn("POST"),
+			put: makeSseFn("PUT"),
+			trace: makeSseFn("TRACE")
+		},
+		trace: makeMethodFn("TRACE")
+	};
+};
+//#endregion
+//#region src/api/client.ts
+/** The methods Ky does not repeat by default, because repeating them is not safe in general. */
+const WRITE_METHODS = /* @__PURE__ */ new Set(["PATCH", "POST"]);
+/** Attio does not process a rate-limited request, so that is the one failure after which a write is repeated. */
+const writeRetry = {
+	methods: ["patch", "post"],
+	shouldRetry: ({ error }) => isHTTPError(error) && error.response.status === 429
+};
+/** Sends a request through Ky for its timeout and its retries. */
+async function transport(...input) {
+	const request = new Request(...input);
+	const pending = ky(request, WRITE_METHODS.has(request.method) ? { retry: writeRetry } : {});
+	const [response, body] = await Promise.all([pending, pending.text()]);
+	return new Response(body || null, response);
+}
+function attioClient(env) {
+	const accessToken = env.ATTIO_ACCESS_TOKEN?.trim();
+	if (!accessToken) throw new CliError("No Attio access token is configured.", {
+		code: "AUTH_REQUIRED",
+		exitCode: 2,
+		hint: "Set ATTIO_ACCESS_TOKEN to an Attio access token."
+	});
+	const client = createClient({
+		auth: accessToken,
+		baseUrl: "https://api.attio.com",
+		fetch: transport,
+		throwOnError: true
+	});
+	client.interceptors.error.use((error, response) => {
+		if (isHTTPError(error)) return httpError(error.response.status, error.data);
+		return response ? error : networkError(error);
+	});
+	return client;
+}
+//#endregion
+//#region src/commands/operation.ts
+/**
+* Wraps an SDK function so every operation runs the same way. Command-line input has no static
+* type, and Attio is what validates it.
+*/
+function operation(definition) {
+	const { call, ...details } = definition;
+	return {
+		...details,
+		run: async (client, input) => {
+			const { data } = await call({
+				...input,
+				client
+			});
+			return data;
+		}
+	};
+}
+const ARGUMENT_TYPES = {
+	boolean: "boolean",
+	integer: "number",
+	string: "string"
+};
+function optionName(parameter) {
+	return parameter.replaceAll("_", "-");
+}
+function parseBody(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		throw usageError("--body must be valid JSON.");
+	}
+}
+/** Builds the CLI command that runs one operation with the options given on the command line. */
+function operationCommand(name, source, env) {
+	const args = {};
+	for (const option of source.options) args[optionName(option.name)] = {
+		description: option.description,
+		required: option.required || void 0,
+		type: ARGUMENT_TYPES[option.type]
+	};
+	if (source.body !== "none") args.body = {
+		description: "Request body as JSON",
+		required: source.body === "required" || void 0,
+		type: "string"
+	};
+	return define({
+		name,
+		description: source.description,
+		args,
+		run: async (ctx) => {
+			const values = ctx.values;
+			const input = {};
+			for (const option of source.options) {
+				const value = values[optionName(option.name)];
+				if (value !== void 0) (input[option.in] ??= {})[option.name] = value;
+			}
+			if (typeof values.body === "string") input.body = parseBody(values.body);
+			return JSON.stringify(await source.run(attioClient(env), input), null, 2);
+		}
+	});
+}
+//#endregion
+//#region src/types/attio/client.gen.ts
+const client = createClient(createConfig({
+	baseUrl: "https://api.attio.com",
+	throwOnError: true
+}));
+//#endregion
+//#region src/types/attio/sdk.gen.ts
+/**
+* List objects
+*
+* Lists all system-defined and user-defined objects in your workspace.
+*
+* Required scopes: `object_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2Objects = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects",
+	...options
+});
+/**
+* Create an object
+*
+* Creates a new custom object in your workspace.
+*
+* Required scopes: `object_configuration:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2Objects = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete an object
+*
+* Deletes a single object by its `object_id` or slug, along with all of its records. Only custom objects can be deleted; system objects, such as people and companies, cannot.
+*
+* This endpoint should be used with caution as it has the potential to remove a large amount of potentially valuable data.
+*
+* Required scopes: `object_configuration:read-write`, `record_permission:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const deleteV2ObjectsByObject = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects/{object}",
+	...options
+});
+/**
+* Get an object
+*
+* Gets a single object by its `object_id` or slug.
+*
+* Required scopes: `object_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2ObjectsByObject = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects/{object}",
+	...options
+});
+/**
+* Update an object
+*
+* Updates a single object. The object to be updated is identified by its `object_id`.
+*
+* Required scopes: `object_configuration:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const patchV2ObjectsByObject = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects/{object}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List views for object
+*
+* Lists saved views for an object. Results are ordered by view ID (`id.view_id` ascending).
+*
+* Required scopes: `object_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2ObjectsByObjectViews = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects/{object}/views",
+	...options
+});
+/**
+* List activities
+*
+* Lists all system-defined and user-defined activities in your workspace.
+*
+* This endpoint is in alpha and may be subject to breaking changes as we gather feedback.
+*
+* Required scopes: `activity_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2Activities = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/activities",
+	...options
+});
+/**
+* Create an activity
+*
+* Creates a new custom activity in your workspace. Your workspace must have the custom activities billing feature enabled. Public apps may instead create activities with the integration activities billing feature.
+*
+* This endpoint is in alpha and may be subject to breaking changes as we gather feedback.
+*
+* Required scopes: `activity_configuration:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2Activities = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/activities",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete an activity
+*
+* Deletes a single activity by its `activity_id` or slug, along with all of its records. Archived activities can also be deleted.
+*
+* This endpoint should be used with caution as it has the potential to remove a large amount of potentially valuable data.
+*
+* This endpoint is in alpha and may be subject to breaking changes as we gather feedback.
+*
+* Required scopes: `activity_configuration:read-write`, `activity_record:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const deleteV2ActivitiesByActivity = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/activities/{activity}",
+	...options
+});
+/**
+* Get an activity
+*
+* Gets a single activity by its `activity_id` or slug.
+*
+* This endpoint is in alpha and may be subject to breaking changes as we gather feedback.
+*
+* Required scopes: `activity_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2ActivitiesByActivity = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/activities/{activity}",
+	...options
+});
+/**
+* Update an activity
+*
+* Updates a single activity by its `activity_id` or slug. The schema an activity extends is fixed after creation, so `extends` cannot be changed.
+*
+* This endpoint is in alpha and may be subject to breaking changes as we gather feedback.
+*
+* Required scopes: `activity_configuration:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const patchV2ActivitiesByActivity = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/activities/{activity}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List activity records
+*
+* Lists activity records, with the option to filter and sort results.
+*
+* This endpoint is in alpha and may be subject to breaking changes as we gather feedback.
+*
+* Required scopes: `activity_record:read`, `activity_configuration:read`, `object_configuration:read`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2ActivitiesByActivityRecordsQuery = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/activities/{activity}/records/query",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Create an activity record
+*
+* Creates a new activity record, for example one specific phone call.
+*
+* This endpoint is in alpha and may be subject to breaking changes as we gather feedback.
+*
+* Required scopes: `activity_record:read-write`, `activity_configuration:read`, `object_configuration:read`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2ActivitiesByActivityRecords = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/activities/{activity}/records",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Upsert an activity record
+*
+* Use this endpoint to create or update an activity record. A matching attribute is used to search for existing activity records. If a record is found with the same value for the matching attribute, that record will be updated. If no record with the same value for the matching attribute is found, a new record will be created instead. If you would like to avoid matching, please use the create activity record endpoint.
+*
+* If the matching attribute is a multiselect attribute, new values will be added and existing values will not be deleted. For any other multiselect attribute, all values will be either created or deleted as necessary to match the list of supplied values.
+*
+* This endpoint is in alpha and may be subject to breaking changes as we gather feedback.
+*
+* Required scopes: `activity_record:read-write`, `activity_configuration:read`, `object_configuration:read`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const putV2ActivitiesByActivityRecords = (options) => (options.client ?? client).put({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/activities/{activity}/records",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete an activity record
+*
+* Deletes a single activity record by its `record_id`.
+*
+* This endpoint is in alpha and may be subject to breaking changes as we gather feedback.
+*
+* Required scopes: `activity_record:read-write`, `activity_configuration:read`, `object_configuration:read`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const deleteV2ActivitiesByActivityRecordsByRecordId = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/activities/{activity}/records/{record_id}",
+	...options
+});
+/**
+* Get an activity record
+*
+* Gets a single activity record by its `record_id`.
+*
+* This endpoint is in alpha and may be subject to breaking changes as we gather feedback.
+*
+* Required scopes: `activity_record:read`, `activity_configuration:read`, `object_configuration:read`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2ActivitiesByActivityRecordsByRecordId = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/activities/{activity}/records/{record_id}",
+	...options
+});
+/**
+* Update an activity record (append multiselect values)
+*
+* Use this endpoint to update activity records by `record_id`. If the update payload includes multiselect attributes, the values supplied will be created and prepended to the list of values that already exist (if any). Use the `PUT` endpoint to overwrite or remove multiselect attribute values.
+*
+* This endpoint is in alpha and may be subject to breaking changes as we gather feedback.
+*
+* Required scopes: `activity_record:read-write`, `activity_configuration:read`, `object_configuration:read`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const patchV2ActivitiesByActivityRecordsByRecordId = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/activities/{activity}/records/{record_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Update an activity record (overwrite multiselect values)
+*
+* Use this endpoint to update activity records by `record_id`. If the update payload includes multiselect attributes, the values supplied will overwrite/remove the list of values that already exist (if any). Use the `PATCH` endpoint to append multiselect values without removing those that already exist.
+*
+* This endpoint is in alpha and may be subject to breaking changes as we gather feedback.
+*
+* Required scopes: `activity_record:read-write`, `activity_configuration:read`, `object_configuration:read`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const putV2ActivitiesByActivityRecordsByRecordId = (options) => (options.client ?? client).put({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/activities/{activity}/records/{record_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List attributes
+*
+* Lists all attributes defined on a specific object or list. Attributes are returned in the order that they are sorted by in the UI.
+*
+* When `target` is `objects`, the required scopes are `object_configuration:read`. When `target` is `lists`, the required scopes are `list_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2ByTargetByIdentifierAttributes = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/{target}/{identifier}/attributes",
+	...options
+});
+/**
+* Create an attribute
+*
+* Creates a new attribute on either an object or a list.
+*
+* For record-reference attributes, you can optionally create a bidirectional relationship by providing a `relationship` object. This will create two entangled attributes: one on the specified object and a reverse attribute on the related object.
+*
+* To create an attribute on an object, you must also have the `object_configuration:read-write` scope.
+*
+* To create an attribute on a list, you must also have the `list_configuration:read-write` scope.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2ByTargetByIdentifierAttributes = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/{target}/{identifier}/attributes",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Get an attribute
+*
+* Gets information about a single attribute on either an object or a list.
+*
+* When `target` is `objects`, the required scopes are `object_configuration:read`. When `target` is `lists`, the required scopes are `list_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2ByTargetByIdentifierAttributesByAttribute = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/{target}/{identifier}/attributes/{attribute}",
+	...options
+});
+/**
+* Update an attribute
+*
+* Updates a single attribute on a given object or list.
+*
+* When `target` is `objects`, the required scopes are `object_configuration:read-write`. When `target` is `lists`, the required scopes are `list_configuration:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const patchV2ByTargetByIdentifierAttributesByAttribute = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/{target}/{identifier}/attributes/{attribute}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List select options
+*
+* Lists all select options for a particular attribute on either an object or a list.
+*
+* When `target` is `objects`, the required scopes are `object_configuration:read`. When `target` is `lists`, the required scopes are `list_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2ByTargetByIdentifierAttributesByAttributeOptions = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/{target}/{identifier}/attributes/{attribute}/options",
+	...options
+});
+/**
+* Create a select option
+*
+* Adds a select option to a select attribute on an object or a list.
+*
+* When `target` is `objects`, the required scopes are `object_configuration:read-write`. When `target` is `lists`, the required scopes are `list_configuration:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2ByTargetByIdentifierAttributesByAttributeOptions = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/{target}/{identifier}/attributes/{attribute}/options",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Update a select option
+*
+* Updates a select option on an attribute on either an object or a list.
+*
+* When `target` is `objects`, the required scopes are `object_configuration:read-write`. When `target` is `lists`, the required scopes are `list_configuration:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const patchV2ByTargetByIdentifierAttributesByAttributeOptionsByOption = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/{target}/{identifier}/attributes/{attribute}/options/{option}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List statuses
+*
+* Lists all statuses for a particular status attribute on either an object or a list.
+*
+* When `target` is `objects`, the required scopes are `object_configuration:read`. When `target` is `lists`, the required scopes are `list_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2ByTargetByIdentifierAttributesByAttributeStatuses = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/{target}/{identifier}/attributes/{attribute}/statuses",
+	...options
+});
+/**
+* Create a status
+*
+* Add a new status to a status attribute on either an object or a list.
+*
+* When `target` is `objects`, the required scopes are `object_configuration:read-write`. When `target` is `lists`, the required scopes are `list_configuration:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2ByTargetByIdentifierAttributesByAttributeStatuses = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/{target}/{identifier}/attributes/{attribute}/statuses",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Update a status
+*
+* Update a status on an status attribute on either an object or a list.
+*
+* When `target` is `objects`, the required scopes are `object_configuration:read-write`. When `target` is `lists`, the required scopes are `list_configuration:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const patchV2ByTargetByIdentifierAttributesByAttributeStatusesByStatus = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/{target}/{identifier}/attributes/{attribute}/statuses/{status}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List records
+*
+* Lists people, company or other records, with the option to filter and sort results.
+*
+* Required scopes: `record_permission:read`, `object_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2ObjectsByObjectRecordsQuery = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects/{object}/records/query",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Create a record
+*
+* Creates a new person, company or other record. This endpoint will throw on conflicts of unique attributes. If you would prefer to update records on conflicts, please use the [Upsert record endpoint](/rest-api/endpoint-reference/records/upsert-a-record) instead.
+*
+* Required scopes: `record_permission:read-write`, `object_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2ObjectsByObjectRecords = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects/{object}/records",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Upsert a record
+*
+* Use this endpoint to create or update people, companies and other records. A matching attribute is used to search for existing records. If a record is found with the same value for the matching attribute, that record will be updated. If no record with the same value for the matching attribute is found, a new record will be created instead. If you would like to avoid matching, please use the [Create record endpoint](/rest-api/endpoint-reference/records/create-a-record).
+*
+* If the matching attribute is a multiselect attribute, new values will be added and existing values will not be deleted. For any other multiselect attribute, all values will be either created or deleted as necessary to match the list of supplied values.
+*
+* Required scopes: `record_permission:read-write`, `object_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const putV2ObjectsByObjectRecords = (options) => (options.client ?? client).put({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects/{object}/records",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete a record
+*
+* Deletes a single record (e.g. a company or person) by ID.
+*
+* Required scopes: `object_configuration:read`, `record_permission:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const deleteV2ObjectsByObjectRecordsByRecordId = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects/{object}/records/{record_id}",
+	...options
+});
+/**
+* Get a record
+*
+* Gets a single person, company or other record by its `record_id`.
+*
+* Required scopes: `record_permission:read`, `object_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2ObjectsByObjectRecordsByRecordId = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects/{object}/records/{record_id}",
+	...options
+});
+/**
+* Update a record (append multiselect values)
+*
+* Use this endpoint to update people, companies, and other records by `record_id`. If the update payload includes multiselect attributes, the values supplied will be created and prepended to the list of values that already exist (if any). Use the `PUT` endpoint to overwrite or remove multiselect attribute values.
+*
+* Required scopes: `record_permission:read-write`, `object_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const patchV2ObjectsByObjectRecordsByRecordId = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects/{object}/records/{record_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Update a record (overwrite multiselect values)
+*
+* Use this endpoint to update people, companies, and other records by `record_id`. If the update payload includes multiselect attributes, the values supplied will overwrite/remove the list of values that already exist (if any). Use the `PATCH` endpoint to append multiselect values without removing those that already exist.
+*
+* Required scopes: `record_permission:read-write`, `object_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const putV2ObjectsByObjectRecordsByRecordId = (options) => (options.client ?? client).put({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects/{object}/records/{record_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Merge two records
+*
+* Merges two records of the same object together. Where both records have a value for the same attribute, the primary record's value takes precedence.
+*
+* Merging produces a **new** record, so the `new_record_id` returned will match neither of the records supplied in the request. Both of the original records are marked as merged and can no longer be read or written.
+*
+* Large merges are completed asynchronously. A `200` response means the merged record is readable immediately. A `202` response means the merge has been accepted but is still being applied, and reading the merged record will return a `404` with the `merge_in_progress` error code until it completes.
+*
+* This endpoint is not idempotent. Because both original records are marked as merged, repeating the same request returns `404`.
+*
+* This endpoint is rate limited to 5 requests per second.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `record_permission:read-write`, `object_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2ObjectsByObjectRecordsMerge = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects/{object}/records/merge",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List record attribute values
+*
+* Gets all values for a given attribute on a record. Historic values can be queried using the `show_historic` query param. Historic values cannot be queried on COMINT (Communication Intelligence) or enriched attributes and the endpoint will return a 400 error if this is attempted. Historic values are sorted from oldest to newest (by `active_from`). Some attributes are subject to billing status and will return an empty array of values if theworkspace being queried does not have the required billing flag enabled.
+*
+* Required scopes: `record_permission:read`, `object_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2ObjectsByObjectRecordsByRecordIdAttributesByAttributeValues = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects/{object}/records/{record_id}/attributes/{attribute}/values",
+	...options
+});
+/**
+* Write record attribute values
+*
+* Replaces the entire value history of a single attribute on a record, primarily to migrate historic data from an external source. Every value the attribute currently has is destroyed, including values not present in the request, and the supplied values are written with the `active_from` and `active_until` timestamps given.
+*
+* Values may be supplied in any order and gaps between intervals are allowed. For attributes that accept a single value, at most one value may be active at a time, so intervals may not overlap and at most one may have a `null` `active_until`. At least one value is required.
+*
+* Webhooks and workflow triggers do not fire for these writes, so migrating history does not replay automations. Search indexes and caches are still updated, and formula attributes that depend on this attribute are still recalculated.
+*
+* Value history cannot be written for relationship attributes, formula attributes, enriched attributes, or immutable system attributes such as the entry's parent record.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `record_permission:read-write`, `object_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const putV2ObjectsByObjectRecordsByRecordIdAttributesByAttributeValues = (options) => (options.client ?? client).put({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects/{object}/records/{record_id}/attributes/{attribute}/values",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List record entries
+*
+* List all entries, across all lists, for which this record is the parent. The response includes metadata for each entry, including `entry_id`, `list_id`, and `created_at`, but does not include entry values. To retrieve the values, call [Get a list entry](/rest-api/endpoint-reference/entries/get-a-list-entry) separately for each entry.
+*
+* Required scopes: `record_permission:read`, `object_configuration:read`, `list_entry:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2ObjectsByObjectRecordsByRecordIdEntries = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects/{object}/records/{record_id}/entries",
+	...options
+});
+/**
+* Search records
+*
+* The search records endpoint provides a convenient way to fuzzy search for records across one or more objects.
+* The matching strategy employed in this endpoint follows the in-product strategy and will match names, domains, emails, phone numbers and social handles on people and companies, and labels on all other objects.
+* Please note, results returned from this endpoint are eventually consistent. For results which are guaranteed to be up to date, please use the record query endpoint instead.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `record_permission:read`, `object_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2ObjectsRecordsSearch = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/objects/records/search",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Query SQL
+*
+* Query records and lists with SQL. Your workspace must be on the Enterprise plan in order to access this endpoint.
+*
+* This endpoint is rate limited to 2 requests per second.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `record_permission:read`, `object_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2Sql = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/sql",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List all lists
+*
+* List all lists that your access token has access to. lists are returned in the order that they are sorted in the sidebar.
+*
+* Required scopes: `list_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2Lists = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/lists",
+	...options
+});
+/**
+* Create a list
+*
+* Creates a new list.
+*
+* Once you have your list, add attributes to it using the [Create attribute](/rest-api/endpoint-reference/attributes/create-an-attribute) API, and add records to it using the [Add records to list](/rest-api/endpoint-reference/entries/create-an-entry-add-record-to-list) API.
+*
+* New lists must specify which records can be added with the `parent_object` parameter which accepts either an object slug or an object ID. Permissions for the list are controlled with the `workspace_access` and `workspace_member_access` parameters.
+*
+* Please note that new lists must have either `workspace_access` set to `"full-access"` or one or more element of `workspace_member_access` with a `"full-access"` level. It is also possible to receive a `403` billing error if your workspace is not on a plan that supports either advanced workspace or workspace member-level access for lists.
+*
+* Required scopes: `list_configuration:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2Lists = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/lists",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Get a list
+*
+* Gets a single list in your workspace that your access token has access to.
+*
+* Required scopes: `list_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2ListsByList = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/lists/{list}",
+	...options
+});
+/**
+* Update a list
+*
+* Updates an existing list. Permissions for the list are controlled with the `workspace_access` and `workspace_member_access` parameters. Please note that lists must have either `workspace_access` set to `"full-access"` or one or more element of `workspace_member_access` with a `"full-access"` level. It is also possible to receive a `403` billing error if your workspace is not on a plan that supports either advanced workspace or workspace member level access for lists. Changing the parent object of a list is not possible through the API as it can have unintended side-effects that should be considered carefully. If you wish to carry out a parent object change you should do so through the UI.
+*
+* Required scopes: `list_configuration:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const patchV2ListsByList = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/lists/{list}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List views for list
+*
+* Lists saved views for a list. Results are ordered by view ID (`id.view_id` ascending).
+*
+* Required scopes: `list_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2ListsByListViews = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/lists/{list}/views",
+	...options
+});
+/**
+* List entries
+*
+* Lists entries in a given list, with the option to filter and sort results.
+*
+* Required scopes: `list_entry:read`, `list_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2ListsByListEntriesQuery = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/lists/{list}/entries/query",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Create an entry (add record to list)
+*
+* Adds a record to a list as a new list entry. This endpoint will throw on conflicts of unique attributes. Multiple list entries are allowed for the same parent record
+*
+* Required scopes: `list_entry:read-write`, `list_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2ListsByListEntries = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/lists/{list}/entries",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Upsert a list entry by parent
+*
+* Use this endpoint to create or update a list entry for a given parent record. If an entry with the specified parent record is found, that entry will be updated. If no such entry is found, a new entry will be created instead. If there are multiple entries with the same parent record, this endpoint with return the "MULTIPLE_MATCH_RESULTS" error. When writing to multi-select attributes, all values will be either created or deleted as necessary to match the list of values supplied in the request body.
+*
+* Required scopes: `list_entry:read-write`, `list_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const putV2ListsByListEntries = (options) => (options.client ?? client).put({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/lists/{list}/entries",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete a list entry
+*
+* Deletes a single list entry by its `entry_id`.
+*
+* Required scopes: `list_entry:read-write`, `list_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const deleteV2ListsByListEntriesByEntryId = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/lists/{list}/entries/{entry_id}",
+	...options
+});
+/**
+* Get a list entry
+*
+* Gets a single list entry by its `entry_id`.
+*
+* Required scopes: `list_entry:read`, `list_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2ListsByListEntriesByEntryId = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/lists/{list}/entries/{entry_id}",
+	...options
+});
+/**
+* Update a list entry (append multiselect values)
+*
+* Use this endpoint to update list entries by `entry_id`. If the update payload includes multiselect attributes, the values supplied will be created and prepended to the list of values that already exist (if any). Use the `PUT` endpoint to overwrite or remove multiselect attribute values.
+*
+* Required scopes: `list_entry:read-write`, `list_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const patchV2ListsByListEntriesByEntryId = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/lists/{list}/entries/{entry_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Update a list entry (overwrite multiselect values)
+*
+* Use this endpoint to update list entries by `entry_id`. If the update payload includes multiselect attributes, the values supplied will overwrite/remove the list of values that already exist (if any). Use the `PATCH` endpoint to add multiselect attribute values without removing those value that already exist.
+*
+* Required scopes: `list_entry:read-write`, `list_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const putV2ListsByListEntriesByEntryId = (options) => (options.client ?? client).put({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/lists/{list}/entries/{entry_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List attribute values for a list entry
+*
+* Gets all values for a given attribute on a list entry. This endpoint has the ability to return all historic values using the `show_historic` query param. Historic values are sorted from oldest to newest (by `active_from`).
+*
+* Required scopes: `list_entry:read`, `list_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2ListsByListEntriesByEntryIdAttributesByAttributeValues = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/lists/{list}/entries/{entry_id}/attributes/{attribute}/values",
+	...options
+});
+/**
+* Write list entry attribute values
+*
+* Replaces the entire value history of a single attribute on a list entry, primarily to migrate historic data from an external source. Every value the attribute currently has is destroyed, including values not present in the request, and the supplied values are written with the `active_from` and `active_until` timestamps given.
+*
+* Values may be supplied in any order and gaps between intervals are allowed. For attributes that accept a single value, at most one value may be active at a time, so intervals may not overlap and at most one may have a `null` `active_until`. At least one value is required.
+*
+* Webhooks and workflow triggers do not fire for these writes, so migrating history does not replay automations. Search indexes and caches are still updated, and formula attributes that depend on this attribute are still recalculated.
+*
+* Value history cannot be written for relationship attributes, formula attributes, enriched attributes, or immutable system attributes such as the entry's parent record.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `list_entry:read-write`, `list_configuration:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const putV2ListsByListEntriesByEntryIdAttributesByAttributeValues = (options) => (options.client ?? client).put({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/lists/{list}/entries/{entry_id}/attributes/{attribute}/values",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List workspace members
+*
+* Lists all workspace members in the workspace.
+*
+* Required scopes: `user_management:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2WorkspaceMembers = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/workspace_members",
+	...options
+});
+/**
+* Get a workspace member
+*
+* Gets a single workspace member by ID.
+*
+* Required scopes: `user_management:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2WorkspaceMembersByWorkspaceMemberId = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/workspace_members/{workspace_member_id}",
+	...options
+});
+/**
+* List notes
+*
+* List notes for all records or for a specific record.
+*
+* This endpoint is temporarily rate limited to 10 requests per second.
+*
+* Required scopes: `note:read`, `object_configuration:read`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2Notes = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/notes",
+	...options
+});
+/**
+* Create a note
+*
+* Creates a new note for a given record.
+*
+* Required scopes: `note:read-write`, `object_configuration:read`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2Notes = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/notes",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete a note
+*
+* Delete a single note by ID.
+*
+* Required scopes: `note:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const deleteV2NotesByNoteId = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/notes/{note_id}",
+	...options
+});
+/**
+* Get a note
+*
+* Get a single note by ID.
+*
+* Required scopes: `note:read`, `object_configuration:read`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2NotesByNoteId = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/notes/{note_id}",
+	...options
+});
+/**
+* Update a note
+*
+* Updates an existing note's title and/or content. Only the fields you provide are changed, and any field you omit is left untouched. Providing `content` replaces the note's entire content. A note's parent record cannot be changed.
+*
+* Required scopes: `note:read-write`, `object_configuration:read`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const patchV2NotesByNoteId = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/notes/{note_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List tasks
+*
+* List all tasks. Results are sorted by creation date, from oldest to newest.
+*
+* Required scopes: `task:read`, `object_configuration:read`, `record_permission:read`, `user_management:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2Tasks = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/tasks",
+	...options
+});
+/**
+* Create a task
+*
+* Creates a new task.
+*
+* At present, tasks can only be created from plaintext without record reference formatting.
+*
+* Required scopes: `task:read-write`, `object_configuration:read`, `record_permission:read`, `user_management:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2Tasks = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/tasks",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete a task
+*
+* Delete a task by ID.
+*
+* Required scopes: `task:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const deleteV2TasksByTaskId = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/tasks/{task_id}",
+	...options
+});
+/**
+* Get a task
+*
+* Get a single task by ID.
+*
+* Required scopes: `task:read`, `object_configuration:read`, `record_permission:read`, `user_management:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2TasksByTaskId = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/tasks/{task_id}",
+	...options
+});
+/**
+* Update a task
+*
+* Updates an existing task by `task_id`. At present, only the `deadline_at`, `is_completed`, `linked_records`, and `assignees` fields can be updated.
+*
+* Required scopes: `task:read-write`, `object_configuration:read`, `record_permission:read`, `user_management:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const patchV2TasksByTaskId = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/tasks/{task_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List threads
+*
+* List threads of comments on a record or list entry.
+*
+* Each thread in the response includes at most `80` replies, starting with the oldest. When a thread holds more, its `has_more_comments` is `true`; use [Get a thread and its comments](/rest-api/endpoint-reference/threads/get-a-thread-and-its-comments) to page through every comment in that thread.
+*
+* To view threads on records, you will need the `object_configuration:read` and `record_permission:read` scopes.
+*
+* To view threads on list entries, you will need the `list_configuration:read` and `list_entry:read` scopes.
+*
+* Required scopes: `comment:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2Threads = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/threads",
+	...options
+});
+/**
+* Get a thread and its comments
+*
+* Get a thread and page through its comments, oldest first, starting with the comment that opened it.
+*
+* Comments are paginated: at most `250` are returned per request. Keep paginating for as long as a `next_cursor` is returned.
+*
+* Supply `created_after` to return only the comments created after a timestamp, which is useful when polling a thread for new replies. The comment that opened the thread is returned only when it also satisfies the filter.
+*
+* To view threads on records, you will need the `object_configuration:read` and `record_permission:read` scopes.
+*
+* To view threads on list entries, you will need the `list_configuration:read` and `list_entry:read` scopes.
+*
+* Required scopes: `comment:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2ThreadsByThreadId = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/threads/{thread_id}",
+	...options
+});
+/**
+* Create a comment
+*
+* Creates a new comment related to an existing thread, record or entry.
+*
+* To create comments on records, you will need the `object_configuration:read` and `record_permission:read` scopes.
+*
+* To create comments on list entries, you will need the `list_configuration:read` and `list_entry:read` scopes.
+*
+* Required scopes: `comment:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2Comments = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/comments",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete a comment
+*
+* Deletes a comment by ID. If deleting a comment at the head of a thread, all messages in the thread are also deleted.
+*
+* A workspace-level access token may delete any comment. A user-level access token may only delete comments authored by the member it acts for.
+*
+* Required scopes: `comment:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const deleteV2CommentsByCommentId = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/comments/{comment_id}",
+	...options
+});
+/**
+* Get a comment
+*
+* Get a single comment by ID.
+*
+* To view comments on records, you will need the `object_configuration:read` and `record_permission:read` scopes.
+*
+* To view comments on list entries, you will need the `list_configuration:read` and `list_entry:read` scopes.
+*
+* Required scopes: `comment:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2CommentsByCommentId = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/comments/{comment_id}",
+	...options
+});
+/**
+* List emails
+*
+* Lists email metadata from your workspace's connected mailboxes. Email content is never returned.
+*
+* At least one of `linked_object` with `linked_record_ids`, `participants`, or `domain` must be supplied; there is no way to list every email. When several are supplied they are combined with OR: emails matching any of the filters are returned.
+*
+* > **Requesting access:** this endpoint is enabled per workspace and per app while it is in alpha. Contact [support@attio.com](mailto:support@attio.com) to request access.
+*
+* **Things to know**
+*
+* - Filters that identify your own workspace are ignored. This covers a member's or invited member's address, one of your mailboxes, and any of their domains. If every filter you supply is ignored, an empty page is returned.
+* - A filter that names a protected recipient in your workspace is rejected rather than ignored. This covers an address or a domain you supply directly. A record whose address or domain is a protected recipient is ignored instead, in the same way as the filters above.
+* - Emails from a mailbox shared with your workspace as metadata only are returned without a subject line. An email is left out entirely when it has no participant you may see — that is, when every participant outside your workspace is a protected recipient.
+* - An email that reached more than one of your mailboxes is returned once, and `id.mailbox_id` identifies whichever copy was readable.
+* - `linked_records` is derived when you make the request rather than stored, so it reflects your records as they are now.
+* - Emails are returned newest first, ordered by when they were sent. Each request scans a bounded number of emails, so a page can hold fewer emails than `limit`, or none at all, while more are still available. Keep paginating for as long as a `next_cursor` is returned, rather than stopping on a short page.
+*
+* This endpoint is in alpha and may be subject to breaking changes as we gather feedback.
+*
+* Required scopes: `email:read`, `record_permission:read`, `object_configuration:read`.
+*
+* Supported token levels: `workspace`.
+*/
+const getV2Emails = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/emails",
+	...options
+});
+/**
+* Add emails to the unsubscribe list
+*
+* Adds email addresses to the workspace's sequence unsubscribe list. Email addresses on the unsubscribe list cannot be enrolled in any sequence, and any of their active sequence runs are exited. Email addresses that are already on the unsubscribe list are ignored, so this endpoint is safe to retry.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `sequence_unsubscribe:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2SequencesUnsubscribedEmails = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/sequences/unsubscribed_emails",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List meetings
+*
+* Lists all meetings in the workspace using a deterministic sort order. When both the `participants` and `linked_record_id` filters are supplied, they are combined with OR: meetings that match either filter are returned.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `meeting:read`, `record_permission:read`.
+*
+* Supported token levels: `workspace`.
+*/
+const getV2Meetings = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/meetings",
+	...options
+});
+/**
+* Create a meeting
+*
+* Creates a new meeting. [See here](/rest-api/guides/syncing-meetings) for guidance on avoiding duplicate meetings.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `meeting:read-write`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2Meetings = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/meetings",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete a meeting
+*
+* Deletes a single meeting by ID.
+*
+* Meetings created by calendar sync cannot be deleted through the API. Delete the underlying calendar event, or disconnect the calendar, instead.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `meeting:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const deleteV2MeetingsByMeetingId = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/meetings/{meeting_id}",
+	...options
+});
+/**
+* Get a meeting
+*
+* Get a single meeting by ID.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `meeting:read`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2MeetingsByMeetingId = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/meetings/{meeting_id}",
+	...options
+});
+/**
+* Update a meeting (append linked records)
+*
+* Links records to a meeting. The records supplied are added to the meeting's existing linked records, and records which are already linked are ignored. Use the `PUT` endpoint to replace or remove linked records.
+*
+* No other meeting fields can be updated. Attio automatically links the meeting participants' companies to the meeting; this behavior is asynchronous.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `meeting:read-write`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const patchV2MeetingsByMeetingId = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/meetings/{meeting_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Update a meeting (overwrite linked records)
+*
+* Replaces a meeting's linked records with the records supplied. Any record which is currently linked and is not in the request is unlinked, including records which Attio linked automatically from the meeting's participants. Passing an empty array unlinks every record. Use the `PATCH` endpoint to add linked records without removing the records which already exist.
+*
+* No other meeting fields can be updated. Attio automatically links the meeting participants' companies to the meeting; this behavior is asynchronous, so a company which is linked after this request completes is not removed by it.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `meeting:read-write`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const putV2MeetingsByMeetingId = (options) => (options.client ?? client).put({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/meetings/{meeting_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* List call recordings
+*
+* List all call recordings for a meeting.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `meeting:read`, `call_recording:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2MeetingsByMeetingIdCallRecordings = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/meetings/{meeting_id}/call_recordings",
+	...options
+});
+/**
+* Create call recording
+*
+* Create a call recording for a meeting. This endpoint is rate limited to 1 request per second.
+*
+* A `transcript` should always be provided — it is technically optional for backwards compatibility, but a call recording created without one will be missing summaries and other transcript-derived features. `video_url` is optional, and a transcript-only call recording (with no video) is fully supported.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `meeting:read`, `call_recording:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2MeetingsByMeetingIdCallRecordings = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/meetings/{meeting_id}/call_recordings",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete call recording
+*
+* Deletes the specified call recording. This will remove the call recording and all associated data.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `meeting:read`, `call_recording:read-write`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const deleteV2MeetingsByMeetingIdCallRecordingsByCallRecordingId = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/meetings/{meeting_id}/call_recordings/{call_recording_id}",
+	...options
+});
+/**
+* Get call recording
+*
+* Get a single call recording by ID.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `meeting:read`, `call_recording:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2MeetingsByMeetingIdCallRecordingsByCallRecordingId = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/meetings/{meeting_id}/call_recordings/{call_recording_id}",
+	...options
+});
+/**
+* Deprecated: Get call transcript
+*
+* Deprecated: prefer using `GET /v2/meetings/:meeting_id/call_recordings/:call_recording_id` to get the transcript for a call recording.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `meeting:read`, `call_recording:read`.
+*
+* Supported token levels: `workspace`.
+*/
+const getV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdTranscript = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/meetings/{meeting_id}/call_recordings/{call_recording_id}/transcript",
+	...options
+});
+/**
+* List files
+*
+* Lists internal files, externally connected files and folders for a specific record. Use the `object` and `record_id` query parameters to specify the record. Optional query parameters may be provided to filter results by storage provider or parent folder.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `object_configuration:read`, `record_permission:read`, `file:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2Files = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/files",
+	...options
+});
+/**
+* Create a folder
+*
+* Creates a native folder entry or a connected file/folder entry on an object record.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `file:read-write`, `object_configuration:read`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const postV2Files = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/files",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete a file
+*
+* Delete a single file by ID. Deleting a folder will delete all of its descendants.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `file:read-write`, `object_configuration:read`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const deleteV2FilesByFileId = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/files/{file_id}",
+	...options
+});
+/**
+* Get a file
+*
+* Get a single file entry by ID.
+*
+* This endpoint is in beta. We will aim to avoid breaking changes, but small updates may be made as we roll out to more users.
+*
+* Required scopes: `file:read`, `object_configuration:read`, `record_permission:read`.
+*
+* Supported token levels: `workspace`, `user`.
+*/
+const getV2FilesByFileId = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/files/{file_id}",
+	...options
+});
+/**
+* List webhooks
+*
+* Get all of the webhooks in your workspace.
+*
+* Required scopes: `webhook:read`.
+*
+* Supported token levels: `workspace`.
+*/
+const getV2Webhooks = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/webhooks",
+	...options
+});
+/**
+* Create a webhook
+*
+* Create a webhook and associated subscriptions.
+*
+* Each combination of target URL, event type and filter must be unique within your workspace; duplicates are rejected with a 409.
+*
+* Required scopes: `webhook:read-write`.
+*
+* Supported token levels: `workspace`.
+*/
+const postV2Webhooks = (options) => (options.client ?? client).post({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/webhooks",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Delete a webhook
+*
+* Delete a webhook by ID.
+*
+* Required scopes: `webhook:read-write`.
+*
+* Supported token levels: `workspace`.
+*/
+const deleteV2WebhooksByWebhookId = (options) => (options.client ?? client).delete({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/webhooks/{webhook_id}",
+	...options
+});
+/**
+* Get a webhook
+*
+* Get a single webhook.
+*
+* Required scopes: `webhook:read`.
+*
+* Supported token levels: `workspace`.
+*/
+const getV2WebhooksByWebhookId = (options) => (options.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/webhooks/{webhook_id}",
+	...options
+});
+/**
+* Update a webhook
+*
+* Update a webhook and associated subscriptions.
+*
+* Each combination of target URL, event type and filter must be unique within your workspace; duplicates are rejected with a 409. Changing the target URL re-checks the webhook's existing subscriptions against the new URL.
+*
+* Required scopes: `webhook:read-write`.
+*
+* Supported token levels: `workspace`.
+*/
+const patchV2WebhooksByWebhookId = (options) => (options.client ?? client).patch({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/webhooks/{webhook_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
+	}
+});
+/**
+* Identify
+*
+* Identify the current access token, the workspace it is linked to, and any permissions it has.
+*
+* Every kind of Attio access token can be introspected:
+*
+* - **Workspace access tokens**, created from a workspace's settings. These have no OAuth client, so `client_id` and `aud` contain the workspace access token's own ID.
+* - **OAuth access tokens**, granted to an app through the OAuth 2.0 authorization code flow. `client_id` and `aud` contain the app ID.
+* - **App access tokens**, issued to an app installation and exposed to that app's server functions as `ATTIO_API_TOKEN`. `client_id` and `aud` contain the app ID.
+*
+* Per [RFC 7662](https://www.rfc-editor.org/rfc/rfc7662), `active` is the only member guaranteed to be present. `exp` is always `null`, because Attio access tokens do not currently expire.
+* All other members are optional, and are omitted rather than returned as `null` when they are not present.
+*
+* Unknown, revoked, and deleted tokens are not treated as an error. They return `200` with `{"active": false}` and no other members.
+*/
+const getV2Self = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/self",
+	...options
+});
+//#endregion
+//#region src/types/attio/commands.gen.ts
+const groups = {
+	objects: {
+		commands: {
+			"list-objects": operation({
+				body: "none",
+				call: getV2Objects,
+				description: "List objects",
+				options: []
+			}),
+			"create-an-object": operation({
+				body: "required",
+				call: postV2Objects,
+				description: "Create an object",
+				options: []
+			}),
+			"delete-an-object": operation({
+				body: "none",
+				call: deleteV2ObjectsByObject,
+				description: "Delete an object",
+				options: [{
+					description: "A UUID or slug to identify the object.",
+					in: "path",
+					name: "object",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"get-an-object": operation({
+				body: "none",
+				call: getV2ObjectsByObject,
+				description: "Get an object",
+				options: [{
+					description: "A UUID or slug to identify the object.",
+					in: "path",
+					name: "object",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"update-an-object": operation({
+				body: "required",
+				call: patchV2ObjectsByObject,
+				description: "Update an object",
+				options: [{
+					description: "A UUID or slug to identify the object.",
+					in: "path",
+					name: "object",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"list-views-for-object": operation({
+				body: "none",
+				call: getV2ObjectsByObjectViews,
+				description: "List views for object",
+				options: [
+					{
+						description: "A UUID or slug to identify the object.",
+						in: "path",
+						name: "object",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "`true` to include archived views. See our [archiving guide](/docs/archiving-vs-deleting) for more information on archiving.",
+						in: "query",
+						name: "show_archived",
+						required: false,
+						type: "boolean"
+					},
+					{
+						description: "The maximum number of views to return. Must be between 1 and 1000. Defaults to 500.",
+						in: "query",
+						name: "limit",
+						required: false,
+						type: "integer"
+					},
+					{
+						description: "A pagination cursor from a previous response's `pagination.next_cursor`. Omit for the first page.",
+						in: "query",
+						name: "cursor",
+						required: false,
+						type: "string"
+					}
+				]
+			})
+		},
+		description: "Objects are the core data models inside of Attio."
+	},
+	activities: {
+		commands: {
+			"list-activities": operation({
+				body: "none",
+				call: getV2Activities,
+				description: "List activities",
+				options: [{
+					description: "The maximum number of activities to return. Must be between 1 and 1000. Defaults to 100.",
+					in: "query",
+					name: "limit",
+					required: false,
+					type: "integer"
+				}, {
+					description: "A pagination cursor used to fetch the next page of activities. Responses with more activities will include a cursor for you to use here. If not provided, the first page will be returned.",
+					in: "query",
+					name: "cursor",
+					required: false,
+					type: "string"
+				}]
+			}),
+			"create-an-activity": operation({
+				body: "required",
+				call: postV2Activities,
+				description: "Create an activity",
+				options: []
+			}),
+			"delete-an-activity": operation({
+				body: "none",
+				call: deleteV2ActivitiesByActivity,
+				description: "Delete an activity",
+				options: [{
+					description: "A UUID or slug to identify the activity.",
+					in: "path",
+					name: "activity",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"get-an-activity": operation({
+				body: "none",
+				call: getV2ActivitiesByActivity,
+				description: "Get an activity",
+				options: [{
+					description: "A UUID or slug to identify the activity.",
+					in: "path",
+					name: "activity",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"update-an-activity": operation({
+				body: "required",
+				call: patchV2ActivitiesByActivity,
+				description: "Update an activity",
+				options: [{
+					description: "A UUID or slug to identify the activity.",
+					in: "path",
+					name: "activity",
+					required: true,
+					type: "string"
+				}]
+			})
+		},
+		description: ""
+	},
+	"activity-records": {
+		commands: {
+			"list-activity-records": operation({
+				body: "required",
+				call: postV2ActivitiesByActivityRecordsQuery,
+				description: "List activity records",
+				options: [{
+					description: "A UUID or slug to identify the activity.",
+					in: "path",
+					name: "activity",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"create-an-activity-record": operation({
+				body: "required",
+				call: postV2ActivitiesByActivityRecords,
+				description: "Create an activity record",
+				options: [{
+					description: "A UUID or slug to identify the activity.",
+					in: "path",
+					name: "activity",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"upsert-an-activity-record": operation({
+				body: "required",
+				call: putV2ActivitiesByActivityRecords,
+				description: "Upsert an activity record",
+				options: [{
+					description: "A UUID or slug to identify the activity.",
+					in: "path",
+					name: "activity",
+					required: true,
+					type: "string"
+				}, {
+					description: "The ID or slug of the attribute to use to check if an activity record already exists. The attribute must be unique.",
+					in: "query",
+					name: "matching_attribute",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"delete-an-activity-record": operation({
+				body: "none",
+				call: deleteV2ActivitiesByActivityRecordsByRecordId,
+				description: "Delete an activity record",
+				options: [{
+					description: "A UUID or slug to identify the activity.",
+					in: "path",
+					name: "activity",
+					required: true,
+					type: "string"
+				}, {
+					description: "A UUID identifying the activity record to delete.",
+					in: "path",
+					name: "record_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"get-an-activity-record": operation({
+				body: "none",
+				call: getV2ActivitiesByActivityRecordsByRecordId,
+				description: "Get an activity record",
+				options: [{
+					description: "A UUID or slug to identify the activity.",
+					in: "path",
+					name: "activity",
+					required: true,
+					type: "string"
+				}, {
+					description: "A UUID identifying the activity record.",
+					in: "path",
+					name: "record_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"update-an-activity-record-append-multiselect-values": operation({
+				body: "required",
+				call: patchV2ActivitiesByActivityRecordsByRecordId,
+				description: "Update an activity record (append multiselect values)",
+				options: [{
+					description: "A UUID or slug to identify the activity.",
+					in: "path",
+					name: "activity",
+					required: true,
+					type: "string"
+				}, {
+					description: "A UUID identifying the activity record to update.",
+					in: "path",
+					name: "record_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"update-an-activity-record-overwrite-multiselect-values": operation({
+				body: "required",
+				call: putV2ActivitiesByActivityRecordsByRecordId,
+				description: "Update an activity record (overwrite multiselect values)",
+				options: [{
+					description: "A UUID or slug to identify the activity.",
+					in: "path",
+					name: "activity",
+					required: true,
+					type: "string"
+				}, {
+					description: "A UUID identifying the activity record to update.",
+					in: "path",
+					name: "record_id",
+					required: true,
+					type: "string"
+				}]
+			})
+		},
+		description: ""
+	},
+	attributes: {
+		commands: {
+			"list-attributes": operation({
+				body: "none",
+				call: getV2ByTargetByIdentifierAttributes,
+				description: "List attributes",
+				options: [
+					{
+						description: "Whether the attributes are on an object or a list.",
+						in: "path",
+						name: "target",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the object or list the attributes belong to.",
+						in: "path",
+						name: "identifier",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "The maximum number of results to return. See the [full guide to pagination here](/rest-api/guides/pagination).",
+						in: "query",
+						name: "limit",
+						required: false,
+						type: "integer"
+					},
+					{
+						description: "The number of results to skip over before returning. See the [full guide to pagination here](/rest-api/guides/pagination).",
+						in: "query",
+						name: "offset",
+						required: false,
+						type: "integer"
+					},
+					{
+						description: "Whether archived attributes should be included in the results. See the [full guide to archiving here](/docs/archiving-vs-deleting).",
+						in: "query",
+						name: "show_archived",
+						required: false,
+						type: "boolean"
+					}
+				]
+			}),
+			"create-an-attribute": operation({
+				body: "required",
+				call: postV2ByTargetByIdentifierAttributes,
+				description: "Create an attribute",
+				options: [{
+					description: "Whether the attribute is to be created on an object or a list.",
+					in: "path",
+					name: "target",
+					required: true,
+					type: "string"
+				}, {
+					description: "A UUID or slug to identify the object or list the attribute belongs to.",
+					in: "path",
+					name: "identifier",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"get-an-attribute": operation({
+				body: "none",
+				call: getV2ByTargetByIdentifierAttributesByAttribute,
+				description: "Get an attribute",
+				options: [
+					{
+						description: "Whether the attribute is on an object or a list.",
+						in: "path",
+						name: "target",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the object or list the attribute belongs to.",
+						in: "path",
+						name: "identifier",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the attribute.",
+						in: "path",
+						name: "attribute",
+						required: true,
+						type: "string"
+					}
+				]
+			}),
+			"update-an-attribute": operation({
+				body: "required",
+				call: patchV2ByTargetByIdentifierAttributesByAttribute,
+				description: "Update an attribute",
+				options: [
+					{
+						description: "Whether the attribute is on an object or a list.",
+						in: "path",
+						name: "target",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the object or list the attribute belongs to.",
+						in: "path",
+						name: "identifier",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the attribute.",
+						in: "path",
+						name: "attribute",
+						required: true,
+						type: "string"
+					}
+				]
+			}),
+			"list-select-options": operation({
+				body: "none",
+				call: getV2ByTargetByIdentifierAttributesByAttributeOptions,
+				description: "List select options",
+				options: [
+					{
+						description: "Whether the attribute is on an object or a list.",
+						in: "path",
+						name: "target",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the object or list the select attribute belongs to.",
+						in: "path",
+						name: "identifier",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the attribute you want to list select options on.",
+						in: "path",
+						name: "attribute",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "`true` if you want the results to include archived select options.",
+						in: "query",
+						name: "show_archived",
+						required: false,
+						type: "boolean"
+					}
+				]
+			}),
+			"create-a-select-option": operation({
+				body: "required",
+				call: postV2ByTargetByIdentifierAttributesByAttributeOptions,
+				description: "Create a select option",
+				options: [
+					{
+						description: "Whether the attribute is on an object or a list.",
+						in: "path",
+						name: "target",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the object or list the select attribute belongs to.",
+						in: "path",
+						name: "identifier",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the attribute to create a select option on.",
+						in: "path",
+						name: "attribute",
+						required: true,
+						type: "string"
+					}
+				]
+			}),
+			"update-a-select-option": operation({
+				body: "required",
+				call: patchV2ByTargetByIdentifierAttributesByAttributeOptionsByOption,
+				description: "Update a select option",
+				options: [
+					{
+						description: "Whether the attribute is on an object or a list.",
+						in: "path",
+						name: "target",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the object or list the select attribute belongs to.",
+						in: "path",
+						name: "identifier",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the select attribute.",
+						in: "path",
+						name: "attribute",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or select option title to identify the select option you would like to update.",
+						in: "path",
+						name: "option",
+						required: true,
+						type: "string"
+					}
+				]
+			}),
+			"list-statuses": operation({
+				body: "none",
+				call: getV2ByTargetByIdentifierAttributesByAttributeStatuses,
+				description: "List statuses",
+				options: [
+					{
+						description: "Whether the attribute is on an object or a list.",
+						in: "path",
+						name: "target",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the object or list the status attribute belongs to.",
+						in: "path",
+						name: "identifier",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the attribute you want to list statuses on.",
+						in: "path",
+						name: "attribute",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "`true` if you want the results to include archived statuses. See our [archiving guide](/docs/archiving-vs-deleting) for more information on archiving.",
+						in: "query",
+						name: "show_archived",
+						required: false,
+						type: "boolean"
+					}
+				]
+			}),
+			"create-a-status": operation({
+				body: "required",
+				call: postV2ByTargetByIdentifierAttributesByAttributeStatuses,
+				description: "Create a status",
+				options: [
+					{
+						description: "Whether the attribute is on an object or a list.",
+						in: "path",
+						name: "target",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the object or list the status attribute belongs to.",
+						in: "path",
+						name: "identifier",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the attribute the status will belong to.",
+						in: "path",
+						name: "attribute",
+						required: true,
+						type: "string"
+					}
+				]
+			}),
+			"update-a-status": operation({
+				body: "required",
+				call: patchV2ByTargetByIdentifierAttributesByAttributeStatusesByStatus,
+				description: "Update a status",
+				options: [
+					{
+						description: "Whether the attribute is on an object or a list.",
+						in: "path",
+						name: "target",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the object or list the status attribute belongs to.",
+						in: "path",
+						name: "identifier",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the attribute to update the status on.",
+						in: "path",
+						name: "attribute",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or status title to identify the status to update.",
+						in: "path",
+						name: "status",
+						required: true,
+						type: "string"
+					}
+				]
+			})
+		},
+		description: "Attributes model properties of objects and lists."
+	},
+	records: {
+		commands: {
+			"list-records": operation({
+				body: "required",
+				call: postV2ObjectsByObjectRecordsQuery,
+				description: "List records",
+				options: [{
+					description: "A UUID or slug to identify the object to list records for.",
+					in: "path",
+					name: "object",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"create-a-record": operation({
+				body: "required",
+				call: postV2ObjectsByObjectRecords,
+				description: "Create a record",
+				options: [{
+					description: "The UUID or slug identifying the object the created record should belong to.",
+					in: "path",
+					name: "object",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"upsert-a-record": operation({
+				body: "required",
+				call: putV2ObjectsByObjectRecords,
+				description: "Upsert a record",
+				options: [{
+					description: "A UUID or slug to identify the object the record should belong to.",
+					in: "path",
+					name: "object",
+					required: true,
+					type: "string"
+				}, {
+					description: "The ID or slug of the attribute to use to check if a record already exists. The attribute must be unique.",
+					in: "query",
+					name: "matching_attribute",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"delete-a-record": operation({
+				body: "none",
+				call: deleteV2ObjectsByObjectRecordsByRecordId,
+				description: "Delete a record",
+				options: [{
+					description: "The UUID or slug of the object the record belongs to.",
+					in: "path",
+					name: "object",
+					required: true,
+					type: "string"
+				}, {
+					description: "The UUID of the record to delete.",
+					in: "path",
+					name: "record_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"get-a-record": operation({
+				body: "none",
+				call: getV2ObjectsByObjectRecordsByRecordId,
+				description: "Get a record",
+				options: [{
+					description: "A UUID or slug identifying the object that the record belongs to.",
+					in: "path",
+					name: "object",
+					required: true,
+					type: "string"
+				}, {
+					description: "A UUID identifying the record.",
+					in: "path",
+					name: "record_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"update-a-record-append-multiselect-values": operation({
+				body: "required",
+				call: patchV2ObjectsByObjectRecordsByRecordId,
+				description: "Update a record (append multiselect values)",
+				options: [{
+					description: "A UUID or slug of the object the record belongs to.",
+					in: "path",
+					name: "object",
+					required: true,
+					type: "string"
+				}, {
+					description: "A UUID of the record to update.",
+					in: "path",
+					name: "record_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"update-a-record-overwrite-multiselect-values": operation({
+				body: "required",
+				call: putV2ObjectsByObjectRecordsByRecordId,
+				description: "Update a record (overwrite multiselect values)",
+				options: [{
+					description: "A UUID or slug of the object the record belongs to.",
+					in: "path",
+					name: "object",
+					required: true,
+					type: "string"
+				}, {
+					description: "A UUID of the record to update.",
+					in: "path",
+					name: "record_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"merge-two-records": operation({
+				body: "required",
+				call: postV2ObjectsByObjectRecordsMerge,
+				description: "Merge two records",
+				options: [{
+					description: "A UUID or slug of the object both records belong to.",
+					in: "path",
+					name: "object",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"list-record-attribute-values": operation({
+				body: "none",
+				call: getV2ObjectsByObjectRecordsByRecordIdAttributesByAttributeValues,
+				description: "List record attribute values",
+				options: [
+					{
+						description: "A UUID or slug to identify the object the record belongs to.",
+						in: "path",
+						name: "object",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID to identify the record you want to query values on.",
+						in: "path",
+						name: "record_id",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the attribute you want to query values on.",
+						in: "path",
+						name: "attribute",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "If `true`, the endpoint will return all historic values for the attribute. If `false`, the endpoint will only return the currently active value(s). Defaults to `false`. Cannot be set to `true` for COMINT attributes or enriched attributes on people/company objects.",
+						in: "query",
+						name: "show_historic",
+						required: false,
+						type: "boolean"
+					},
+					{
+						description: "The maximum number of results to return. See the [full guide to pagination here](/rest-api/guides/pagination).",
+						in: "query",
+						name: "limit",
+						required: false,
+						type: "integer"
+					},
+					{
+						description: "The number of results to skip over before returning. See the [full guide to pagination here](/rest-api/guides/pagination).",
+						in: "query",
+						name: "offset",
+						required: false,
+						type: "integer"
+					}
+				]
+			}),
+			"write-record-attribute-values": operation({
+				body: "required",
+				call: putV2ObjectsByObjectRecordsByRecordIdAttributesByAttributeValues,
+				description: "Write record attribute values",
+				options: [
+					{
+						description: "A UUID or slug to identify the object the record belongs to.",
+						in: "path",
+						name: "object",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID to identify the record you want to query values on.",
+						in: "path",
+						name: "record_id",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the attribute you want to query values on.",
+						in: "path",
+						name: "attribute",
+						required: true,
+						type: "string"
+					}
+				]
+			}),
+			"list-record-entries": operation({
+				body: "none",
+				call: getV2ObjectsByObjectRecordsByRecordIdEntries,
+				description: "List record entries",
+				options: [
+					{
+						description: "A UUID or slug identifying the object that the record belongs to.",
+						in: "path",
+						name: "object",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID identifying the record.",
+						in: "path",
+						name: "record_id",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "The maximum number of results to return. The default is `100` and the maximum is `1000`. See the [full guide to pagination here](/rest-api/guides/pagination).",
+						in: "query",
+						name: "limit",
+						required: false,
+						type: "integer"
+					},
+					{
+						description: "The number of results to skip over before returning. The default is `0`. See the [full guide to pagination here](/rest-api/guides/pagination).",
+						in: "query",
+						name: "offset",
+						required: false,
+						type: "integer"
+					}
+				]
+			}),
+			"search-records": operation({
+				body: "required",
+				call: postV2ObjectsRecordsSearch,
+				description: "Search records",
+				options: []
+			})
+		},
+		description: "Records are individual instances of objects e.g. a specific person or company."
+	},
+	sql: {
+		commands: { "query-sql": operation({
+			body: "required",
+			call: postV2Sql,
+			description: "Query SQL",
+			options: []
+		}) },
+		description: "Query records and list entries across your workspace using SQL."
+	},
+	lists: {
+		commands: {
+			"list-all-lists": operation({
+				body: "none",
+				call: getV2Lists,
+				description: "List all lists",
+				options: []
+			}),
+			"create-a-list": operation({
+				body: "required",
+				call: postV2Lists,
+				description: "Create a list",
+				options: []
+			}),
+			"get-a-list": operation({
+				body: "none",
+				call: getV2ListsByList,
+				description: "Get a list",
+				options: [{
+					description: "A UUID or slug to identify the list.",
+					in: "path",
+					name: "list",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"update-a-list": operation({
+				body: "required",
+				call: patchV2ListsByList,
+				description: "Update a list",
+				options: [{
+					description: "A UUID or slug to identify the list to update.",
+					in: "path",
+					name: "list",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"list-views-for-list": operation({
+				body: "none",
+				call: getV2ListsByListViews,
+				description: "List views for list",
+				options: [
+					{
+						description: "A UUID or slug to identify the list.",
+						in: "path",
+						name: "list",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "`true` to include archived views. See our [archiving guide](/docs/archiving-vs-deleting) for more information on archiving.",
+						in: "query",
+						name: "show_archived",
+						required: false,
+						type: "boolean"
+					},
+					{
+						description: "The maximum number of views to return. Must be between 1 and 1000. Defaults to 500.",
+						in: "query",
+						name: "limit",
+						required: false,
+						type: "integer"
+					},
+					{
+						description: "A pagination cursor from a previous response's `pagination.next_cursor`. Omit for the first page.",
+						in: "query",
+						name: "cursor",
+						required: false,
+						type: "string"
+					}
+				]
+			})
+		},
+		description: "Lists are used to model a particular process."
+	},
+	entries: {
+		commands: {
+			"list-entries": operation({
+				body: "required",
+				call: postV2ListsByListEntriesQuery,
+				description: "List entries",
+				options: [{
+					description: "A UUID or slug to identify the list to retrieve entries from.",
+					in: "path",
+					name: "list",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"create-an-entry-add-record-to-list": operation({
+				body: "required",
+				call: postV2ListsByListEntries,
+				description: "Create an entry (add record to list)",
+				options: [{
+					description: "The UUID or slug identifying the list that the created list entry should belong to.",
+					in: "path",
+					name: "list",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"upsert-a-list-entry-by-parent": operation({
+				body: "required",
+				call: putV2ListsByListEntries,
+				description: "Upsert a list entry by parent",
+				options: [{
+					description: "A UUID or slug of the list the list entry belongs to.",
+					in: "path",
+					name: "list",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"delete-a-list-entry": operation({
+				body: "none",
+				call: deleteV2ListsByListEntriesByEntryId,
+				description: "Delete a list entry",
+				options: [{
+					description: "A UUID or slug identifying the list the entry is in.",
+					in: "path",
+					name: "list",
+					required: true,
+					type: "string"
+				}, {
+					description: "A UUID identifying the entry to delete.",
+					in: "path",
+					name: "entry_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"get-a-list-entry": operation({
+				body: "none",
+				call: getV2ListsByListEntriesByEntryId,
+				description: "Get a list entry",
+				options: [{
+					description: "A UUID or slug identifying the list the entry is in.",
+					in: "path",
+					name: "list",
+					required: true,
+					type: "string"
+				}, {
+					description: "A UUID identifying the entry.",
+					in: "path",
+					name: "entry_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"update-a-list-entry-append-multiselect-values": operation({
+				body: "required",
+				call: patchV2ListsByListEntriesByEntryId,
+				description: "Update a list entry (append multiselect values)",
+				options: [{
+					description: "A UUID or slug of the list the list entry belongs to.",
+					in: "path",
+					name: "list",
+					required: true,
+					type: "string"
+				}, {
+					description: "A UUID of the list entry to update.",
+					in: "path",
+					name: "entry_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"update-a-list-entry-overwrite-multiselect-values": operation({
+				body: "required",
+				call: putV2ListsByListEntriesByEntryId,
+				description: "Update a list entry (overwrite multiselect values)",
+				options: [{
+					description: "A UUID or slug of the list the list entry belongs to.",
+					in: "path",
+					name: "list",
+					required: true,
+					type: "string"
+				}, {
+					description: "A UUID of the list entry to update.",
+					in: "path",
+					name: "entry_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"list-attribute-values-for-a-list-entry": operation({
+				body: "none",
+				call: getV2ListsByListEntriesByEntryIdAttributesByAttributeValues,
+				description: "List attribute values for a list entry",
+				options: [
+					{
+						description: "A UUID or slug identifying the list the entry is in.",
+						in: "path",
+						name: "list",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID identifying the entry.",
+						in: "path",
+						name: "entry_id",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the attribute you want to query values on.",
+						in: "path",
+						name: "attribute",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "If `true`, the endpoint will return all historic values for the attribute. If `false`, the endpoint will only return the currently active value(s). Defaults to `false`. Can only be set to `true` for attributes which support historic data; the endpoint will throw if set to `true` for non-historic attributes.",
+						in: "query",
+						name: "show_historic",
+						required: false,
+						type: "boolean"
+					},
+					{
+						description: "The maximum number of results to return. See the [full guide to pagination here](/rest-api/guides/pagination).",
+						in: "query",
+						name: "limit",
+						required: false,
+						type: "integer"
+					},
+					{
+						description: "The number of results to skip over before returning. See the [full guide to pagination here](/rest-api/guides/pagination).",
+						in: "query",
+						name: "offset",
+						required: false,
+						type: "integer"
+					}
+				]
+			}),
+			"write-list-entry-attribute-values": operation({
+				body: "required",
+				call: putV2ListsByListEntriesByEntryIdAttributesByAttributeValues,
+				description: "Write list entry attribute values",
+				options: [
+					{
+						description: "A UUID or slug identifying the list the entry is in.",
+						in: "path",
+						name: "list",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID identifying the entry.",
+						in: "path",
+						name: "entry_id",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "A UUID or slug to identify the attribute you want to query values on.",
+						in: "path",
+						name: "attribute",
+						required: true,
+						type: "string"
+					}
+				]
+			})
+		},
+		description: "Entries are elements in a list that reference a single parent record."
+	},
+	"workspace-members": {
+		commands: {
+			"list-workspace-members": operation({
+				body: "none",
+				call: getV2WorkspaceMembers,
+				description: "List workspace members",
+				options: []
+			}),
+			"get-a-workspace-member": operation({
+				body: "none",
+				call: getV2WorkspaceMembersByWorkspaceMemberId,
+				description: "Get a workspace member",
+				options: [{
+					description: "A UUID to identify the workspace member.",
+					in: "path",
+					name: "workspace_member_id",
+					required: true,
+					type: "string"
+				}]
+			})
+		},
+		description: "Workspace members represent a user with access to a workspace."
+	},
+	notes: {
+		commands: {
+			"list-notes": operation({
+				body: "none",
+				call: getV2Notes,
+				description: "List notes",
+				options: [
+					{
+						description: "The maximum number of results to return. The default is `10` and the maximum is `50`. See the [full guide to pagination here](/rest-api/guides/pagination).",
+						in: "query",
+						name: "limit",
+						required: false,
+						type: "integer"
+					},
+					{
+						description: "The number of results to skip over before returning. The default is `0`. See the [full guide to pagination here](/rest-api/guides/pagination).",
+						in: "query",
+						name: "offset",
+						required: false,
+						type: "integer"
+					},
+					{
+						description: "The slug or ID of the parent object the notes belong to.",
+						in: "query",
+						name: "parent_object",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "The ID of the parent record the notes belong to.",
+						in: "query",
+						name: "parent_record_id",
+						required: false,
+						type: "string"
+					}
+				]
+			}),
+			"create-a-note": operation({
+				body: "required",
+				call: postV2Notes,
+				description: "Create a note",
+				options: []
+			}),
+			"delete-a-note": operation({
+				body: "none",
+				call: deleteV2NotesByNoteId,
+				description: "Delete a note",
+				options: [{
+					description: "A UUID which identifies the note to delete.",
+					in: "path",
+					name: "note_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"get-a-note": operation({
+				body: "none",
+				call: getV2NotesByNoteId,
+				description: "Get a note",
+				options: [{
+					description: "A UUID which identifies the note.",
+					in: "path",
+					name: "note_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"update-a-note": operation({
+				body: "required",
+				call: patchV2NotesByNoteId,
+				description: "Update a note",
+				options: [{
+					description: "A UUID which identifies the note to update.",
+					in: "path",
+					name: "note_id",
+					required: true,
+					type: "string"
+				}]
+			})
+		},
+		description: "Notes are rich text documents that reference a single parent record."
+	},
+	tasks: {
+		commands: {
+			"list-tasks": operation({
+				body: "none",
+				call: getV2Tasks,
+				description: "List tasks",
+				options: [
+					{
+						description: "The maximum number of results to return. Defaults to 500. See the [full guide to pagination here](/rest-api/guides/pagination).",
+						in: "query",
+						name: "limit",
+						required: false,
+						type: "integer"
+					},
+					{
+						description: "The number of results to skip over before returning. Defaults to 0. See the [full guide to pagination here](/rest-api/guides/pagination).",
+						in: "query",
+						name: "offset",
+						required: false,
+						type: "integer"
+					},
+					{
+						description: "Optionally sort the results. \"created_at:asc\" returns oldest results first, \"created_at:desc\" returns the newest results first. \"completed_at:asc\" and \"completed_at:desc\" sort by completion time. With \"completed_at:asc\", incomplete tasks (no completion date) appear first, followed by completed tasks oldest-first. With \"completed_at:desc\", completed tasks appear first (newest-first), followed by incomplete tasks. To exclude incomplete tasks, filter by is_completed. If unspecified, defaults to \"created_at:asc\" (oldest results first).",
+						in: "query",
+						name: "sort",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "Pass a value to this parameter to filter results to only those tasks that contain the specified record in the `linked_records` property of the task. This parameter should identify the object that the linked record belongs to. For example, if filtering to tasks that link to a specific person record, this parameter should be `people`. If provided, `linked_record_id` must also be provided.",
+						in: "query",
+						name: "linked_object",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "Pass a value to this parameter to filter results to only those tasks that contain the specified record in the `linked_records` property of the task. This parameter should contain the record ID of the linked record. If provided, `linked_object` must also be provided.",
+						in: "query",
+						name: "linked_record_id",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "Filter tasks by workspace member assignees. Workspace members can be referenced by either their email address or ID. Pass an empty value or the string `null` to find tasks with no assignee.",
+						in: "query",
+						name: "assignee",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "Filter tasks by whether they have been completed. By default, both completed and non-completed tasks are returned. Specify `true` to only return completed tasks, or `false` to only return non-completed tasks.",
+						in: "query",
+						name: "is_completed",
+						required: false,
+						type: "boolean"
+					}
+				]
+			}),
+			"create-a-task": operation({
+				body: "required",
+				call: postV2Tasks,
+				description: "Create a task",
+				options: []
+			}),
+			"delete-a-task": operation({
+				body: "none",
+				call: deleteV2TasksByTaskId,
+				description: "Delete a task",
+				options: [{
+					description: "The ID of the task to delete.",
+					in: "path",
+					name: "task_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"get-a-task": operation({
+				body: "none",
+				call: getV2TasksByTaskId,
+				description: "Get a task",
+				options: [{
+					description: "The ID of the task.",
+					in: "path",
+					name: "task_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"update-a-task": operation({
+				body: "required",
+				call: patchV2TasksByTaskId,
+				description: "Update a task",
+				options: [{
+					description: "The ID of the task to update.",
+					in: "path",
+					name: "task_id",
+					required: true,
+					type: "string"
+				}]
+			})
+		},
+		description: "A task is a defined, actionable item with references to linked records and assigned workspace members."
+	},
+	threads: {
+		commands: {
+			"list-threads": operation({
+				body: "none",
+				call: getV2Threads,
+				description: "List threads",
+				options: [
+					{
+						description: "Use this parameter to filter to threads on a specific record. Must be passed with `object`.",
+						in: "query",
+						name: "record_id",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "Use this parameter to filter to threads on a specific record. Must be passed with `record_id`. Accepts either a slug or an ID.",
+						in: "query",
+						name: "object",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "Use this parameter to filter to threads on a specific entry. Must be passed with `list`.",
+						in: "query",
+						name: "entry_id",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "Use this parameter to filter to threads on a specific entry. Must be passed with `entry_id`. Accepts either a slug or an ID.",
+						in: "query",
+						name: "list",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "The maximum number of results to return. The default is `10` and the maximum is `50`. See the [full guide to pagination here](/rest-api/guides/pagination).",
+						in: "query",
+						name: "limit",
+						required: false,
+						type: "integer"
+					},
+					{
+						description: "The number of results to skip over before returning. The default is `0`. See the [full guide to pagination here](/rest-api/guides/pagination).",
+						in: "query",
+						name: "offset",
+						required: false,
+						type: "integer"
+					}
+				]
+			}),
+			"get-a-thread-and-its-comments": operation({
+				body: "none",
+				call: getV2ThreadsByThreadId,
+				description: "Get a thread and its comments",
+				options: [
+					{
+						description: "A UUID which identifies the thread.",
+						in: "path",
+						name: "thread_id",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "The maximum number of comments to return. Defaults to `250`, which is also the maximum.",
+						in: "query",
+						name: "limit",
+						required: false,
+						type: "integer"
+					},
+					{
+						description: "A cursor for pagination. Use the `next_cursor` from the previous response to get the next page of comments.",
+						in: "query",
+						name: "cursor",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "Only return comments created after this timestamp.",
+						in: "query",
+						name: "created_after",
+						required: false,
+						type: "string"
+					}
+				]
+			})
+		},
+		description: "Threads are groups of comments on either a record or entry."
+	},
+	comments: {
+		commands: {
+			"create-a-comment": operation({
+				body: "required",
+				call: postV2Comments,
+				description: "Create a comment",
+				options: []
+			}),
+			"delete-a-comment": operation({
+				body: "none",
+				call: deleteV2CommentsByCommentId,
+				description: "Delete a comment",
+				options: [{
+					description: "The ID of the comment to delete.",
+					in: "path",
+					name: "comment_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"get-a-comment": operation({
+				body: "none",
+				call: getV2CommentsByCommentId,
+				description: "Get a comment",
+				options: [{
+					description: "A UUID which identifies the comment.",
+					in: "path",
+					name: "comment_id",
+					required: true,
+					type: "string"
+				}]
+			})
+		},
+		description: "Comments are messages on a thread."
+	},
+	emails: {
+		commands: { "list-emails": operation({
+			body: "none",
+			call: getV2Emails,
+			description: "List emails",
+			options: [
+				{
+					description: "The maximum number of emails to return. Must be between 1 and 50. Defaults to 25.",
+					in: "query",
+					name: "limit",
+					required: false,
+					type: "integer"
+				},
+				{
+					description: "A pagination cursor used to fetch the next page of emails. Responses with more emails will include a cursor for you to use here. If not provided, the first page will be returned.",
+					in: "query",
+					name: "cursor",
+					required: false,
+					type: "string"
+				},
+				{
+					description: "The object to filter emails by. Must be the slug or ID of either the people or companies object. If provided, linked_record_ids must also be provided.",
+					in: "query",
+					name: "linked_object",
+					required: false,
+					type: "string"
+				},
+				{
+					description: "A comma-separated list of up to 10 record IDs to filter emails by. All IDs must belong to the object given in `linked_object`, so filtering by both people and companies requires two requests. If provided, linked_object must also be provided.",
+					in: "query",
+					name: "linked_record_ids",
+					required: false,
+					type: "string"
+				},
+				{
+					description: "A comma-separated list of up to 10 email addresses. Emails that include at least one of them as a participant are returned.",
+					in: "query",
+					name: "participants",
+					required: false,
+					type: "string"
+				},
+				{
+					description: "A domain to filter emails by. Emails with at least one participant at this domain are returned.",
+					in: "query",
+					name: "domain",
+					required: false,
+					type: "string"
+				},
+				{
+					description: "Only return emails sent after this timestamp. `sent_after` is exclusive, so an email sent at exactly this timestamp is not returned.",
+					in: "query",
+					name: "sent_after",
+					required: false,
+					type: "string"
+				},
+				{
+					description: "Only return emails sent before this timestamp. `sent_before` is exclusive, so an email sent at exactly this timestamp is not returned.",
+					in: "query",
+					name: "sent_before",
+					required: false,
+					type: "string"
+				},
+				{
+					description: "If `true`, an email is only returned when at least one participant outside your workspace looks like a person rather than an automated sender (`notifications@`, `no-reply@`, meeting notetakers, …). Defaults to `false`, which returns every email regardless of who sent it.",
+					in: "query",
+					name: "exclude_automated_participants",
+					required: false,
+					type: "boolean"
+				}
+			]
+		}) },
+		description: "Emails are messages synced from connected mailboxes."
+	},
+	sequences: {
+		commands: { "add-emails-to-the-unsubscribe-list": operation({
+			body: "required",
+			call: postV2SequencesUnsubscribedEmails,
+			description: "Add emails to the unsubscribe list",
+			options: []
+		}) },
+		description: "Sequences are automated email campaigns sent from Attio."
+	},
+	meetings: {
+		commands: {
+			"list-meetings": operation({
+				body: "none",
+				call: getV2Meetings,
+				description: "List meetings",
+				options: [
+					{
+						description: "The maximum number of meetings to return. Must be between 1 and 200. Defaults to 50.",
+						in: "query",
+						name: "limit",
+						required: false,
+						type: "integer"
+					},
+					{
+						description: "A pagination cursor used to fetch the next page of meetings. Responses with more meetings will include a cursor for you to use here. If not provided, the first page will be returned.",
+						in: "query",
+						name: "cursor",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "The object to filter meetings by. Must be a valid object slug or ID. If provided, linked_record_id must also be provided.",
+						in: "query",
+						name: "linked_object",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "Used to filter meetings to only those values that include a specific linked record. Must be a valid record ID. If provided, linked_object must also be provided. When combined with `participants`, the filters are combined with OR: meetings matching either filter are returned.",
+						in: "query",
+						name: "linked_record_id",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "A comma-separated list of emails to filter meetings by. If provided, meetings will be filtered to only include meetings that include at least one of the provided emails as participants. When combined with `linked_record_id`, the filters are combined with OR: meetings matching either filter are returned.",
+						in: "query",
+						name: "participants",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "The order in which to sort the meetings. Defaults to start_asc.",
+						in: "query",
+						name: "sort",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "Use `ends_from` to filter meetings to only those that end after the specified timestamp. `ends_from` is inclusive, meaning that meetings that end at the exact timestamp will be included in results. When evaluating all-day meetings, we filter results from the perspective of a specific timezone (see `timezone` for more information).",
+						in: "query",
+						name: "ends_from",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "Use `starts_before` to filter meetings to only those that start before the specified timestamp. `starts_before` is exclusive, meaning that meetings that start at the exact timestamp will not be included in results. When evaluating all-day meetings, we filter results from the perspective of a specific timezone (see `timezone` for more information).",
+						in: "query",
+						name: "starts_before",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "The timezone to use when filtering meetings using `ends_from` and `starts_before`. Defaults to UTC. This property has no effect for non-all-day meetings.",
+						in: "query",
+						name: "timezone",
+						required: false,
+						type: "string"
+					}
+				]
+			}),
+			"create-a-meeting": operation({
+				body: "required",
+				call: postV2Meetings,
+				description: "Create a meeting",
+				options: []
+			}),
+			"delete-a-meeting": operation({
+				body: "none",
+				call: deleteV2MeetingsByMeetingId,
+				description: "Delete a meeting",
+				options: [{
+					description: "A UUID which identifies the meeting to delete.",
+					in: "path",
+					name: "meeting_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"get-a-meeting": operation({
+				body: "none",
+				call: getV2MeetingsByMeetingId,
+				description: "Get a meeting",
+				options: [{
+					description: "A UUID which identifies the meeting.",
+					in: "path",
+					name: "meeting_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"update-a-meeting-append-linked-records": operation({
+				body: "required",
+				call: patchV2MeetingsByMeetingId,
+				description: "Update a meeting (append linked records)",
+				options: [{
+					description: "A UUID which identifies the meeting to update.",
+					in: "path",
+					name: "meeting_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"update-a-meeting-overwrite-linked-records": operation({
+				body: "required",
+				call: putV2MeetingsByMeetingId,
+				description: "Update a meeting (overwrite linked records)",
+				options: [{
+					description: "A UUID which identifies the meeting to update.",
+					in: "path",
+					name: "meeting_id",
+					required: true,
+					type: "string"
+				}]
+			})
+		},
+		description: "Meetings are events synced from your calendar, added manually or added from third-party integrations."
+	},
+	"call-recordings": {
+		commands: {
+			"list-call-recordings": operation({
+				body: "none",
+				call: getV2MeetingsByMeetingIdCallRecordings,
+				description: "List call recordings",
+				options: [
+					{
+						description: "The ID of the meeting to list call recordings for.",
+						in: "path",
+						name: "meeting_id",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "The maximum number of results to return. Defaults to 50 with a maximum of 200.",
+						in: "query",
+						name: "limit",
+						required: false,
+						type: "integer"
+					},
+					{
+						description: "A cursor for pagination. Use the `next_cursor` from the previous response to get the next page of results.",
+						in: "query",
+						name: "cursor",
+						required: false,
+						type: "string"
+					}
+				]
+			}),
+			"create-call-recording": operation({
+				body: "required",
+				call: postV2MeetingsByMeetingIdCallRecordings,
+				description: "Create call recording",
+				options: [{
+					description: "The ID of the meeting this recording belongs to.",
+					in: "path",
+					name: "meeting_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"delete-call-recording": operation({
+				body: "none",
+				call: deleteV2MeetingsByMeetingIdCallRecordingsByCallRecordingId,
+				description: "Delete call recording",
+				options: [{
+					description: "The ID of the meeting this call recording belongs to.",
+					in: "path",
+					name: "meeting_id",
+					required: true,
+					type: "string"
+				}, {
+					description: "The ID of the call recording to delete.",
+					in: "path",
+					name: "call_recording_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"get-call-recording": operation({
+				body: "none",
+				call: getV2MeetingsByMeetingIdCallRecordingsByCallRecordingId,
+				description: "Get call recording",
+				options: [{
+					description: "The ID of the meeting this recording belongs to.",
+					in: "path",
+					name: "meeting_id",
+					required: true,
+					type: "string"
+				}, {
+					description: "The ID of the call recording to retrieve.",
+					in: "path",
+					name: "call_recording_id",
+					required: true,
+					type: "string"
+				}]
+			})
+		},
+		description: "Call recordings store video, audio, transcript and speaker information for calls."
+	},
+	transcripts: {
+		commands: { "deprecated-get-call-transcript": operation({
+			body: "none",
+			call: getV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdTranscript,
+			description: "Deprecated: Get call transcript",
+			options: [
+				{
+					description: "The ID of the meeting.",
+					in: "path",
+					name: "meeting_id",
+					required: true,
+					type: "string"
+				},
+				{
+					description: "The ID of the call recording to get the transcript for.",
+					in: "path",
+					name: "call_recording_id",
+					required: true,
+					type: "string"
+				},
+				{
+					description: "A cursor for pagination through transcript segments. Use the `next_cursor` from the previous response to get the next page of speech segments within this transcript.",
+					in: "query",
+					name: "cursor",
+					required: false,
+					type: "string"
+				}
+			]
+		}) },
+		description: "Transcripts contain the speech segments and speaker information for a call recording."
+	},
+	files: {
+		commands: {
+			"list-files": operation({
+				body: "none",
+				call: getV2Files,
+				description: "List files",
+				options: [
+					{
+						description: "The object slug or ID.",
+						in: "query",
+						name: "object",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "The record ID for the specific record whose files you want to list.",
+						in: "query",
+						name: "record_id",
+						required: true,
+						type: "string"
+					},
+					{
+						description: "Filter results by storage provider.",
+						in: "query",
+						name: "storage_provider",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "Filter by parent folder ID. Each file entry has provided optioanl parent_folder_id that can be used to filter results by folder. When omitted, entries at all nesting levels are returned.",
+						in: "query",
+						name: "parent_folder_id",
+						required: false,
+						type: "string"
+					},
+					{
+						description: "The maximum number of files to return. Must be between 1 and 200. Defaults to 50.",
+						in: "query",
+						name: "limit",
+						required: false,
+						type: "integer"
+					},
+					{
+						description: "A pagination cursor used to fetch the next page of files. Responses with more files will include a cursor for you to use here. If not provided, the first page will be returned.",
+						in: "query",
+						name: "cursor",
+						required: false,
+						type: "string"
+					}
+				]
+			}),
+			"create-a-folder": operation({
+				body: "required",
+				call: postV2Files,
+				description: "Create a folder",
+				options: []
+			}),
+			"delete-a-file": operation({
+				body: "none",
+				call: deleteV2FilesByFileId,
+				description: "Delete a file",
+				options: [{
+					description: "A UUID which identifies the file to delete.",
+					in: "path",
+					name: "file_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"get-a-file": operation({
+				body: "none",
+				call: getV2FilesByFileId,
+				description: "Get a file",
+				options: [{
+					description: "A UUID which identifies the file entry.",
+					in: "path",
+					name: "file_id",
+					required: true,
+					type: "string"
+				}]
+			})
+		},
+		description: "Files are documents and folders linked to records, stored either in Attio or connected via external storage providers."
+	},
+	webhooks: {
+		commands: {
+			"list-webhooks": operation({
+				body: "none",
+				call: getV2Webhooks,
+				description: "List webhooks",
+				options: [{
+					description: "The maximum number of results to return, between 10 and 100, defaults to 10. See the [full guide to pagination here](/rest-api/guides/pagination).",
+					in: "query",
+					name: "limit",
+					required: false,
+					type: "integer"
+				}, {
+					description: "The number of results to skip over before returning, defaults to 0. See the [full guide to pagination here](/rest-api/guides/pagination).",
+					in: "query",
+					name: "offset",
+					required: false,
+					type: "integer"
+				}]
+			}),
+			"create-a-webhook": operation({
+				body: "required",
+				call: postV2Webhooks,
+				description: "Create a webhook",
+				options: []
+			}),
+			"delete-a-webhook": operation({
+				body: "none",
+				call: deleteV2WebhooksByWebhookId,
+				description: "Delete a webhook",
+				options: [{
+					description: "A UUID identifying the webhook to delete.",
+					in: "path",
+					name: "webhook_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"get-a-webhook": operation({
+				body: "none",
+				call: getV2WebhooksByWebhookId,
+				description: "Get a webhook",
+				options: [{
+					description: "A UUID which identifies the webhook.",
+					in: "path",
+					name: "webhook_id",
+					required: true,
+					type: "string"
+				}]
+			}),
+			"update-a-webhook": operation({
+				body: "required",
+				call: patchV2WebhooksByWebhookId,
+				description: "Update a webhook",
+				options: [{
+					description: "A UUID which identifies the webhook.",
+					in: "path",
+					name: "webhook_id",
+					required: true,
+					type: "string"
+				}]
+			})
+		},
+		description: "Webhooks allow you to listen for changes to data in Attio, for example when a record is updated."
+	},
+	meta: {
+		commands: { identify: operation({
+			body: "none",
+			call: getV2Self,
+			description: "Identify",
+			options: []
+		}) },
+		description: "Meta endpoints are used to get information about the API token."
+	}
+};
+//#endregion
+//#region src/cli.ts
+const rootCommand = define({
+	name: "attio-api",
+	description: "Agent-friendly access to the Attio API",
+	run: () => "Run \"attio --help\" for usage information."
+});
+/** One command per group of operations, with the group's operations beneath it. */
+function commandTree(env) {
+	const tree = {};
+	for (const [group, { commands, description }] of Object.entries(groups)) {
+		const subCommands = {};
+		for (const [name, source] of Object.entries(commands)) subCommands[name] = operationCommand(name, source, env);
+		tree[group] = define({
+			name: group,
+			description,
+			run: () => `Run "attio-api ${group} --help" for usage information.`,
+			subCommands
+		});
+	}
+	return tree;
+}
+async function main(argv = process.argv.slice(2), env = process.env) {
+	try {
+		const pkg = await import("./package-CUMEUo_X.mjs");
+		await cli(argv, rootCommand, {
+			name: "attio-api",
+			version: pkg.default.version,
+			strict: true,
+			subCommands: commandTree(env),
+			renderHeader: (ctx) => ctx.values.help ? renderHeader(ctx) : Promise.resolve(""),
+			renderValidationErrors: null,
+			onBeforeCommand: (ctx) => {
+				if (ctx.validationError || ctx.values.help || ctx.values.version) return;
+				const unexpected = [...ctx.positionals.slice(ctx.commandPath.length), ...ctx.rest];
+				if (unexpected.length > 0) throw usageError(`Unexpected argument: ${unexpected.join(" ")}`);
+			},
+			onAfterCommand: (ctx, result) => {
+				if (ctx.values.help || ctx.values.version) return;
+				if (result) console.log(result);
+			}
+		});
+		return 0;
+	} catch (error) {
+		return reportError(error);
+	}
+}
+//#endregion
+export { main };
+
+//# sourceMappingURL=cli-CLfvqLdQ.mjs.map