@keystrokehq/ramp 0.0.1

package/dist/cards.mjs

@@ -0,0 +1,166 @@
+import { createRampClient } from "./client.mjs";
+import { _ as rampTerminateCardInputSchema, a as rampCardListSchema, d as rampCardSchema, g as rampSuspendCardInputSchema, h as rampCreateVirtualCardInputSchema, i as rampCardListInputSchema, m as rampCreatePhysicalCardInputSchema, n as rampCardFundTransferSchema, p as rampCardUpdateInputSchema, r as rampCardGetInputSchema, v as rampUnsuspendCardInputSchema } from "./cards-BfgPcR38.mjs";
+import { t as rampDeferredTaskSchema } from "./users-ufcXrfNK.mjs";
+import { t as rampOperation } from "./factory-Da6YVHdL.mjs";
+import { t as omitUndefined } from "./shared-CTTtP5gv.mjs";
+import { z } from "zod";
+
+//#region src/cards.ts
+const listCards = rampOperation({
+	id: "list_cards",
+	name: "List Cards",
+	description: "List Ramp cards, optionally filtered by cardholder, entity, card program, or state.",
+	input: rampCardListInputSchema,
+	output: rampCardListSchema,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		const query = omitUndefined({
+			cardholder_id: input.cardholder_id,
+			entity_id: input.entity_id,
+			state: input.state,
+			card_program_id: input.card_program_id,
+			page_size: input.pageSize,
+			start: input.cursor
+		});
+		return rampCardListSchema.parse(await client.request("/cards", { query }));
+	}
+});
+const getCard = rampOperation({
+	id: "get_card",
+	name: "Get Card",
+	description: "Fetch a Ramp card by id.",
+	input: rampCardGetInputSchema,
+	output: rampCardSchema,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampCardSchema.parse(await client.request(`/cards/${encodeURIComponent(input.cardId)}`));
+	}
+});
+const createVirtualCard = rampOperation({
+	id: "create_virtual_card",
+	name: "Create Virtual Card",
+	description: "Create a new virtual Ramp card for an existing user.",
+	input: rampCreateVirtualCardInputSchema,
+	output: rampDeferredTaskSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		const { idempotency_key, ...body } = input;
+		return rampDeferredTaskSchema.parse(await client.request("/cards/deferred/virtual", {
+			method: "POST",
+			body,
+			...idempotency_key !== void 0 ? { idempotencyKey: idempotency_key } : {}
+		}));
+	}
+});
+const createPhysicalCard = rampOperation({
+	id: "create_physical_card",
+	name: "Create Physical Card",
+	description: "Order a physical Ramp card for an existing user.",
+	input: rampCreatePhysicalCardInputSchema,
+	output: rampDeferredTaskSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		const { idempotency_key, ...body } = input;
+		return rampDeferredTaskSchema.parse(await client.request("/cards/deferred/physical", {
+			method: "POST",
+			body,
+			...idempotency_key !== void 0 ? { idempotencyKey: idempotency_key } : {}
+		}));
+	}
+});
+const updateCard = rampOperation({
+	id: "update_card",
+	name: "Update Card",
+	description: "Update display name or spending restrictions on an existing Ramp card.",
+	input: rampCardUpdateInputSchema,
+	output: rampCardSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		const { cardId, ...body } = input;
+		await client.request(`/cards/${encodeURIComponent(cardId)}`, {
+			method: "PATCH",
+			body: omitUndefined(body)
+		});
+		return rampCardSchema.parse(await client.request(`/cards/${encodeURIComponent(cardId)}`));
+	}
+});
+const suspendCard = rampOperation({
+	id: "suspend_card",
+	name: "Suspend Card",
+	description: "Temporarily suspend a Ramp card. Issues a deferred task.",
+	input: rampSuspendCardInputSchema,
+	output: rampDeferredTaskSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampDeferredTaskSchema.parse(await client.request(`/cards/${encodeURIComponent(input.cardId)}/deferred/suspension`, {
+			method: "POST",
+			body: {}
+		}));
+	}
+});
+const unsuspendCard = rampOperation({
+	id: "unsuspend_card",
+	name: "Unsuspend Card",
+	description: "Restore a previously suspended Ramp card. Issues a deferred task.",
+	input: rampUnsuspendCardInputSchema,
+	output: rampDeferredTaskSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampDeferredTaskSchema.parse(await client.request(`/cards/${encodeURIComponent(input.cardId)}/deferred/unsuspension`, {
+			method: "POST",
+			body: {}
+		}));
+	}
+});
+const terminateCard = rampOperation({
+	id: "terminate_card",
+	name: "Terminate Card",
+	description: "Permanently terminate a Ramp card. This is irreversible.",
+	input: rampTerminateCardInputSchema,
+	output: rampDeferredTaskSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		const { cardId, idempotency_key } = input;
+		return rampDeferredTaskSchema.parse(await client.request(`/cards/${encodeURIComponent(cardId)}/deferred/termination`, {
+			method: "POST",
+			body: {},
+			...idempotency_key !== void 0 ? { idempotencyKey: idempotency_key } : {}
+		}));
+	}
+});
+const listCardFundTransfers = rampOperation({
+	id: "list_card_fund_transfers",
+	name: "List Card Fund Transfers",
+	description: "List fund transfers associated with Ramp cards.",
+	input: z.object({
+		card_id: z.string().trim().min(1).optional(),
+		pageSize: z.number().int().positive().max(100).optional(),
+		cursor: z.string().trim().min(1).optional()
+	}),
+	output: z.object({
+		data: z.array(rampCardFundTransferSchema),
+		page: z.object({ next: z.string().optional() }).optional()
+	}),
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		const query = omitUndefined({
+			card_id: input.card_id,
+			page_size: input.pageSize,
+			start: input.cursor
+		});
+		const response = await client.request("/card-fund-transfers", { query });
+		return {
+			data: (response?.data ?? []).map((item) => rampCardFundTransferSchema.parse(item)),
+			...response?.page !== void 0 ? { page: response.page } : {}
+		};
+	}
+});
+
+//#endregion
+export { createPhysicalCard, createVirtualCard, getCard, listCardFundTransfers, listCards, suspendCard, terminateCard, unsuspendCard, updateCard };

