attio-ts-sdk 1.0.0 → 1.1.0

package/dist/index.mjs

@@ -97,6 +97,12 @@ const runBatch = (items, options = {}) => {
 
 //#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;
@@ -131,6 +137,18 @@ var TtlCache = class {
 		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);
@@ -149,12 +167,88 @@ const setCachedClient = (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
@@ -766,6 +860,22 @@ const createClient = (config = {}) => {
 	};
 };
 
+//#endregion
+//#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/attio/error-enhancer.ts
 const knownFieldValues = /* @__PURE__ */ new Map();
@@ -961,31 +1071,6 @@ const normalizeAttioError = (error, context = {}) => {
 	return networkError;
 };
 
-//#endregion
-//#region src/attio/config.ts
-const TRAILING_SLASHES_REGEX = /\/+$/;
-const WHITESPACE_REGEX = /\s/;
-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 MISSING_API_KEY_ERROR = "Missing Attio API key. Set ATTIO_API_KEY or pass apiKey.";
-const AuthTokenSchema = z.string().min(1, MISSING_API_KEY_ERROR).min(10, "Invalid Attio API key: too short.").refine((t) => !WHITESPACE_REGEX.test(t), "Invalid Attio API key: contains whitespace.");
-const validateAuthToken = (token) => {
-	if (token === void 0 || token.length === 0) throw new AttioConfigError(MISSING_API_KEY_ERROR, { code: "MISSING_API_KEY" });
-	const result = AuthTokenSchema.safeParse(token);
-	if (!result.success) throw new AttioConfigError(result.error.issues[0].message, { code: "INVALID_API_KEY" });
-	return result.data;
-};
-const resolveResponseStyle = (config) => config?.responseStyle ?? "fields";
-const resolveThrowOnError = (config) => config?.throwOnError ?? true;
-
 //#endregion
 //#region src/attio/retry.ts
 const DEFAULT_RETRY_CONFIG = {
@@ -1034,7 +1119,7 @@ const isRetryableError = (error, config) => {
 	return isRetryableStatus(info?.status, config);
 };
 const getRetryAfterMs = (error) => extractRetryErrorInfo(error)?.retryAfterMs;
-const callWithRetry = async (fn, config) => {
+async function callWithRetry(fn, config) {
 	const retryConfig = {
 		...DEFAULT_RETRY_CONFIG,
 		...config
@@ -1052,13 +1137,20 @@ const callWithRetry = async (fn, config) => {
 		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,
@@ -1066,16 +1158,16 @@ const attioClientShapeSchema = z.object({
 	}).passthrough()
 }).passthrough();
 const AttioClientSchema = z.any().refine((value) => attioClientShapeSchema.safeParse(value).success, { message: "Invalid cached Attio client." });
-const combineSignalsWithAny = (initSignal, controllerSignal) => AbortSignal.any([initSignal, controllerSignal]);
-const combineSignalsWithFallback = (initSignal, controllerSignal) => {
+const combineSignalsWithAny = ({ requestSignal, timeoutSignal }) => AbortSignal.any([requestSignal, timeoutSignal]);
+const combineSignalsWithFallback = ({ requestSignal, timeoutSignal }) => {
 	const combinedController = new AbortController();
-	if (initSignal.aborted) {
+	if (requestSignal.aborted) {
 		combinedController.abort();
 		return { combinedSignal: combinedController.signal };
 	}
 	const abortCombined = () => combinedController.abort();
-	initSignal.addEventListener("abort", abortCombined, { once: true });
-	controllerSignal.addEventListener("abort", abortCombined, { once: true });
+	requestSignal.addEventListener("abort", abortCombined, { once: true });
+	timeoutSignal.addEventListener("abort", abortCombined, { once: true });
 	return {
 		combinedSignal: combinedController.signal,
 		abortCombined
@@ -1090,8 +1182,14 @@ const resolveFetch = (config) => {
 		const timeoutId = setTimeout(() => controller.abort(), config.timeoutMs);
 		let combinedSignal = controller.signal;
 		let abortCombined;
-		if (init?.signal) if (typeof AbortSignal !== "undefined" && "any" in AbortSignal) combinedSignal = combineSignalsWithAny(init.signal, controller.signal);
-		else ({combinedSignal, abortCombined} = combineSignalsWithFallback(init.signal, controller.signal));
+		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,
@@ -1109,12 +1207,77 @@ const resolveFetch = (config) => {
 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 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) => {
@@ -1155,6 +1318,7 @@ 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({
@@ -1169,22 +1333,28 @@ const createAttioClientWithAuthToken = ({ config = {}, authToken }) => {
 		responseStyle,
 		throwOnError
 	});
-	applyInterceptors(base);
-	return wrapClient(base, retry);
+	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: validateAuthToken(resolveAuthToken(config))
+		authToken: resolveAuthToken(config)
 	});
 };
 const getAttioClient = (config = {}) => {
 	const cacheEnabled = config.cache?.enabled ?? true;
-	const authToken = validateAuthToken(resolveAuthToken(config));
-	const cacheKey = buildClientCacheKey({
+	const authToken = resolveAuthToken(config);
+	const cacheKey = authToken ? buildClientCacheKey({
 		config,
 		authToken
-	});
+	}) : void 0;
 	if (cacheEnabled && cacheKey) {
 		const cached = getCachedClient(cacheKey, AttioClientSchema);
 		if (cached) return cached;
@@ -18460,35 +18630,136 @@ const getV2Self = (options) => (options?.client ?? client).get({
 
 //#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
@@ -18498,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) => {
@@ -18518,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 ?? {}
 		} },
@@ -18550,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,
@@ -18579,33 +18840,51 @@ const buildAttributeMetadataPath = (input) => ({
 	identifier: input.identifier,
 	attribute: input.attribute
 });
-const listAttributeMetadata = async ({ input, cache, fetcher }) => {
+const listAttributeMetadata = async ({ input, cache, fetcher, itemSchema }) => {
 	const cacheKey = buildKey(input.target, input.identifier, input.attribute);
-	const cached = cache.get(cacheKey);
-	if (cached) return cached;
+	const arraySchema = z.array(itemSchema);
+	if (cache) {
+		const cached = cache.get(cacheKey);
+		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: resolveAttioClient(input),
+		client,
 		path: buildAttributeMetadataPath(input),
-		...input.options
-	}));
+		...options
+	}), { schema: itemSchema });
 	const titles = extractTitles(items);
 	updateKnownFieldValues(input.attribute, titles);
-	cache.set(cacheKey, items);
+	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) => {
@@ -18617,18 +18896,32 @@ const getAttribute = async (input) => {
 			attribute: input.attribute
 		},
 		...input.options
-	}));
+	}), { schema: zAttribute });
+};
+const getAttributeOptions = (input) => {
+	const client = resolveAttioClient(input);
+	return listAttributeMetadata({
+		input: {
+			...input,
+			client
+		},
+		cache: getMetadataCache(client, "options"),
+		fetcher: getV2ByTargetByIdentifierAttributesByAttributeOptions,
+		itemSchema: zSelectOption
+	});
+};
+const getAttributeStatuses = (input) => {
+	const client = resolveAttioClient(input);
+	return listAttributeMetadata({
+		input: {
+			...input,
+			client
+		},
+		cache: getMetadataCache(client, "statuses"),
+		fetcher: getV2ByTargetByIdentifierAttributesByAttributeStatuses,
+		itemSchema: zStatus
+	});
 };
