@keystrokehq/typeform 0.0.1

package/README.md

@@ -0,0 +1,159 @@
+# @keystrokehq/typeform
+
+Official Keystroke integration for [Typeform](https://www.typeform.com/).
+
+Ship code-first automations over Typeform forms, responses, themes, images, workspaces, webhooks, and account metadata, plus a direct-binding webhook trigger that fires when a respondent submits a form.
+
+## Install
+
+```bash
+pnpm add @keystrokehq/typeform
+```
+
+## Connect
+
+Typeform supports two authentication modes. Both are handled by the same public connection credential set — a user connecting an account through Keystroke's OAuth flow and a server-to-server install using a Personal Access Token (PAT) share the same runtime contract.
+
+### OAuth (recommended — "click to connect")
+
+```bash
+keystroke connect typeform
+```
+
+This triggers the standard Keystroke OAuth 2.0 flow against `https://api.typeform.com/oauth/authorize`, requests the full read/write scopes plus `offline` (for refresh tokens), and stores the resulting token under the `TYPEFORM_ACCESS_TOKEN` vault key.
+
+### Personal Access Token (server-to-server)
+
+Generate a PAT in your Typeform **Personal Tokens** settings and populate the vault entry directly:
+
+```bash
+export TYPEFORM_ACCESS_TOKEN=tfp_xxxxxxxx…
+```
+
+Typeform treats OAuth access tokens and PATs identically at the wire level (`Authorization: Bearer <token>`), so all operations and triggers in this package work against either.
+
+## Public surface
+
+Authored workflow code should import **only** these subpaths:
+
+| Subpath | What it exports |
+|---|---|
+| `@keystrokehq/typeform/connection` | `typeform` credential set + `TypeformCredentials` type |
+| `@keystrokehq/typeform/client` | `createTypeformClient`, `TypeformApiError`, `createLeakyBucketRateLimiter` |
+| `@keystrokehq/typeform/schemas` | Reusable Zod schemas (`typeformFormSchema`, `typeformResponseSchema`, …) |
+| `@keystrokehq/typeform/events` | Curated trigger event schemas + types |
+| `@keystrokehq/typeform/verification` | `verifyTypeformWebhookRequest`, `buildTypeformWebhookSignature` |
+| `@keystrokehq/typeform/triggers` | `webhooks.formResponseSubmitted(...)` direct binding |
+| `@keystrokehq/typeform/accounts` | `getAboutMe` |
+| `@keystrokehq/typeform/forms` | `listForms`, `getForm`, `createForm`, `updateForm`, `patchForm`, `deleteForm` |
+| `@keystrokehq/typeform/responses` | `getFormResponses`, `deleteResponses`, `getAllResponseFiles` |
+| `@keystrokehq/typeform/themes` | `listThemes`, `getTheme`, `createTheme`, `updateTheme`, `patchTheme`, `deleteTheme` |
+| `@keystrokehq/typeform/images` | `listImages`, `createImage`, `getImageBySize`, `getBackgroundBySize`, `getChoiceImageBySize`, `deleteImage` |
+| `@keystrokehq/typeform/videos` | `uploadVideo` |
+| `@keystrokehq/typeform/workspaces` | `listWorkspaces`, `getWorkspace`, `createWorkspace`, `createAccountWorkspace`, `updateWorkspace`, `deleteWorkspace` |
+| `@keystrokehq/typeform/webhooks` | `listWebhooks`, `getWebhook`, `createOrUpdateWebhook`, `deleteWebhook` |
+| `@keystrokehq/typeform/insights` | `getFormMessages`, `updateFormMessages` |
+
+Hidden, repo-only subpaths (`_official`, `_runtime`) are for platform internals — **do not import these from authored code**.
+
+## Quickstart
+
+### Call a Typeform operation inside a workflow
+
+```ts
+import { Workflow } from '@keystrokehq/core';
+import { listForms } from '@keystrokehq/typeform/forms';
+import { z } from 'zod';
+
+export const triageNewForms = new Workflow({
+  id: 'triage_new_forms',
+  name: 'Triage new Typeform forms',
+  input: z.object({}),
+  output: z.object({ count: z.number() }),
+  async run() {
+    const { items } = await listForms.run({ pageSize: 20 });
+    return { count: items.length };
+  },
+});
+```
+
+### React to form submissions (direct-binding webhook trigger)
+
+```ts
+import { Workflow } from '@keystrokehq/core';
+import { webhooks } from '@keystrokehq/typeform/triggers';
+import { z } from 'zod';
+
+export const captureLead = new Workflow({
+  id: 'capture_typeform_lead',
+  name: 'Capture Lead',
+  triggers: [
+    webhooks.formResponseSubmitted({
+      filter: (event) => event.formId === 'LEADS2026',
+      transform: (event) => ({
+        formId: event.formId,
+        token: event.token,
+        email: event.answers?.find((a) => a.field.type === 'email')?.email,
+      }),
+    }),
+  ],
+  input: z.object({ formId: z.string(), token: z.string(), email: z.string().optional() }),
+  output: z.object({ ok: z.boolean() }),
+  async run() {
+    return { ok: true };
+  },
+});
+```
+
+## Support surfaces
+
+### Using the raw Typeform client
+
+Most workflows should call operations directly. When you need more control (e.g. custom pagination), drop to the client:
+
+```ts
+import { createTypeformClient } from '@keystrokehq/typeform/client';
+import type { TypeformCredentials } from '@keystrokehq/typeform/connection';
+
+export async function listAllForms(credentials: TypeformCredentials) {
+  const client = createTypeformClient(credentials);
+  return client.forms.list({ page_size: 200 });
+}
+```
+
+### Signature verification
+
+Use `verifyTypeformWebhookRequest` when you accept Typeform webhooks on a custom route (the built-in trigger already verifies for you):
+
+```ts
+import { verifyTypeformWebhookRequest } from '@keystrokehq/typeform/verification';
+
+const ok = verifyTypeformWebhookRequest(
+  { headers: request.headers, rawBody: request.rawBody },
+  webhookSigningSecret
+);
+```
+
+### Provisioning a webhook
+
+`createOrUpdateWebhook` wires the integration's shared signing secret onto a new or updated webhook subscription (unsigned webhooks are rejected at the schema boundary):
+
+```ts
+import { createOrUpdateWebhook } from '@keystrokehq/typeform/webhooks';
+
+await createOrUpdateWebhook.run({
+  formId: 'LEADS2026',
+  tag: 'keystroke-capture-lead',
+  url: 'https://webhooks.keystroke.dev/typeform',
+  secret: process.env.TYPEFORM_WEBHOOK_SECRET!,
+});
+```
+
+## Caveats
+
+- **Single native webhook event.** Typeform only emits `form_response` when a respondent completes a submission. There are no partial-response or form-mutation webhooks; use polling (`getFormResponses` with a cursor) if you need finer granularity.
+- **Signed file URLs expire quickly.** `getAllResponseFiles` returns the signed URL path; fetch the content immediately and, if you need durable storage, re-host it yourself.
+- **PAT vs OAuth parity.** OAuth access tokens refresh automatically through the Keystroke vault. PATs do not; rotate them on the Typeform side and update the vault entry.
+- **Rate limits.** Typeform publishes a baseline of 2 requests/second per token. The client enforces a leaky-bucket limiter by default and retries `429` with `Retry-After`.
+- **Irreversible response deletion.** `deleteResponses` requires an explicit `confirm: true` flag in input to prevent accidental data loss.
+- **Webhook signing is mandatory.** `createOrUpdateWebhook` refuses to provision an unsigned webhook; the trigger likewise fails closed when the internal app credential set has no `webhookSecret`.

package/dist/_official/index.d.mts

@@ -0,0 +1,3 @@
+import { i as typeformOfficialIntegration, r as typeformBundle } from "../integration-d_VqlGvZ.mjs";
+import { n as typeformAppCredentialSet, r as typeformPlatformProviderSeed, t as TypeformAppCredentials } from "../provider-app-BnLMYj3B.mjs";
+export { TypeformAppCredentials, typeformAppCredentialSet, typeformBundle, typeformOfficialIntegration, typeformPlatformProviderSeed };

package/dist/_official/index.mjs

@@ -0,0 +1,3 @@
+import { a as typeformPlatformProviderSeed, i as typeformAppCredentialSet, n as typeformBundle, r as typeformOfficialIntegration } from "../integration-BCzgn7Dm.mjs";
+
+export { typeformAppCredentialSet, typeformBundle, typeformOfficialIntegration, typeformPlatformProviderSeed };

package/dist/_runtime/index.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/_runtime/index.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/accounts.d.mts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/accounts.d.ts
+declare const getAboutMe: _keystrokehq_core0.Operation<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+  alias: z.ZodOptional<z.ZodString>;
+  email: z.ZodOptional<z.ZodString>;
+  language: z.ZodOptional<z.ZodString>;
+  user_id: z.ZodOptional<z.ZodString>;
+}, z.core.$catchall<z.ZodUnknown>>, readonly [_keystrokehq_core0.CredentialSet<"typeform", z.ZodObject<{
+  TYPEFORM_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  TYPEFORM_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+//#endregion
+export { getAboutMe };

package/dist/accounts.mjs

@@ -0,0 +1,20 @@
+import { createTypeformClient } from "./client.mjs";
+import { w as typeformAccountSchema } from "./workspace-C1CCnvgv.mjs";
+import { t as typeformOperation } from "./factory-B_dyn39A.mjs";
+import { z } from "zod";
+
+//#region src/accounts.ts
+const getAboutMe = typeformOperation({
+	id: "get_about_me",
+	name: "Get About Me",
+	description: "Retrieve basic information about the connected Typeform account.",
+	input: z.object({}),
+	output: typeformAccountSchema,
+	run: async (_input, credentials) => {
+		const response = await createTypeformClient(credentials).accounts.getAboutMe();
+		return typeformAccountSchema.parse(response);
+	}
+});
+
+//#endregion
+export { getAboutMe };

package/dist/client.d.mts

@@ -0,0 +1,104 @@
+import { t as TypeformCredentials } from "./integration-d_VqlGvZ.mjs";
+
+//#region src/client.d.ts
+type Primitive = string | number | boolean;
+type QueryValue = Primitive | readonly Primitive[] | undefined;
+type TypeformApiErrorKind = 'auth' | 'http' | 'rate_limit' | 'validation';
+interface TypeformApiErrorOptions {
+  readonly kind: TypeformApiErrorKind;
+  readonly status: number;
+  readonly body: unknown;
+  readonly requestId?: string;
+  readonly providerCode?: string;
+  readonly retryAfterSeconds?: number;
+  readonly retryable: boolean;
+}
+declare class TypeformApiError extends Error {
+  readonly kind: TypeformApiErrorKind;
+  readonly status: number;
+  readonly body: unknown;
+  readonly requestId: string | undefined;
+  readonly providerCode: string | undefined;
+  readonly retryAfterSeconds: number | undefined;
+  readonly retryable: boolean;
+  constructor(message: string, options: TypeformApiErrorOptions);
+}
+interface TypeformRateLimiter {
+  readonly acquire: () => Promise<void>;
+}
+interface LeakyBucketOptions {
+  readonly ratePerSecond?: number;
+  readonly burst?: number;
+}
+declare function createLeakyBucketRateLimiter(options?: LeakyBucketOptions): TypeformRateLimiter;
+interface TypeformClientConfig {
+  readonly baseUrl?: string;
+  readonly rateLimiter?: TypeformRateLimiter;
+  readonly fetch?: typeof fetch;
+  readonly maxRateLimitRetries?: number;
+}
+interface TypeformListResponse<T> {
+  readonly items: T[];
+  readonly pageCount?: number;
+  readonly totalItems?: number;
+  readonly pageSize?: number;
+}
+declare function createTypeformClient(credentials: TypeformCredentials, config?: TypeformClientConfig): {
+  accounts: {
+    getAboutMe: () => Promise<unknown>;
+  };
+  forms: {
+    list: (query?: Record<string, QueryValue>) => Promise<unknown>;
+    get: (formId: string) => Promise<unknown>;
+    create: (body: unknown) => Promise<unknown>;
+    update: (formId: string, body: unknown) => Promise<unknown>;
+    patch: (formId: string, body: unknown) => Promise<unknown>;
+    delete: (formId: string) => Promise<void>;
+  };
+  responses: {
+    list: (formId: string, query?: Record<string, QueryValue>) => Promise<unknown>;
+    delete: (formId: string, includedTokens: readonly string[]) => Promise<void>;
+  };
+  responseFiles: {
+    download: (formId: string, responseId: string, fieldId: string, filename: string) => Promise<unknown>;
+  };
+  themes: {
+    list: (query?: Record<string, QueryValue>) => Promise<unknown>;
+    get: (themeId: string) => Promise<unknown>;
+    create: (body: unknown) => Promise<unknown>;
+    update: (themeId: string, body: unknown) => Promise<unknown>;
+    patch: (themeId: string, body: unknown) => Promise<unknown>;
+    delete: (themeId: string) => Promise<void>;
+  };
+  images: {
+    list: () => Promise<unknown>;
+    create: (body: unknown) => Promise<unknown>;
+    getBySize: (imageId: string, size: string) => Promise<unknown>;
+    getBackgroundBySize: (imageId: string, size: string) => Promise<unknown>;
+    getChoiceBySize: (imageId: string, size: string) => Promise<unknown>;
+    delete: (imageId: string) => Promise<void>;
+  };
+  videos: {
+    upload: (body: unknown) => Promise<unknown>;
+  };
+  workspaces: {
+    list: (query?: Record<string, QueryValue>) => Promise<unknown>;
+    get: (workspaceId: string) => Promise<unknown>;
+    create: (body: unknown) => Promise<unknown>;
+    update: (workspaceId: string, body: unknown) => Promise<unknown>;
+    delete: (workspaceId: string) => Promise<void>;
+  };
+  webhooks: {
+    list: (formId: string) => Promise<unknown>;
+    get: (formId: string, tag: string) => Promise<unknown>;
+    createOrUpdate: (formId: string, tag: string, body: unknown) => Promise<unknown>;
+    delete: (formId: string, tag: string) => Promise<void>;
+  };
+  insights: {
+    getFormMessages: (formId: string) => Promise<unknown>;
+    updateFormMessages: (formId: string, body: unknown) => Promise<void>;
+  };
+};
+type TypeformClient = ReturnType<typeof createTypeformClient>;
+//#endregion
+export { TypeformApiError, TypeformApiErrorKind, TypeformApiErrorOptions, TypeformClient, TypeformClientConfig, type TypeformListResponse, TypeformRateLimiter, createLeakyBucketRateLimiter, createTypeformClient };

package/dist/client.mjs

@@ -0,0 +1,308 @@
+import { t as typeform } from "./integration-BCzgn7Dm.mjs";
+import { n as TYPEFORM_CONNECT_HINT, t as TYPEFORM_API_BASE_URL } from "./shared-D0ONnQL8.mjs";
+import { CredentialRevokedError } from "@keystrokehq/core/errors";
+import { createErrorNormalizingProxy } from "@keystrokehq/integration-authoring";
+
+//#region src/client.ts
+var TypeformApiError = class extends Error {
+	kind;
+	status;
+	body;
+	requestId;
+	providerCode;
+	retryAfterSeconds;
+	retryable;
+	constructor(message, options) {
+		super(message);
+		this.name = "TypeformApiError";
+		this.kind = options.kind;
+		this.status = options.status;
+		this.body = options.body;
+		this.requestId = options.requestId;
+		this.providerCode = options.providerCode;
+		this.retryAfterSeconds = options.retryAfterSeconds;
+		this.retryable = options.retryable;
+	}
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function extractErrorMessage(body, status) {
+	if (isRecord(body)) {
+		const description = typeof body.description === "string" ? body.description : void 0;
+		const message = typeof body.message === "string" ? body.message : void 0;
+		return description ?? message ?? `HTTP ${status}`;
+	}
+	return `HTTP ${status}`;
+}
+function extractProviderCode(body) {
+	if (isRecord(body) && typeof body.code === "string") return body.code;
+}
+function classifyError(status, _body, retryAfterSeconds) {
+	if (status === 429) return {
+		kind: "rate_limit",
+		retryable: true
+	};
+	if (status === 401 || status === 403) return {
+		kind: "auth",
+		retryable: false
+	};
+	if (status === 422) return {
+		kind: "validation",
+		retryable: false
+	};
+	if (status >= 500 && status < 600) return {
+		kind: "http",
+		retryable: true
+	};
+	if (retryAfterSeconds !== void 0) return {
+		kind: "http",
+		retryable: true
+	};
+	return {
+		kind: "http",
+		retryable: false
+	};
+}
+function parseRetryAfter(value) {
+	if (!value) return void 0;
+	const asNumber = Number(value);
+	if (Number.isFinite(asNumber) && asNumber >= 0) return asNumber;
+	const asDate = Date.parse(value);
+	if (!Number.isNaN(asDate)) return Math.max(0, Math.ceil((asDate - Date.now()) / 1e3));
+}
+function isAuthError(error) {
+	return error instanceof TypeformApiError && error.kind === "auth";
+}
+function normalizeTypeformError(error, context) {
+	if (isAuthError(error)) return new CredentialRevokedError(typeform.id, `Typeform authentication failed while calling \`${context.methodPath}\`. The stored credentials for ${typeform.id} may be revoked or expired. ${TYPEFORM_CONNECT_HINT}`);
+	if (error instanceof TypeformApiError) return new Error(`Typeform API call failed while calling \`${context.methodPath}\` (${error.status}): ${error.message}`, { cause: error });
+	if (error instanceof Error) return new Error(`Typeform API call failed while calling \`${context.methodPath}\`: ${error.message}`, { cause: error });
+	return /* @__PURE__ */ new Error(`Typeform API call failed while calling \`${context.methodPath}\`.`);
+}
+function appendQuery(searchParams, query) {
+	if (!query) return;
+	for (const [key, value] of Object.entries(query)) {
+		if (value === void 0) continue;
+		if (Array.isArray(value)) {
+			if (value.length === 0) continue;
+			searchParams.set(key, value.map(String).join(","));
+			continue;
+		}
+		searchParams.set(key, String(value));
+	}
+}
+function createLeakyBucketRateLimiter(options = {}) {
+	const ratePerSecond = options.ratePerSecond ?? 2;
+	const burst = options.burst ?? 2;
+	const intervalMs = 1e3 / ratePerSecond;
+	let tokens = burst;
+	let lastRefill = Date.now();
+	let chain = Promise.resolve();
+	async function acquireOne() {
+		const now = Date.now();
+		const elapsed = now - lastRefill;
+		if (elapsed > 0) {
+			const refill = Math.floor(elapsed / intervalMs);
+			if (refill > 0) {
+				tokens = Math.min(burst, tokens + refill);
+				lastRefill = lastRefill + refill * intervalMs;
+			}
+		}
+		if (tokens > 0) {
+			tokens -= 1;
+			return;
+		}
+		const waitMs = Math.max(0, lastRefill + intervalMs - now);
+		await new Promise((resolve) => setTimeout(resolve, waitMs));
+		tokens = Math.min(burst, tokens + 1);
+		lastRefill = Date.now();
+		tokens -= 1;
+	}
+	return { acquire: () => {
+		const next = chain.then(acquireOne);
+		chain = next.catch(() => void 0);
+		return next;
+	} };
+}
+function makeRequest(accessToken, config) {
+	const baseUrl = config.baseUrl ?? TYPEFORM_API_BASE_URL;
+	const limiter = config.rateLimiter ?? createLeakyBucketRateLimiter();
+	const fetchImpl = config.fetch ?? globalThis.fetch.bind(globalThis);
+	const maxRateLimitRetries = config.maxRateLimitRetries ?? 3;
+	async function request(path, options = {}) {
+		let attempt = 0;
+		for (;;) {
+			await limiter.acquire();
+			const url = new URL(`${baseUrl}${path}`);
+			const query = new URLSearchParams();
+			appendQuery(query, options.query);
+			const search = query.toString();
+			if (search.length > 0) url.search = search;
+			const headers = {
+				Authorization: `Bearer ${accessToken}`,
+				"Content-Type": "application/json",
+				...options.headers ?? {}
+			};
+			const response = await fetchImpl(url, {
+				method: options.method ?? "GET",
+				headers,
+				...options.body !== void 0 ? { body: JSON.stringify(options.body) } : {}
+			});
+			if (response.status === 204) return;
+			const responseBody = (response.headers.get("content-type") ?? "").includes("application/json") ? await response.json() : await response.text();
+			if (response.ok) return responseBody;
+			const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
+			const { kind, retryable } = classifyError(response.status, responseBody, retryAfter);
+			if (kind === "rate_limit" && attempt < maxRateLimitRetries) {
+				attempt += 1;
+				const waitMs = Math.max(0, (retryAfter ?? 1) * 1e3);
+				await new Promise((resolve) => setTimeout(resolve, waitMs));
+				continue;
+			}
+			const requestId = response.headers.get("x-request-id") ?? void 0;
+			throw new TypeformApiError(extractErrorMessage(responseBody, response.status), {
+				kind,
+				status: response.status,
+				body: responseBody,
+				providerCode: extractProviderCode(responseBody),
+				retryAfterSeconds: retryAfter,
+				retryable,
+				...requestId !== void 0 ? { requestId } : {}
+			});
+		}
+	}
+	return request;
+}
+function accountsApi(request) {
+	return { getAboutMe: () => request("/me") };
+}
+function formsApi(request) {
+	return {
+		list: (query) => request("/forms", { query }),
+		get: (formId) => request(`/forms/${encodeURIComponent(formId)}`),
+		create: (body) => request("/forms", {
+			method: "POST",
+			body
+		}),
+		update: (formId, body) => request(`/forms/${encodeURIComponent(formId)}`, {
+			method: "PUT",
+			body
+		}),
+		patch: (formId, body) => request(`/forms/${encodeURIComponent(formId)}`, {
+			method: "PATCH",
+			body
+		}),
+		delete: (formId) => request(`/forms/${encodeURIComponent(formId)}`, { method: "DELETE" })
+	};
+}
+function responsesApi(request) {
+	return {
+		list: (formId, query) => request(`/forms/${encodeURIComponent(formId)}/responses`, { query }),
+		delete: (formId, includedTokens) => request(`/forms/${encodeURIComponent(formId)}/responses`, {
+			method: "DELETE",
+			query: { included_tokens: includedTokens }
+		})
+	};
+}
+function responseFilesApi(request) {
+	return { download: async (formId, responseId, fieldId, filename) => {
+		return request(`/forms/${encodeURIComponent(formId)}/responses/${encodeURIComponent(responseId)}/fields/${encodeURIComponent(fieldId)}/files/${encodeURIComponent(filename)}`, { rawResponse: true });
+	} };
+}
+function themesApi(request) {
+	return {
+		list: (query) => request("/themes", { query }),
+		get: (themeId) => request(`/themes/${encodeURIComponent(themeId)}`),
+		create: (body) => request("/themes", {
+			method: "POST",
+			body
+		}),
+		update: (themeId, body) => request(`/themes/${encodeURIComponent(themeId)}`, {
+			method: "PUT",
+			body
+		}),
+		patch: (themeId, body) => request(`/themes/${encodeURIComponent(themeId)}`, {
+			method: "PATCH",
+			body
+		}),
+		delete: (themeId) => request(`/themes/${encodeURIComponent(themeId)}`, { method: "DELETE" })
+	};
+}
+function imagesApi(request) {
+	return {
+		list: () => request("/images"),
+		create: (body) => request("/images", {
+			method: "POST",
+			body
+		}),
+		getBySize: (imageId, size) => request(`/images/${encodeURIComponent(imageId)}/image/${encodeURIComponent(size)}`),
+		getBackgroundBySize: (imageId, size) => request(`/images/${encodeURIComponent(imageId)}/background/${encodeURIComponent(size)}`),
+		getChoiceBySize: (imageId, size) => request(`/images/${encodeURIComponent(imageId)}/choice/${encodeURIComponent(size)}`),
+		delete: (imageId) => request(`/images/${encodeURIComponent(imageId)}`, { method: "DELETE" })
+	};
+}
+function videosApi(request) {
+	return { upload: (body) => request("/videos", {
+		method: "POST",
+		body
+	}) };
+}
+function workspacesApi(request) {
+	return {
+		list: (query) => request("/workspaces", { query }),
+		get: (workspaceId) => request(`/workspaces/${encodeURIComponent(workspaceId)}`),
+		create: (body) => request("/workspaces", {
+			method: "POST",
+			body
+		}),
+		update: (workspaceId, body) => request(`/workspaces/${encodeURIComponent(workspaceId)}`, {
+			method: "PATCH",
+			body
+		}),
+		delete: (workspaceId) => request(`/workspaces/${encodeURIComponent(workspaceId)}`, { method: "DELETE" })
+	};
+}
+function webhooksApi(request) {
+	return {
+		list: (formId) => request(`/forms/${encodeURIComponent(formId)}/webhooks`),
+		get: (formId, tag) => request(`/forms/${encodeURIComponent(formId)}/webhooks/${encodeURIComponent(tag)}`),
+		createOrUpdate: (formId, tag, body) => request(`/forms/${encodeURIComponent(formId)}/webhooks/${encodeURIComponent(tag)}`, {
+			method: "PUT",
+			body
+		}),
+		delete: (formId, tag) => request(`/forms/${encodeURIComponent(formId)}/webhooks/${encodeURIComponent(tag)}`, { method: "DELETE" })
+	};
+}
+function insightsApi(request) {
+	return {
+		getFormMessages: (formId) => request(`/forms/${encodeURIComponent(formId)}/messages`),
+		updateFormMessages: (formId, body) => request(`/forms/${encodeURIComponent(formId)}/messages`, {
+			method: "PUT",
+			body
+		})
+	};
+}
+function createTypeformApiClient(accessToken, config) {
+	const request = makeRequest(accessToken, config);
+	return {
+		accounts: accountsApi(request),
+		forms: formsApi(request),
+		responses: responsesApi(request),
+		responseFiles: responseFilesApi(request),
+		themes: themesApi(request),
+		images: imagesApi(request),
+		videos: videosApi(request),
+		workspaces: workspacesApi(request),
+		webhooks: webhooksApi(request),
+		insights: insightsApi(request)
+	};
+}
+function createTypeformClient(credentials, config = {}) {
+	const accessToken = credentials.TYPEFORM_ACCESS_TOKEN.trim();
+	if (accessToken.length === 0) throw new Error(`Typeform authentication failed while calling Typeform API \`client initialization\`. ${TYPEFORM_CONNECT_HINT}`);
+	return createErrorNormalizingProxy(createTypeformApiClient(accessToken, config), normalizeTypeformError);
+}
+
+//#endregion
+export { TypeformApiError, createLeakyBucketRateLimiter, createTypeformClient };

package/dist/connection.d.mts

@@ -0,0 +1,2 @@
+import { i as typeformOfficialIntegration, n as typeform, t as TypeformCredentials } from "./integration-d_VqlGvZ.mjs";
+export { type TypeformCredentials, typeform, typeformOfficialIntegration };

package/dist/connection.mjs

@@ -0,0 +1,3 @@
+import { r as typeformOfficialIntegration, t as typeform } from "./integration-BCzgn7Dm.mjs";
+
+export { typeform, typeformOfficialIntegration };