@keystrokehq/ramp 0.0.1

package/dist/transactions.mjs

@@ -0,0 +1,81 @@
+import { createRampClient } from "./client.mjs";
+import { i as rampTransactionSchema, n as rampTransactionListInputSchema, r as rampTransactionListSchema, t as rampTransactionGetInputSchema } from "./transactions-Djd0oIGK.mjs";
+import { t as rampOperation } from "./factory-Da6YVHdL.mjs";
+import { t as omitUndefined } from "./shared-CTTtP5gv.mjs";
+import { z } from "zod";
+
+//#region src/transactions.ts
+function clientFor(credentials, options) {
+	return createRampClient(credentials, options);
+}
+const listTransactions = rampOperation({
+	id: "list_transactions",
+	name: "List Transactions",
+	description: "List Ramp card transactions with optional filters (date range, amount, merchant, user, state). Returns a single page of results; use `cursor` to paginate.",
+	input: rampTransactionListInputSchema,
+	output: rampTransactionListSchema,
+	run: async (input, credentials) => {
+		const client = clientFor(credentials);
+		const query = omitUndefined({
+			department_id: input.department_id,
+			location_id: input.location_id,
+			card_id: input.card_id,
+			entity_id: input.entity_id,
+			merchant_id: input.merchant_id,
+			sk_category_id: input.sk_category_id,
+			state: input.state,
+			min_amount: input.minAmount,
+			max_amount: input.maxAmount,
+			from_date: input.start,
+			to_date: input.end,
+			order_by_date_desc: input.orderBy === "user_transaction_time DESC" ? true : void 0,
+			page_size: input.pageSize,
+			start: input.cursor
+		});
+		const response = await client.request("/transactions", { query });
+		return rampTransactionListSchema.parse(response);
+	}
+});
+const getTransaction = rampOperation({
+	id: "get_transaction",
+	name: "Get Transaction",
+	description: "Fetch a single Ramp card transaction by id.",
+	input: rampTransactionGetInputSchema,
+	output: rampTransactionSchema,
+	run: async (input, credentials) => {
+		const response = await clientFor(credentials).request(`/transactions/${encodeURIComponent(input.transactionId)}`);
+		return rampTransactionSchema.parse(response);
+	}
+});
+const listAllTransactions = rampOperation({
+	id: "list_all_transactions",
+	name: "List All Transactions (auto-paginated)",
+	description: "Stream every matching Ramp transaction by following `page.next` until exhausted. Use with care on large date ranges.",
+	input: rampTransactionListInputSchema,
+	output: z.object({ data: z.array(rampTransactionSchema) }),
+	run: async (input, credentials) => {
+		const client = clientFor(credentials);
+		const query = omitUndefined({
+			department_id: input.department_id,
+			location_id: input.location_id,
+			card_id: input.card_id,
+			entity_id: input.entity_id,
+			merchant_id: input.merchant_id,
+			sk_category_id: input.sk_category_id,
+			state: input.state,
+			min_amount: input.minAmount,
+			max_amount: input.maxAmount,
+			from_date: input.start,
+			to_date: input.end
+		});
+		const data = [];
+		for await (const item of client.paginate("/transactions", {
+			query,
+			pageSize: input.pageSize ?? 100
+		})) data.push(rampTransactionSchema.parse(item));
+		return { data };
+	}
+});
+
+//#endregion
+export { getTransaction, listAllTransactions, listTransactions };

package/dist/transfers-WBQZVdGP.mjs

