@keystrokehq/typeform 0.0.1

package/dist/forms.mjs

@@ -0,0 +1,147 @@
+import { a as mapPagePagination, o as omitUndefined, r as asRecord } from "./shared-D0ONnQL8.mjs";
+import { createTypeformClient } from "./client.mjs";
+import { C as typeformFormSchema, N as typeformLooseObjectSchema, S as typeformFormRefSchema, k as typeformIdentifierSchema, x as typeformFormListSchema } from "./workspace-C1CCnvgv.mjs";
+import { t as typeformOperation } from "./factory-B_dyn39A.mjs";
+import { z } from "zod";
+
+//#region src/forms.ts
+const listFormsInputSchema = z.object({
+	page: z.number().int().positive().optional(),
+	pageSize: z.number().int().positive().max(200).optional(),
+	search: z.string().trim().min(1).optional(),
+	workspaceId: z.string().trim().min(1).optional()
+});
+const getFormInputSchema = z.object({ formId: typeformIdentifierSchema });
+const createFormInputSchema = z.object({
+	title: z.string().trim().min(1),
+	workspaceHref: z.string().trim().min(1).optional(),
+	themeHref: z.string().trim().min(1).optional(),
+	language: z.string().trim().min(1).optional(),
+	settings: typeformLooseObjectSchema().optional(),
+	welcomeScreens: z.array(typeformLooseObjectSchema()).optional(),
+	thankyouScreens: z.array(typeformLooseObjectSchema()).optional(),
+	fields: z.array(typeformLooseObjectSchema()).optional(),
+	hidden: z.array(z.string()).optional(),
+	variables: typeformLooseObjectSchema().optional(),
+	logic: z.array(typeformLooseObjectSchema()).optional()
+});
+const updateFormInputSchema = createFormInputSchema.extend({ formId: typeformIdentifierSchema });
+const patchFormInputSchema = z.object({
+	formId: typeformIdentifierSchema,
+	operations: z.array(z.object({
+		op: z.enum([
+			"add",
+			"replace",
+			"remove",
+			"copy",
+			"move",
+			"test"
+		]),
+		path: z.string().trim().min(1),
+		value: z.unknown().optional(),
+		from: z.string().trim().min(1).optional()
+	})).min(1)
+});
+const deleteFormInputSchema = z.object({ formId: typeformIdentifierSchema });
+function buildFormBody(input) {
+	return omitUndefined({
+		title: input.title,
+		workspace: input.workspaceHref ? { href: input.workspaceHref } : void 0,
+		theme: input.themeHref ? { href: input.themeHref } : void 0,
+		language: input.language,
+		settings: input.settings,
+		welcome_screens: input.welcomeScreens,
+		thankyou_screens: input.thankyouScreens,
+		fields: input.fields,
+		hidden: input.hidden,
+		variables: input.variables,
+		logic: input.logic
+	});
+}
+function mapFormList(raw) {
+	const record = asRecord(raw);
+	const items = Array.isArray(record.items) ? record.items : [];
+	return typeformFormListSchema.parse({
+		items: items.map((item) => typeformFormRefSchema.parse(item)),
+		pagination: mapPagePagination(record)
+	});
+}
+const listForms = typeformOperation({
+	id: "list_forms",
+	name: "List Forms",
+	description: "List Typeform forms visible to the connected account.",
+	input: listFormsInputSchema,
+	output: typeformFormListSchema,
+	run: async (input, credentials) => {
+		return mapFormList(await createTypeformClient(credentials).forms.list(omitUndefined({
+			page: input.page,
+			page_size: input.pageSize,
+			search: input.search,
+			workspace_id: input.workspaceId
+		})));
+	}
+});
+const getForm = typeformOperation({
+	id: "get_form",
+	name: "Get Form",
+	description: "Fetch a single Typeform form by id.",
+	input: getFormInputSchema,
+	output: typeformFormSchema,
+	run: async (input, credentials) => {
+		const response = await createTypeformClient(credentials).forms.get(input.formId);
+		return typeformFormSchema.parse(response);
+	}
+});
+const createForm = typeformOperation({
+	id: "create_form",
+	name: "Create Form",
+	description: "Create a new Typeform form in the connected account.",
+	input: createFormInputSchema,
+	output: typeformFormSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const response = await createTypeformClient(credentials).forms.create(buildFormBody(input));
+		return typeformFormSchema.parse(response);
+	}
+});
+const updateForm = typeformOperation({
+	id: "update_form",
+	name: "Update Form",
+	description: "Replace a Typeform form by id (full PUT).",
+	input: updateFormInputSchema,
+	output: typeformFormSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createTypeformClient(credentials);
+		const { formId, ...rest } = input;
+		const response = await client.forms.update(formId, buildFormBody(rest));
+		return typeformFormSchema.parse(response);
+	}
+});
+const patchForm = typeformOperation({
+	id: "patch_form",
+	name: "Patch Form",
+	description: "Apply a JSON Patch (RFC 6902) operation set to a Typeform form.",
+	input: patchFormInputSchema,
+	output: typeformFormSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const response = await createTypeformClient(credentials).forms.patch(input.formId, input.operations);
+		return typeformFormSchema.parse(response);
+	}
+});
+const deleteForm = typeformOperation({
+	id: "delete_form",
+	name: "Delete Form",
+	description: "Delete a Typeform form by id. Deletion is irreversible.",
+	input: deleteFormInputSchema,
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, credentials) => {
+		await createTypeformClient(credentials).forms.delete(input.formId);
+		return { success: true };
+	}
+});
+
+//#endregion
+export { createForm, deleteForm, getForm, listForms, patchForm, updateForm };