package/dist/cashbacks.d.mts

@@ -0,0 +1,46 @@
+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/cashbacks.d.ts
+declare const listCashbacks: _keystrokehq_core0.Operation<zod.ZodObject<{
+  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.ZodString>;
+    granted_date: 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 getCashback: _keystrokehq_core0.Operation<zod.ZodObject<{
+  cashbackId: 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.ZodString>;
+  granted_date: 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 { getCashback, listCashbacks };

package/dist/cashbacks.mjs

@@ -0,0 +1,34 @@
+import { createRampClient } from "./client.mjs";
+import { i as rampCashbackSchema, n as rampCashbackListInputSchema, r as rampCashbackListSchema, t as rampCashbackGetInputSchema } from "./transfers-WBQZVdGP.mjs";
+import { t as rampOperation } from "./factory-Da6YVHdL.mjs";
+import { t as omitUndefined } from "./shared-CTTtP5gv.mjs";
+
+//#region src/cashbacks.ts
+const listCashbacks = rampOperation({
+	id: "list_cashbacks",
+	name: "List Cashbacks",
+	description: "List cashback credits granted to the connected Ramp business.",
+	input: rampCashbackListInputSchema,
+	output: rampCashbackListSchema,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampCashbackListSchema.parse(await client.request("/cashbacks", { query: omitUndefined({
+			page_size: input.pageSize,
+			start: input.cursor
+		}) }));
+	}
+});
+const getCashback = rampOperation({
+	id: "get_cashback",
+	name: "Get Cashback",
+	description: "Fetch a cashback credit by id.",
+	input: rampCashbackGetInputSchema,
+	output: rampCashbackSchema,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampCashbackSchema.parse(await client.request(`/cashbacks/${encodeURIComponent(input.cashbackId)}`));
+	}
+});
+
+//#endregion
+export { getCashback, listCashbacks };

package/dist/client.d.mts