@@ -0,0 +1,40 @@
+import { a as rampListPaginationInputSchema, c as rampMoneySchema, f as rampTimestampSchema, i as rampIdSchema, o as rampListResponseSchema } from "./common-CUpmNYXw.mjs";
+import { z } from "zod";
+
+//#region src/schemas/transfers.ts
+const rampTransferStatusSchema = z.enum([
+	"PENDING",
+	"PROCESSING",
+	"COMPLETED",
+	"CANCELED",
+	"FAILED"
+]);
+const rampTransferSchema = z.object({
+	id: rampIdSchema,
+	amount: rampMoneySchema.optional(),
+	status: rampTransferStatusSchema.optional(),
+	created_at: rampTimestampSchema.optional(),
+	settled_at: rampTimestampSchema.optional(),
+	source_account: z.string().optional(),
+	destination_account: z.string().optional(),
+	entity_id: rampIdSchema.optional()
+}).passthrough();
+const rampTransferListInputSchema = z.object({
+	entity_id: rampIdSchema.optional(),
+	status: rampTransferStatusSchema.optional()
+}).merge(rampListPaginationInputSchema);
+const rampTransferListSchema = rampListResponseSchema(rampTransferSchema);
+const rampTransferGetInputSchema = z.object({ transferId: rampIdSchema });
+const rampCashbackSchema = z.object({
+	id: rampIdSchema,
+	amount: rampMoneySchema.optional(),
+	status: z.string().optional(),
+	granted_date: rampTimestampSchema.optional(),
+	entity_id: rampIdSchema.optional()
+}).passthrough();
+const rampCashbackListInputSchema = rampListPaginationInputSchema;
+const rampCashbackListSchema = rampListResponseSchema(rampCashbackSchema);
+const rampCashbackGetInputSchema = z.object({ cashbackId: rampIdSchema });
+
+//#endregion
+export { rampTransferGetInputSchema as a, rampTransferSchema as c, rampCashbackSchema as i, rampTransferStatusSchema as l, rampCashbackListInputSchema as n, rampTransferListInputSchema as o, rampCashbackListSchema as r, rampTransferListSchema as s, rampCashbackGetInputSchema as t };

package/dist/transfers.d.mts

@@ -0,0 +1,72 @@
+import * as zod from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+import * as zod_v4_core0 from "zod/v4/core";
+
+//#region src/transfers.d.ts
+declare const listTransfers: _keystrokehq_core0.Operation<zod.ZodObject<{
+  entity_id: zod.ZodOptional<zod.ZodString>;
+  status: zod.ZodOptional<zod.ZodEnum<{
+    PENDING: "PENDING";
+    CANCELED: "CANCELED";
+    FAILED: "FAILED";
+    PROCESSING: "PROCESSING";
+    COMPLETED: "COMPLETED";
+  }>>;
+  pageSize: zod.ZodOptional<zod.ZodNumber>;
+  cursor: zod.ZodOptional<zod.ZodString>;
+}, zod_v4_core0.$strip>, zod.ZodObject<{
+  data: zod.ZodArray<zod.ZodObject<{
+    id: zod.ZodString;
+    amount: zod.ZodOptional<zod.ZodObject<{
+      amountCents: zod.ZodNumber;
+      currency: zod.ZodString;
+    }, zod_v4_core0.$strip>>;
+    status: zod.ZodOptional<zod.ZodEnum<{
+      PENDING: "PENDING";
+      CANCELED: "CANCELED";
+      FAILED: "FAILED";
+      PROCESSING: "PROCESSING";
+      COMPLETED: "COMPLETED";
+    }>>;
+    created_at: zod.ZodOptional<zod.ZodString>;
+    settled_at: zod.ZodOptional<zod.ZodString>;
+    source_account: zod.ZodOptional<zod.ZodString>;
+    destination_account: zod.ZodOptional<zod.ZodString>;
+    entity_id: zod.ZodOptional<zod.ZodString>;
+  }, zod_v4_core0.$loose>>;
+  page: zod.ZodOptional<zod.ZodObject<{
+    next: zod.ZodOptional<zod.ZodString>;
+  }, zod_v4_core0.$strip>>;
+}, zod_v4_core0.$strip>, readonly [_keystrokehq_core0.CredentialSet<"ramp", zod.ZodObject<{
+  RAMP_ACCESS_TOKEN: zod.ZodString;
+}, zod_v4_core0.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<zod.ZodObject<{
+  RAMP_ACCESS_TOKEN: zod.ZodString;
+}, zod_v4_core0.$strip>>[] | undefined>], undefined>;
+declare const getTransfer: _keystrokehq_core0.Operation<zod.ZodObject<{
+  transferId: zod.ZodString;
+}, zod_v4_core0.$strip>, zod.ZodObject<{
+  id: zod.ZodString;
+  amount: zod.ZodOptional<zod.ZodObject<{
+    amountCents: zod.ZodNumber;
+    currency: zod.ZodString;
+  }, zod_v4_core0.$strip>>;
+  status: zod.ZodOptional<zod.ZodEnum<{
+    PENDING: "PENDING";
+    CANCELED: "CANCELED";
+    FAILED: "FAILED";
+    PROCESSING: "PROCESSING";
+    COMPLETED: "COMPLETED";
+  }>>;
+  created_at: zod.ZodOptional<zod.ZodString>;
+  settled_at: zod.ZodOptional<zod.ZodString>;
+  source_account: zod.ZodOptional<zod.ZodString>;
+  destination_account: zod.ZodOptional<zod.ZodString>;
+  entity_id: zod.ZodOptional<zod.ZodString>;
+}, zod_v4_core0.$loose>, readonly [_keystrokehq_core0.CredentialSet<"ramp", zod.ZodObject<{
+  RAMP_ACCESS_TOKEN: zod.ZodString;
+}, zod_v4_core0.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<zod.ZodObject<{
+  RAMP_ACCESS_TOKEN: zod.ZodString;
+}, zod_v4_core0.$strip>>[] | undefined>], undefined>;
+//#endregion
+export { getTransfer, listTransfers };

