@keystrokehq/ramp 0.0.1

package/dist/departments.d.mts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/departments.d.ts
+declare const listDepartments: _keystrokehq_core0.Operation<z.ZodObject<{
+  pageSize: z.ZodOptional<z.ZodNumber>;
+  cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  data: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+  }, z.core.$loose>>;
+  page: z.ZodOptional<z.ZodObject<{
+    next: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"ramp", z.ZodObject<{
+  RAMP_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  RAMP_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const getDepartment: _keystrokehq_core0.Operation<z.ZodObject<{
+  departmentId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>, readonly [_keystrokehq_core0.CredentialSet<"ramp", z.ZodObject<{
+  RAMP_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  RAMP_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const createDepartment: _keystrokehq_core0.Operation<z.ZodObject<{
+  name: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>, readonly [_keystrokehq_core0.CredentialSet<"ramp", z.ZodObject<{
+  RAMP_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  RAMP_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const updateDepartment: _keystrokehq_core0.Operation<z.ZodObject<{
+  departmentId: z.ZodString;
+  name: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>, readonly [_keystrokehq_core0.CredentialSet<"ramp", z.ZodObject<{
+  RAMP_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  RAMP_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const deleteDepartment: _keystrokehq_core0.Operation<z.ZodObject<{
+  departmentId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  success: z.ZodBoolean;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"ramp", z.ZodObject<{
+  RAMP_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  RAMP_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+//#endregion
+export { createDepartment, deleteDepartment, getDepartment, listDepartments, updateDepartment };

package/dist/departments.mjs

@@ -0,0 +1,79 @@
+import { createRampClient } from "./client.mjs";
+import { a as rampDepartmentListSchema, i as rampDepartmentListInputSchema, n as rampDepartmentDeleteInputSchema, o as rampDepartmentSchema, r as rampDepartmentGetInputSchema, s as rampDepartmentUpdateInputSchema, t as rampDepartmentCreateInputSchema } from "./organization-BSaEpvBn.mjs";
+import { t as rampOperation } from "./factory-Da6YVHdL.mjs";
+import { t as omitUndefined } from "./shared-CTTtP5gv.mjs";
+import { z } from "zod";
+
+//#region src/departments.ts
+const listDepartments = rampOperation({
+	id: "list_departments",
+	name: "List Departments",
+	description: "List all departments configured for the connected Ramp business.",
+	input: rampDepartmentListInputSchema,
+	output: rampDepartmentListSchema,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampDepartmentListSchema.parse(await client.request("/departments", { query: omitUndefined({
+			page_size: input.pageSize,
+			start: input.cursor
+		}) }));
+	}
+});
+const getDepartment = rampOperation({
+	id: "get_department",
+	name: "Get Department",
+	description: "Fetch a Ramp department by id.",
+	input: rampDepartmentGetInputSchema,
+	output: rampDepartmentSchema,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampDepartmentSchema.parse(await client.request(`/departments/${encodeURIComponent(input.departmentId)}`));
+	}
+});
+const createDepartment = rampOperation({
+	id: "create_department",
+	name: "Create Department",
+	description: "Create a new department in the Ramp org hierarchy.",
+	input: rampDepartmentCreateInputSchema,
+	output: rampDepartmentSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampDepartmentSchema.parse(await client.request("/departments", {
+			method: "POST",
+			body: input
+		}));
+	}
+});
+const updateDepartment = rampOperation({
+	id: "update_department",
+	name: "Update Department",
+	description: "Rename an existing Ramp department.",
+	input: rampDepartmentUpdateInputSchema,
+	output: rampDepartmentSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		const { departmentId, name } = input;
+		await client.request(`/departments/${encodeURIComponent(departmentId)}`, {
+			method: "PATCH",
+			body: { name }
+		});
+		return rampDepartmentSchema.parse(await client.request(`/departments/${encodeURIComponent(departmentId)}`));
+	}
+});
+const deleteDepartment = rampOperation({
+	id: "delete_department",
+	name: "Delete Department",
+	description: "Delete a Ramp department by id.",
+	input: rampDepartmentDeleteInputSchema,
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, credentials) => {
+		await createRampClient(credentials).request(`/departments/${encodeURIComponent(input.departmentId)}`, { method: "DELETE" });
+		return { success: true };
+	}
+});
+
+//#endregion
+export { createDepartment, deleteDepartment, getDepartment, listDepartments, updateDepartment };

package/dist/entities.d.mts

@@ -0,0 +1,38 @@
+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/entities.d.ts
+declare const listEntities: _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;
+    entity_name: zod.ZodOptional<zod.ZodString>;
+    country_code: zod.ZodOptional<zod.ZodString>;
+    is_primary: zod.ZodOptional<zod.ZodBoolean>;
+  }, 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 getEntity: _keystrokehq_core0.Operation<zod.ZodObject<{
+  entityId: zod.ZodString;
+}, zod_v4_core0.$strip>, zod.ZodObject<{
+  id: zod.ZodString;
+  entity_name: zod.ZodOptional<zod.ZodString>;
+  country_code: zod.ZodOptional<zod.ZodString>;
+  is_primary: zod.ZodOptional<zod.ZodBoolean>;
+}, 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 { getEntity, listEntities };

package/dist/entities.mjs

@@ -0,0 +1,34 @@
+import { createRampClient } from "./client.mjs";
+import { a as rampEntitySchema, i as rampEntityListSchema, n as rampEntityGetInputSchema, r as rampEntityListInputSchema } from "./business-CztnWUvt.mjs";
+import { t as rampOperation } from "./factory-Da6YVHdL.mjs";
+import { t as omitUndefined } from "./shared-CTTtP5gv.mjs";
+
+//#region src/entities.ts
+const listEntities = rampOperation({
+	id: "list_entities",
+	name: "List Entities",
+	description: "List legal entities configured under the connected Ramp business.",
+	input: rampEntityListInputSchema,
+	output: rampEntityListSchema,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampEntityListSchema.parse(await client.request("/entities", { query: omitUndefined({
+			page_size: input.pageSize,
+			start: input.cursor
+		}) }));
+	}
+});
+const getEntity = rampOperation({
+	id: "get_entity",
+	name: "Get Entity",
+	description: "Fetch a Ramp legal entity by id.",
+	input: rampEntityGetInputSchema,
+	output: rampEntitySchema,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampEntitySchema.parse(await client.request(`/entities/${encodeURIComponent(input.entityId)}`));
+	}
+});
+
+//#endregion
+export { getEntity, listEntities };

package/dist/errors-Sm92tugz.d.mts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+
+//#region src/schemas/errors.d.ts
+/**
+ * Ramp returns a fairly consistent error body shape:
+ *   { error_v2: { message, notes, additional_info, error_code } }
+ * or a flattened `{ error: string, message?: string }` for older endpoints.
+ *
+ * We normalize both into a single shape before throwing.
+ */
+declare const rampErrorPayloadSchema: z.ZodObject<{
+  status: z.ZodOptional<z.ZodNumber>;
+  error_v2: z.ZodOptional<z.ZodObject<{
+    message: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    additional_info: z.ZodOptional<z.ZodString>;
+    error_code: z.ZodOptional<z.ZodString>;
+    parameter: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  error: z.ZodOptional<z.ZodString>;
+  message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type RampErrorPayload = z.infer<typeof rampErrorPayloadSchema>;
+/**
+ * Discriminated union of known Ramp failure modes. Emitted by the client to
+ * aid downstream retry/approval logic.
+ */
+declare const rampErrorKindSchema: z.ZodEnum<{
+  unknown: "unknown";
+  network: "network";
+  timeout: "timeout";
+  auth_revoked: "auth_revoked";
+  missing_scope: "missing_scope";
+  rate_limited: "rate_limited";
+  validation: "validation";
+  not_found: "not_found";
+  conflict: "conflict";
+  server_error: "server_error";
+}>;
+type RampErrorKind = z.infer<typeof rampErrorKindSchema>;
+//#endregion
+export { rampErrorPayloadSchema as i, RampErrorPayload as n, rampErrorKindSchema as r, RampErrorKind as t };

package/dist/events.d.mts

@@ -0,0 +1,30 @@
+import { a as RampWebhookEventEnvelope, c as rampWebhookEventEnvelopeSchema, r as RampDocumentedWebhookEventType, t as RAMP_DOCUMENTED_WEBHOOK_EVENT_TYPES } from "./webhook-sde3Ui2N.mjs";
+import { z } from "zod";
+
+//#region src/events.d.ts
+/**
+ * Enumeration of the coarse-grained event families that the package exposes
+ * via the {@link webhooks} namespace. Each family maps to multiple underlying
+ * Ramp event `type` values (e.g. `transactionsAny` covers authorized/cleared/
+ * declined/updated).
+ */
+declare const rampWebhookFamilySchema: z.ZodEnum<{
+  transactions: "transactions";
+  bills: "bills";
+  purchase_orders: "purchase_orders";
+  spend_requests: "spend_requests";
+  applications: "applications";
+  unified_requests: "unified_requests";
+}>;
+type RampWebhookFamily = z.infer<typeof rampWebhookFamilySchema>;
+interface RampWebhookEvent {
+  readonly id: string;
+  readonly type: RampDocumentedWebhookEventType | string;
+  readonly family: RampWebhookFamily | undefined;
+  readonly createdAt: string;
+  readonly businessId: string;
+  readonly objectId: string;
+}
+declare function toRampWebhookEvent(envelope: RampWebhookEventEnvelope): RampWebhookEvent;
+//#endregion
+export { RAMP_DOCUMENTED_WEBHOOK_EVENT_TYPES, type RampDocumentedWebhookEventType, RampWebhookEvent, type RampWebhookEventEnvelope, RampWebhookFamily, rampWebhookEventEnvelopeSchema, rampWebhookFamilySchema, toRampWebhookEvent };

package/dist/events.mjs

@@ -0,0 +1,39 @@
+import { a as rampWebhookEventEnvelopeSchema, t as RAMP_DOCUMENTED_WEBHOOK_EVENT_TYPES } from "./webhook-CsbvcgrC.mjs";
+import { z } from "zod";
+
+//#region src/events.ts
+/**
+* Enumeration of the coarse-grained event families that the package exposes
+* via the {@link webhooks} namespace. Each family maps to multiple underlying
+* Ramp event `type` values (e.g. `transactionsAny` covers authorized/cleared/
+* declined/updated).
+*/
+const rampWebhookFamilySchema = z.enum([
+	"transactions",
+	"bills",
+	"purchase_orders",
+	"spend_requests",
+	"applications",
+	"unified_requests"
+]);
+function familyFor(eventType) {
+	if (eventType.startsWith("transactions.")) return "transactions";
+	if (eventType.startsWith("bills.")) return "bills";
+	if (eventType.startsWith("purchase_orders.")) return "purchase_orders";
+	if (eventType.startsWith("spend_requests.")) return "spend_requests";
+	if (eventType.startsWith("applications.")) return "applications";
+	if (eventType.startsWith("unified_requests.")) return "unified_requests";
+}
+function toRampWebhookEvent(envelope) {
+	return {
+		id: envelope.id,
+		type: envelope.type,
+		family: familyFor(envelope.type),
+		createdAt: envelope.created_at,
+		businessId: envelope.business_id,
+		objectId: envelope.object.id
+	};
+}
+
+//#endregion
+export { RAMP_DOCUMENTED_WEBHOOK_EVENT_TYPES, rampWebhookEventEnvelopeSchema, rampWebhookFamilySchema, toRampWebhookEvent };

package/dist/factory-Da6YVHdL.mjs

@@ -0,0 +1,15 @@
+import { n as ramp } from "./integration-BGliAxAS.mjs";
+import { createOfficialOperationFactory } from "@keystrokehq/integration-authoring/official";
+
+//#region src/factory.ts
+/**
+* Operation factory bound to the public Ramp OAuth credential set.
+*
+* Every operation exported by the package MUST be declared via this factory
+* so that the platform can route credentials, surface manifests, and enforce
+* `needsApproval` gating consistently. Do not instantiate `Operation` directly.
+*/
+const rampOperation = createOfficialOperationFactory(ramp);
+
+//#endregion
+export { rampOperation as t };

package/dist/index.d.mts

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

package/dist/index.mjs

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

package/dist/integration-BGliAxAS.mjs

@@ -0,0 +1,124 @@
+import { defineOfficialIntegration } from "@keystrokehq/integration-authoring/official";
+import { z } from "zod";
+import { CredentialSet } from "@keystrokehq/core";
+
+//#region src/_official/provider-app.ts
+/**
+* Internal credential set for the Keystroke-owned Ramp OAuth application.
+*
+* Mirrors the `zoomAppCredentialSet` pattern: stores the client id/secret that
+* Keystroke uses to speak to Ramp's token endpoint, and optionally the webhook
+* signing secret used to verify inbound `X-Ramp-Signature` headers.
+*
+* This is never exposed directly to end users — the public OAuth flow injects
+* access tokens into {@link ramp} (defined in `integration.ts`).
+*/
+const rampAppCredentialSet = new CredentialSet({
+	id: "ramp-app",
+	exposure: "platform-only",
+	name: "Ramp App",
+	auth: z.object({
+		clientId: z.string().min(1),
+		clientSecret: z.string().min(1),
+		webhookSecret: z.string().min(1).optional()
+	})
+});
+const rampPlatformProviderSeed = {
+	provider: "ramp",
+	appRef: "ramp-platform",
+	displayName: "Ramp Platform",
+	credentialSetName: "Keystroke Ramp Platform App",
+	envShape: {
+		KEYSTROKE_PLATFORM_RAMP_CLIENT_ID: z.string().optional(),
+		KEYSTROKE_PLATFORM_RAMP_CLIENT_SECRET: z.string().optional(),
+		KEYSTROKE_PLATFORM_RAMP_WEBHOOK_SECRET: z.string().optional()
+	},
+	requiredEnvKeys: ["KEYSTROKE_PLATFORM_RAMP_CLIENT_ID", "KEYSTROKE_PLATFORM_RAMP_CLIENT_SECRET"],
+	externalAppIdEnvKey: "KEYSTROKE_PLATFORM_RAMP_CLIENT_ID",
+	buildCredentials: (env) => ({
+		clientId: env.KEYSTROKE_PLATFORM_RAMP_CLIENT_ID,
+		clientSecret: env.KEYSTROKE_PLATFORM_RAMP_CLIENT_SECRET,
+		...env.KEYSTROKE_PLATFORM_RAMP_WEBHOOK_SECRET ? { webhookSecret: env.KEYSTROKE_PLATFORM_RAMP_WEBHOOK_SECRET } : {}
+	})
+};
+
+//#endregion
+//#region src/integration.ts
+/**
+* Public auth schema for Ramp connections.
+*
+* Stores only the OAuth access token. The Ramp platform issues access tokens
+* with a ~10-day lifetime; the refresh token lifecycle is managed by the
+* platform OAuth machinery and does not need to be re-exposed here.
+*
+* Deliberately does NOT include environment discrimination — we route all
+* API traffic through `https://api.ramp.com` by default. Sandbox usage
+* requires bypassing the public connection and calling {@link createRampClient}
+* directly with `{ environment: 'sandbox' }`.
+*/
+const rampAuthSchema = z.object({ RAMP_ACCESS_TOKEN: z.string().min(1) });
+/**
+* OAuth scopes requested at connect time.
+*
+* Only includes scopes that are currently documented in Ramp's developer docs
+* (verified 2026-04-17). Operations gated on undocumented scopes must fail at
+* runtime with `RampMissingScopeError` and must NOT add phantom scopes here.
+*/
+const RAMP_OAUTH_SCOPES = [
+	"accounting:read",
+	"accounting:write",
+	"bank_accounts:read",
+	"bills:read",
+	"bills:write",
+	"business:read",
+	"card_programs:read",
+	"card_programs:write",
+	"cards:read",
+	"cards:write",
+	"cashbacks:read",
+	"departments:read",
+	"departments:write",
+	"entities:read",
+	"limits:read",
+	"limits:write",
+	"locations:read",
+	"locations:write",
+	"memos:read",
+	"receipt_integrations:read",
+	"receipt_integrations:write",
+	"receipts:read",
+	"receipts:write",
+	"reimbursements:read",
+	"spend_programs:read",
+	"statements:read",
+	"transactions:read",
+	"transfers:read",
+	"users:read",
+	"users:write",
+	"vendors:read",
+	"vendors:write"
+];
+const rampOfficialIntegration = {
+	id: "ramp",
+	name: "Ramp",
+	description: "Ramp corporate cards, spend management, bill pay, reimbursements, and accounting integrations for Keystroke workflows.",
+	auth: rampAuthSchema,
+	connections: [{
+		id: "oauth",
+		kind: "oauth",
+		tokenType: "refreshable",
+		authUrl: "https://app.ramp.com/v1/authorize",
+		tokenUrl: "https://api.ramp.com/developer/v1/token",
+		revokeUrl: "https://api.ramp.com/developer/v1/token/revoke",
+		scopes: RAMP_OAUTH_SCOPES,
+		vault: { accessToken: "RAMP_ACCESS_TOKEN" }
+	}]
+};
+const rampBundle = defineOfficialIntegration({
+	...rampOfficialIntegration,
+	internal: { providerApp: rampAppCredentialSet }
+});
+const ramp = rampBundle.credentialSet;
+
+//#endregion
+export { rampAppCredentialSet as a, rampOfficialIntegration as i, ramp as n, rampPlatformProviderSeed as o, rampBundle as r, RAMP_OAUTH_SCOPES as t };

package/dist/integration-Dd6tOtSy.d.mts

@@ -0,0 +1,47 @@
+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
+/**
+ * OAuth scopes requested at connect time.
+ *
+ * Only includes scopes that are currently documented in Ramp's developer docs
+ * (verified 2026-04-17). Operations gated on undocumented scopes must fail at
+ * runtime with `RampMissingScopeError` and must NOT add phantom scopes here.
+ */
+declare const RAMP_OAUTH_SCOPES: readonly ["accounting:read", "accounting:write", "bank_accounts:read", "bills:read", "bills:write", "business:read", "card_programs:read", "card_programs:write", "cards:read", "cards:write", "cashbacks:read", "departments:read", "departments:write", "entities:read", "limits:read", "limits:write", "locations:read", "locations:write", "memos:read", "receipt_integrations:read", "receipt_integrations:write", "receipts:read", "receipts:write", "reimbursements:read", "spend_programs:read", "statements:read", "transactions:read", "transfers:read", "users:read", "users:write", "vendors:read", "vendors:write"];
+declare const rampOfficialIntegration: {
+  id: "ramp";
+  name: string;
+  description: string;
+  auth: z.ZodObject<{
+    RAMP_ACCESS_TOKEN: z.ZodString;
+  }, z.core.$strip>;
+  connections: {
+    id: string;
+    kind: "oauth";
+    tokenType: "refreshable";
+    authUrl: string;
+    tokenUrl: string;
+    revokeUrl: string;
+    scopes: readonly ["accounting:read", "accounting:write", "bank_accounts:read", "bills:read", "bills:write", "business:read", "card_programs:read", "card_programs:write", "cards:read", "cards:write", "cashbacks:read", "departments:read", "departments:write", "entities:read", "limits:read", "limits:write", "locations:read", "locations:write", "memos:read", "receipt_integrations:read", "receipt_integrations:write", "receipts:read", "receipts:write", "reimbursements:read", "spend_programs:read", "statements:read", "transactions:read", "transfers:read", "users:read", "users:write", "vendors:read", "vendors:write"];
+    vault: {
+      accessToken: "RAMP_ACCESS_TOKEN";
+    };
+  }[];
+};
+declare const rampBundle: _keystrokehq_integration_authoring_official0.OfficialIntegrationBundle<"ramp", z.ZodObject<{
+  RAMP_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>;
+declare const ramp: _keystrokehq_core0.CredentialSet<"ramp", z.ZodObject<{
+  RAMP_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  RAMP_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>;
+type RampCredentials = InferCredentialSetAuth<typeof ramp>;
+type RampOAuthScope = (typeof RAMP_OAUTH_SCOPES)[number];
+//#endregion
+export { rampBundle as a, ramp as i, RampCredentials as n, rampOfficialIntegration as o, RampOAuthScope as r, RAMP_OAUTH_SCOPES as t };