@@ -0,0 +1,79 @@
+import { n as RampCredentials } from "./integration-Dd6tOtSy.mjs";
+import { t as RampErrorKind } from "./errors-Sm92tugz.mjs";
+
+//#region src/client.d.ts
+declare const RAMP_API_HOSTS: {
+  readonly production: "https://api.ramp.com";
+  readonly sandbox: "https://demo-api.ramp.com";
+};
+type RampEnvironment = keyof typeof RAMP_API_HOSTS;
+type Primitive = string | number | boolean;
+type QueryValue = Primitive | readonly Primitive[] | null | undefined;
+interface RampQuery {
+  readonly [key: string]: QueryValue;
+}
+interface RampRequestOptions {
+  readonly method?: 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';
+  readonly body?: unknown;
+  readonly query?: RampQuery;
+  readonly idempotencyKey?: string;
+  /** Signal a multipart upload. `body` must be a `FormData` instance. */
+  readonly multipart?: boolean;
+  /** When true, the raw Response is returned instead of the parsed body. */
+  readonly raw?: boolean;
+  readonly timeoutMs?: number;
+  readonly headers?: Record<string, string>;
+}
+interface RampClientOptions {
+  readonly environment?: RampEnvironment;
+  readonly fetchImpl?: typeof fetch;
+  readonly timeoutMs?: number;
+  readonly maxRetries?: number;
+  readonly now?: () => number;
+  /** Hook for tests: sleeps between retries. */
+  readonly sleep?: (ms: number) => Promise<void>;
+}
+/**
+ * Structured Ramp error. The `kind` discriminator tells downstream consumers
+ * how to react (retry, prompt re-auth, surface validation message, etc.).
+ */
+declare class RampApiError extends Error {
+  readonly kind: RampErrorKind;
+  readonly status: number;
+  readonly body: unknown;
+  readonly errorCode?: string;
+  readonly retryAfterMs?: number;
+  constructor(init: {
+    kind: RampErrorKind;
+    status: number;
+    message: string;
+    body?: unknown;
+    errorCode?: string;
+    retryAfterMs?: number;
+    cause?: unknown;
+  });
+}
+/**
+ * Thrown when a Ramp operation requires an OAuth scope that was not granted
+ * to the connected app (including scopes Ramp has not yet published).
+ */
+declare class RampMissingScopeError extends Error {
+  readonly requiredScope: string;
+  readonly operation: string;
+  constructor(operation: string, requiredScope: string, detail?: string);
+}
+declare function createRampApiClient(accessToken: string, options?: RampClientOptions): RampApiClient;
+interface RampApiClient {
+  request<T = unknown>(path: string, init?: RampRequestOptions): Promise<T>;
+  paginate<TItem>(path: string, init?: Omit<RampRequestOptions, 'method'> & {
+    readonly pageSize?: number;
+  }): AsyncGenerator<TItem, void, void>;
+  readonly environment: RampEnvironment;
+}
+/**
+ * Public factory — callers normally use {@link createRampClient} below.
+ */
+declare function createRampClient(credentials: RampCredentials, options?: RampClientOptions): RampClient;
+type RampClient = RampApiClient;
+//#endregion
+export { RampApiClient, RampApiError, RampClient, RampClientOptions, RampEnvironment, RampMissingScopeError, RampQuery, RampRequestOptions, createRampApiClient, createRampClient };

package/dist/client.mjs