package/dist/transfers.mjs

@@ -0,0 +1,36 @@
+import { createRampClient } from "./client.mjs";
+import { a as rampTransferGetInputSchema, c as rampTransferSchema, o as rampTransferListInputSchema, s as rampTransferListSchema } from "./transfers-WBQZVdGP.mjs";
+import { t as rampOperation } from "./factory-Da6YVHdL.mjs";
+import { t as omitUndefined } from "./shared-CTTtP5gv.mjs";
+
+//#region src/transfers.ts
+const listTransfers = rampOperation({
+	id: "list_transfers",
+	name: "List Transfers",
+	description: "List funding transfers between the connected Ramp business and external accounts.",
+	input: rampTransferListInputSchema,
+	output: rampTransferListSchema,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampTransferListSchema.parse(await client.request("/transfers", { query: omitUndefined({
+			entity_id: input.entity_id,
+			status: input.status,
+			page_size: input.pageSize,
+			start: input.cursor
+		}) }));
+	}
+});
+const getTransfer = rampOperation({
+	id: "get_transfer",
+	name: "Get Transfer",
+	description: "Fetch a transfer by id.",
+	input: rampTransferGetInputSchema,
+	output: rampTransferSchema,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampTransferSchema.parse(await client.request(`/transfers/${encodeURIComponent(input.transferId)}`));
+	}
+});
+
+//#endregion
+export { getTransfer, listTransfers };

package/dist/triggers/index.d.mts