package/dist/images.d.mts

@@ -0,0 +1,112 @@
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/images.d.ts
+declare const listImages: _keystrokehq_core0.Operation<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+  items: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    file_name: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    media_type: z.ZodOptional<z.ZodString>;
+    has_alpha: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$catchall<z.ZodUnknown>>>;
+}, z.core.$strip>, 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>;
+declare const createImage: _keystrokehq_core0.Operation<z.ZodObject<{
+  fileName: z.ZodString;
+  image: z.ZodOptional<z.ZodString>;
+  url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  file_name: z.ZodOptional<z.ZodString>;
+  url: z.ZodOptional<z.ZodString>;
+  width: z.ZodOptional<z.ZodNumber>;
+  height: z.ZodOptional<z.ZodNumber>;
+  media_type: z.ZodOptional<z.ZodString>;
+  has_alpha: z.ZodOptional<z.ZodBoolean>;
+}, 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>;
+declare const getImageBySize: _keystrokehq_core0.Operation<z.ZodObject<{
+  imageId: z.ZodString;
+  size: z.ZodEnum<{
+    default: "default";
+    thumbnail: "thumbnail";
+    mobile: "mobile";
+  }>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  file_name: z.ZodOptional<z.ZodString>;
+  url: z.ZodOptional<z.ZodString>;
+  width: z.ZodOptional<z.ZodNumber>;
+  height: z.ZodOptional<z.ZodNumber>;
+  media_type: z.ZodOptional<z.ZodString>;
+  has_alpha: z.ZodOptional<z.ZodBoolean>;
+}, 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>;
+declare const getBackgroundBySize: _keystrokehq_core0.Operation<z.ZodObject<{
+  imageId: z.ZodString;
+  size: z.ZodEnum<{
+    default: "default";
+    thumbnail: "thumbnail";
+    mobile: "mobile";
+    tablet: "tablet";
+  }>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  file_name: z.ZodOptional<z.ZodString>;
+  url: z.ZodOptional<z.ZodString>;
+  width: z.ZodOptional<z.ZodNumber>;
+  height: z.ZodOptional<z.ZodNumber>;
+  media_type: z.ZodOptional<z.ZodString>;
+  has_alpha: z.ZodOptional<z.ZodBoolean>;
+}, 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>;
+declare const getChoiceImageBySize: _keystrokehq_core0.Operation<z.ZodObject<{
+  imageId: z.ZodString;
+  size: z.ZodEnum<{
+    default: "default";
+    thumbnail: "thumbnail";
+    supersize: "supersize";
+    supermobile: "supermobile";
+    supersizefit: "supersizefit";
+    supermobilefit: "supermobilefit";
+  }>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  file_name: z.ZodOptional<z.ZodString>;
+  url: z.ZodOptional<z.ZodString>;
+  width: z.ZodOptional<z.ZodNumber>;
+  height: z.ZodOptional<z.ZodNumber>;
+  media_type: z.ZodOptional<z.ZodString>;
+  has_alpha: z.ZodOptional<z.ZodBoolean>;
+}, 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>;
+declare const deleteImage: _keystrokehq_core0.Operation<z.ZodObject<{
+  imageId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  success: z.ZodBoolean;
+}, z.core.$strip>, 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 { createImage, deleteImage, getBackgroundBySize, getChoiceImageBySize, getImageBySize, listImages };

package/dist/images.mjs