@@ -0,0 +1,248 @@
+import { n as ramp } from "./integration-BGliAxAS.mjs";
+import { CredentialRevokedError } from "@keystrokehq/core/errors";
+import { createErrorNormalizingProxy } from "@keystrokehq/integration-authoring";
+
+//#region src/client.ts
+const RAMP_API_HOSTS = {
+	production: "https://api.ramp.com",
+	sandbox: "https://demo-api.ramp.com"
+};
+const RAMP_API_BASE_PATH = "/developer/v1";
+const DEFAULT_TIMEOUT_MS = 3e4;
+const MAX_RETRIES = 3;
+const BASE_RETRY_DELAY_MS = 500;
+const CONNECT_HINT = "If you haven't connected Ramp yet, run `keystroke connect ramp`.";
+/**
+* Structured Ramp error. The `kind` discriminator tells downstream consumers
+* how to react (retry, prompt re-auth, surface validation message, etc.).
+*/
+var RampApiError = class extends Error {
+	kind;
+	status;
+	body;
+	errorCode;
+	retryAfterMs;
+	constructor(init) {
+		super(init.message, init.cause !== void 0 ? { cause: init.cause } : void 0);
+		this.name = "RampApiError";
+		this.kind = init.kind;
+		this.status = init.status;
+		this.body = init.body;
+		this.errorCode = init.errorCode;
+		this.retryAfterMs = init.retryAfterMs;
+	}
+};
+/**
+* Thrown when a Ramp operation requires an OAuth scope that was not granted
+* to the connected app (including scopes Ramp has not yet published).
+*/
+var RampMissingScopeError = class extends Error {
+	requiredScope;
+	operation;
+	constructor(operation, requiredScope, detail) {
+		super(`Ramp operation \`${operation}\` requires scope \`${requiredScope}\` which is not available on the connected credential. ${detail ?? ""}`.trim());
+		this.name = "RampMissingScopeError";
+		this.operation = operation;
+		this.requiredScope = requiredScope;
+	}
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function toQueryString(query) {
+	if (!query) return "";
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) {
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) {
+			if (value.length === 0) continue;
+			for (const item of value) params.append(key, String(item));
+			continue;
+		}
+		params.set(key, String(value));
+	}
+	const stringified = params.toString();
+	return stringified.length > 0 ? `?${stringified}` : "";
+}
+function classifyStatus(status, body) {
+	if (status === 401) return "auth_revoked";
+	if (status === 403) return (extractErrorMessage(body)?.toLowerCase() ?? "").includes("scope") ? "missing_scope" : "auth_revoked";
+	if (status === 404) return "not_found";
+	if (status === 409) return "conflict";
+	if (status === 422) return "validation";
+	if (status === 429) return "rate_limited";
+	if (status >= 500) return "server_error";
+	if (status >= 400) return "validation";
+	return "unknown";
+}
+function extractErrorMessage(body) {
+	if (!isRecord(body)) return void 0;
+	const errorV2 = isRecord(body.error_v2) ? body.error_v2 : void 0;
+	if (errorV2 && typeof errorV2.message === "string") return errorV2.message;
+	if (typeof body.message === "string") return body.message;
+	if (typeof body.error === "string") return body.error;
+}
+function extractErrorCode(body) {
+	if (!isRecord(body)) return void 0;
+	const errorV2 = isRecord(body.error_v2) ? body.error_v2 : void 0;
+	if (errorV2 && typeof errorV2.error_code === "string") return errorV2.error_code;
+}
+function parseRetryAfter(headerValue) {
+	if (!headerValue) return void 0;
+	const asNumber = Number(headerValue);
+	if (Number.isFinite(asNumber) && asNumber >= 0) return asNumber * 1e3;
+	const asDate = Date.parse(headerValue);
+	if (!Number.isNaN(asDate)) return Math.max(0, asDate - Date.now());
+}
+async function sleepDefault(ms) {
+	if (ms <= 0) return;
+	await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function shouldRetry(kind, attempt, maxRetries) {
+	if (attempt >= maxRetries) return false;
+	return kind === "rate_limited" || kind === "server_error" || kind === "timeout";
+}
+function isAuthRevoked(error) {
+	return error instanceof RampApiError && error.kind === "auth_revoked";
+}
+function normalizeRampError(error, context) {
+	if (isAuthRevoked(error)) return new CredentialRevokedError(ramp.id, `Ramp authentication failed while calling \`${context.methodPath}\`. The stored credentials for ${ramp.id} may be revoked or expired. ${CONNECT_HINT}`);
+	if (error instanceof RampApiError) return new Error(`Ramp API call failed while calling \`${context.methodPath}\` (${error.status} ${error.kind}): ${error.message}`, { cause: error });
+	if (error instanceof Error) return new Error(`Ramp API call failed while calling \`${context.methodPath}\`: ${error.message}`, { cause: error });
+	return /* @__PURE__ */ new Error(`Ramp API call failed while calling \`${context.methodPath}\`.`);
+}
+function createRampApiClient(accessToken, options = {}) {
+	const environment = options.environment ?? "production";
+	const baseUrl = `${RAMP_API_HOSTS[environment]}${RAMP_API_BASE_PATH}`;
+	const fetchImpl = options.fetchImpl ?? fetch;
+	const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const maxRetries = options.maxRetries ?? MAX_RETRIES;
+	const sleep = options.sleep ?? sleepDefault;
+	async function request(path, init = {}) {
+		const url = `${baseUrl}${path}${toQueryString(init.query)}`;
+		const method = init.method ?? "GET";
+		const headers = {
+			Authorization: `Bearer ${accessToken}`,
+			Accept: "application/json",
+			...init.headers
+		};
+		let body;
+		if (init.body !== void 0) if (init.multipart) {
+			if (!(init.body instanceof FormData)) throw new TypeError("RampApiClient: multipart=true requires body to be a FormData instance");
+			body = init.body;
+		} else {
+			headers["Content-Type"] = "application/json";
+			body = JSON.stringify(init.body);
+		}
+		if (init.idempotencyKey !== void 0) headers["Idempotency-Key"] = init.idempotencyKey;
+		let attempt = 0;
+		for (;;) {
+			const attemptTimeoutMs = init.timeoutMs ?? timeoutMs;
+			const controller = new AbortController();
+			const timer = setTimeout(() => controller.abort(), attemptTimeoutMs);
+			let response;
+			try {
+				response = await fetchImpl(url, {
+					method,
+					headers,
+					...body !== void 0 ? { body } : {},
+					signal: controller.signal
+				});
+			} catch (error) {
+				clearTimeout(timer);
+				const isAbort = error instanceof Error && (error.name === "AbortError" || error.message.includes("aborted"));
+				const kind = isAbort ? "timeout" : "network";
+				if (shouldRetry(kind, attempt, maxRetries)) {
+					attempt += 1;
+					await sleep(BASE_RETRY_DELAY_MS * 2 ** (attempt - 1));
+					continue;
+				}
+				throw new RampApiError({
+					kind,
+					status: 0,
+					message: isAbort ? `Request to \`${path}\` timed out after ${attemptTimeoutMs}ms` : `Request to \`${path}\` failed: ${error.message ?? String(error)}`,
+					cause: error
+				});
+			}
+			clearTimeout(timer);
+			if (init.raw) {
+				if (!response.ok) {
+					const raw = await response.text();
+					throw new RampApiError({
+						kind: classifyStatus(response.status, raw),
+						status: response.status,
+						message: `HTTP ${response.status} for \`${path}\``,
+						body: raw
+					});
+				}
+				return response;
+			}
+			if (response.status === 204) return;
+			const parsedBody = (response.headers.get("content-type") ?? "").includes("application/json") ? await response.json().catch(() => void 0) : await response.text().catch(() => void 0);
+			if (!response.ok) {
+				const kind = classifyStatus(response.status, parsedBody);
+				const message = extractErrorMessage(parsedBody) ?? `HTTP ${response.status}`;
+				const errorCode = extractErrorCode(parsedBody);
+				const retryAfterMs = parseRetryAfter(response.headers.get("retry-after"));
+				if (shouldRetry(kind, attempt, maxRetries)) {
+					attempt += 1;
+					await sleep(retryAfterMs ?? BASE_RETRY_DELAY_MS * 2 ** (attempt - 1));
+					continue;
+				}
+				throw new RampApiError({
+					kind,
+					status: response.status,
+					message,
+					body: parsedBody,
+					errorCode,
+					retryAfterMs
+				});
+			}
+			return parsedBody;
+		}
+	}
+	async function* paginate(path, init = {}) {
+		let cursor;
+		let loops = 0;
+		const hardStop = 1e4;
+		for (;;) {
+			const query = {
+				...init.query ?? {},
+				...cursor !== void 0 ? { start: cursor } : {},
+				...init.pageSize !== void 0 ? { page_size: init.pageSize } : {}
+			};
+			const response = await request(path, {
+				...init,
+				query,
+				method: "GET"
+			});
+			const data = response?.data ?? [];
+			for (const item of data) yield item;
+			const next = response?.page?.next;
+			if (!next) return;
+			cursor = next;
+			loops += 1;
+			if (loops >= hardStop) throw new RampApiError({
+				kind: "unknown",
+				status: 0,
+				message: `Ramp pagination exceeded ${hardStop} pages for \`${path}\` — refusing to continue`
+			});
+		}
+	}
+	return {
+		request,
+		paginate,
+		environment
+	};
+}
+/**
+* Public factory — callers normally use {@link createRampClient} below.
+*/
+function createRampClient(credentials, options = {}) {
+	const accessToken = credentials.RAMP_ACCESS_TOKEN.trim();
+	if (accessToken.length === 0) throw new Error(`Ramp authentication failed during client initialization. ${CONNECT_HINT}`);
+	return createErrorNormalizingProxy(createRampApiClient(accessToken, options), normalizeRampError);
+}
+
+//#endregion
+export { RampApiError, RampMissingScopeError, createRampApiClient, createRampClient };

package/dist/common-CUpmNYXw.mjs

@@ -0,0 +1,64 @@
+import { z } from "zod";
+
+//#region src/schemas/common.ts
+/**
+* Non-empty identifier string, trimmed. Applied to every Ramp resource ID,
+* path parameter, and cursor.
+*/
+const rampIdSchema = z.string().trim().min(1);
+/**
+* ISO-8601 timestamp. Ramp always returns UTC timestamps with `Z` suffix.
+* We validate shape only; downstream mappers convert to `Date` when needed.
+*/
+const rampTimestampSchema = z.string().trim().min(1);
+const rampCurrencyCodeSchema = z.string().trim().length(3).regex(/^[A-Z]{3}$/u, { message: "Currency must be an ISO-4217 3-letter uppercase code" });
+/**
+* Monetary value as surfaced to Keystroke users. Ramp stores amounts as integer
+* cents; we preserve that representation so math stays exact.
+*/
+const rampMoneySchema = z.object({
+	amountCents: z.number().int(),
+	currency: rampCurrencyCodeSchema
+});
+const rampPageCursorSchema = z.string().trim().min(1);
+const rampPageInfoSchema = z.object({ next: z.string().trim().min(1).optional() });
+const rampListPaginationInputSchema = z.object({
+	pageSize: z.number().int().positive().max(100).optional(),
+	cursor: rampPageCursorSchema.optional()
+});
+/**
+* Generic "one resource" envelope. Ramp returns single-resource endpoints as
+* the resource directly (not wrapped), so this is rarely used; we keep it for
+* consistency with list envelopes.
+*/
+function rampResourceEnvelope(itemSchema) {
+	return itemSchema;
+}
+/**
+* Generic `{ data: T[], page: { next } }` list envelope — the canonical Ramp
+* pagination wire shape.
+*/
+function rampListResponseSchema(itemSchema) {
+	return z.object({
+		data: z.array(itemSchema),
+		page: rampPageInfoSchema.optional()
+	});
+}
+/**
+* Ramp list endpoints accept `start`, `end`, `from`, `to`, `since`, and
+* assorted domain-specific date filters. This schema captures the common
+* start/end filter that many endpoints share.
+*/
+const rampDateRangeInputSchema = z.object({
+	start: rampTimestampSchema.optional(),
+	end: rampTimestampSchema.optional()
+});
+/**
+* Ramp "accounting connection" identifier. Not a full resource in all
+* endpoints but referenced widely.
+*/
+const rampAccountingConnectionIdSchema = rampIdSchema;
+const rampMetadataSchema = z.record(z.string(), z.unknown());
+
+//#endregion
+export { rampListPaginationInputSchema as a, rampMoneySchema as c, rampResourceEnvelope as d, rampTimestampSchema as f, rampIdSchema as i, rampPageCursorSchema as l, rampCurrencyCodeSchema as n, rampListResponseSchema as o, rampDateRangeInputSchema as r, rampMetadataSchema as s, rampAccountingConnectionIdSchema as t, rampPageInfoSchema as u };

package/dist/connection.d.mts

@@ -0,0 +1,2 @@
+import { a as rampBundle, i as ramp, n as RampCredentials, o as rampOfficialIntegration, r as RampOAuthScope, t as RAMP_OAUTH_SCOPES } from "./integration-Dd6tOtSy.mjs";
+export { RAMP_OAUTH_SCOPES, type RampCredentials, type RampOAuthScope, ramp, rampBundle, rampOfficialIntegration };

package/dist/connection.mjs

@@ -0,0 +1,3 @@
+import { i as rampOfficialIntegration, n as ramp, r as rampBundle, t as RAMP_OAUTH_SCOPES } from "./integration-BGliAxAS.mjs";
+
+export { RAMP_OAUTH_SCOPES, ramp, rampBundle, rampOfficialIntegration };