@@ -0,0 +1,81 @@
+import { i as ramp } from "../integration-Dd6tOtSy.mjs";
+import { n as rampAppCredentialSet } from "../provider-app-JO525h-N.mjs";
+import { c as rampWebhookEventEnvelopeSchema } from "../webhook-sde3Ui2N.mjs";
+import { toRampWebhookEvent } from "../events.mjs";
+import { E as rampUserSchema, Ft as rampSpendRequestSchema, Kt as rampBillSchema, R as rampTransferSchema, W as rampTransactionSchema, X as rampReimbursementSchema, h as rampVendorSchema, it as rampApplicationSchema, lt as rampPurchaseOrderSchema, mt as rampUnifiedRequestSchema } from "../vendors-B7DQrlAn.mjs";
+import { z } from "zod";
+import { BoundTrigger, WebhookRequest } from "@keystrokehq/core";
+import { IntegrationTriggerBindingFactory, IntegrationTriggerBindingOptions, createWebhookTriggerBindingFactory } from "@keystrokehq/integration-authoring";
+import { PollingTriggerManifest, WebhookTriggerManifest } from "@keystrokehq/core/trigger";
+
+//#region src/triggers/polling-bindings.d.ts
+type RampPollResponse<TItemSchema extends z.ZodTypeAny> = {
+  data: z.output<TItemSchema>[];
+};
+type RampPollingBindingFactory<TItemSchema extends z.ZodTypeAny> = IntegrationTriggerBindingFactory<RampPollResponse<TItemSchema>, readonly [typeof ramp], PollingTriggerManifest, RampPollResponse<TItemSchema>>;
+declare const pollTransactions: RampPollingBindingFactory<typeof rampTransactionSchema>;
+declare const pollUsers: RampPollingBindingFactory<typeof rampUserSchema>;
+declare const pollBills: RampPollingBindingFactory<typeof rampBillSchema>;
+declare const pollVendors: RampPollingBindingFactory<typeof rampVendorSchema>;
+declare const pollReimbursements: RampPollingBindingFactory<typeof rampReimbursementSchema>;
+declare const pollSpendRequests: RampPollingBindingFactory<typeof rampSpendRequestSchema>;
+declare const pollPurchaseOrders: RampPollingBindingFactory<typeof rampPurchaseOrderSchema>;
+declare const pollApplications: RampPollingBindingFactory<typeof rampApplicationSchema>;
+declare const pollUnifiedRequests: RampPollingBindingFactory<typeof rampUnifiedRequestSchema>;
+declare const pollTransfers: RampPollingBindingFactory<typeof rampTransferSchema>;
+//#endregion
+//#region src/triggers/shared.d.ts
+type RampWebhookCredentialSets = readonly [typeof ramp, typeof rampAppCredentialSet];
+type RampWebhookBindingOptions<TOutput> = IntegrationTriggerBindingOptions<RampWebhookEvent, TOutput, WebhookRequest>;
+type RampWebhookBoundTrigger<TOutput> = BoundTrigger<z.output<typeof rampWebhookEventEnvelopeSchema>, RampWebhookCredentialSets, WebhookTriggerManifest, TOutput, WebhookRequest>;
+type RampWebhookEvent = ReturnType<typeof toRampWebhookEvent>;
+declare function createRampWebhookBinding(defaultName: string, defaultDescription: string, eventTypeMatches: (eventType: string) => boolean): ReturnType<typeof createWebhookTriggerBindingFactory<typeof rampWebhookEventEnvelopeSchema, RampWebhookEvent, RampWebhookCredentialSets>>;
+//#endregion
+//#region src/triggers/webhook-bindings.d.ts
+type Binding = <TOutput = RampWebhookEvent>(options?: IntegrationTriggerBindingOptions<RampWebhookEvent, TOutput, WebhookRequest>) => RampWebhookBoundTrigger<TOutput>;
+/**
+ * Ramp webhook namespace.
+ *
+ * Contains only currently-documented webhook events (15 specific + 6 coarse
+ * `any*` helpers) as of 2026-04-17. See IMPLEMENTATION_NOTES.md § 7 Q2 for
+ * the rationale behind this catalog (PLAN.md mentioned many additional
+ * events that are not currently published by Ramp).
+ */
+declare const webhooks: Readonly<{
+  transactions: Readonly<{
+    authorized: Binding;
+    cleared: Binding;
+    declined: Binding;
+    updated: Binding;
+    any: Binding;
+  }>;
+  bills: Readonly<{
+    approved: Binding;
+    paid: Binding;
+    created: Binding;
+    canceled: Binding;
+    any: Binding;
+  }>;
+  purchaseOrders: Readonly<{
+    created: Binding;
+    approved: Binding;
+    denied: Binding;
+    any: Binding;
+  }>;
+  spendRequests: Readonly<{
+    commentCreated: Binding;
+    any: Binding;
+  }>;
+  applications: Readonly<{
+    approved: Binding;
+    denied: Binding;
+    any: Binding;
+  }>;
+  unifiedRequests: Readonly<{
+    updated: Binding;
+    any: Binding;
+  }>;
+}>;
+type RampWebhooksNamespace = typeof webhooks;
+//#endregion
+export { type RampWebhookBindingOptions, type RampWebhookBoundTrigger, type RampWebhookCredentialSets, type RampWebhookEvent, type RampWebhooksNamespace, createRampWebhookBinding, pollApplications, pollBills, pollPurchaseOrders, pollReimbursements, pollSpendRequests, pollTransactions, pollTransfers, pollUnifiedRequests, pollUsers, pollVendors, webhooks };

package/dist/triggers/index.mjs