@@ -0,0 +1,104 @@
+import { o as omitUndefined, r as asRecord } from "./shared-D0ONnQL8.mjs";
+import { createTypeformClient } from "./client.mjs";
+import { A as typeformImageBackgroundSizeSchema, M as typeformImageSizeSchema, j as typeformImageChoiceSizeSchema, k as typeformIdentifierSchema, v as typeformImageListSchema, y as typeformImageSchema } from "./workspace-C1CCnvgv.mjs";
+import { t as typeformOperation } from "./factory-B_dyn39A.mjs";
+import { z } from "zod";
+
+//#region src/images.ts
+const listImagesInputSchema = z.object({});
+const createImageInputSchema = z.object({
+	fileName: z.string().trim().min(1),
+	image: z.string().trim().min(1).optional(),
+	url: z.string().trim().min(1).optional()
+});
+const getImageBySizeInputSchema = z.object({
+	imageId: typeformIdentifierSchema,
+	size: typeformImageSizeSchema
+});
+const getBackgroundBySizeInputSchema = z.object({
+	imageId: typeformIdentifierSchema,
+	size: typeformImageBackgroundSizeSchema
+});
+const getChoiceImageBySizeInputSchema = z.object({
+	imageId: typeformIdentifierSchema,
+	size: typeformImageChoiceSizeSchema
+});
+const deleteImageInputSchema = z.object({ imageId: typeformIdentifierSchema });
+const listImages = typeformOperation({
+	id: "list_images",
+	name: "List Images",
+	description: "List image assets in the connected Typeform account.",
+	input: listImagesInputSchema,
+	output: typeformImageListSchema,
+	run: async (_input, credentials) => {
+		const response = await createTypeformClient(credentials).images.list();
+		const record = asRecord(response);
+		const items = Array.isArray(record.items) ? record.items : Array.isArray(response) ? response : [];
+		return typeformImageListSchema.parse({ items: items.map((item) => typeformImageSchema.parse(item)) });
+	}
+});
+const createImage = typeformOperation({
+	id: "create_image",
+	name: "Create Image",
+	description: "Upload a new image asset to the Typeform account (base64 or URL-sourced).",
+	input: createImageInputSchema,
+	output: typeformImageSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		if (!input.image && !input.url) throw new Error("createImage requires either `image` (base64) or `url`.");
+		const response = await createTypeformClient(credentials).images.create(omitUndefined({
+			file_name: input.fileName,
+			image: input.image,
+			url: input.url
+		}));
+		return typeformImageSchema.parse(response);
+	}
+});
+const getImageBySize = typeformOperation({
+	id: "get_image_by_size",
+	name: "Get Image by Size",
+	description: "Fetch a sized variant of an image asset.",
+	input: getImageBySizeInputSchema,
+	output: typeformImageSchema,
+	run: async (input, credentials) => {
+		const response = await createTypeformClient(credentials).images.getBySize(input.imageId, input.size);
+		return typeformImageSchema.parse(response);
+	}
+});
+const getBackgroundBySize = typeformOperation({
+	id: "get_background_by_size",
+	name: "Get Background Image by Size",
+	description: "Fetch a sized variant of a background image asset.",
+	input: getBackgroundBySizeInputSchema,
+	output: typeformImageSchema,
+	run: async (input, credentials) => {
+		const response = await createTypeformClient(credentials).images.getBackgroundBySize(input.imageId, input.size);
+		return typeformImageSchema.parse(response);
+	}
+});
+const getChoiceImageBySize = typeformOperation({
+	id: "get_choice_image_by_size",
+	name: "Get Choice Image by Size",
+	description: "Fetch a sized variant of a picture-choice image asset.",
+	input: getChoiceImageBySizeInputSchema,
+	output: typeformImageSchema,
+	run: async (input, credentials) => {
+		const response = await createTypeformClient(credentials).images.getChoiceBySize(input.imageId, input.size);
+		return typeformImageSchema.parse(response);
+	}
+});
+const deleteImage = typeformOperation({
+	id: "delete_image",
+	name: "Delete Image",
+	description: "Delete an image asset.",
+	input: deleteImageInputSchema,
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, credentials) => {
+		await createTypeformClient(credentials).images.delete(input.imageId);
+		return { success: true };
+	}
+});
+
+//#endregion
+export { createImage, deleteImage, getBackgroundBySize, getChoiceImageBySize, getImageBySize, listImages };

package/dist/index.d.mts

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

package/dist/index.mjs

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

