attio-ts-sdk 0.0.0 → 1.1.0

package/dist/index.mjs

@@ -1,5 +1,256 @@
 import { z } from "zod";
+import process from "node:process";
 
+//#region src/attio/batch.ts
+const recordSuccess = (params) => {
+	const { state, currentIndex, value, label, isCancelled } = params;
+	if (isCancelled?.()) return;
+	state.results[currentIndex] = {
+		status: "fulfilled",
+		value,
+		label
+	};
+};
+const recordFailure = (params) => {
+	const { state, currentIndex, error, label, options, abortController, isCancelled, reject } = params;
+	if (options.stopOnError) {
+		if (!state.stopped) {
+			state.stopped = true;
+			if (abortController && !abortController.signal.aborted) abortController.abort();
+			reject(error);
+		}
+		return;
+	}
+	if (isCancelled()) return;
+	state.results[currentIndex] = {
+		status: "rejected",
+		reason: error,
+		label
+	};
+};
+const launchNextItem = (params) => {
+	const { items, state, abortController, options, isCancelled, reject, launchNext } = params;
+	const currentIndex = state.index;
+	const item = items[currentIndex];
+	state.index += 1;
+	state.active += 1;
+	item.run(abortController ? { signal: abortController.signal } : void 0).then((value) => {
+		recordSuccess({
+			state,
+			currentIndex,
+			value,
+			label: item.label,
+			isCancelled
+		});
+	}).catch((error) => {
+		recordFailure({
+			state,
+			currentIndex,
+			error,
+			label: item.label,
+			options,
+			abortController,
+			isCancelled,
+			reject
+		});
+	}).finally(() => {
+		state.active -= 1;
+		if (!isCancelled()) launchNext();
+	});
+};
+/**
+* Returns an empty results array when called with no items.
+*/
+const runBatch = (items, options = {}) => {
+	if (items.length === 0) return Promise.resolve([]);
+	const concurrency = Math.max(1, options.concurrency ?? 4);
+	const state = {
+		results: new Array(items.length),
+		index: 0,
+		active: 0,
+		stopped: false
+	};
+	const abortController = options.stopOnError ? new AbortController() : void 0;
+	const isCancelled = () => abortController?.signal.aborted ?? state.stopped;
+	return new Promise((resolve, reject) => {
+		const launchNext = () => {
+			if (isCancelled()) return;
+			if (state.index >= items.length && state.active === 0) {
+				resolve(state.results);
+				return;
+			}
+			while (state.active < concurrency && state.index < items.length) launchNextItem({
+				items,
+				state,
+				concurrency,
+				abortController,
+				options,
+				isCancelled,
+				resolve,
+				reject,
+				launchNext
+			});
+		};
+		launchNext();
+	});
+};
+
+//#endregion
+//#region src/attio/cache.ts
+const DEFAULT_METADATA_CACHE_TTL_MS = 300 * 1e3;
+const DEFAULT_METADATA_CACHE_MAX_ENTRIES = {
+	attributes: 200,
+	options: 500,
+	statuses: 500
+};
+var TtlCache = class {
+	ttlMs;
+	maxEntries;
+	store = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.ttlMs = options.ttlMs;
+		this.maxEntries = options.maxEntries;
+	}
+	get(key) {
+		const entry = this.store.get(key);
+		if (!entry) return;
+		if (Date.now() >= entry.expiresAt) {
+			this.store.delete(key);
+			return;
+		}
+		return entry.value;
+	}
+	set(key, value) {
+		if (this.maxEntries && this.store.size >= this.maxEntries && !this.store.has(key)) {
+			const oldestKey = this.store.keys().next().value;
+			if (oldestKey !== void 0) this.store.delete(oldestKey);
+		}
+		this.store.set(key, {
+			value,
+			expiresAt: Date.now() + this.ttlMs
+		});
+	}
+	delete(key) {
+		this.store.delete(key);
+	}
+	clear() {
+		this.store.clear();
+	}
+};
+const createTtlCacheAdapter = (params) => {
+	const cache = new TtlCache({
+		ttlMs: params.ttlMs,
+		maxEntries: params.maxEntries
+	});
+	return {
+		get: (key) => cache.get(key),
+		set: (key, value) => cache.set(key, value),
+		delete: (key) => cache.delete(key),
+		clear: () => cache.clear()
+	};
+};
+const clientCache = /* @__PURE__ */ new Map();
+const getCachedClient = (key, validator) => {
+	const cached = clientCache.get(key);
+	if (cached === void 0) return;
+	try {
+		const result = validator.safeParse(cached);
+		if (!result.success) return;
+		return result.data;
+	} catch {
+		return;
+	}
+};
+const setCachedClient = (key, client) => {
+	clientCache.set(key, client);
+};
+const clearClientCache = () => {
+	clientCache.clear();
+};
+const ANONYMOUS_HASH = "anon";
+const hashToken = (value) => {
+	if (value === void 0) return ANONYMOUS_HASH;
+	let hash = 5381;
+	for (let i = 0; i < value.length; i += 1) hash = hash * 33 ^ value.charCodeAt(i);
+	return (hash >>> 0).toString(36);
+};
+const createTtlCache = (options) => new TtlCache(options);
+const metadataCacheRegistry = /* @__PURE__ */ new Map();
+const resolveMaxEntries = (maxEntries, scope) => {
+	if (typeof maxEntries === "number") return maxEntries;
+	if (maxEntries && maxEntries[scope] !== void 0) return maxEntries[scope];
+	return DEFAULT_METADATA_CACHE_MAX_ENTRIES[scope];
+};
+const isMetadataCacheDisabled = (config) => config.enabled === false;
+const createMetadataCacheManager = (config = {}) => {
+	if (isMetadataCacheDisabled(config)) return {
+		get: () => void 0,
+		clear: () => void 0
+	};
+	const ttlMs = config.ttlMs ?? DEFAULT_METADATA_CACHE_TTL_MS;
+	const adapterFactory = config.adapter ?? { create: (params) => createTtlCacheAdapter(params) };
+	const caches = /* @__PURE__ */ new Map();
+	const get = (scope) => {
+		const existing = caches.get(scope);
+		if (existing) return existing;
+		const adapter = adapterFactory.create({
+			scope,
+			ttlMs,
+			maxEntries: resolveMaxEntries(config.maxEntries, scope)
+		});
+		caches.set(scope, adapter);
+		return adapter;
+	};
+	const clear = () => {
+		for (const adapter of caches.values()) adapter.clear();
+		caches.clear();
+	};
+	return {
+		get,
+		clear
+	};
+};
+const buildMetadataCacheFingerprint = (config) => {
+	return `ttl:${config.ttlMs ?? "default"}|max:${typeof config.maxEntries === "number" ? config.maxEntries : JSON.stringify(config.maxEntries ?? "default")}`;
+};
+const getMetadataCacheManager = (key, config) => {
+	if (config?.enabled === false) return createMetadataCacheManager(config);
+	if (config?.adapter) return createMetadataCacheManager(config);
+	const registryKey = `${key}|${config ? buildMetadataCacheFingerprint(config) : "default"}`;
+	const existing = metadataCacheRegistry.get(registryKey);
+	if (existing) return existing;
+	const manager = createMetadataCacheManager(config);
+	metadataCacheRegistry.set(registryKey, manager);
+	return manager;
+};
+const clearMetadataCacheRegistry = () => {
+	for (const manager of metadataCacheRegistry.values()) manager.clear();
+	metadataCacheRegistry.clear();
+};
+const isAttioCacheDisabled = (config) => config?.enabled === false;
+const resolveMetadataCacheConfig = (config) => {
+	if (isAttioCacheDisabled(config)) return { enabled: false };
+	const metadataBase = config?.metadata;
+	if (metadataBase?.enabled === false) return { enabled: false };
+	return {
+		enabled: true,
+		ttlMs: metadataBase?.ttlMs,
+		maxEntries: metadataBase?.maxEntries,
+		adapter: metadataBase?.adapter
+	};
+};
+const createAttioCacheManager = (key, config) => {
+	const metadata = getMetadataCacheManager(key, resolveMetadataCacheConfig(config));
+	const clear = () => {
+		metadata.clear();
+	};
+	return {
+		metadata,
+		clear
+	};
+};
+
+//#endregion
 //#region src/generated/core/bodySerializer.gen.ts
 const jsonBodySerializer = { bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value) };
 
@@ -610,74 +861,600 @@ const createClient = (config = {}) => {
 };
 
 //#endregion
-//#region src/generated/client.gen.ts
-const client = createClient(createConfig({ baseUrl: "https://api.attio.com" }));
+//#region src/attio/config.ts
+const TRAILING_SLASHES_REGEX = /\/+$/;
+const DEFAULT_BASE_URL = "https://api.attio.com";
+const getEnvValue = (key) => {
+	if (typeof process === "undefined") return;
+	return process.env?.[key];
+};
+const normalizeBaseUrl = (baseUrl) => baseUrl.replace(TRAILING_SLASHES_REGEX, "");
+const resolveBaseUrl = (config) => {
+	return normalizeBaseUrl(config?.baseUrl ?? getEnvValue("ATTIO_BASE_URL") ?? DEFAULT_BASE_URL);
+};
+const resolveAuthToken = (config) => config?.apiKey ?? config?.accessToken ?? config?.authToken ?? getEnvValue("ATTIO_API_KEY") ?? getEnvValue("ATTIO_ACCESS_TOKEN");
+const resolveResponseStyle = (config) => config?.responseStyle ?? "fields";
+const resolveThrowOnError = (config) => config?.throwOnError ?? true;
 
 //#endregion
-//#region src/generated/zod.gen.ts
-const zStatus = z.object({
-	id: z.object({
-		workspace_id: z.uuid(),
-		object_id: z.uuid(),
-		attribute_id: z.uuid(),
-		status_id: z.uuid()
-	}),
-	title: z.string(),
-	is_archived: z.boolean(),
-	celebration_enabled: z.boolean(),
-	target_time_in_status: z.union([z.string(), z.null()])
-});
-const zSelectOption = z.object({
-	id: z.object({
-		workspace_id: z.uuid(),
-		object_id: z.uuid(),
-		attribute_id: z.uuid(),
-		option_id: z.uuid()
-	}),
-	title: z.string(),
-	is_archived: z.boolean()
+//#region src/attio/error-enhancer.ts
+const knownFieldValues = /* @__PURE__ */ new Map();
+const VALUE_PATTERNS = [
+	/constraint:\s*([^,]+)/i,
+	/option name\s+'([^']+)'/i,
+	/option name\s+"([^"]+)"/i
+];
+const getKnownFieldValues = (field) => knownFieldValues.get(field);
+const updateKnownFieldValues = (field, values) => {
+	const unique = Array.from(new Set(values.map((value) => value.trim()))).filter(Boolean);
+	if (unique.length > 0) knownFieldValues.set(field, unique);
+	else knownFieldValues.delete(field);
+};
+const extractMismatchContext = (error) => {
+	const { message, data: rawData } = error;
+	const data = rawData;
+	const path = (Array.isArray(data?.path) ? data?.path[0] : data?.path) ?? data?.field ?? data?.attribute ?? void 0;
+	if (typeof message !== "string" || typeof path !== "string") return;
+	let value;
+	for (const pattern of VALUE_PATTERNS) {
+		const match = message.match(pattern);
+		if (match?.[1]) {
+			value = match[1].trim();
+			break;
+		}
+	}
+	return {
+		field: path,
+		value
+	};
+};
+const levenshtein = (a, b) => {
+	const matrix = [];
+	const aLen = a.length;
+	const bLen = b.length;
+	for (let i = 0; i <= bLen; i += 1) matrix[i] = [i];
+	for (let j = 0; j <= aLen; j += 1) matrix[0][j] = j;
+	for (let i = 1; i <= bLen; i += 1) for (let j = 1; j <= aLen; j += 1) if (b.charAt(i - 1) === a.charAt(j - 1)) matrix[i][j] = matrix[i - 1][j - 1];
+	else matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+	return matrix[bLen][aLen];
+};
+const scoreCandidates = (value, candidates) => {
+	const normalized = value.toLowerCase();
+	return candidates.map((candidate) => ({
+		candidate,
+		score: levenshtein(normalized, candidate.toLowerCase())
+	})).sort((a, b) => a.score - b.score).map((entry) => entry.candidate);
+};
+const enhanceAttioError = (error) => {
+	if (!error?.isApiError) return error;
+	const context = extractMismatchContext(error);
+	if (!(context?.field && context?.value)) return error;
+	const candidates = knownFieldValues.get(context.field);
+	if (candidates === void 0 || candidates.length === 0) return error;
+	const matches = scoreCandidates(context.value, candidates).slice(0, 3);
+	error.suggestions = {
+		field: context.field,
+		attempted: context.value,
+		bestMatch: matches[0],
+		matches
+	};
+	return error;
+};
+
+//#endregion
+//#region src/attio/errors.ts
+var AttioError = class extends Error {
+	status;
+	code;
+	type;
+	requestId;
+	data;
+	response;
+	request;
+	retryAfterMs;
+	isNetworkError;
+	isApiError;
+	suggestions;
+	constructor(message, details = {}) {
+		super(message, details.cause ? { cause: details.cause } : void 0);
+		this.name = "AttioError";
+		this.status = details.status;
+		this.code = details.code;
+		this.type = details.type;
+		this.data = details.data;
+	}
+};
+const applyDefaultCode = (details, code) => ({
+	...details,
+	code: details.code ?? code
 });