@@ -0,0 +1,199 @@
+import { a as rampAppCredentialSet, n as ramp } from "../integration-BGliAxAS.mjs";
+import { createRampClient } from "../client.mjs";
+import { l as rampBillSchema } from "../bills-B8W9et3K.mjs";
+import { h as rampSpendRequestSchema } from "../business-CztnWUvt.mjs";
+import { i as rampApplicationSchema, l as rampPurchaseOrderSchema, m as rampUnifiedRequestSchema } from "../new-resources-BBJsJEjT.mjs";
+import { i as rampReimbursementSchema } from "../reimbursements-OknrZUMF.mjs";
+import { i as rampTransactionSchema } from "../transactions-Djd0oIGK.mjs";
+import { c as rampTransferSchema } from "../transfers-WBQZVdGP.mjs";
+import { c as rampUserSchema } from "../users-ufcXrfNK.mjs";
+import { p as rampVendorSchema } from "../vendors-Bx1cgXwC.mjs";
+import { a as rampWebhookEventEnvelopeSchema } from "../webhook-CsbvcgrC.mjs";
+import { toRampWebhookEvent } from "../events.mjs";
+import { verifyRampWebhookRequest } from "../verification.mjs";
+import { z } from "zod";
+import { createPollingTriggerBindingFactory, createWebhookTriggerBindingFactory } from "@keystrokehq/integration-authoring";
+
+//#region src/triggers/polling-bindings.ts
+/**
+* Polling triggers compensate for gaps in Ramp's native webhook catalog. Each
+* binding polls a canonical list endpoint on a conservative cadence (5m) and
+* emits one event per resource id discovered since the last poll.
+*/
+const RAMP_CREDENTIAL_SETS = [ramp];
+function responseShape(item) {
+	return z.object({ data: z.array(item) });
+}
+function pollListEndpoint(path, itemSchema, queryBuilder) {
+	return async (ctx) => {
+		const client = createRampClient(ctx.credentials.ramp);
+		const query = queryBuilder ? queryBuilder(ctx.lastPolledAt) : {};
+		const filtered = Object.fromEntries(Object.entries(query).filter(([, v]) => v !== void 0));
+		return { data: ((await client.request(path, { query: filtered }))?.data ?? []).map((item) => itemSchema.parse(item)) };
+	};
+}
+const pollTransactions = createPollingTriggerBindingFactory({
+	defaultName: "Ramp Poll Transactions",
+	defaultDescription: "Polls /transactions every 5 minutes and emits new rows.",
+	schedule: "*/5 * * * *",
+	response: responseShape(rampTransactionSchema),
+	credentialSets: RAMP_CREDENTIAL_SETS,
+	poll: pollListEndpoint("/transactions", rampTransactionSchema, (lastPolledAt) => ({
+		from_date: lastPolledAt,
+		page_size: 100
+	}))
+});
+const pollUsers = createPollingTriggerBindingFactory({
+	defaultName: "Ramp Poll Users",
+	defaultDescription: "Polls /users every hour to surface new or updated users.",
+	schedule: "0 * * * *",
+	response: responseShape(rampUserSchema),
+	credentialSets: RAMP_CREDENTIAL_SETS,
+	poll: pollListEndpoint("/users", rampUserSchema, () => ({ page_size: 100 }))
+});
+const pollBills = createPollingTriggerBindingFactory({
+	defaultName: "Ramp Poll Bills",
+	defaultDescription: "Polls /bills every 5 minutes for newly-created or updated bills.",
+	schedule: "*/5 * * * *",
+	response: responseShape(rampBillSchema),
+	credentialSets: RAMP_CREDENTIAL_SETS,
+	poll: pollListEndpoint("/bills", rampBillSchema, () => ({ page_size: 100 }))
+});
+const pollVendors = createPollingTriggerBindingFactory({
+	defaultName: "Ramp Poll Vendors",
+	defaultDescription: "Polls /vendors hourly to surface new vendors.",
+	schedule: "0 * * * *",
+	response: responseShape(rampVendorSchema),
+	credentialSets: RAMP_CREDENTIAL_SETS,
+	poll: pollListEndpoint("/vendors", rampVendorSchema, () => ({ page_size: 100 }))
+});
+const pollReimbursements = createPollingTriggerBindingFactory({
+	defaultName: "Ramp Poll Reimbursements",
+	defaultDescription: "Polls /reimbursements every 5 minutes.",
+	schedule: "*/5 * * * *",
+	response: responseShape(rampReimbursementSchema),
+	credentialSets: RAMP_CREDENTIAL_SETS,
+	poll: pollListEndpoint("/reimbursements", rampReimbursementSchema, (lastPolledAt) => ({
+		from_date: lastPolledAt,
+		page_size: 100
+	}))
+});
+const pollSpendRequests = createPollingTriggerBindingFactory({
+	defaultName: "Ramp Poll Spend Requests",
+	defaultDescription: "Polls /spend-requests every 5 minutes.",
+	schedule: "*/5 * * * *",
+	response: responseShape(rampSpendRequestSchema),
+	credentialSets: RAMP_CREDENTIAL_SETS,
+	poll: pollListEndpoint("/spend-requests", rampSpendRequestSchema, () => ({ page_size: 100 }))
+});
+const pollPurchaseOrders = createPollingTriggerBindingFactory({
+	defaultName: "Ramp Poll Purchase Orders",
+	defaultDescription: "Polls /purchase-orders every 5 minutes.",
+	schedule: "*/5 * * * *",
+	response: responseShape(rampPurchaseOrderSchema),
+	credentialSets: RAMP_CREDENTIAL_SETS,
+	poll: pollListEndpoint("/purchase-orders", rampPurchaseOrderSchema, () => ({ page_size: 100 }))
+});
+const pollApplications = createPollingTriggerBindingFactory({
+	defaultName: "Ramp Poll Applications",
+	defaultDescription: "Polls /applications every 10 minutes for workflow requests.",
+	schedule: "*/10 * * * *",
+	response: responseShape(rampApplicationSchema),
+	credentialSets: RAMP_CREDENTIAL_SETS,
+	poll: pollListEndpoint("/applications", rampApplicationSchema, () => ({ page_size: 100 }))
+});
+const pollUnifiedRequests = createPollingTriggerBindingFactory({
+	defaultName: "Ramp Poll Unified Requests",
+	defaultDescription: "Polls /unified-requests every 10 minutes.",
+	schedule: "*/10 * * * *",
+	response: responseShape(rampUnifiedRequestSchema),
+	credentialSets: RAMP_CREDENTIAL_SETS,
+	poll: pollListEndpoint("/unified-requests", rampUnifiedRequestSchema, () => ({ page_size: 100 }))
+});
+const pollTransfers = createPollingTriggerBindingFactory({
+	defaultName: "Ramp Poll Transfers",
+	defaultDescription: "Polls /transfers every 15 minutes.",
+	schedule: "*/15 * * * *",
+	response: responseShape(rampTransferSchema),
+	credentialSets: RAMP_CREDENTIAL_SETS,
+	poll: pollListEndpoint("/transfers", rampTransferSchema, () => ({ page_size: 100 }))
+});
+
+//#endregion
+//#region src/triggers/shared.ts
+function createRampWebhookBinding(defaultName, defaultDescription, eventTypeMatches) {
+	return createWebhookTriggerBindingFactory({
+		defaultName,
+		defaultDescription,
+		path: "/ramp",
+		method: "POST",
+		payload: rampWebhookEventEnvelopeSchema,
+		credentialSets: [ramp, rampAppCredentialSet],
+		verify: (request, ctx) => {
+			const { webhookSecret } = ctx.credentials["ramp-app"];
+			if (!webhookSecret) throw new Error("Ramp webhook secret is not configured. Set KEYSTROKE_PLATFORM_RAMP_WEBHOOK_SECRET after registering a webhook subscription.");
+			if (!verifyRampWebhookRequest(request, webhookSecret)) throw new Error("Invalid Ramp webhook signature.");
+		},
+		definitionFilter: (payload) => eventTypeMatches(payload.type),
+		mapPayload: (payload) => toRampWebhookEvent(payload),
+		idempotencyKey: (_payload, mappedPayload) => mappedPayload?.id,
+		response: { successStatus: 200 }
+	});
+}
+
+//#endregion
+//#region src/triggers/webhook-bindings.ts
+function exact(eventType) {
+	const bind = createRampWebhookBinding(`Ramp ${eventType}`, `Ramp ${eventType} event`, (type) => type === eventType);
+	return (options) => bind(options);
+}
+function prefix(name, description, prefixStr) {
+	const bind = createRampWebhookBinding(name, description, (type) => type.startsWith(prefixStr));
+	return (options) => bind(options);
+}
+/**
+* Ramp webhook namespace.
+*
+* Contains only currently-documented webhook events (15 specific + 6 coarse
+* `any*` helpers) as of 2026-04-17. See IMPLEMENTATION_NOTES.md § 7 Q2 for
+* the rationale behind this catalog (PLAN.md mentioned many additional
+* events that are not currently published by Ramp).
+*/
+const webhooks = Object.freeze({
+	transactions: Object.freeze({
+		authorized: exact("transactions.authorized"),
+		cleared: exact("transactions.cleared"),
+		declined: exact("transactions.declined"),
+		updated: exact("transactions.updated"),
+		any: prefix("Ramp Any Transaction Event", "Any transaction.* webhook (authorized/cleared/declined/updated)", "transactions.")
+	}),
+	bills: Object.freeze({
+		approved: exact("bills.approved"),
+		paid: exact("bills.paid"),
+		created: exact("bills.created"),
+		canceled: exact("bills.canceled"),
+		any: prefix("Ramp Any Bill Event", "Any bills.* webhook (approved/paid/created/canceled)", "bills.")
+	}),
+	purchaseOrders: Object.freeze({
+		created: exact("purchase_orders.created"),
+		approved: exact("purchase_orders.approved"),
+		denied: exact("purchase_orders.denied"),
+		any: prefix("Ramp Any Purchase Order Event", "Any purchase_orders.* webhook", "purchase_orders.")
+	}),
+	spendRequests: Object.freeze({
+		commentCreated: exact("spend_requests.comment_created"),
+		any: prefix("Ramp Any Spend Request Event", "Any spend_requests.* webhook", "spend_requests.")
+	}),
+	applications: Object.freeze({
+		approved: exact("applications.approved"),
+		denied: exact("applications.denied"),
+		any: prefix("Ramp Any Application Event", "Any applications.* webhook", "applications.")
+	}),
+	unifiedRequests: Object.freeze({
+		updated: exact("unified_requests.updated"),
+		any: prefix("Ramp Any Unified Request Event", "Any unified_requests.* webhook", "unified_requests.")
+	})
+});
+
+//#endregion
+export { createRampWebhookBinding, pollApplications, pollBills, pollPurchaseOrders, pollReimbursements, pollSpendRequests, pollTransactions, pollTransfers, pollUnifiedRequests, pollUsers, pollVendors, webhooks };