-const getAttributeOptions = async (input) => listAttributeMetadata({
-	input,
-	cache: optionsCache,
-	fetcher: getV2ByTargetByIdentifierAttributesByAttributeOptions
-});
-const getAttributeStatuses = async (input) => listAttributeMetadata({
-	input,
-	cache: statusesCache,
-	fetcher: getV2ByTargetByIdentifierAttributesByAttributeStatuses
-});
 
 //#endregion
 //#region src/attio/notes.ts
@@ -18638,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) => {
@@ -18648,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
 	}));
@@ -18656,11 +18953,62 @@ 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({
@@ -18671,17 +19019,38 @@ 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;
@@ -18698,6 +19067,36 @@ 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
@@ -18748,7 +19147,7 @@ const extractIdFromUnknown = (value) => {
 	if (!record) return;
 	return extractIdFromRecord(record);
 };
-const extractValues = (obj) => {
+const extractValues$1 = (obj) => {
 	const record = parseObject(obj);
 	if (!record) return;
 	return extractValuesObject(record);
@@ -18784,7 +19183,7 @@ const hasValidRecordId = (raw) => {
 const extractNestedValues = (result) => {
 	const candidates = collectNestedCandidates(result);
 	for (const candidate of candidates) {
-		const values = extractValues(candidate);
+		const values = extractValues$1(candidate);
 		if (values) return values;
 	}
 };
@@ -18822,18 +19221,22 @@ function normalizeRecords(items, options = defaultNormalizeRecordOptions) {
 	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,
@@ -18841,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({
@@ -18887,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
@@ -18902,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({
@@ -18929,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
@@ -18952,5 +19550,5 @@ const getWorkspaceMember = async (input) => {
 };
 
 //#endregion
-export { AttioApiError, AttioBatchError, AttioConfigError, AttioEnvironmentError, AttioError, AttioNetworkError, AttioResponseError, AttioRetryError, DEFAULT_BASE_URL, DEFAULT_RETRY_CONFIG, TtlCache, addListEntry, buildAttributeMetadataPath, buildKey, calculateRetryDelay, callWithRetry, clearClientCache, createAttioClient, createNote, createPageResultSchema, createRecord, createTask, createTtlCache, deleteNote, deleteRecord, deleteTask, deleteV2CommentsByCommentId, deleteV2ListsByListEntriesByEntryId, deleteV2MeetingsByMeetingIdCallRecordingsByCallRecordingId, deleteV2NotesByNoteId, deleteV2ObjectsByObjectRecordsByRecordId, deleteV2TasksByTaskId, deleteV2WebhooksByWebhookId, enhanceAttioError, extractRecordId, extractTitles, 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, listAttributeMetadata, listAttributes, listLists, listNotes, listTasks, listWorkspaceMembers, normalizeAttioError, normalizeBaseUrl, normalizeRecord, normalizeRecords, paginate, 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, 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