package/dist/insights.d.mts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/insights.d.ts
+declare const getFormMessages: _keystrokehq_core0.Operation<z.ZodObject<{
+  formId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  [x: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, 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>;
+declare const updateFormMessages: _keystrokehq_core0.Operation<z.ZodObject<{
+  formId: z.ZodString;
+  messages: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  success: z.ZodBoolean;
+}, z.core.$strip>, 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 { getFormMessages, updateFormMessages };

package/dist/insights.mjs

@@ -0,0 +1,37 @@
+import { createTypeformClient } from "./client.mjs";
+import { _ as typeformFormMessagesSchema, k as typeformIdentifierSchema } from "./workspace-C1CCnvgv.mjs";
+import { t as typeformOperation } from "./factory-B_dyn39A.mjs";
+import { z } from "zod";
+
+//#region src/insights.ts
+const getFormMessagesInputSchema = z.object({ formId: typeformIdentifierSchema });
+const updateFormMessagesInputSchema = z.object({
+	formId: typeformIdentifierSchema,
+	messages: z.record(z.string(), z.string())
+});
+const getFormMessages = typeformOperation({
+	id: "get_form_messages",
+	name: "Get Form Messages",
+	description: "Retrieve the customizable copy overrides (messages) for a Typeform form.",
+	input: getFormMessagesInputSchema,
+	output: typeformFormMessagesSchema,
+	run: async (input, credentials) => {
+		const response = await createTypeformClient(credentials).insights.getFormMessages(input.formId);
+		return typeformFormMessagesSchema.parse(response);
+	}
+});
+const updateFormMessages = typeformOperation({
+	id: "update_form_messages",
+	name: "Update Form Messages",
+	description: "Replace the customizable copy overrides (messages) for a Typeform form.",
+	input: updateFormMessagesInputSchema,
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, credentials) => {
+		await createTypeformClient(credentials).insights.updateFormMessages(input.formId, input.messages);
+		return { success: true };
+	}
+});
+
+//#endregion
+export { getFormMessages, updateFormMessages };

package/dist/integration-BCzgn7Dm.mjs

@@ -0,0 +1,76 @@
+import { defineOfficialIntegration } from "@keystrokehq/integration-authoring/official";
+import { z } from "zod";
+import { CredentialSet } from "@keystrokehq/core";
+
+//#region src/_official/provider-app.ts
+const typeformAppCredentialSet = new CredentialSet({
+	id: "typeform-app",
+	exposure: "platform-only",
+	name: "Typeform App",
+	auth: z.object({
+		clientId: z.string().min(1),
+		clientSecret: z.string().min(1),
+		webhookSecret: z.string().min(1).optional()
+	})
+});
+const typeformPlatformProviderSeed = {
+	provider: "typeform",
+	appRef: "typeform-platform",
+	displayName: "Typeform Platform",
+	credentialSetName: "Keystroke Typeform Platform App",
+	envShape: {
+		KEYSTROKE_PLATFORM_TYPEFORM_CLIENT_ID: z.string().optional(),
+		KEYSTROKE_PLATFORM_TYPEFORM_CLIENT_SECRET: z.string().optional(),
+		KEYSTROKE_PLATFORM_TYPEFORM_WEBHOOK_SECRET: z.string().optional()
+	},
+	requiredEnvKeys: ["KEYSTROKE_PLATFORM_TYPEFORM_CLIENT_ID", "KEYSTROKE_PLATFORM_TYPEFORM_CLIENT_SECRET"],
+	externalAppIdEnvKey: "KEYSTROKE_PLATFORM_TYPEFORM_CLIENT_ID",
+	buildCredentials: (env) => ({
+		clientId: env.KEYSTROKE_PLATFORM_TYPEFORM_CLIENT_ID,
+		clientSecret: env.KEYSTROKE_PLATFORM_TYPEFORM_CLIENT_SECRET,
+		...env.KEYSTROKE_PLATFORM_TYPEFORM_WEBHOOK_SECRET ? { webhookSecret: env.KEYSTROKE_PLATFORM_TYPEFORM_WEBHOOK_SECRET } : {}
+	})
+};
+
+//#endregion
+//#region src/integration.ts
+const typeformAuthSchema = z.object({ TYPEFORM_ACCESS_TOKEN: z.string().min(1) });
+const typeformOfficialIntegration = {
+	id: "typeform",
+	name: "Typeform",
+	description: "Typeform forms, responses, themes, images, workspaces, and form_response webhooks for Keystroke workflows",
+	auth: typeformAuthSchema,
+	connections: [{
+		id: "oauth",
+		kind: "oauth",
+		tokenType: "refreshable",
+		authUrl: "https://api.typeform.com/oauth/authorize",
+		tokenUrl: "https://api.typeform.com/oauth/token",
+		revokeUrl: "https://api.typeform.com/oauth/revoke",
+		scopes: [
+			"accounts:read",
+			"forms:read",
+			"forms:write",
+			"responses:read",
+			"responses:write",
+			"images:read",
+			"images:write",
+			"themes:read",
+			"themes:write",
+			"workspaces:read",
+			"workspaces:write",
+			"webhooks:read",
+			"webhooks:write",
+			"offline"
+		],
+		vault: { accessToken: "TYPEFORM_ACCESS_TOKEN" }
+	}]
+};
+const typeformBundle = defineOfficialIntegration({
+	...typeformOfficialIntegration,
+	internal: { providerApp: typeformAppCredentialSet }
+});
+const typeform = typeformBundle.credentialSet;
+
+//#endregion
+export { typeformPlatformProviderSeed as a, typeformAppCredentialSet as i, typeformBundle as n, typeformOfficialIntegration as r, typeform as t };

package/dist/integration-d_VqlGvZ.d.mts

@@ -0,0 +1,38 @@
+import * as _keystrokehq_integration_authoring_official0 from "@keystrokehq/integration-authoring/official";
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+import { InferCredentialSetAuth } from "@keystrokehq/core/credential-set";
+
+//#region src/integration.d.ts
+declare const typeformOfficialIntegration: {
+  id: "typeform";
+  name: string;
+  description: string;
+  auth: z.ZodObject<{
+    TYPEFORM_ACCESS_TOKEN: z.ZodString;
+  }, z.core.$strip>;
+  connections: {
+    id: string;
+    kind: "oauth";
+    tokenType: "refreshable";
+    authUrl: string;
+    tokenUrl: string;
+    revokeUrl: string;
+    scopes: string[];
+    vault: {
+      accessToken: "TYPEFORM_ACCESS_TOKEN";
+    };
+  }[];
+};
+declare const typeformBundle: _keystrokehq_integration_authoring_official0.OfficialIntegrationBundle<"typeform", z.ZodObject<{
+  TYPEFORM_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>;
+declare const typeform: _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>;
+type TypeformCredentials = InferCredentialSetAuth<typeof typeform>;
+//#endregion
+export { typeformOfficialIntegration as i, typeform as n, typeformBundle as r, TypeformCredentials as t };

package/dist/messaging.d.mts

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

package/dist/messaging.mjs

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

package/dist/provider-app-BnLMYj3B.d.mts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { CredentialSet } from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/_official/provider-app.d.ts
+declare const typeformAppCredentialSet: CredentialSet<"typeform-app", z.ZodObject<{
+  clientId: z.ZodString;
+  clientSecret: z.ZodString;
+  webhookSecret: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  clientId: z.ZodString;
+  clientSecret: z.ZodString;
+  webhookSecret: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>[] | undefined>;
+declare const typeformPlatformProviderSeed: {
+  readonly provider: "typeform";
+  readonly appRef: "typeform-platform";
+  readonly displayName: "Typeform Platform";
+  readonly credentialSetName: "Keystroke Typeform Platform App";
+  readonly envShape: {
+    readonly KEYSTROKE_PLATFORM_TYPEFORM_CLIENT_ID: z.ZodOptional<z.ZodString>;
+    readonly KEYSTROKE_PLATFORM_TYPEFORM_CLIENT_SECRET: z.ZodOptional<z.ZodString>;
+    readonly KEYSTROKE_PLATFORM_TYPEFORM_WEBHOOK_SECRET: z.ZodOptional<z.ZodString>;
+  };
+  readonly requiredEnvKeys: readonly ["KEYSTROKE_PLATFORM_TYPEFORM_CLIENT_ID", "KEYSTROKE_PLATFORM_TYPEFORM_CLIENT_SECRET"];
+  readonly externalAppIdEnvKey: "KEYSTROKE_PLATFORM_TYPEFORM_CLIENT_ID";
+  readonly buildCredentials: (env: Record<string, string | undefined>) => {
+    webhookSecret?: string | undefined;
+    clientId: string | undefined;
+    clientSecret: string | undefined;
+  };
+};
+type TypeformAppCredentials = z.infer<typeof typeformAppCredentialSet.auth>;
+//#endregion
+export { typeformAppCredentialSet as n, typeformPlatformProviderSeed as r, TypeformAppCredentials as t };