-/**
-* A union of possible value types, as required in request bodies.
-*/
-const zInputValue = z.union([
-	z.object({
-		referenced_actor_type: z.enum(["workspace-member"]),
-		referenced_actor_id: z.uuid()
-	}),
-	z.object({ workspace_member_email_address: z.string() }),
-	z.object({ value: z.boolean() }),
-	z.object({ currency_value: z.number() }),
-	z.object({ value: z.string() }),
-	z.object({ domain: z.optional(z.string()) }),
-	z.object({ email_address: z.optional(z.string()) }),
-	z.object({
-		target_object: z.string(),
-		target_record_id: z.uuid()
-	}),
-	z.object({
-		target_object: z.string(),
-		"[slug_or_id_of_matching_attribute]": z.array(z.union([
-			z.object({ domain: z.optional(z.string()) }),
-			z.object({ email_address: z.optional(z.string()) }),
-			z.object({ value: z.optional(z.number()) }),
-			z.object({
-				original_phone_number: z.optional(z.string()),
-				country_code: z.optional(z.enum([
-					"AF",
-					"AX",
-					"AL",
-					"DZ",
-					"AS",
-					"AD",
-					"AO",
-					"AI",
-					"AQ",
-					"AG",
-					"AR",
-					"AM",
-					"AW",
-					"AU",
+var AttioBatchError = class extends AttioError {
+	constructor(message, details = {}) {
+		super(message, applyDefaultCode(details, "BATCH_ERROR"));
+		this.name = "AttioBatchError";
+	}
+};
+var AttioConfigError = class extends AttioError {
+	constructor(message, details = {}) {
+		super(message, applyDefaultCode(details, "CONFIG_ERROR"));
+		this.name = "AttioConfigError";
+	}
+};
+var AttioEnvironmentError = class extends AttioError {
+	constructor(message, details = {}) {
+		super(message, applyDefaultCode(details, "ENVIRONMENT_ERROR"));
+		this.name = "AttioEnvironmentError";
+	}
+};
+var AttioResponseError = class extends AttioError {
+	constructor(message, details = {}) {
+		super(message, applyDefaultCode(details, "RESPONSE_ERROR"));
+		this.name = "AttioResponseError";
+	}
+};
+var AttioRetryError = class extends AttioError {
+	constructor(message, details = {}) {
+		super(message, applyDefaultCode(details, "RETRY_ERROR"));
+		this.name = "AttioRetryError";
+	}
+};
+var AttioApiError = class extends AttioError {
+	constructor(message, details = {}) {
+		super(message, details);
+		this.name = "AttioApiError";
+		this.isApiError = true;
+	}
+};
+var AttioNetworkError = class extends AttioError {
+	constructor(message, details = {}) {
+		super(message, details);
+		this.name = "AttioNetworkError";
+		this.isNetworkError = true;
+	}
+};
+const getHeaderValue = (response, key) => {
+	if (!response) return;
+	return response.headers.get(key) ?? void 0;
+};
+const parseRetryAfter = (response) => {
+	if (!response) return;
+	const raw = response.headers.get("Retry-After");
+	if (!raw) return;
+	const seconds = Number(raw);
+	if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+	const dateMs = Date.parse(raw);
+	if (!Number.isNaN(dateMs)) return Math.max(0, dateMs - Date.now());
+};
+const extractMessage = (error, fallback) => {
+	if (typeof error === "string") return error;
+	if (error && typeof error === "object") {
+		const maybe = error;
+		if (typeof maybe.message === "string") return maybe.message;
+	}
+	return fallback ?? "Request failed.";
+};
+const extractStatusCode = (payload) => {
+	if (typeof payload.status_code === "number") return payload.status_code;
+	if (typeof payload.status === "number") return payload.status;
+};
+const extractDetails = (error) => {
+	if (!error || typeof error !== "object") return {};
+	const payload = error;
+	return {
+		code: typeof payload.code === "string" ? payload.code : void 0,
+		type: typeof payload.type === "string" ? payload.type : void 0,
+		status: extractStatusCode(payload),
+		message: typeof payload.message === "string" ? payload.message : void 0,
+		data: payload
+	};
+};
+const normalizeAttioError = (error, context = {}) => {
+	const { response, request } = context;
+	const details = extractDetails(error);
+	const status = response?.status ?? details.status;
+	const message = extractMessage(error, response?.statusText ?? details.message);
+	const requestId = getHeaderValue(response, "x-request-id") ?? getHeaderValue(response, "x-attio-request-id");
+	if (response) {
+		const apiError = new AttioApiError(message, {
+			...details,
+			status
+		});
+		apiError.requestId = requestId;
+		apiError.response = response;
+		apiError.request = request;
+		apiError.data = details.data ?? error;
+		apiError.retryAfterMs = parseRetryAfter(response);
+		return enhanceAttioError(apiError);
+	}
+	const networkError = new AttioNetworkError(message, details);
+	networkError.request = request;
+	return networkError;
+};
+
+//#endregion
+//#region src/attio/retry.ts
+const DEFAULT_RETRY_CONFIG = {
+	maxRetries: 3,
+	initialDelayMs: 500,
+	maxDelayMs: 5e3,
+	retryableStatusCodes: [
+		408,
+		429,
+		500,
+		502,
+		503,
+		504
+	],
+	respectRetryAfter: true
+};
+const RetryErrorSchema = z.object({
+	status: z.number().optional(),
+	isNetworkError: z.boolean().optional(),
+	retryAfterMs: z.number().optional()
+});
+const extractRetryErrorInfo = (error) => {
+	if (error instanceof AttioError) return {
+		status: error.status,
+		isNetworkError: error.isNetworkError,
+		retryAfterMs: error.retryAfterMs
+	};
+	const result = RetryErrorSchema.safeParse(error);
+	if (!result.success) return;
+	return result.data;
+};
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const calculateRetryDelay = (attempt, config, retryAfterMs) => {
+	if (config.respectRetryAfter && retryAfterMs && retryAfterMs > 0) return Math.min(retryAfterMs, config.maxDelayMs);
+	const base = config.initialDelayMs * 2 ** attempt;
+	const jitter = .75 + Math.random() * .5;
+	return Math.min(base * jitter, config.maxDelayMs);
+};
+const isRetryableStatus = (status, config) => {
+	if (status === void 0) return true;
+	return config.retryableStatusCodes.includes(status);
+};
+const isRetryableError = (error, config) => {
+	const info = extractRetryErrorInfo(error);
+	if (info?.isNetworkError) return true;
+	return isRetryableStatus(info?.status, config);
+};
+const getRetryAfterMs = (error) => extractRetryErrorInfo(error)?.retryAfterMs;
+async function callWithRetry(fn, config) {
+	const retryConfig = {
+		...DEFAULT_RETRY_CONFIG,
+		...config
+	};
+	let attempt = 0;
+	while (attempt <= retryConfig.maxRetries) try {
+		return await fn();
+	} catch (error) {
+		if (!isRetryableError(error, retryConfig)) throw error;
+		if (attempt >= retryConfig.maxRetries) throw new AttioRetryError("Retry attempts exhausted.", {
+			code: "RETRY_EXHAUSTED",
+			cause: error
+		});
+		await sleep(calculateRetryDelay(attempt, retryConfig, getRetryAfterMs(error)));
+		attempt += 1;
+	}
+	throw new AttioRetryError("Retry attempts exhausted.", { code: "RETRY_EXHAUSTED" });
+}
+
+//#endregion
+//#region src/attio/client.ts
+const interceptorUseSchema = z.object({ use: z.function() }).passthrough();
+const attioClientShapeSchema = z.object({
+	request: z.function(),
+	cache: z.object({
+		metadata: z.object({
+			get: z.function(),
+			clear: z.function()
+		}).passthrough(),
+		clear: z.function()
+	}).passthrough(),
+	interceptors: z.object({
+		error: interceptorUseSchema,
+		request: interceptorUseSchema,
+		response: interceptorUseSchema
+	}).passthrough()
+}).passthrough();
+const AttioClientSchema = z.any().refine((value) => attioClientShapeSchema.safeParse(value).success, { message: "Invalid cached Attio client." });
+const combineSignalsWithAny = ({ requestSignal, timeoutSignal }) => AbortSignal.any([requestSignal, timeoutSignal]);
+const combineSignalsWithFallback = ({ requestSignal, timeoutSignal }) => {
+	const combinedController = new AbortController();
+	if (requestSignal.aborted) {
+		combinedController.abort();
+		return { combinedSignal: combinedController.signal };
+	}
+	const abortCombined = () => combinedController.abort();
+	requestSignal.addEventListener("abort", abortCombined, { once: true });
+	timeoutSignal.addEventListener("abort", abortCombined, { once: true });
+	return {
+		combinedSignal: combinedController.signal,
+		abortCombined
+	};
+};
+const resolveFetch = (config) => {
+	const baseFetch = config?.fetch ?? globalThis.fetch;
+	if (!baseFetch) throw new AttioEnvironmentError("Fetch is not available in this environment.", { code: "FETCH_UNAVAILABLE" });
+	if (!config?.timeoutMs) return baseFetch;
+	return async (input, init) => {
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), config.timeoutMs);
+		let combinedSignal = controller.signal;
+		let abortCombined;
+		if (init?.signal) {
+			const signals = {
+				requestSignal: init.signal,
+				timeoutSignal: controller.signal
+			};
+			if (typeof AbortSignal !== "undefined" && "any" in AbortSignal) combinedSignal = combineSignalsWithAny(signals);
+			else ({combinedSignal, abortCombined} = combineSignalsWithFallback(signals));
+		}
+		try {
+			return await baseFetch(input, {
+				...init,
+				signal: combinedSignal
+			});
+		} finally {
+			if (abortCombined) {
+				init?.signal?.removeEventListener("abort", abortCombined);
+				controller.signal.removeEventListener("abort", abortCombined);
+			}
+			clearTimeout(timeoutId);
+		}
+	};
+};
+const buildClientCacheKey = ({ config, authToken }) => {
+	if (config.cache?.key) return `${config.cache.key}:${hashToken(authToken)}`;
+};
+const buildMetadataCacheKey = ({ config, authToken, baseUrl }) => `${config.cache?.key ?? "attio"}:${hashToken(authToken)}:${baseUrl}`;
+const composeHook = (first, second) => {
+	if (!first) return second;
+	if (!second) return first;
+	return (payload) => {
+		first(payload);
+		second(payload);
+	};
+};
+const createLoggerHooks = (logger) => {
+	if (!logger) return {};
+	const { debug, error: logError } = logger;
+	return {
+		onRequest: debug ? ({ request }) => debug("attio.request", {
+			method: request.method,
+			url: request.url
+		}) : void 0,
+		onResponse: debug ? ({ response, request }) => debug("attio.response", {
+			method: request.method,
+			url: request.url,
+			status: response.status
+		}) : void 0,
+		onError: logError ? ({ error, request, response }) => logError("attio.error", {
+			message: error.message,
+			code: error.code,
+			status: error.status,
+			requestId: error.requestId,
+			url: request?.url,
+			responseStatus: response?.status
+		}) : void 0
+	};
+};
+const resolveClientHooks = (config) => {
+	const loggerHooks = createLoggerHooks(config?.logger);
+	const customHooks = config?.hooks ?? {};
+	return {
+		onRequest: composeHook(loggerHooks.onRequest, customHooks.onRequest),
+		onResponse: composeHook(loggerHooks.onResponse, customHooks.onResponse),
+		onError: composeHook(loggerHooks.onError, customHooks.onError)
+	};
+};
+const applyInterceptors = (client, hooks) => {
+	if (hooks.onRequest) client.interceptors.request.use((request, options) => {
+		hooks.onRequest?.({
+			request,
+			options
+		});
+		return request;
+	});
+	if (hooks.onResponse) client.interceptors.response.use((response, request, options) => {
+		hooks.onResponse?.({
+			response,
+			request,
+			options
+		});
+		return response;
+	});
+	client.interceptors.error.use((error, response, request, options) => {
+		const normalized = normalizeAttioError(error, {
+			response,
+			request,
+			options
+		});
+		hooks.onError?.({
+			error: normalized,
+			response,
+			request,
+			options
+		});
+		return normalized;
+	});
+};
+const wrapClient = (base, retry) => {
+	const requestWithRetry = (options) => {
+		const { retry: retryOverride, ...rest } = options;
+		return callWithRetry(() => base.request(rest), {
+			...retry,
+			...retryOverride
+		});
+	};
+	const makeMethod = (method) => (options) => requestWithRetry({
+		...options,
+		method
+	});
+	return {
+		...base,
+		request: requestWithRetry,
+		connect: makeMethod("CONNECT"),
+		delete: makeMethod("DELETE"),
+		get: makeMethod("GET"),
+		head: makeMethod("HEAD"),
+		options: makeMethod("OPTIONS"),
+		patch: makeMethod("PATCH"),
+		post: makeMethod("POST"),
+		put: makeMethod("PUT"),
+		trace: makeMethod("TRACE")
+	};
+};
+const extractAndCleanConfig = (config) => {
+	const { apiKey: _apiKey, accessToken: _accessToken, authToken: _authToken, cache: _cache, retry, timeoutMs, headers, ...cleanConfig } = config;
+	return {
+		cleanConfig,
+		headers,
+		retry,
+		timeoutMs
+	};
+};
+const createAttioClientWithAuthToken = ({ config = {}, authToken }) => {
+	const baseUrl = resolveBaseUrl(config);
+	const responseStyle = resolveResponseStyle(config);
+	const throwOnError = resolveThrowOnError(config);
+	const hooks = resolveClientHooks(config);
+	const { cleanConfig, headers, retry, timeoutMs } = extractAndCleanConfig(config);
+	const mergedHeaders = mergeHeaders({ Accept: "application/json" }, headers);
+	const base = createClient({
+		...cleanConfig,
+		baseUrl,
+		auth: authToken,
+		headers: mergedHeaders,
+		fetch: resolveFetch({
+			...config,
+			timeoutMs
+		}),
+		responseStyle,
+		throwOnError
+	});
+	applyInterceptors(base, hooks);
+	const wrapped = wrapClient(base, retry);
+	const cache = createAttioCacheManager(buildMetadataCacheKey({
+		config,
+		authToken,
+		baseUrl
+	}), config.cache);
+	return Object.assign(wrapped, { cache });
+};
+const createAttioClient = (config = {}) => {
+	return createAttioClientWithAuthToken({
+		config,
+		authToken: resolveAuthToken(config)
+	});
+};
+const getAttioClient = (config = {}) => {
+	const cacheEnabled = config.cache?.enabled ?? true;
+	const authToken = resolveAuthToken(config);
+	const cacheKey = authToken ? buildClientCacheKey({
+		config,
+		authToken
+	}) : void 0;
+	if (cacheEnabled && cacheKey) {
+		const cached = getCachedClient(cacheKey, AttioClientSchema);
+		if (cached) return cached;
+		const client = createAttioClientWithAuthToken({
+			config,
+			authToken
+		});
+		setCachedClient(cacheKey, client);
+		return client;
+	}
+	return createAttioClientWithAuthToken({
+		config,
+		authToken
+	});
+};
+const resolveAttioClient = (input = {}) => input.client ?? getAttioClient(input.config ?? {});
+
+//#endregion
+//#region src/attio/filters.ts
+const operator = (field, op, value) => ({ [field]: { [op]: value } });
+const filters = {
+	eq: (field, value) => operator(field, "$eq", value),
+	contains: (field, value) => operator(field, "$contains", value),
+	startsWith: (field, value) => operator(field, "$starts_with", value),
+	endsWith: (field, value) => operator(field, "$ends_with", value),
+	notEmpty: (field) => operator(field, "$not_empty", true),
+	and: (...conditions) => ({ $and: conditions }),
+	or: (...conditions) => ({ $or: conditions }),
+	not: (condition) => ({ $not: condition })
+};
+
+//#endregion
+//#region src/generated/client.gen.ts
+const client = createClient(createConfig({ baseUrl: "https://api.attio.com" }));
+
+//#endregion
+//#region src/generated/zod.gen.ts
+const zStatus = z.object({
+	id: z.object({
+		workspace_id: z.uuid(),
+		object_id: z.uuid(),
+		attribute_id: z.uuid(),
+		status_id: z.uuid()
+	}),
+	title: z.string(),
+	is_archived: z.boolean(),
+	celebration_enabled: z.boolean(),
+	target_time_in_status: z.union([z.string(), z.null()])
+});
+const zSelectOption = z.object({
+	id: z.object({
+		workspace_id: z.uuid(),
+		object_id: z.uuid(),
+		attribute_id: z.uuid(),
+		option_id: z.uuid()
+	}),
+	title: z.string(),
+	is_archived: z.boolean()
+});
+/**
+* A union of possible value types, as required in request bodies.
+*/
+const zInputValue = z.union([
+	z.object({
+		referenced_actor_type: z.enum(["workspace-member"]),
+		referenced_actor_id: z.uuid()
+	}),
+	z.object({ workspace_member_email_address: z.string() }),
+	z.object({ value: z.boolean() }),
+	z.object({ currency_value: z.number() }),
+	z.object({ value: z.string() }),
+	z.object({ domain: z.optional(z.string()) }),
+	z.object({ email_address: z.optional(z.string()) }),
+	z.object({
+		target_object: z.string(),
+		target_record_id: z.uuid()
+	}),
+	z.object({
+		target_object: z.string(),
+		"[slug_or_id_of_matching_attribute]": z.array(z.union([
+			z.object({ domain: z.optional(z.string()) }),
+			z.object({ email_address: z.optional(z.string()) }),
+			z.object({ value: z.optional(z.number()) }),
+			z.object({
+				original_phone_number: z.optional(z.string()),
+				country_code: z.optional(z.enum([
+					"AF",
+					"AX",
+					"AL",
+					"DZ",
+					"AS",
+					"AD",
+					"AO",
+					"AI",
+					"AQ",
+					"AG",
+					"AR",
+					"AM",
+					"AW",
+					"AU",
 					"AT",
 					"AZ",
 					"BS",
@@ -1508,6 +2285,7 @@ const zOutputValue = z.union([
 			"DKK",
 			"EUR",
 			"HKD",
+			"HUF",
 			"ISK",
 			"INR",
 			"ILS",
@@ -2218,6 +2996,7 @@ const zAttribute = z.object({
 				"DKK",
 				"EUR",
 				"HKD",
+				"HUF",
 				"ISK",
 				"INR",
 				"ILS",
@@ -2579,6 +3358,7 @@ const zPostV2ByTargetByIdentifierAttributesData = z.object({
 					"DKK",
 					"EUR",
 					"HKD",
+					"HUF",
 					"ISK",
 					"INR",
 					"ILS",
@@ -2673,6 +3453,7 @@ const zPatchV2ByTargetByIdentifierAttributesByAttributeData = z.object({
 					"DKK",
 					"EUR",
 					"HKD",
+					"HUF",
 					"ISK",
 					"INR",
 					"ILS",
@@ -2907,6 +3688,7 @@ const zPostV2ObjectsByObjectRecordsQueryResponse = z.object({ data: z.array(z.ob
 				"DKK",
 				"EUR",
 				"HKD",
+				"HUF",
 				"ISK",
 				"INR",
 				"ILS",
@@ -3770,6 +4552,7 @@ const zPostV2ObjectsByObjectRecordsResponse = z.object({ data: z.object({
 				"DKK",
 				"EUR",
 				"HKD",
+				"HUF",
 				"ISK",
 				"INR",
 				"ILS",
@@ -4633,6 +5416,7 @@ const zPutV2ObjectsByObjectRecordsResponse = z.object({ data: z.object({
 				"DKK",
 				"EUR",
 				"HKD",
+				"HUF",
 				"ISK",
 				"INR",
 				"ILS",
@@ -5511,6 +6295,7 @@ const zGetV2ObjectsByObjectRecordsByRecordIdResponse = z.object({ data: z.object
 				"DKK",
 				"EUR",
 				"HKD",
+				"HUF",
 				"ISK",
 				"INR",
 				"ILS",
@@ -6377,6 +7162,7 @@ const zPatchV2ObjectsByObjectRecordsByRecordIdResponse = z.object({ data: z.obje
 				"DKK",
 				"EUR",
 				"HKD",
+				"HUF",
 				"ISK",
 				"INR",
 				"ILS",
@@ -7243,6 +8029,7 @@ const zPutV2ObjectsByObjectRecordsByRecordIdResponse = z.object({ data: z.object
 				"DKK",
 				"EUR",
 				"HKD",
+				"HUF",
 				"ISK",
 				"INR",
 				"ILS",
@@ -8106,6 +8893,7 @@ const zGetV2ObjectsByObjectRecordsByRecordIdAttributesByAttributeValuesResponse
 			"DKK",
 			"EUR",
 			"HKD",
+			"HUF",
 			"ISK",
 			"INR",
 			"ILS",
@@ -9129,6 +9917,7 @@ const zPostV2ListsByListEntriesQueryResponse = z.object({ data: z.array(z.object
 				"DKK",
 				"EUR",
 				"HKD",
+				"HUF",
 				"ISK",
 				"INR",
 				"ILS",
@@ -9997,6 +10786,7 @@ const zPostV2ListsByListEntriesResponse = z.object({ data: z.object({
 				"DKK",
 				"EUR",
 				"HKD",
+				"HUF",
 				"ISK",
 				"INR",
 				"ILS",
@@ -10865,6 +11655,7 @@ const zPutV2ListsByListEntriesResponse = z.object({ data: z.object({
 				"DKK",
 				"EUR",
 				"HKD",
+				"HUF",
 				"ISK",
 				"INR",
 				"ILS",
@@ -11744,6 +12535,7 @@ const zGetV2ListsByListEntriesByEntryIdResponse = z.object({ data: z.object({
 				"DKK",
 				"EUR",
 				"HKD",
+				"HUF",
 				"ISK",
 				"INR",
 				"ILS",
@@ -12611,6 +13403,7 @@ const zPatchV2ListsByListEntriesByEntryIdResponse = z.object({ data: z.object({
 				"DKK",
 				"EUR",
 				"HKD",
+				"HUF",
 				"ISK",
 				"INR",
 				"ILS",
@@ -13478,6 +14271,7 @@ const zPutV2ListsByListEntriesByEntryIdResponse = z.object({ data: z.object({
 				"DKK",
 				"EUR",
 				"HKD",
+				"HUF",
 				"ISK",
 				"INR",
 				"ILS",
@@ -14341,6 +15135,7 @@ const zGetV2ListsByListEntriesByEntryIdAttributesByAttributeValuesResponse = z.o
 			"DKK",
 			"EUR",
 			"HKD",
+			"HUF",
 			"ISK",
 			"INR",
 			"ILS",
@@ -17633,732 +18428,338 @@ const getV2MeetingsByMeetingId = (options) => (options.client ?? client).get({
 * 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`.
-*/
-const getV2MeetingsByMeetingIdCallRecordings = (options) => (options.client ?? client).get({
-	requestValidator: async (data) => await zGetV2MeetingsByMeetingIdCallRecordingsData.parseAsync(data),
-	responseValidator: async (data) => await zGetV2MeetingsByMeetingIdCallRecordingsResponse.parseAsync(data),
-	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.
-*
-* This endpoint is in alpha and may be subject to breaking changes as we gather feedback.
-*
-* Required scopes: `meeting:read`, `call_recording:read-write`.
-*/
-const postV2MeetingsByMeetingIdCallRecordings = (options) => (options.client ?? client).post({
-	requestValidator: async (data) => await zPostV2MeetingsByMeetingIdCallRecordingsData.parseAsync(data),
-	responseValidator: async (data) => await zPostV2MeetingsByMeetingIdCallRecordingsResponse.parseAsync(data),
-	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 alpha and may be subject to breaking changes as we gather feedback.
-*
-* Required scopes: `meeting:read`, `call_recording:read-write`.
-*/
-const deleteV2MeetingsByMeetingIdCallRecordingsByCallRecordingId = (options) => (options.client ?? client).delete({
-	requestValidator: async (data) => await zDeleteV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdData.parseAsync(data),
-	responseValidator: async (data) => await zDeleteV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdResponse.parseAsync(data),
-	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`.
-*/
-const getV2MeetingsByMeetingIdCallRecordingsByCallRecordingId = (options) => (options.client ?? client).get({
-	requestValidator: async (data) => await zGetV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdData.parseAsync(data),
-	responseValidator: async (data) => await zGetV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdResponse.parseAsync(data),
-	security: [{
-		scheme: "bearer",
-		type: "http"
-	}],
-	url: "/v2/meetings/{meeting_id}/call_recordings/{call_recording_id}",
-	...options
-});
-/**
-* Get call transcript
-*
-* 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`.
-*/
-const getV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdTranscript = (options) => (options.client ?? client).get({
-	requestValidator: async (data) => await zGetV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdTranscriptData.parseAsync(data),
-	responseValidator: async (data) => await zGetV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdTranscriptResponse.parseAsync(data),
-	security: [{
-		scheme: "bearer",
-		type: "http"
-	}],
-	url: "/v2/meetings/{meeting_id}/call_recordings/{call_recording_id}/transcript",
-	...options
-});
-/**
-* List webhooks
-*
-* Get all of the webhooks in your workspace.
-*
-* Required scopes: `webhook:read`.
-*/
-const getV2Webhooks = (options) => (options?.client ?? client).get({
-	requestValidator: async (data) => await zGetV2WebhooksData.parseAsync(data),
-	responseValidator: async (data) => await zGetV2WebhooksResponse.parseAsync(data),
-	security: [{
-		scheme: "bearer",
-		type: "http"
-	}],
-	url: "/v2/webhooks",
-	...options
-});
-/**
-* Create a webhook
-*
-* Create a webhook and associated subscriptions.
-*
-* Required scopes: `webhook:read-write`.
-*/
-const postV2Webhooks = (options) => (options.client ?? client).post({
-	requestValidator: async (data) => await zPostV2WebhooksData.parseAsync(data),
-	responseValidator: async (data) => await zPostV2WebhooksResponse.parseAsync(data),
-	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`.
-*/
-const deleteV2WebhooksByWebhookId = (options) => (options.client ?? client).delete({
-	requestValidator: async (data) => await zDeleteV2WebhooksByWebhookIdData.parseAsync(data),
-	responseValidator: async (data) => await zDeleteV2WebhooksByWebhookIdResponse.parseAsync(data),
-	security: [{
-		scheme: "bearer",
-		type: "http"
-	}],
-	url: "/v2/webhooks/{webhook_id}",
-	...options
-});
-/**
-* Get a webhook
-*
-* Get a single webhook.
-*
-* Required scopes: `webhook:read`.
-*/
-const getV2WebhooksByWebhookId = (options) => (options.client ?? client).get({
-	requestValidator: async (data) => await zGetV2WebhooksByWebhookIdData.parseAsync(data),
-	responseValidator: async (data) => await zGetV2WebhooksByWebhookIdResponse.parseAsync(data),
-	security: [{
-		scheme: "bearer",
-		type: "http"
-	}],
-	url: "/v2/webhooks/{webhook_id}",
-	...options
-});
-/**
-* Update a webhook
-*
-* Update a webhook and associated subscriptions.
-*
-* Required scopes: `webhook:read-write`.
-*/
-const patchV2WebhooksByWebhookId = (options) => (options.client ?? client).patch({
-	requestValidator: async (data) => await zPatchV2WebhooksByWebhookIdData.parseAsync(data),
-	responseValidator: async (data) => await zPatchV2WebhooksByWebhookIdResponse.parseAsync(data),
-	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.
-*/
-const getV2Self = (options) => (options?.client ?? client).get({
-	requestValidator: async (data) => await zGetV2SelfData.parseAsync(data),
-	responseValidator: async (data) => await zGetV2SelfResponse.parseAsync(data),
+*/
+const getV2MeetingsByMeetingIdCallRecordings = (options) => (options.client ?? client).get({
+	requestValidator: async (data) => await zGetV2MeetingsByMeetingIdCallRecordingsData.parseAsync(data),
+	responseValidator: async (data) => await zGetV2MeetingsByMeetingIdCallRecordingsResponse.parseAsync(data),
 	security: [{
 		scheme: "bearer",
 		type: "http"
 	}],
-	url: "/v2/self",
+	url: "/v2/meetings/{meeting_id}/call_recordings",
 	...options
 });
-
-//#endregion
-//#region src/attio/batch.ts
 /**
-* Returns an empty results array when called with no items.
+* Create call recording
+*
+* Create a call recording for a meeting. This endpoint is rate limited to 1 request per second.
+*
+* This endpoint is in alpha and may be subject to breaking changes as we gather feedback.
+*
+* Required scopes: `meeting:read`, `call_recording:read-write`.
 */
-const runBatch = async (items, options = {}) => {
-	if (items.length === 0) return [];
-	const concurrency = Math.max(1, options.concurrency ?? 4);
-	const results = [];
-	let index = 0;
-	let active = 0;
-	let stopped = false;
-	const abortController = options.stopOnError ? new AbortController() : void 0;
-	const isCancelled = () => abortController?.signal.aborted ?? stopped;
-	return new Promise((resolve, reject) => {
-		const launchNext = () => {
-			if (isCancelled()) return;
-			if (index >= items.length && active === 0) {
-				resolve(results);
-				return;
-			}
-			while (active < concurrency && index < items.length) {
-				const currentIndex = index;
-				const item = items[currentIndex];
-				index += 1;
-				active += 1;
-				item.run(abortController ? { signal: abortController.signal } : void 0).then((value) => {
-					if (isCancelled()) return;
-					results[currentIndex] = {
-						status: "fulfilled",
-						value,
-						label: item.label
-					};
-				}).catch((reason) => {
-					if (options.stopOnError) {
-						if (!stopped) {
-							stopped = true;
-							if (abortController && !abortController.signal.aborted) abortController.abort();
-							reject(reason);
-						}
-						return;
-					}
-					if (isCancelled()) return;
-					results[currentIndex] = {
-						status: "rejected",
-						reason,
-						label: item.label
-					};
-				}).finally(() => {
-					active -= 1;
-					if (isCancelled()) return;
-					launchNext();
-				});
-			}
-		};
-		launchNext();
-	});
-};
-
-//#endregion
-//#region src/attio/cache.ts
-var TtlCache = class {
-	ttlMs;
-	maxEntries;
-	store = /* @__PURE__ */ new Map();
-	constructor(options) {
-		this.ttlMs = options.ttlMs;
-		this.maxEntries = options.maxEntries;
-	}
-	get(key) {
-		const entry = this.store.get(key);
-		if (!entry) return;
-		if (Date.now() >= entry.expiresAt) {
-			this.store.delete(key);
-			return;
-		}
-		return entry.value;
-	}
-	set(key, value) {
-		if (this.maxEntries && this.store.size >= this.maxEntries && !this.store.has(key)) {
-			const oldestKey = this.store.keys().next().value;
-			if (oldestKey !== void 0) this.store.delete(oldestKey);
-		}
-		this.store.set(key, {
-			value,
-			expiresAt: Date.now() + this.ttlMs
-		});
-	}
-	delete(key) {
-		this.store.delete(key);
-	}
-	clear() {
-		this.store.clear();
-	}
-};
-const createTtlCache = (options) => new TtlCache(options);
-const clientCache = /* @__PURE__ */ new Map();
-const getCachedClient = (key) => {
-	return clientCache.get(key);
-};
-const setCachedClient = (key, client) => {
-	clientCache.set(key, client);
-};
-const clearClientCache = () => {
-	clientCache.clear();
-};
-const hashToken = (value) => {
-	let hash = 5381;
-	for (let i = 0; i < value.length; i += 1) hash = hash * 33 ^ value.charCodeAt(i);
-	return (hash >>> 0).toString(36);
-};
-
-//#endregion
-//#region src/attio/config.ts
-const DEFAULT_BASE_URL = "https://api.attio.com";
-const getEnvValue = (key) => {
-	if (typeof process === "undefined") return void 0;
-	return process.env?.[key];
-};
-const normalizeBaseUrl = (baseUrl) => {
-	return baseUrl.replace(/\/+$/, "");
-};
-const resolveBaseUrl = (config) => {
-	return normalizeBaseUrl(config?.baseUrl ?? getEnvValue("ATTIO_BASE_URL") ?? DEFAULT_BASE_URL);
-};
-const resolveAuthToken = (config) => {
-	return config?.apiKey ?? config?.accessToken ?? config?.authToken ?? getEnvValue("ATTIO_API_KEY") ?? getEnvValue("ATTIO_ACCESS_TOKEN");
-};
-const validateAuthToken = (token) => {
-	if (!token || typeof token !== "string") throw new Error("Missing Attio API key. Set ATTIO_API_KEY or pass apiKey.");
-	if (/\s/.test(token)) throw new Error("Invalid Attio API key: contains whitespace.");
-	if (token.length < 10) throw new Error("Invalid Attio API key: too short.");
-	return token;
-};
-const resolveResponseStyle = (config) => config?.responseStyle ?? "fields";
-const resolveThrowOnError = (config) => config?.throwOnError ?? true;
-
-//#endregion
-//#region src/attio/retry.ts
-const DEFAULT_RETRY_CONFIG = {
-	maxRetries: 3,
-	initialDelayMs: 500,
-	maxDelayMs: 5e3,
-	retryableStatusCodes: [
-		408,
-		429,
-		500,
-		502,
-		503,
-		504
-	],
-	respectRetryAfter: true
-};
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-const calculateRetryDelay = (attempt, config, retryAfterMs) => {
-	if (config.respectRetryAfter && retryAfterMs && retryAfterMs > 0) return Math.min(retryAfterMs, config.maxDelayMs);
-	const base = config.initialDelayMs * 2 ** attempt;
-	const jitter = .75 + Math.random() * .5;
-	return Math.min(base * jitter, config.maxDelayMs);
-};
-const isRetryableStatus = (status, config) => {
-	if (status === void 0) return true;
-	return config.retryableStatusCodes.includes(status);
-};
-const isRetryableError = (error, config) => {
-	const typed = error;
-	if (typed?.isNetworkError) return true;
-	return isRetryableStatus(typed?.status, config);
-};
-const getRetryAfterMs = (error) => {
-	const typed = error;
-	if (typed?.retryAfterMs) return typed.retryAfterMs;
-};
-const callWithRetry = async (fn, config) => {
-	const retryConfig = {
-		...DEFAULT_RETRY_CONFIG,
-		...config
-	};
-	let attempt = 0;
-	while (attempt <= retryConfig.maxRetries) try {
-		return await fn();
-	} catch (error) {
-		if (!isRetryableError(error, retryConfig) || attempt >= retryConfig.maxRetries) throw error;
-		await sleep(calculateRetryDelay(attempt, retryConfig, getRetryAfterMs(error)));
-		attempt += 1;
-	}
-	throw new Error("Retry attempts exhausted.");
-};
-
-//#endregion
-//#region src/attio/error-enhancer.ts
-const knownFieldValues = /* @__PURE__ */ new Map();
-const getKnownFieldValues = (field) => knownFieldValues.get(field);
-const updateKnownFieldValues = (field, values) => {
-	const unique = Array.from(new Set(values.map((value) => value.trim()))).filter(Boolean);
-	if (unique.length > 0) knownFieldValues.set(field, unique);
-	else knownFieldValues.delete(field);
-};
-const extractMismatchContext = (error) => {
-	const data = error.data;
-	const message = error.message;
-	const path = (Array.isArray(data?.path) ? data?.path[0] : data?.path) ?? data?.field ?? data?.attribute ?? void 0;
-	if (typeof message !== "string" || typeof path !== "string") return;
-	const patterns = [
-		/constraint:\s*([^,]+)/i,
-		/option name\s+'([^']+)'/i,
-		/option name\s+"([^"]+)"/i
-	];
-	let value;
-	for (const pattern of patterns) {
-		const match = message.match(pattern);
-		if (match?.[1]) {
-			value = match[1].trim();
-			break;
-		}
-	}
-	return {
-		field: path,
-		value
-	};
-};
-const levenshtein = (a, b) => {
-	const matrix = [];
-	const aLen = a.length;
-	const bLen = b.length;
-	for (let i = 0; i <= bLen; i += 1) matrix[i] = [i];
-	for (let j = 0; j <= aLen; j += 1) matrix[0][j] = j;
-	for (let i = 1; i <= bLen; i += 1) for (let j = 1; j <= aLen; j += 1) if (b.charAt(i - 1) === a.charAt(j - 1)) matrix[i][j] = matrix[i - 1][j - 1];
-	else matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
-	return matrix[bLen][aLen];
-};
-const scoreCandidates = (value, candidates) => {
-	const normalized = value.toLowerCase();
-	return candidates.map((candidate) => ({
-		candidate,
-		score: levenshtein(normalized, candidate.toLowerCase())
-	})).sort((a, b) => a.score - b.score).map((entry) => entry.candidate);
-};
-const enhanceAttioError = (error) => {
-	if (!error?.isApiError) return error;
-	const context = extractMismatchContext(error);
-	if (!context?.field || !context?.value) return error;
-	const candidates = knownFieldValues.get(context.field);
-	if (!candidates?.length) return error;
-	const matches = scoreCandidates(context.value, candidates).slice(0, 3);
-	error.suggestions = {
-		field: context.field,
-		attempted: context.value,
-		bestMatch: matches[0],
-		matches
-	};
-	return error;
-};
-
-//#endregion
-//#region src/attio/errors.ts
-var AttioError = class extends Error {
-	status;
-	code;
-	type;
-	requestId;
-	data;
-	response;
-	request;
-	retryAfterMs;
-	isNetworkError;
-	isApiError;
-	suggestions;
-	constructor(message, details = {}) {
-		super(message);
-		this.name = "AttioError";
-		this.status = details.status;
-		this.code = details.code;
-		this.type = details.type;
-		this.data = details.data;
-	}
-};
-var AttioApiError = class extends AttioError {
-	constructor(message, details = {}) {
-		super(message, details);
-		this.name = "AttioApiError";
-		this.isApiError = true;
-	}
-};
-var AttioNetworkError = class extends AttioError {
-	constructor(message, details = {}) {
-		super(message, details);
-		this.name = "AttioNetworkError";
-		this.isNetworkError = true;
-	}
-};
-const getHeaderValue = (response, key) => {
-	if (!response) return;
-	return response.headers.get(key) ?? void 0;
-};
-const parseRetryAfter = (response) => {
-	if (!response) return;
-	const raw = response.headers.get("Retry-After");
-	if (!raw) return;
-	const seconds = Number(raw);
-	if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
-	const dateMs = Date.parse(raw);
-	if (!Number.isNaN(dateMs)) return Math.max(0, dateMs - Date.now());
-};
-const extractMessage = (error, fallback) => {
-	if (typeof error === "string") return error;
-	if (error && typeof error === "object") {
-		const maybe = error;
-		if (typeof maybe.message === "string") return maybe.message;
+const postV2MeetingsByMeetingIdCallRecordings = (options) => (options.client ?? client).post({
+	requestValidator: async (data) => await zPostV2MeetingsByMeetingIdCallRecordingsData.parseAsync(data),
+	responseValidator: async (data) => await zPostV2MeetingsByMeetingIdCallRecordingsResponse.parseAsync(data),
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/meetings/{meeting_id}/call_recordings",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
 	}
-	return fallback ?? "Request failed.";
-};
-const extractDetails = (error) => {
-	if (!error || typeof error !== "object") return {};
-	const payload = error;
-	return {
-		code: typeof payload.code === "string" ? payload.code : void 0,
-		type: typeof payload.type === "string" ? payload.type : void 0,
-		status: typeof payload.status_code === "number" ? payload.status_code : typeof payload.status === "number" ? payload.status : void 0,
-		message: typeof payload.message === "string" ? payload.message : void 0,
-		data: payload
-	};
-};
-const normalizeAttioError = (error, context = {}) => {
-	const { response, request } = context;
-	const details = extractDetails(error);
-	const status = response?.status ?? details.status;
-	const message = extractMessage(error, response?.statusText ?? details.message);
-	const requestId = getHeaderValue(response, "x-request-id") ?? getHeaderValue(response, "x-attio-request-id");
-	if (response) {
-		const apiError = new AttioApiError(message, {
-			...details,
-			status
-		});
-		apiError.requestId = requestId;
-		apiError.response = response;
-		apiError.request = request;
-		apiError.data = details.data ?? error;
-		apiError.retryAfterMs = parseRetryAfter(response);
-		return enhanceAttioError(apiError);
+});
+/**
+* Delete call recording
+*
+* Deletes the specified call recording. This will remove the call recording and all associated data.
+*
+* This endpoint is in alpha and may be subject to breaking changes as we gather feedback.
+*
+* Required scopes: `meeting:read`, `call_recording:read-write`.
+*/
+const deleteV2MeetingsByMeetingIdCallRecordingsByCallRecordingId = (options) => (options.client ?? client).delete({
+	requestValidator: async (data) => await zDeleteV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdData.parseAsync(data),
+	responseValidator: async (data) => await zDeleteV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdResponse.parseAsync(data),
+	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`.
+*/
+const getV2MeetingsByMeetingIdCallRecordingsByCallRecordingId = (options) => (options.client ?? client).get({
+	requestValidator: async (data) => await zGetV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdData.parseAsync(data),
+	responseValidator: async (data) => await zGetV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdResponse.parseAsync(data),
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/meetings/{meeting_id}/call_recordings/{call_recording_id}",
+	...options
+});
+/**
+* Get call transcript
+*
+* 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`.
+*/
+const getV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdTranscript = (options) => (options.client ?? client).get({
+	requestValidator: async (data) => await zGetV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdTranscriptData.parseAsync(data),
+	responseValidator: async (data) => await zGetV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdTranscriptResponse.parseAsync(data),
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/meetings/{meeting_id}/call_recordings/{call_recording_id}/transcript",
+	...options
+});
+/**
+* List webhooks
+*
+* Get all of the webhooks in your workspace.
+*
+* Required scopes: `webhook:read`.
+*/
+const getV2Webhooks = (options) => (options?.client ?? client).get({
+	requestValidator: async (data) => await zGetV2WebhooksData.parseAsync(data),
+	responseValidator: async (data) => await zGetV2WebhooksResponse.parseAsync(data),
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/webhooks",
+	...options
+});
+/**
+* Create a webhook
+*
+* Create a webhook and associated subscriptions.
+*
+* Required scopes: `webhook:read-write`.
+*/
+const postV2Webhooks = (options) => (options.client ?? client).post({
+	requestValidator: async (data) => await zPostV2WebhooksData.parseAsync(data),
+	responseValidator: async (data) => await zPostV2WebhooksResponse.parseAsync(data),
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/webhooks",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
 	}
-	const networkError = new AttioNetworkError(message, details);
-	networkError.request = request;
-	return networkError;
-};
-
-//#endregion
-//#region src/attio/client.ts
-const resolveFetch = (config) => {
-	const baseFetch = config?.fetch ?? globalThis.fetch;
-	if (!baseFetch) throw new Error("Fetch is not available in this environment.");
-	if (!config?.timeoutMs) return baseFetch;
-	return async (input, init) => {
-		const controller = new AbortController();
-		const timeoutId = setTimeout(() => controller.abort(), config.timeoutMs);
-		let combinedSignal = controller.signal;
-		let abortCombined;
-		if (init?.signal) if (typeof AbortSignal !== "undefined" && "any" in AbortSignal) combinedSignal = AbortSignal.any([init.signal, controller.signal]);
-		else {
-			const combinedController = new AbortController();
-			combinedSignal = combinedController.signal;
-			if (init.signal.aborted) combinedController.abort();
-			else {
-				abortCombined = () => combinedController.abort();
-				init.signal.addEventListener("abort", abortCombined, { once: true });
-				controller.signal.addEventListener("abort", abortCombined, { once: true });
-			}
-		}
-		try {
-			return await baseFetch(input, {
-				...init,
-				signal: combinedSignal
-			});
-		} finally {
-			if (abortCombined) {
-				init?.signal?.removeEventListener("abort", abortCombined);
-				controller.signal.removeEventListener("abort", abortCombined);
-			}
-			clearTimeout(timeoutId);
-		}
-	};
-};
-const buildClientCacheKey = ({ config, authToken }) => {
-	if (config.cache?.key) return `${config.cache.key}:${hashToken(authToken)}`;
-};
-const applyInterceptors = (client) => {
-	client.interceptors.error.use((error, response, request, options) => normalizeAttioError(error, {
-		response,
-		request,
-		options
-	}));
-};
-const wrapClient = (base, retry) => {
-	const requestWithRetry = async (options) => {
-		const { retry: retryOverride, ...rest } = options;
-		return callWithRetry(() => base.request(rest), {
-			...retry,
-			...retryOverride
-		});
-	};
-	const makeMethod = (method) => (options) => requestWithRetry({
-		...options,
-		method
-	});
-	return {
-		...base,
-		request: requestWithRetry,
-		connect: makeMethod("CONNECT"),
-		delete: makeMethod("DELETE"),
-		get: makeMethod("GET"),
-		head: makeMethod("HEAD"),
-		options: makeMethod("OPTIONS"),
-		patch: makeMethod("PATCH"),
-		post: makeMethod("POST"),
-		put: makeMethod("PUT"),
-		trace: makeMethod("TRACE")
-	};
-};
-const createAttioClientWithAuthToken = ({ config = {}, authToken }) => {
-	const baseUrl = resolveBaseUrl(config);
-	const responseStyle = resolveResponseStyle(config);
-	const throwOnError = resolveThrowOnError(config);
-	const headers = config.headers;
-	const retry = config.retry;
-	const timeoutMs = config.timeoutMs;
-	const cleanConfig = { ...config };
-	delete cleanConfig.apiKey;
-	delete cleanConfig.accessToken;
-	delete cleanConfig.authToken;
-	delete cleanConfig.cache;
-	delete cleanConfig.retry;
-	delete cleanConfig.timeoutMs;
-	delete cleanConfig.headers;
-	const mergedHeaders = mergeHeaders({ Accept: "application/json" }, headers);
-	const base = createClient({
-		...cleanConfig,
-		baseUrl,
-		auth: authToken,
-		headers: mergedHeaders,
-		fetch: resolveFetch({
-			...config,
-			timeoutMs
-		}),
-		responseStyle,
-		throwOnError
-	});
-	applyInterceptors(base);
-	return wrapClient(base, retry);
-};
-const createAttioClient = (config = {}) => {
-	return createAttioClientWithAuthToken({
-		config,
-		authToken: validateAuthToken(resolveAuthToken(config))
-	});
-};
-const getAttioClient = (config = {}) => {
-	const cacheEnabled = config.cache?.enabled ?? true;
-	const authToken = validateAuthToken(resolveAuthToken(config));
-	const cacheKey = buildClientCacheKey({
-		config,
-		authToken
-	});
-	if (cacheEnabled && cacheKey) {
-		const cached = getCachedClient(cacheKey);
-		if (cached) return cached;
-		const client = createAttioClientWithAuthToken({
-			config,
-			authToken
-		});
-		setCachedClient(cacheKey, client);
-		return client;
+});
+/**
+* Delete a webhook
+*
+* Delete a webhook by ID.
+*
+* Required scopes: `webhook:read-write`.
+*/
+const deleteV2WebhooksByWebhookId = (options) => (options.client ?? client).delete({
+	requestValidator: async (data) => await zDeleteV2WebhooksByWebhookIdData.parseAsync(data),
+	responseValidator: async (data) => await zDeleteV2WebhooksByWebhookIdResponse.parseAsync(data),
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/webhooks/{webhook_id}",
+	...options
+});
+/**
+* Get a webhook
+*
+* Get a single webhook.
+*
+* Required scopes: `webhook:read`.
+*/
+const getV2WebhooksByWebhookId = (options) => (options.client ?? client).get({
+	requestValidator: async (data) => await zGetV2WebhooksByWebhookIdData.parseAsync(data),
+	responseValidator: async (data) => await zGetV2WebhooksByWebhookIdResponse.parseAsync(data),
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/webhooks/{webhook_id}",
+	...options
+});
+/**
+* Update a webhook
+*
+* Update a webhook and associated subscriptions.
+*
+* Required scopes: `webhook:read-write`.
+*/
+const patchV2WebhooksByWebhookId = (options) => (options.client ?? client).patch({
+	requestValidator: async (data) => await zPatchV2WebhooksByWebhookIdData.parseAsync(data),
+	responseValidator: async (data) => await zPatchV2WebhooksByWebhookIdResponse.parseAsync(data),
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/webhooks/{webhook_id}",
+	...options,
+	headers: {
+		"Content-Type": "application/json",
+		...options.headers
 	}
-	return createAttioClientWithAuthToken({
-		config,
-		authToken
-	});
-};
-const resolveAttioClient = (input = {}) => {
-	return input.client ?? getAttioClient(input.config ?? {});
-};
-
-//#endregion
-//#region src/attio/filters.ts
-const operator = (field, op, value) => ({ [field]: { [op]: value } });
-const filters = {
-	eq: (field, value) => operator(field, "$eq", value),
-	contains: (field, value) => operator(field, "$contains", value),
-	startsWith: (field, value) => operator(field, "$starts_with", value),
-	endsWith: (field, value) => operator(field, "$ends_with", value),
-	notEmpty: (field) => operator(field, "$not_empty", true),
-	and: (...conditions) => ({ $and: conditions }),
-	or: (...conditions) => ({ $or: conditions }),
-	not: (condition) => ({ $not: condition })
-};
+});
+/**
+* Identify
+*
+* Identify the current access token, the workspace it is linked to, and any permissions it has.
+*/
+const getV2Self = (options) => (options?.client ?? client).get({
+	requestValidator: async (data) => await zGetV2SelfData.parseAsync(data),
+	responseValidator: async (data) => await zGetV2SelfResponse.parseAsync(data),
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/v2/self",
+	...options
+});
 
 //#endregion
 //#region src/attio/response.ts
-const unwrapData = (result) => {
-	if (!result || typeof result !== "object") return result;
-	if ("data" in result) return result.data;
-	return result;
-};
-const unwrapItems = (result) => {
-	const data = unwrapData(result);
-	if (Array.isArray(data)) return data;
-	if (data && typeof data === "object") {
+const DEFAULT_UNWRAP_DEPTH = 3;
+const responseEnvelopeSchema = z.object({
+	data: z.unknown().optional(),
+	error: z.unknown().optional(),
+	request: z.instanceof(Request).optional(),
+	response: z.instanceof(Response).optional()
+}).passthrough();
+function unwrapData(result, options = {}) {
+	const maxDepth = options.maxDepth ?? DEFAULT_UNWRAP_DEPTH;
+	let current = result;
+	for (let depth = 0; depth < maxDepth; depth += 1) {
+		if (!current || typeof current !== "object") break;
+		if (!("data" in current)) break;
+		current = current.data;
+	}
+	if (options.schema) {
+		const parsed = options.schema.safeParse(current);
+		if (!parsed.success) throw createSchemaError(parsed.error);
+		return parsed.data;
+	}
+	return current;
+}
+/**
+* Searches nested data structures for an array, checking `data`, `items`,
+* and `records` keys at each level up to DEFAULT_UNWRAP_DEPTH.
+*/
+const findArrayInData = (initialData) => {
+	let data = initialData;
+	for (let depth = 0; depth < DEFAULT_UNWRAP_DEPTH; depth += 1) {
+		if (Array.isArray(data)) return data;
+		if (!data || typeof data !== "object") return;
 		const record = data;
 		const nested = record.data ?? record.items ?? record.records;
-		if (Array.isArray(nested)) return nested;
+		if (nested === void 0) return;
+		data = nested;
 	}
-	return [];
+};
+const validateItemsArray = (items, schema) => {
+	const parsed = z.array(schema).safeParse(items);
+	if (!parsed.success) throw createSchemaError(parsed.error);
+	return parsed.data;
+};
+function unwrapItems(result, options = {}) {
+	const items = findArrayInData(unwrapData(result));
+	if (!items) return [];
+	if (options.schema) return validateItemsArray(items, options.schema);
+	return items;
+}
+const readPaginationCursor = (pagination) => {
+	if (!pagination || typeof pagination !== "object") return null;
+	const cursor = pagination.next_cursor ?? pagination.nextCursor;
+	return typeof cursor === "string" ? cursor : null;
 };
 const unwrapPaginationCursor = (result) => {
-	const readCursor = (pagination) => {
-		if (!pagination || typeof pagination !== "object") return null;
-		const cursor = pagination.next_cursor ?? pagination.nextCursor;
-		return typeof cursor === "string" ? cursor : null;
-	};
 	if (result && typeof result === "object") {
-		const rootCursor = readCursor(result.pagination);
+		const rootCursor = readPaginationCursor(result.pagination);
 		if (rootCursor) return rootCursor;
 	}
 	const data = unwrapData(result);
 	if (!data || typeof data !== "object") return null;
-	return readCursor(data.pagination);
+	return readPaginationCursor(data.pagination);
+};
+const readPaginationOffset = (pagination) => {
+	if (!pagination || typeof pagination !== "object") return null;
+	const record = pagination;
+	const nextOffset = record.next_offset ?? record.nextOffset;
+	return typeof nextOffset === "number" ? nextOffset : null;
+};
+const unwrapPaginationOffset = (result) => {
+	if (result && typeof result === "object") {
+		const rootOffset = readPaginationOffset(result.pagination);
+		if (rootOffset !== null) return rootOffset;
+	}
+	const data = unwrapData(result);
+	if (!data || typeof data !== "object") return null;
+	return readPaginationOffset(data.pagination);
 };
+const parseResponseEnvelope = (result) => {
+	const parsed = responseEnvelopeSchema.safeParse(result);
+	if (!parsed.success) return;
+	return parsed.data;
+};
+const createSchemaError = (details) => new AttioResponseError("Invalid API response: schema mismatch", {
+	code: "INVALID_RESPONSE",
+	data: details
+});
+function assertOk(result, options) {
+	const envelope = parseResponseEnvelope(result);
+	if (envelope?.error !== void 0) throw normalizeAttioError(envelope.error, {
+		response: envelope.response,
+		request: envelope.request
+	});
+	const unwrapped = unwrapData(envelope?.data ?? result, { maxDepth: options?.maxDepth });
+	if (!options?.schema) return unwrapped;
+	const parsed = options.schema.safeParse(unwrapped);
+	if (!parsed.success) throw createSchemaError(parsed.error);
+	return parsed.data;
+}
+function toResult(result, options) {
+	const envelope = parseResponseEnvelope(result);
+	if (envelope?.error !== void 0) return {
+		ok: false,
+		error: normalizeAttioError(envelope.error, {
+			response: envelope.response,
+			request: envelope.request
+		}),
+		request: envelope.request,
+		response: envelope.response
+	};
+	const unwrapped = unwrapData(envelope?.data ?? result, { maxDepth: options?.maxDepth });
+	if (!options?.schema) return {
+		ok: true,
+		value: unwrapped,
+		request: envelope?.request,
+		response: envelope?.response
+	};
+	const parsed = options.schema.safeParse(unwrapped);
+	if (!parsed.success) return {
+		ok: false,
+		error: createSchemaError(parsed.error),
+		request: envelope?.request,
+		response: envelope?.response
+	};
+	return {
+		ok: true,
+		value: parsed.data,
+		request: envelope?.request,
+		response: envelope?.response
+	};
+}
 
 //#endregion
 //#region src/attio/lists.ts
@@ -18368,7 +18769,8 @@ const listLists = async (input = {}) => {
 const getList = async (input) => {
 	return unwrapData(await getV2ListsByList({
 		client: resolveAttioClient(input),
-		path: { list: input.list }
+		path: { list: input.list },
+		...input.options
 	}));
 };
 const queryListEntries = async (input) => {
@@ -18388,6 +18790,7 @@ const addListEntry = async (input) => {
 		client: resolveAttioClient(input),
 		path: { list: input.list },
 		body: { data: {
+			parent_object: input.parentObject,
 			parent_record_id: input.parentRecordId,
 			entry_values: input.entryValues ?? {}
 		} },
@@ -18420,19 +18823,7 @@ const removeListEntry = async (input) => {
 
 //#endregion
 //#region src/attio/metadata.ts
-const DEFAULT_TTL_MS = 300 * 1e3;
-const attributesCache = createTtlCache({
-	ttlMs: DEFAULT_TTL_MS,
-	maxEntries: 200
-});
-const optionsCache = createTtlCache({
-	ttlMs: DEFAULT_TTL_MS,
-	maxEntries: 500
-});
-const statusesCache = createTtlCache({
-	ttlMs: DEFAULT_TTL_MS,
-	maxEntries: 500
-});
+const getMetadataCache = (client, scope) => client.cache.metadata.get(scope);
 const buildKey = (target, identifier, attribute) => [
 	target,
 	identifier,
@@ -18444,41 +18835,56 @@ const extractTitles = (items) => items.reduce((titles, item) => {
 	if (parsed.success) titles.push(parsed.data.title);
 	return titles;
 }, []);
-let AttributeMetadata;
-(function(_AttributeMetadata) {
-	const buildPath = _AttributeMetadata.buildPath = (input) => ({
-		target: input.target,
-		identifier: input.identifier,
-		attribute: input.attribute
-	});
-	_AttributeMetadata.list = async ({ input, cache, fetcher }) => {
-		const cacheKey = buildKey(input.target, input.identifier, input.attribute);
+const buildAttributeMetadataPath = (input) => ({
+	target: input.target,
+	identifier: input.identifier,
+	attribute: input.attribute
+});
+const listAttributeMetadata = async ({ input, cache, fetcher, itemSchema }) => {
+	const cacheKey = buildKey(input.target, input.identifier, input.attribute);
+	const arraySchema = z.array(itemSchema);
+	if (cache) {
 		const cached = cache.get(cacheKey);
-		if (cached) return cached;
-		const items = unwrapItems(await fetcher({
-			client: resolveAttioClient(input),
-			path: buildPath(input),
-			...input.options
-		}));
-		const titles = extractTitles(items);
-		updateKnownFieldValues(input.attribute, titles);
-		cache.set(cacheKey, items);
-		return items;
-	};
-})(AttributeMetadata || (AttributeMetadata = {}));
+		if (cached) {
+			const parsed = arraySchema.safeParse(cached);
+			if (parsed.success) return parsed.data;
+			cache.delete(cacheKey);
+		}
+	}
+	const client = resolveAttioClient(input);
+	const options = input.options ?? {};
+	const items = unwrapItems(await fetcher({
+		client,
+		path: buildAttributeMetadataPath(input),
+		...options
+	}), { schema: itemSchema });
+	const titles = extractTitles(items);
+	updateKnownFieldValues(input.attribute, titles);
+	cache?.set(cacheKey, items);
+	return items;
+};
 const listAttributes = async (input) => {
+	const client = resolveAttioClient(input);
+	const cache = getMetadataCache(client, "attributes");
 	const cacheKey = buildKey(input.target, input.identifier);
-	const cached = attributesCache.get(cacheKey);
-	if (cached) return cached;
+	const arraySchema = z.array(zAttribute);
+	if (cache) {
+		const cached = cache.get(cacheKey);
+		if (cached) {
+			const parsed = arraySchema.safeParse(cached);
+			if (!parsed.success) throw createSchemaError(parsed.error);
+			return parsed.data;
+		}
+	}
 	const items = unwrapItems(await getV2ByTargetByIdentifierAttributes({
-		client: resolveAttioClient(input),
+		client,
 		path: {
 			target: input.target,
 			identifier: input.identifier
 		},
 		...input.options
-	}));
-	attributesCache.set(cacheKey, items);
+	}), { schema: zAttribute });
+	cache?.set(cacheKey, items);
 	return items;
 };
 const getAttribute = async (input) => {
@@ -18490,20 +18896,30 @@ const getAttribute = async (input) => {
 			attribute: input.attribute
 		},
 		...input.options
-	}));
+	}), { schema: zAttribute });
 };
-const getAttributeOptions = async (input) => {
-	return AttributeMetadata.list({
-		input,
-		cache: optionsCache,
-		fetcher: getV2ByTargetByIdentifierAttributesByAttributeOptions
+const getAttributeOptions = (input) => {
+	const client = resolveAttioClient(input);
+	return listAttributeMetadata({
+		input: {
+			...input,
+			client
+		},
+		cache: getMetadataCache(client, "options"),
+		fetcher: getV2ByTargetByIdentifierAttributesByAttributeOptions,
+		itemSchema: zSelectOption
 	});
 };
-const getAttributeStatuses = async (input) => {
-	return AttributeMetadata.list({
-		input,
-		cache: statusesCache,
-		fetcher: getV2ByTargetByIdentifierAttributesByAttributeStatuses
+const getAttributeStatuses = (input) => {
+	const client = resolveAttioClient(input);
+	return listAttributeMetadata({
+		input: {
+			...input,
+			client
+		},
+		cache: getMetadataCache(client, "statuses"),
+		fetcher: getV2ByTargetByIdentifierAttributesByAttributeStatuses,
+		itemSchema: zStatus
 	});
 };
 
@@ -18515,7 +18931,8 @@ const listNotes = async (input = {}) => {
 const getNote = async (input) => {
 	return unwrapData(await getV2NotesByNoteId({
 		client: resolveAttioClient(input),
-		path: { note_id: input.noteId }
+		path: { note_id: input.noteId },
+		...input.options
 	}));
 };
 const createNote = async (input) => {
@@ -18525,7 +18942,10 @@ const createNote = async (input) => {
 			parent_object: input.parentObject,
 			parent_record_id: input.parentRecordId,
 			title: input.title,
-			content: input.content
+			format: input.format,
+			content: input.content,
+			created_at: input.createdAt,
+			meeting_id: input.meetingId
 		} },
 		...input.options
 	}));
@@ -18533,19 +18953,104 @@ const createNote = async (input) => {
 const deleteNote = async (input) => {
 	await deleteV2NotesByNoteId({
 		client: resolveAttioClient(input),
-		path: { note_id: input.noteId }
+		path: { note_id: input.noteId },
+		...input.options
 	});
 	return true;
 };
 
+//#endregion
+//#region src/attio/objects.ts
+const AttioObjectSchema = z.object({
+	id: z.object({
+		workspace_id: z.string(),
+		object_id: z.string()
+	}),
+	api_slug: z.string(),
+	singular_noun: z.string(),
+	plural_noun: z.string(),
+	created_at: z.string()
+}).passthrough();
+const listObjects = async (input = {}) => {
+	return unwrapItems(await getV2Objects({
+		client: resolveAttioClient(input),
+		...input.options
+	}), { schema: AttioObjectSchema });
+};
+const getObject = async (input) => {
+	return unwrapData(await getV2ObjectsByObject({
+		client: resolveAttioClient(input),
+		path: { object: input.object },
+		...input.options
+	}), { schema: AttioObjectSchema });
+};
+const createObject = async (input) => {
+	return unwrapData(await postV2Objects({
+		client: resolveAttioClient(input),
+		body: { data: {
+			api_slug: input.apiSlug,
+			singular_noun: input.singularNoun,
+			plural_noun: input.pluralNoun
+		} },
+		...input.options
+	}), { schema: AttioObjectSchema });
+};
+const buildUpdateObjectData = (input) => ({
+	...input.apiSlug !== void 0 && { api_slug: input.apiSlug },
+	...input.singularNoun !== void 0 && { singular_noun: input.singularNoun },
+	...input.pluralNoun !== void 0 && { plural_noun: input.pluralNoun }
+});
+const updateObject = async (input) => {
+	return unwrapData(await patchV2ObjectsByObject({
+		client: resolveAttioClient(input),
+		path: { object: input.object },
+		body: { data: buildUpdateObjectData(input) },
+		...input.options
+	}), { schema: AttioObjectSchema });
+};
+
 //#endregion
 //#region src/attio/pagination.ts
+const createPageResultSchema = (itemSchema) => z.object({
+	items: z.array(itemSchema),
+	nextCursor: z.string().nullish()
+});
+const basePageResultSchema = z.object({
+	items: z.array(z.unknown()),
+	nextCursor: z.string().nullish()
+});
+const createOffsetPageResultSchema = (itemSchema) => z.object({
+	items: z.array(itemSchema),
+	nextOffset: z.number().nullish(),
+	total: z.number().optional()
+});
+const baseOffsetPageResultSchema = z.object({
+	items: z.array(z.unknown()),
+	nextOffset: z.number().nullish(),
+	total: z.number().optional()
+});
 const toPageResult = (result) => {
 	return {
 		items: unwrapItems(result),
 		nextCursor: unwrapPaginationCursor(result)
 	};
 };
+const toOffsetPageResult = (result) => {
+	return {
+		items: unwrapItems(result),
+		nextOffset: unwrapPaginationOffset(result)
+	};
+};
+const parsePageResult = (page, itemSchema) => {
+	const result = (itemSchema ? createPageResultSchema(itemSchema) : basePageResultSchema).safeParse(page);
+	if (!result.success) return;
+	return result.data;
+};
+const parseOffsetPageResult = (page, itemSchema) => {
+	const result = (itemSchema ? createOffsetPageResultSchema(itemSchema) : baseOffsetPageResultSchema).safeParse(page);
+	if (!result.success) return;
+	return result.data;
+};
 const paginate = async (fetchPage, options = {}) => {
 	const items = [];
 	let cursor = options.cursor ?? null;
@@ -18554,7 +19059,7 @@ const paginate = async (fetchPage, options = {}) => {
 	const maxItems = options.maxItems ?? Number.POSITIVE_INFINITY;
 	while (pages < maxPages && items.length < maxItems) {
 		const page = await fetchPage(cursor);
-		const { items: pageItems, nextCursor } = page !== null && typeof page === "object" && Array.isArray(page.items) ? page : toPageResult(page);
+		const { items: pageItems, nextCursor } = parsePageResult(page, options.itemSchema) ?? toPageResult(page);
 		items.push(...pageItems);
 		pages += 1;
 		if (!nextCursor) break;
@@ -18562,60 +19067,176 @@ const paginate = async (fetchPage, options = {}) => {
 	}
 	return items.slice(0, maxItems);
 };
+const DEFAULT_OFFSET_PAGE_SIZE = 50;
+const resolveNextOffset = ({ nextOffset, pageItemsLength, limit, currentOffset }) => {
+	if (typeof nextOffset === "number") return nextOffset;
+	if (pageItemsLength < limit) return null;
+	return currentOffset + limit;
+};
+const paginateOffset = async (fetchPage, options = {}) => {
+	const items = [];
+	const maxPages = options.maxPages ?? Number.POSITIVE_INFINITY;
+	const maxItems = options.maxItems ?? Number.POSITIVE_INFINITY;
+	const limit = Math.max(1, options.limit ?? options.pageSize ?? DEFAULT_OFFSET_PAGE_SIZE);
+	let offset = Math.max(0, options.offset ?? 0);
+	let pages = 0;
+	while (pages < maxPages && items.length < maxItems) {
+		const page = await fetchPage(offset, limit);
+		const { items: pageItems, nextOffset } = parseOffsetPageResult(page, options.itemSchema) ?? toOffsetPageResult(page);
+		items.push(...pageItems);
+		pages += 1;
+		if (items.length >= maxItems) break;
+		const resolvedOffset = resolveNextOffset({
+			nextOffset,
+			pageItemsLength: pageItems.length,
+			limit,
+			currentOffset: offset
+		});
+		if (resolvedOffset === null || resolvedOffset <= offset) break;
+		offset = resolvedOffset;
+	}
+	return items.slice(0, maxItems);
+};
 
 //#endregion
 //#region src/attio/record-utils.ts
-const extractAnyId = (obj) => {
-	if (!obj || typeof obj !== "object") return;
-	const record = obj;
-	const idObj = record.id;
-	return idObj?.record_id ?? idObj?.company_id ?? idObj?.person_id ?? idObj?.list_id ?? idObj?.task_id ?? (typeof record.id === "string" ? record.id : void 0) ?? record.record_id ?? record.company_id ?? record.person_id ?? record.list_id ?? record.task_id;
+const attioRecordIdSchema = z.string().brand();
+const defaultNormalizeRecordOptions = { emptyBehavior: "reject" };
+const emptyObjectIssueCode = "EMPTY_OBJECT";
+const unknownObjectSchema = z.object({}).passthrough();
+const nonEmptyObjectSchema = unknownObjectSchema.superRefine((value, ctx) => {
+	if (Object.keys(value).length === 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "Expected non-empty object",
+		params: { code: emptyObjectIssueCode }
+	});
+});
+const recordIdFieldsSchema = z.object({
+	record_id: attioRecordIdSchema.optional(),
+	company_id: attioRecordIdSchema.optional(),
+	person_id: attioRecordIdSchema.optional(),
+	list_id: attioRecordIdSchema.optional(),
+	task_id: attioRecordIdSchema.optional()
+});
+const unknownArraySchema = z.array(z.unknown());
+const extractIdFromFields = (fields) => fields.record_id ?? fields.company_id ?? fields.person_id ?? fields.list_id ?? fields.task_id;
+function parseObject(value, options) {
+	const parsed = ((options?.emptyBehavior ?? "allow") === "allow" ? unknownObjectSchema : nonEmptyObjectSchema).safeParse(value);
+	if (parsed.success) return parsed.data;
+	if (options) throw parsed.error;
+}
+const parseId = (value) => {
+	const parsed = attioRecordIdSchema.safeParse(value);
+	return parsed.success ? parsed.data : void 0;
 };
-const extractValues = (obj) => {
-	if (!obj || typeof obj !== "object") return;
-	const values = obj.values;
-	if (!values || typeof values !== "object" || Array.isArray(values)) return;
-	return values;
+const parseIdFields = (value) => {
+	const parsed = recordIdFieldsSchema.safeParse(value);
+	return parsed.success ? parsed.data : void 0;
+};
+const parseArray = (value) => {
+	const parsed = unknownArraySchema.safeParse(value);
+	return parsed.success ? parsed.data : void 0;
+};
+const extractIdFromRecord = (record) => {
+	const idFields = parseIdFields(record.id);
+	return (idFields ? extractIdFromFields(idFields) : void 0) ?? parseId(record.id) ?? parseId(record.record_id) ?? parseId(record.company_id) ?? parseId(record.person_id) ?? parseId(record.list_id) ?? parseId(record.task_id);
+};
+const extractValuesObject = (record) => parseObject(record.values);
+const extractIdFromUnknown = (value) => {
+	const record = parseObject(value);
+	if (!record) return;
+	return extractIdFromRecord(record);
+};
+const extractValues$1 = (obj) => {
+	const record = parseObject(obj);
+	if (!record) return;
+	return extractValuesObject(record);
+};
+const collectNestedCandidates = (record) => {
+	const candidates = [];
+	if (record.data !== void 0) candidates.push(record.data);
+	const dataRecord = parseObject(record.data);
+	if (!dataRecord) return candidates;
+	if (dataRecord.data !== void 0) candidates.push(dataRecord.data);
+	if (dataRecord.record !== void 0) candidates.push(dataRecord.record);
+	const items = parseArray(dataRecord.items);
+	if (items && items.length > 0) candidates.push(items[0]);
+	return candidates;
+};
+const findFirstId = (candidates) => {
+	for (const candidate of candidates) {
+		const nested = extractIdFromUnknown(candidate);
+		if (nested) return nested;
+	}
 };
 const extractRecordId = (obj) => {
-	if (!obj || typeof obj !== "object") return;
-	const record = obj;
-	return extractAnyId(record) ?? extractAnyId(record.data) ?? extractAnyId(record.data?.data) ?? extractAnyId(record.data?.record) ?? extractAnyId(record.data?.items?.[0]);
+	const record = parseObject(obj);
+	if (!record) return;
+	const direct = extractIdFromRecord(record);
+	if (direct) return direct;
+	return findFirstId(collectNestedCandidates(record));
+};
+const hasValidRecordId = (raw) => {
+	const idFields = parseIdFields(raw.id);
+	return Boolean(idFields?.record_id);
 };
-const normalizeRecord = (raw, options = {}) => {
-	if (!raw || typeof raw !== "object") throw new Error("Invalid API response: no data found");
-	if (!options.allowEmpty && Object.keys(raw).length === 0) throw new Error("Invalid API response: empty data object");
-	if (raw.id && raw.id.record_id && raw.values) return raw;
-	const result = { ...raw };
-	if (!result.id || !result.id.record_id) {
+const extractNestedValues = (result) => {
+	const candidates = collectNestedCandidates(result);
+	for (const candidate of candidates) {
+		const values = extractValues$1(candidate);
+		if (values) return values;
+	}
+};
+const parseRecordInput = (raw, options) => {
+	try {
+		return parseObject(raw, { emptyBehavior: options.emptyBehavior ?? "reject" });
+	} catch (error) {
+		if (error instanceof z.ZodError) {
+			if (error.issues.some((issue) => issue.code === z.ZodIssueCode.custom && issue.params?.code === emptyObjectIssueCode)) throw new AttioResponseError("Invalid API response: empty data object", { code: "EMPTY_RESPONSE" });
+			throw new AttioResponseError("Invalid API response: no data found", { code: "INVALID_RESPONSE" });
+		}
+		throw error;
+	}
+};
+function normalizeRecord(raw, options = defaultNormalizeRecordOptions) {
+	const parsedRaw = parseRecordInput(raw, options);
+	if (hasValidRecordId(parsedRaw) && extractValuesObject(parsedRaw)) return parsedRaw;
+	const result = { ...parsedRaw };
+	if (!hasValidRecordId(result)) {
 		const extractedId = extractRecordId(result);
 		if (extractedId) result.id = {
-			...result.id,
+			...parseObject(result.id) ?? {},
 			record_id: extractedId
 		};
 	}
-	if (!result.values) {
-		const dataRecord = result.data;
-		result.values = extractValues(result.data) ?? extractValues(dataRecord?.data) ?? extractValues(dataRecord?.record) ?? extractValues(dataRecord?.items?.[0]) ?? {};
-	}
+	if (!extractValuesObject(result)) result.values = extractNestedValues(result) ?? {};
 	return result;
-};
-const normalizeRecords = (items, options = {}) => {
-	return items.filter((item) => item && typeof item === "object").map((item) => normalizeRecord(item, options));
-};
+}
+function normalizeRecords(items, options = defaultNormalizeRecordOptions) {
+	const normalized = [];
+	for (const item of items) {
+		const record = parseObject(item);
+		if (record) normalized.push(normalizeRecord(record, options));
+	}
+	return normalized;
+}
+
+//#endregion
+//#region src/attio/schemas.ts
+const rawRecordSchema = z.record(z.string(), z.unknown());
 
 //#endregion
 //#region src/attio/records.ts
 const createRecord = async (input) => {
-	return normalizeRecord(unwrapData(await postV2ObjectsByObjectRecords({
+	return normalizeRecord(assertOk(await postV2ObjectsByObjectRecords({
 		client: resolveAttioClient(input),
 		path: { object: input.object },
 		body: { data: { values: input.values } },
 		...input.options
-	})));
+	}), { schema: rawRecordSchema }));
 };
 const updateRecord = async (input) => {
-	return normalizeRecord(unwrapData(await patchV2ObjectsByObjectRecordsByRecordId({
+	return normalizeRecord(assertOk(await patchV2ObjectsByObjectRecordsByRecordId({
 		client: resolveAttioClient(input),
 		path: {
 			object: input.object,
@@ -18623,28 +19244,26 @@ const updateRecord = async (input) => {
 		},
 		body: { data: { values: input.values } },
 		...input.options
-	})));
+	}), { schema: rawRecordSchema }));
 };
 const upsertRecord = async (input) => {
-	return normalizeRecord(unwrapData(await putV2ObjectsByObjectRecords({
+	return normalizeRecord(assertOk(await putV2ObjectsByObjectRecords({
 		client: resolveAttioClient(input),
 		path: { object: input.object },
-		body: {
-			data: { values: input.values },
-			matching_attribute: input.matchingAttribute
-		},
+		body: { data: { values: input.values } },
+		query: { matching_attribute: input.matchingAttribute },
 		...input.options
-	})));
+	}), { schema: rawRecordSchema }));
 };
 const getRecord = async (input) => {
-	return normalizeRecord(unwrapData(await getV2ObjectsByObjectRecordsByRecordId({
+	return normalizeRecord(assertOk(await getV2ObjectsByObjectRecordsByRecordId({
 		client: resolveAttioClient(input),
 		path: {
 			object: input.object,
 			record_id: input.recordId
 		},
 		...input.options
-	})));
+	}), { schema: rawRecordSchema }));
 };
 const deleteRecord = async (input) => {
 	await deleteV2ObjectsByObjectRecordsByRecordId({
@@ -18669,7 +19288,203 @@ const queryRecords = async (input) => {
 			offset: input.offset
 		},
 		...input.options
-	})));
+	}), { schema: rawRecordSchema }));
+};
+
+//#endregion
+//#region src/attio/values.ts
+const nonEmptyStringSchema = z.string().min(1, "Expected a non-empty string.");
+const emailSchema = z.string().email("Expected a valid email address.");
+const currencyCodeSchema = z.string().regex(/^[A-Z]{3}$/, "Expected ISO 4217 currency code.");
+const finiteNumberSchema = z.number().finite("Expected a finite number.");
+const wrapSingle = (input) => [input];
+const value = {
+	string: (input) => wrapSingle({ value: nonEmptyStringSchema.parse(input) }),
+	number: (input) => wrapSingle({ value: finiteNumberSchema.parse(input) }),
+	boolean: (input) => wrapSingle({ value: z.boolean().parse(input) }),
+	domain: (input) => wrapSingle({ domain: nonEmptyStringSchema.parse(input) }),
+	email: (input) => wrapSingle({ email_address: emailSchema.parse(input) }),
+	currency: (input, currencyCode) => {
+		const currency_value = finiteNumberSchema.parse(input);
+		if (currencyCode === void 0) return wrapSingle({ currency_value });
+		return wrapSingle({
+			currency_value,
+			currency_code: currencyCodeSchema.parse(currencyCode)
+		});
+	}
+};
+const recordValuesSchema = z.object({ values: z.record(z.string(), z.array(z.unknown())).optional() }).passthrough();
+const extractValues = (record) => {
+	const parsed = recordValuesSchema.safeParse(record);
+	if (!parsed.success) return;
+	return parsed.data.values;
+};
+const parseValuesOrThrow = (raw, schema, attribute) => {
+	const parsed = [];
+	for (const entry of raw) {
+		const result = schema.safeParse(entry);
+		if (!result.success) throw new AttioResponseError(`Invalid API response: attribute "${attribute}" value mismatch`, {
+			code: "INVALID_VALUE",
+			data: result.error
+		});
+		parsed.push(result.data);
+	}
+	return parsed;
+};
+function getValue(record, attribute, options) {
+	const raw = extractValues(record)?.[attribute];
+	if (!raw) return;
+	if (!options?.schema) return raw;
+	return parseValuesOrThrow(raw, options.schema, attribute);
+}
+function getFirstValue(record, attribute, options) {
+	const values = getValue(record, attribute, options);
+	return values ? values[0] : void 0;
+}
+
+//#endregion
+//#region src/attio/schema.ts
+const createAccessor = (attribute) => ({
+	attribute,
+	getValue: (record) => getValue(record, attribute.api_slug),
+	getFirstValue: (record) => getFirstValue(record, attribute.api_slug),
+	getValueAs: (record, options) => getValue(record, attribute.api_slug, options),
+	getFirstValueAs: (record, options) => getFirstValue(record, attribute.api_slug, options)
+});
+const createSchema = async (input) => {
+	const attributes = await listAttributes({
+		...input,
+		options: input.options
+	});
+	const attributeMap = /* @__PURE__ */ new Map();
+	const attributeSlugs = [];
+	for (const attribute of attributes) {
+		attributeMap.set(attribute.api_slug, attribute);
+		attributeSlugs.push(attribute.api_slug);
+	}
+	const getAttribute = (slug) => attributeMap.get(slug);
+	const getAttributeOrThrow = (slug) => {
+		const attribute = getAttribute(slug);
+		if (!attribute) throw new AttioResponseError(`Unknown attribute slug "${slug}" for ${input.target}:${input.identifier}`, { code: "UNKNOWN_ATTRIBUTE" });
+		return attribute;
+	};
+	const getAccessor = (slug) => {
+		const attribute = getAttribute(slug);
+		if (!attribute) return;
+		return createAccessor(attribute);
+	};
+	const getAccessorOrThrow = (slug) => createAccessor(getAttributeOrThrow(slug));
+	return {
+		target: input.target,
+		identifier: input.identifier,
+		attributes,
+		attributeSlugs,
+		getAttribute,
+		getAttributeOrThrow,
+		getAccessor,
+		getAccessorOrThrow
+	};
+};
+
+//#endregion
+//#region src/attio/sdk.ts
+const createAttioSdk = (input = {}) => {
+	const client = resolveAttioClient(input);
+	return {
+		client,
+		objects: {
+			list: (params = {}) => listObjects({
+				...params,
+				client
+			}),
+			get: (params) => getObject({
+				...params,
+				client
+			}),
+			create: (params) => createObject({
+				...params,
+				client
+			}),
+			update: (params) => updateObject({
+				...params,
+				client
+			})
+		},
+		records: {
+			create: (params) => createRecord({
+				...params,
+				client
+			}),
+			update: (params) => updateRecord({
+				...params,
+				client
+			}),
+			upsert: (params) => upsertRecord({
+				...params,
+				client
+			}),
+			get: (params) => getRecord({
+				...params,
+				client
+			}),
+			delete: (params) => deleteRecord({
+				...params,
+				client
+			}),
+			query: (params) => queryRecords({
+				...params,
+				client
+			})
+		},
+		lists: {
+			list: (params = {}) => listLists({
+				...params,
+				client
+			}),
+			get: (params) => getList({
+				...params,
+				client
+			}),
+			queryEntries: (params) => queryListEntries({
+				...params,
+				client
+			}),
+			addEntry: (params) => addListEntry({
+				...params,
+				client
+			}),
+			updateEntry: (params) => updateListEntry({
+				...params,
+				client
+			}),
+			removeEntry: (params) => removeListEntry({
+				...params,
+				client
+			})
+		},
+		metadata: {
+			listAttributes: (params) => listAttributes({
+				...params,
+				client
+			}),
+			getAttribute: (params) => getAttribute({
+				...params,
+				client
+			}),
+			getAttributeOptions: (params) => getAttributeOptions({
+				...params,
+				client
+			}),
+			getAttributeStatuses: (params) => getAttributeStatuses({
+				...params,
+				client
+			}),
+			schema: (params) => createSchema({
+				...params,
+				client
+			})
+		}
+	};
 };
 
 //#endregion
@@ -18684,26 +19499,27 @@ const searchRecords = async (input) => {
 			limit: input.limit
 		},
 		...input.options
-	})));
+	}), { schema: rawRecordSchema }));
 };
 
 //#endregion
 //#region src/attio/tasks.ts
 const listTasks = async (input = {}) => {
-	return unwrapItems(await getV2Tasks({ client: resolveAttioClient(input) }));
+	return unwrapItems(await getV2Tasks({ client: resolveAttioClient(input) }), { schema: zTask });
 };
 const getTask = async (input) => {
 	return unwrapData(await getV2TasksByTaskId({
 		client: resolveAttioClient(input),
-		path: { task_id: input.taskId }
-	}));
+		path: { task_id: input.taskId },
+		...input.options
+	}), { schema: zTask });
 };
 const createTask = async (input) => {
 	return unwrapData(await postV2Tasks({
 		client: resolveAttioClient(input),
 		body: { data: input.data },
 		...input.options
-	}));
+	}), { schema: zTask });
 };
 const updateTask = async (input) => {
 	return unwrapData(await patchV2TasksByTaskId({
@@ -18711,14 +19527,14 @@ const updateTask = async (input) => {
 		path: { task_id: input.taskId },
 		body: { data: input.data },
 		...input.options
-	}));
+	}), { schema: zTask });
 };
 const deleteTask = async (input) => {
-	await deleteV2TasksByTaskId({
+	return (await deleteV2TasksByTaskId({
 		client: resolveAttioClient(input),
-		path: { task_id: input.taskId }
-	});
-	return true;
+		path: { task_id: input.taskId },
+		...input.options
+	})).data ?? {};
 };
 
 //#endregion
@@ -18734,5 +19550,5 @@ const getWorkspaceMember = async (input) => {
 };
 
 //#endregion
-export { AttioApiError, AttioError, AttioNetworkError, DEFAULT_BASE_URL, DEFAULT_RETRY_CONFIG, TtlCache, addListEntry, calculateRetryDelay, callWithRetry, clearClientCache, createAttioClient, createNote, createRecord, createTask, createTtlCache, deleteNote, deleteRecord, deleteTask, deleteV2CommentsByCommentId, deleteV2ListsByListEntriesByEntryId, deleteV2MeetingsByMeetingIdCallRecordingsByCallRecordingId, deleteV2NotesByNoteId, deleteV2ObjectsByObjectRecordsByRecordId, deleteV2TasksByTaskId, deleteV2WebhooksByWebhookId, enhanceAttioError, extractRecordId, filters, getAttioClient, getAttribute, getAttributeOptions, getAttributeStatuses, getCachedClient, getEnvValue, getKnownFieldValues, getList, getNote, getRecord, getTask, getV2ByTargetByIdentifierAttributes, getV2ByTargetByIdentifierAttributesByAttribute, getV2ByTargetByIdentifierAttributesByAttributeOptions, getV2ByTargetByIdentifierAttributesByAttributeStatuses, getV2CommentsByCommentId, getV2Lists, getV2ListsByList, getV2ListsByListEntriesByEntryId, getV2ListsByListEntriesByEntryIdAttributesByAttributeValues, getV2Meetings, getV2MeetingsByMeetingId, getV2MeetingsByMeetingIdCallRecordings, getV2MeetingsByMeetingIdCallRecordingsByCallRecordingId, getV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdTranscript, getV2Notes, getV2NotesByNoteId, getV2Objects, getV2ObjectsByObject, getV2ObjectsByObjectRecordsByRecordId, getV2ObjectsByObjectRecordsByRecordIdAttributesByAttributeValues, getV2ObjectsByObjectRecordsByRecordIdEntries, getV2Self, getV2Tasks, getV2TasksByTaskId, getV2Threads, getV2ThreadsByThreadId, getV2Webhooks, getV2WebhooksByWebhookId, getV2WorkspaceMembers, getV2WorkspaceMembersByWorkspaceMemberId, getWorkspaceMember, hashToken, isRetryableError, isRetryableStatus, listAttributes, listLists, listNotes, listTasks, listWorkspaceMembers, normalizeAttioError, normalizeBaseUrl, normalizeRecord, normalizeRecords, paginate, patchV2ByTargetByIdentifierAttributesByAttribute, patchV2ByTargetByIdentifierAttributesByAttributeOptionsByOption, patchV2ByTargetByIdentifierAttributesByAttributeStatusesByStatus, patchV2ListsByList, patchV2ListsByListEntriesByEntryId, patchV2ObjectsByObject, patchV2ObjectsByObjectRecordsByRecordId, patchV2TasksByTaskId, patchV2WebhooksByWebhookId, postV2ByTargetByIdentifierAttributes, postV2ByTargetByIdentifierAttributesByAttributeOptions, postV2ByTargetByIdentifierAttributesByAttributeStatuses, postV2Comments, postV2Lists, postV2ListsByListEntries, postV2ListsByListEntriesQuery, postV2Meetings, postV2MeetingsByMeetingIdCallRecordings, postV2Notes, postV2Objects, postV2ObjectsByObjectRecords, postV2ObjectsByObjectRecordsQuery, postV2ObjectsRecordsSearch, postV2Tasks, postV2Webhooks, putV2ListsByListEntries, putV2ListsByListEntriesByEntryId, putV2ObjectsByObjectRecords, putV2ObjectsByObjectRecordsByRecordId, queryListEntries, queryRecords, removeListEntry, resolveAttioClient, resolveAuthToken, resolveBaseUrl, resolveResponseStyle, resolveThrowOnError, runBatch, searchRecords, setCachedClient, sleep, toPageResult, unwrapData, unwrapItems, unwrapPaginationCursor, updateKnownFieldValues, updateListEntry, updateRecord, updateTask, upsertRecord, validateAuthToken };
+export { AttioApiError, AttioBatchError, AttioConfigError, AttioEnvironmentError, AttioError, AttioNetworkError, AttioResponseError, AttioRetryError, DEFAULT_BASE_URL, DEFAULT_METADATA_CACHE_MAX_ENTRIES, DEFAULT_METADATA_CACHE_TTL_MS, DEFAULT_RETRY_CONFIG, TtlCache, addListEntry, assertOk, buildAttributeMetadataPath, buildKey, calculateRetryDelay, callWithRetry, clearClientCache, clearMetadataCacheRegistry, createAttioCacheManager, createAttioClient, createAttioSdk, createNote, createObject, createOffsetPageResultSchema, createPageResultSchema, createRecord, createSchema, createSchemaError, createTask, createTtlCache, createTtlCacheAdapter, deleteNote, deleteRecord, deleteTask, deleteV2CommentsByCommentId, deleteV2ListsByListEntriesByEntryId, deleteV2MeetingsByMeetingIdCallRecordingsByCallRecordingId, deleteV2NotesByNoteId, deleteV2ObjectsByObjectRecordsByRecordId, deleteV2TasksByTaskId, deleteV2WebhooksByWebhookId, enhanceAttioError, extractRecordId, extractTitles, filters, getAttioClient, getAttribute, getAttributeOptions, getAttributeStatuses, getCachedClient, getEnvValue, getFirstValue, getKnownFieldValues, getList, getNote, getObject, getRecord, getTask, getV2ByTargetByIdentifierAttributes, getV2ByTargetByIdentifierAttributesByAttribute, getV2ByTargetByIdentifierAttributesByAttributeOptions, getV2ByTargetByIdentifierAttributesByAttributeStatuses, getV2CommentsByCommentId, getV2Lists, getV2ListsByList, getV2ListsByListEntriesByEntryId, getV2ListsByListEntriesByEntryIdAttributesByAttributeValues, getV2Meetings, getV2MeetingsByMeetingId, getV2MeetingsByMeetingIdCallRecordings, getV2MeetingsByMeetingIdCallRecordingsByCallRecordingId, getV2MeetingsByMeetingIdCallRecordingsByCallRecordingIdTranscript, getV2Notes, getV2NotesByNoteId, getV2Objects, getV2ObjectsByObject, getV2ObjectsByObjectRecordsByRecordId, getV2ObjectsByObjectRecordsByRecordIdAttributesByAttributeValues, getV2ObjectsByObjectRecordsByRecordIdEntries, getV2Self, getV2Tasks, getV2TasksByTaskId, getV2Threads, getV2ThreadsByThreadId, getV2Webhooks, getV2WebhooksByWebhookId, getV2WorkspaceMembers, getV2WorkspaceMembersByWorkspaceMemberId, getValue, getWorkspaceMember, hashToken, isRetryableError, isRetryableStatus, listAttributeMetadata, listAttributes, listLists, listNotes, listObjects, listTasks, listWorkspaceMembers, normalizeAttioError, normalizeBaseUrl, normalizeRecord, normalizeRecords, paginate, paginateOffset, parseOffsetPageResult, parsePageResult, patchV2ByTargetByIdentifierAttributesByAttribute, patchV2ByTargetByIdentifierAttributesByAttributeOptionsByOption, patchV2ByTargetByIdentifierAttributesByAttributeStatusesByStatus, patchV2ListsByList, patchV2ListsByListEntriesByEntryId, patchV2ObjectsByObject, patchV2ObjectsByObjectRecordsByRecordId, patchV2TasksByTaskId, patchV2WebhooksByWebhookId, postV2ByTargetByIdentifierAttributes, postV2ByTargetByIdentifierAttributesByAttributeOptions, postV2ByTargetByIdentifierAttributesByAttributeStatuses, postV2Comments, postV2Lists, postV2ListsByListEntries, postV2ListsByListEntriesQuery, postV2Meetings, postV2MeetingsByMeetingIdCallRecordings, postV2Notes, postV2Objects, postV2ObjectsByObjectRecords, postV2ObjectsByObjectRecordsQuery, postV2ObjectsRecordsSearch, postV2Tasks, postV2Webhooks, putV2ListsByListEntries, putV2ListsByListEntriesByEntryId, putV2ObjectsByObjectRecords, putV2ObjectsByObjectRecordsByRecordId, queryListEntries, queryRecords, removeListEntry, resolveAttioClient, resolveAuthToken, resolveBaseUrl, resolveResponseStyle, resolveThrowOnError, runBatch, searchRecords, setCachedClient, sleep, toOffsetPageResult, toPageResult, toResult, unwrapData, unwrapItems, unwrapPaginationCursor, unwrapPaginationOffset, updateKnownFieldValues, updateListEntry, updateObject, updateRecord, updateTask, upsertRecord, value };
 //# sourceMappingURL=index.mjs.map