package/dist/unified-requests.d.mts

@@ -0,0 +1,67 @@
+import * as zod from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+import * as zod_v4_core0 from "zod/v4/core";
+
+//#region src/unified-requests.d.ts
+declare const listUnifiedRequests: _keystrokehq_core0.Operation<zod.ZodObject<{
+  status: zod.ZodOptional<zod.ZodEnum<{
+    PENDING: "PENDING";
+    APPROVED: "APPROVED";
+    CANCELED: "CANCELED";
+    DENIED: "DENIED";
+    FULFILLED: "FULFILLED";
+  }>>;
+  request_type: zod.ZodOptional<zod.ZodString>;
+  user_id: zod.ZodOptional<zod.ZodString>;
+  pageSize: zod.ZodOptional<zod.ZodNumber>;
+  cursor: zod.ZodOptional<zod.ZodString>;
+}, zod_v4_core0.$strip>, zod.ZodObject<{
+  data: zod.ZodArray<zod.ZodObject<{
+    id: zod.ZodString;
+    status: zod.ZodOptional<zod.ZodEnum<{
+      PENDING: "PENDING";
+      APPROVED: "APPROVED";
+      CANCELED: "CANCELED";
+      DENIED: "DENIED";
+      FULFILLED: "FULFILLED";
+    }>>;
+    request_type: zod.ZodOptional<zod.ZodString>;
+    user_id: zod.ZodOptional<zod.ZodString>;
+    created_at: zod.ZodOptional<zod.ZodString>;
+    updated_at: zod.ZodOptional<zod.ZodString>;
+    resource_id: zod.ZodOptional<zod.ZodString>;
+    resource_type: zod.ZodOptional<zod.ZodString>;
+  }, zod_v4_core0.$loose>>;
+  page: zod.ZodOptional<zod.ZodObject<{
+    next: zod.ZodOptional<zod.ZodString>;
+  }, zod_v4_core0.$strip>>;
+}, zod_v4_core0.$strip>, readonly [_keystrokehq_core0.CredentialSet<"ramp", zod.ZodObject<{
+  RAMP_ACCESS_TOKEN: zod.ZodString;
+}, zod_v4_core0.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<zod.ZodObject<{
+  RAMP_ACCESS_TOKEN: zod.ZodString;
+}, zod_v4_core0.$strip>>[] | undefined>], undefined>;
+declare const getUnifiedRequest: _keystrokehq_core0.Operation<zod.ZodObject<{
+  unifiedRequestId: zod.ZodString;
+}, zod_v4_core0.$strip>, zod.ZodObject<{
+  id: zod.ZodString;
+  status: zod.ZodOptional<zod.ZodEnum<{
+    PENDING: "PENDING";
+    APPROVED: "APPROVED";
+    CANCELED: "CANCELED";
+    DENIED: "DENIED";
+    FULFILLED: "FULFILLED";
+  }>>;
+  request_type: zod.ZodOptional<zod.ZodString>;
+  user_id: zod.ZodOptional<zod.ZodString>;
+  created_at: zod.ZodOptional<zod.ZodString>;
+  updated_at: zod.ZodOptional<zod.ZodString>;
+  resource_id: zod.ZodOptional<zod.ZodString>;
+  resource_type: zod.ZodOptional<zod.ZodString>;
+}, zod_v4_core0.$loose>, readonly [_keystrokehq_core0.CredentialSet<"ramp", zod.ZodObject<{
+  RAMP_ACCESS_TOKEN: zod.ZodString;
+}, zod_v4_core0.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<zod.ZodObject<{
+  RAMP_ACCESS_TOKEN: zod.ZodString;
+}, zod_v4_core0.$strip>>[] | undefined>], undefined>;
+//#endregion
+export { getUnifiedRequest, listUnifiedRequests };

package/dist/unified-requests.mjs

@@ -0,0 +1,37 @@
+import { createRampClient } from "./client.mjs";
+import { d as rampUnifiedRequestGetInputSchema, f as rampUnifiedRequestListInputSchema, m as rampUnifiedRequestSchema, p as rampUnifiedRequestListSchema } from "./new-resources-BBJsJEjT.mjs";
+import { t as rampOperation } from "./factory-Da6YVHdL.mjs";
+import { t as omitUndefined } from "./shared-CTTtP5gv.mjs";
+
+//#region src/unified-requests.ts
+const listUnifiedRequests = rampOperation({
+	id: "list_unified_requests",
+	name: "List Unified Requests",
+	description: "List Ramp \"unified requests\" — the normalised request object spanning spend requests, bills, applications, and purchase orders.",
+	input: rampUnifiedRequestListInputSchema,
+	output: rampUnifiedRequestListSchema,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampUnifiedRequestListSchema.parse(await client.request("/unified-requests", { query: omitUndefined({
+			status: input.status,
+			request_type: input.request_type,
+			user_id: input.user_id,
+			page_size: input.pageSize,
+			start: input.cursor
+		}) }));
+	}
+});
+const getUnifiedRequest = rampOperation({
+	id: "get_unified_request",
+	name: "Get Unified Request",
+	description: "Fetch a unified request by id.",
+	input: rampUnifiedRequestGetInputSchema,
+	output: rampUnifiedRequestSchema,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampUnifiedRequestSchema.parse(await client.request(`/unified-requests/${encodeURIComponent(input.unifiedRequestId)}`));
+	}
+});
+
+//#endregion
+export { getUnifiedRequest, listUnifiedRequests };