@keystrokehq/ramp 0.0.1

package/README.md

@@ -0,0 +1,149 @@
+# @keystrokehq/ramp
+
+Ramp corporate cards, spend management, bill pay, reimbursements, accounting syncs, and webhook helpers for Keystroke workflows.
+
+This package is a single-mode official integration. The package root is intentionally non-canonical — use explicit subpaths instead:
+
+Core modules:
+
+- `@keystrokehq/ramp/connection`
+- `@keystrokehq/ramp/client`
+- `@keystrokehq/ramp/schemas`
+- `@keystrokehq/ramp/events`
+- `@keystrokehq/ramp/triggers`
+- `@keystrokehq/ramp/verification`
+- `@keystrokehq/ramp/messaging`
+
+Resource operations (representative list — see `package.json` `exports` for the full set):
+
+- `@keystrokehq/ramp/transactions`
+- `@keystrokehq/ramp/users`
+- `@keystrokehq/ramp/cards` & `@keystrokehq/ramp/card-programs`
+- `@keystrokehq/ramp/bills`
+- `@keystrokehq/ramp/vendors` & `@keystrokehq/ramp/vendor-bank-accounts`
+- `@keystrokehq/ramp/reimbursements`
+- `@keystrokehq/ramp/departments`, `@keystrokehq/ramp/locations`, `@keystrokehq/ramp/limits`, `@keystrokehq/ramp/memos`
+- `@keystrokehq/ramp/receipts`, `@keystrokehq/ramp/receipt-integrations`, `@keystrokehq/ramp/statements`
+- `@keystrokehq/ramp/business`, `@keystrokehq/ramp/entities`
+- `@keystrokehq/ramp/spend-programs`, `@keystrokehq/ramp/spend-requests`
+- `@keystrokehq/ramp/accounting-fields`, `@keystrokehq/ramp/accounting-gl-accounts`, `@keystrokehq/ramp/accounting-vendors`, `@keystrokehq/ramp/accounting-sync`, `@keystrokehq/ramp/accounting-subsidiaries`, `@keystrokehq/ramp/accounting-tracking-categories`
+- `@keystrokehq/ramp/transfers`, `@keystrokehq/ramp/cashbacks`
+- `@keystrokehq/ramp/webhooks` (management CRUD)
+- `@keystrokehq/ramp/purchase-orders`, `@keystrokehq/ramp/applications`, `@keystrokehq/ramp/unified-requests`
+
+## Connection
+
+Use the public Ramp connection for connected-account workflow operations:
+
+```ts
+import { ramp } from '@keystrokehq/ramp/connection';
+```
+
+The package ships a hand-rolled fetch client in `@keystrokehq/ramp/client` (no third-party SDK) so that the OAuth token lifecycle, webhook signature verification, and Ramp's monetary-cents boundary stay aligned with the official integration model. Sandbox routing (`demo-api.ramp.com`) is available via `createRampClient({ environment: 'sandbox' })` for the rare case that a workflow needs to bypass the public OAuth connection.
+
+The public OAuth surface uses the Authorization Code grant with refreshable access tokens. Ramp also supports Client Credentials for direct-to-API use cases; that grant is not currently wired into the public connection — use `createRampClient` with a pre-obtained bearer token if needed.
+
+## Operations
+
+All operations are bound to the `ramp` connection credential set and are exported from their resource-specific modules. A small sample:
+
+```ts
+import { listTransactions, getTransaction } from '@keystrokehq/ramp/transactions';
+import { listBills, approveBill } from '@keystrokehq/ramp/bills';
+import { createVirtualCard } from '@keystrokehq/ramp/cards';
+
+const { data } = await listTransactions.run({
+  state: 'CLEARED',
+  start: '2026-04-01T00:00:00Z',
+  end: '2026-04-17T00:00:00Z',
+  pageSize: 50,
+});
+
+const bill = await getTransaction.run({ transactionId: data[0]!.id });
+
+const virtualCard = await createVirtualCard.run({
+  userId: 'ramp_user_123',
+  displayName: 'Marketing - April',
+  spendingRestrictions: {
+    amount: 100_000, // cents
+    currency: 'USD',
+    interval: 'MONTHLY',
+  },
+});
+```
+
+All amounts on the Ramp wire are integer cents. The schemas in `@keystrokehq/ramp/schemas` surface these as `{ amountCents: number, currency: string }` tuples to avoid floating-point rounding on monetary math.
+
+## Webhooks
+
+Direct-binding helpers live under the `webhooks` namespace:
+
+```ts
+import { webhooks } from '@keystrokehq/ramp/triggers';
+
+const cleared = webhooks.transactions.cleared({
+  name: 'Ramp Cleared Transaction',
+  transform: (event) => ({
+    transactionId: event.objectId,
+    businessId: event.businessId,
+    createdAt: event.createdAt,
+  }),
+});
+```
+
+Ramp signs every webhook delivery with HMAC-SHA256 over the raw body. The signature ships in the `X-Ramp-Signature` header (hex, no prefix, no signed timestamp). Ramp also runs a URL-validation handshake by posting `{ challenge: "<value>" }` to new webhook endpoints; the helper in `@keystrokehq/ramp/verification` exposes `buildRampWebhookChallengeResponse` so handlers can echo the challenge back in the canonical shape.
+
+Supported webhook event families (currently 15 documented events):
+
+- `transactions.authorized`, `transactions.cleared`, `transactions.declined`, `transactions.updated`
+- `bills.created`, `bills.approved`, `bills.paid`, `bills.canceled`
+- `purchase_orders.created`, `purchase_orders.approved`, `purchase_orders.denied`
+- `spend_requests.comment_created`
+- `applications.approved`, `applications.denied`
+- `unified_requests.updated`
+
+Each family also exposes an `any` binding that matches all events in the family. Older Ramp documentation sometimes references additional webhook names (`transfers.*`, `cards.*`, etc.); those are not currently published as webhooks and are instead covered by polling triggers (see below). If/when Ramp publishes more webhook event types, they will be added here rather than silently emitted by the `any` helpers.
+
+## Polling Triggers
+
+Polling triggers compensate for gaps in the webhook catalog:
+
+```ts
+import {
+  pollTransactions,
+  pollUsers,
+  pollBills,
+  pollVendors,
+  pollReimbursements,
+  pollSpendRequests,
+  pollPurchaseOrders,
+  pollApplications,
+  pollUnifiedRequests,
+  pollTransfers,
+} from '@keystrokehq/ramp/triggers';
+
+const transferPoll = pollTransfers({
+  name: 'Ramp Transfers Poller',
+  transform: (response) => response.data.map((t) => ({
+    transferId: t.id,
+    status: t.status,
+  })),
+});
+```
+
+## Errors
+
+The client throws two package-local error types:
+
+- `RampApiError` — a discriminated error with `kind`, `status`, and parsed `body`. Kinds are: `network`, `timeout`, `auth_revoked`, `missing_scope`, `rate_limited`, `validation`, `not_found`, `conflict`, `server_error`, `unknown`.
+- `RampMissingScopeError` — thrown by operations that require an OAuth scope that is not currently available on the connected app. Ramp has not published scope identifiers for every endpoint; where that is the case, Keystroke requests the documented scope superset and mutations gate on this error at runtime instead of guessing at scope names.
+
+Auth revocation (`kind: 'auth_revoked'`) is translated to `CredentialRevokedError` from `@keystrokehq/core/errors` by the public `createRampClient` proxy so that the platform's reconnect flow can be triggered automatically.
+
+## Caveats
+
+- **Access token lifetime**: Ramp issues access tokens with a ~10-day lifetime; the platform OAuth machinery handles refresh transparently, and there is no user-surfaced expiry to worry about.
+- **Monetary amounts**: Ramp always uses integer cents on the wire — never do floating-point math on `amount` fields. The `mapRampMoney`/`unmapRampMoney` helpers in `@keystrokehq/ramp/shared` handle the cents &harr; `{ amountCents, currency }` conversion.
+- **Rate limits**: Ramp enforces a rolling 200 requests / 10 seconds window. The client retries `429` and `5xx` responses with exponential backoff, honoring `Retry-After` when present.
+- **Pagination**: Every list response is cursor-based; the `next` cursor is `page.next`. Use the `paginate` async generator exposed by the client (and via `list*All*` operations such as `listAllTransactions`) for full-history sweeps.
+- **Scope gating**: The OAuth connection only requests scopes that Ramp publishes. Operations that likely require un-documented scopes (e.g. some card-program writes) will surface a `RampMissingScopeError` at runtime rather than being fabricated client-side.

package/dist/_official/index.d.mts

@@ -0,0 +1,3 @@
+import { a as rampBundle, i as ramp, o as rampOfficialIntegration } from "../integration-Dd6tOtSy.mjs";
+import { n as rampAppCredentialSet, r as rampPlatformProviderSeed, t as RampAppCredentials } from "../provider-app-JO525h-N.mjs";
+export { RampAppCredentials, ramp, rampAppCredentialSet, rampBundle, rampOfficialIntegration, rampPlatformProviderSeed };

package/dist/_official/index.mjs

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

package/dist/_runtime/index.d.mts

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

package/dist/_runtime/index.mjs

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

package/dist/accounting-fields.d.mts

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/accounting-fields.d.ts
+declare const listAccountingFields: _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>;
+    field_type: z.ZodOptional<z.ZodString>;
+    is_splittable: z.ZodOptional<z.ZodBoolean>;
+  }, 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 getAccountingField: _keystrokehq_core0.Operation<z.ZodObject<{
+  fieldId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  field_type: z.ZodOptional<z.ZodString>;
+  is_splittable: z.ZodOptional<z.ZodBoolean>;
+}, 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 createAccountingField: _keystrokehq_core0.Operation<z.ZodObject<{
+  name: z.ZodString;
+  field_type: z.ZodString;
+  ramp_id: z.ZodOptional<z.ZodString>;
+  is_splittable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  field_type: z.ZodOptional<z.ZodString>;
+  is_splittable: z.ZodOptional<z.ZodBoolean>;
+}, 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 updateAccountingField: _keystrokehq_core0.Operation<z.ZodObject<{
+  fieldId: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  is_splittable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  field_type: z.ZodOptional<z.ZodString>;
+  is_splittable: z.ZodOptional<z.ZodBoolean>;
+}, 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 deleteAccountingField: _keystrokehq_core0.Operation<z.ZodObject<{
+  fieldId: 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>;
+declare const listAccountingFieldOptions: _keystrokehq_core0.Operation<z.ZodObject<{
+  field_id: z.ZodString;
+  pageSize: z.ZodOptional<z.ZodNumber>;
+  cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  data: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    ramp_id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    parent_id: 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 uploadAccountingFieldOptions: _keystrokehq_core0.Operation<z.ZodObject<{
+  field_id: z.ZodString;
+  options: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    ramp_id: z.ZodOptional<z.ZodString>;
+    parent_id: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  data: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    ramp_id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    parent_id: 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>;
+//#endregion
+export { createAccountingField, deleteAccountingField, getAccountingField, listAccountingFieldOptions, listAccountingFields, updateAccountingField, uploadAccountingFieldOptions };

package/dist/accounting-fields.mjs

@@ -0,0 +1,108 @@
+import { createRampClient } from "./client.mjs";
+import { a as rampAccountingFieldListSchema, d as rampAccountingFieldUpdateInputSchema, i as rampAccountingFieldListInputSchema, l as rampAccountingFieldOptionUploadInputSchema, n as rampAccountingFieldDeleteInputSchema, o as rampAccountingFieldOptionListInputSchema, r as rampAccountingFieldGetInputSchema, s as rampAccountingFieldOptionListSchema, t as rampAccountingFieldCreateInputSchema, u as rampAccountingFieldSchema } from "./accounting-i6txC-MI.mjs";
+import { t as rampOperation } from "./factory-Da6YVHdL.mjs";
+import { t as omitUndefined } from "./shared-CTTtP5gv.mjs";
+import { z } from "zod";
+
+//#region src/accounting-fields.ts
+const listAccountingFields = rampOperation({
+	id: "list_accounting_fields",
+	name: "List Accounting Fields",
+	description: "List custom accounting fields defined on the Ramp business.",
+	input: rampAccountingFieldListInputSchema,
+	output: rampAccountingFieldListSchema,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampAccountingFieldListSchema.parse(await client.request("/accounting/fields", { query: omitUndefined({
+			page_size: input.pageSize,
+			start: input.cursor
+		}) }));
+	}
+});
+const getAccountingField = rampOperation({
+	id: "get_accounting_field",
+	name: "Get Accounting Field",
+	description: "Fetch a Ramp accounting field by id.",
+	input: rampAccountingFieldGetInputSchema,
+	output: rampAccountingFieldSchema,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampAccountingFieldSchema.parse(await client.request(`/accounting/fields/${encodeURIComponent(input.fieldId)}`));
+	}
+});
+const createAccountingField = rampOperation({
+	id: "create_accounting_field",
+	name: "Create Accounting Field",
+	description: "Create a new custom accounting field.",
+	input: rampAccountingFieldCreateInputSchema,
+	output: rampAccountingFieldSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampAccountingFieldSchema.parse(await client.request("/accounting/fields", {
+			method: "POST",
+			body: input
+		}));
+	}
+});
+const updateAccountingField = rampOperation({
+	id: "update_accounting_field",
+	name: "Update Accounting Field",
+	description: "Update an existing custom accounting field.",
+	input: rampAccountingFieldUpdateInputSchema,
+	output: rampAccountingFieldSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		const { fieldId, ...body } = input;
+		await client.request(`/accounting/fields/${encodeURIComponent(fieldId)}`, {
+			method: "PATCH",
+			body: omitUndefined(body)
+		});
+		return rampAccountingFieldSchema.parse(await client.request(`/accounting/fields/${encodeURIComponent(fieldId)}`));
+	}
+});
+const deleteAccountingField = rampOperation({
+	id: "delete_accounting_field",
+	name: "Delete Accounting Field",
+	description: "Delete a custom accounting field by id.",
+	input: rampAccountingFieldDeleteInputSchema,
+	output: z.object({ success: z.boolean() }),
+	needsApproval: true,
+	run: async (input, credentials) => {
+		await createRampClient(credentials).request(`/accounting/fields/${encodeURIComponent(input.fieldId)}`, { method: "DELETE" });
+		return { success: true };
+	}
+});
+const listAccountingFieldOptions = rampOperation({
+	id: "list_accounting_field_options",
+	name: "List Accounting Field Options",
+	description: "List options configured on a custom accounting field.",
+	input: rampAccountingFieldOptionListInputSchema,
+	output: rampAccountingFieldOptionListSchema,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampAccountingFieldOptionListSchema.parse(await client.request(`/accounting/fields/${encodeURIComponent(input.field_id)}/options`, { query: omitUndefined({
+			page_size: input.pageSize,
+			start: input.cursor
+		}) }));
+	}
+});
+const uploadAccountingFieldOptions = rampOperation({
+	id: "upload_accounting_field_options",
+	name: "Upload Accounting Field Options",
+	description: "Bulk upload options for a custom accounting field.",
+	input: rampAccountingFieldOptionUploadInputSchema,
+	output: rampAccountingFieldOptionListSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampAccountingFieldOptionListSchema.parse(await client.request(`/accounting/fields/${encodeURIComponent(input.field_id)}/options`, {
+			method: "POST",
+			body: { options: input.options }
+		}));
+	}
+});
+
+//#endregion
+export { createAccountingField, deleteAccountingField, getAccountingField, listAccountingFieldOptions, listAccountingFields, updateAccountingField, uploadAccountingFieldOptions };

package/dist/accounting-gl-accounts.d.mts

@@ -0,0 +1,63 @@
+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/accounting-gl-accounts.d.ts
+declare const listGlAccounts: _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;
+    name: zod.ZodOptional<zod.ZodString>;
+    code: zod.ZodOptional<zod.ZodString>;
+    classification: zod.ZodOptional<zod.ZodString>;
+    active: 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 getGlAccount: _keystrokehq_core0.Operation<zod.ZodObject<{
+  glAccountId: zod.ZodString;
+}, zod_v4_core0.$strip>, zod.ZodObject<{
+  id: zod.ZodString;
+  name: zod.ZodOptional<zod.ZodString>;
+  code: zod.ZodOptional<zod.ZodString>;
+  classification: zod.ZodOptional<zod.ZodString>;
+  active: 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>;
+declare const uploadGlAccounts: _keystrokehq_core0.Operation<zod.ZodObject<{
+  gl_accounts: zod.ZodArray<zod.ZodObject<{
+    name: zod.ZodString;
+    code: zod.ZodOptional<zod.ZodString>;
+    classification: zod.ZodOptional<zod.ZodString>;
+    external_id: zod.ZodOptional<zod.ZodString>;
+  }, zod_v4_core0.$strip>>;
+}, zod_v4_core0.$strip>, zod.ZodObject<{
+  data: zod.ZodArray<zod.ZodObject<{
+    id: zod.ZodString;
+    name: zod.ZodOptional<zod.ZodString>;
+    code: zod.ZodOptional<zod.ZodString>;
+    classification: zod.ZodOptional<zod.ZodString>;
+    active: 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>;
+//#endregion
+export { getGlAccount, listGlAccounts, uploadGlAccounts };

package/dist/accounting-gl-accounts.mjs

@@ -0,0 +1,49 @@
+import { createRampClient } from "./client.mjs";
+import { F as rampGlAccountUploadInputSchema, M as rampGlAccountListInputSchema, N as rampGlAccountListSchema, P as rampGlAccountSchema, j as rampGlAccountGetInputSchema } from "./accounting-i6txC-MI.mjs";
+import { t as rampOperation } from "./factory-Da6YVHdL.mjs";
+import { t as omitUndefined } from "./shared-CTTtP5gv.mjs";
+
+//#region src/accounting-gl-accounts.ts
+const listGlAccounts = rampOperation({
+	id: "list_gl_accounts",
+	name: "List GL Accounts",
+	description: "List general-ledger accounts synced from the connected accounting system.",
+	input: rampGlAccountListInputSchema,
+	output: rampGlAccountListSchema,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampGlAccountListSchema.parse(await client.request("/accounting/gl-accounts", { query: omitUndefined({
+			page_size: input.pageSize,
+			start: input.cursor
+		}) }));
+	}
+});
+const getGlAccount = rampOperation({
+	id: "get_gl_account",
+	name: "Get GL Account",
+	description: "Fetch a GL account by id.",
+	input: rampGlAccountGetInputSchema,
+	output: rampGlAccountSchema,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampGlAccountSchema.parse(await client.request(`/accounting/gl-accounts/${encodeURIComponent(input.glAccountId)}`));
+	}
+});
+const uploadGlAccounts = rampOperation({
+	id: "upload_gl_accounts",
+	name: "Upload GL Accounts",
+	description: "Bulk-upload GL accounts from the connected accounting system.",
+	input: rampGlAccountUploadInputSchema,
+	output: rampGlAccountListSchema,
+	needsApproval: true,
+	run: async (input, credentials) => {
+		const client = createRampClient(credentials);
+		return rampGlAccountListSchema.parse(await client.request("/accounting/gl-accounts", {
+			method: "POST",
+			body: input
+		}));
+	}
+});
+
+//#endregion
+export { getGlAccount, listGlAccounts, uploadGlAccounts };

package/dist/accounting-i6txC-MI.mjs

@@ -0,0 +1,116 @@
+import { a as rampListPaginationInputSchema, f as rampTimestampSchema, i as rampIdSchema, o as rampListResponseSchema } from "./common-CUpmNYXw.mjs";
+import { z } from "zod";
+
+//#region src/schemas/accounting.ts
+const rampAccountingFieldSchema = z.object({
+	id: rampIdSchema,
+	name: z.string().optional(),
+	field_type: z.string().optional(),
+	is_splittable: z.boolean().optional()
+}).passthrough();
+const rampAccountingFieldListInputSchema = rampListPaginationInputSchema;
+const rampAccountingFieldListSchema = rampListResponseSchema(rampAccountingFieldSchema);
+const rampAccountingFieldGetInputSchema = z.object({ fieldId: rampIdSchema });
+const rampAccountingFieldCreateInputSchema = z.object({
+	name: z.string().trim().min(1),
+	field_type: z.string().trim().min(1),
+	ramp_id: z.string().trim().min(1).optional(),
+	is_splittable: z.boolean().optional()
+});
+const rampAccountingFieldUpdateInputSchema = z.object({
+	fieldId: rampIdSchema,
+	name: z.string().optional(),
+	is_splittable: z.boolean().optional()
+});
+const rampAccountingFieldDeleteInputSchema = z.object({ fieldId: rampIdSchema });
+const rampAccountingFieldOptionSchema = z.object({
+	id: rampIdSchema,
+	ramp_id: z.string().optional(),
+	name: z.string().optional(),
+	parent_id: rampIdSchema.optional()
+}).passthrough();
+const rampAccountingFieldOptionListInputSchema = z.object({ field_id: rampIdSchema }).merge(rampListPaginationInputSchema);
+const rampAccountingFieldOptionListSchema = rampListResponseSchema(rampAccountingFieldOptionSchema);
+const rampAccountingFieldOptionUploadInputSchema = z.object({
+	field_id: rampIdSchema,
+	options: z.array(z.object({
+		name: z.string().trim().min(1),
+		ramp_id: z.string().trim().min(1).optional(),
+		parent_id: rampIdSchema.optional()
+	})).min(1)
+});
+const rampGlAccountSchema = z.object({
+	id: rampIdSchema,
+	name: z.string().optional(),
+	code: z.string().optional(),
+	classification: z.string().optional(),
+	active: z.boolean().optional()
+}).passthrough();
+const rampGlAccountListInputSchema = rampListPaginationInputSchema;
+const rampGlAccountListSchema = rampListResponseSchema(rampGlAccountSchema);
+const rampGlAccountGetInputSchema = z.object({ glAccountId: rampIdSchema });
+const rampGlAccountUploadInputSchema = z.object({ gl_accounts: z.array(z.object({
+	name: z.string().trim().min(1),
+	code: z.string().trim().min(1).optional(),
+	classification: z.string().optional(),
+	external_id: z.string().optional()
+})).min(1) });
+const rampAccountingVendorSchema = z.object({
+	id: rampIdSchema,
+	name: z.string().optional(),
+	external_id: z.string().optional(),
+	ramp_vendor_id: rampIdSchema.optional(),
+	active: z.boolean().optional()
+}).passthrough();
+const rampAccountingVendorListInputSchema = rampListPaginationInputSchema;
+const rampAccountingVendorListSchema = rampListResponseSchema(rampAccountingVendorSchema);
+const rampAccountingVendorGetInputSchema = z.object({ accountingVendorId: rampIdSchema });
+const rampAccountingVendorUploadInputSchema = z.object({ vendors: z.array(z.object({
+	name: z.string().trim().min(1),
+	external_id: z.string().trim().min(1).optional(),
+	ramp_vendor_id: rampIdSchema.optional()
+})).min(1) });
+const rampAccountingSyncSchema = z.object({
+	id: rampIdSchema,
+	status: z.string().optional(),
+	created_at: rampTimestampSchema.optional(),
+	completed_at: rampTimestampSchema.optional()
+}).passthrough();
+const rampAccountingSyncListInputSchema = rampListPaginationInputSchema;
+const rampAccountingSyncListSchema = rampListResponseSchema(rampAccountingSyncSchema);
+const rampAccountingSyncGetInputSchema = z.object({ syncId: rampIdSchema });
+const rampAccountingSyncCreateInputSchema = z.object({
+	sync_type: z.enum([
+		"BILL",
+		"CARD_TRANSACTION",
+		"REIMBURSEMENT",
+		"TRANSFER",
+		"STATEMENT_CREDIT"
+	]),
+	idempotency_key: z.string().trim().min(1).optional()
+});
+const rampAccountingSubsidiarySchema = z.object({
+	id: rampIdSchema,
+	name: z.string().optional(),
+	external_id: z.string().optional(),
+	entity_id: rampIdSchema.optional()
+}).passthrough();
+const rampAccountingSubsidiaryListInputSchema = rampListPaginationInputSchema;
+const rampAccountingSubsidiaryListSchema = rampListResponseSchema(rampAccountingSubsidiarySchema);
+const rampAccountingSubsidiaryGetInputSchema = z.object({ subsidiaryId: rampIdSchema });
+const rampAccountingSubsidiaryUploadInputSchema = z.object({ subsidiaries: z.array(z.object({
+	name: z.string().trim().min(1),
+	external_id: z.string().trim().min(1).optional(),
+	entity_id: rampIdSchema.optional()
+})).min(1) });
+const rampAccountingTrackingCategorySchema = z.object({
+	id: rampIdSchema,
+	name: z.string().optional(),
+	ramp_id: z.string().optional()
+}).passthrough();
+const rampAccountingTrackingCategoryListInputSchema = rampListPaginationInputSchema;
+const rampAccountingTrackingCategoryListSchema = rampListResponseSchema(rampAccountingTrackingCategorySchema);
+const rampAccountingTrackingCategoryGetInputSchema = z.object({ trackingCategoryId: rampIdSchema });
+
+//#endregion
+export { rampAccountingVendorUploadInputSchema as A, rampAccountingTrackingCategoryListInputSchema as C, rampAccountingVendorListInputSchema as D, rampAccountingVendorGetInputSchema as E, rampGlAccountUploadInputSchema as F, rampGlAccountListInputSchema as M, rampGlAccountListSchema as N, rampAccountingVendorListSchema as O, rampGlAccountSchema as P, rampAccountingTrackingCategoryGetInputSchema as S, rampAccountingTrackingCategorySchema as T, rampAccountingSyncCreateInputSchema as _, rampAccountingFieldListSchema as a, rampAccountingSyncListSchema as b, rampAccountingFieldOptionSchema as c, rampAccountingFieldUpdateInputSchema as d, rampAccountingSubsidiaryGetInputSchema as f, rampAccountingSubsidiaryUploadInputSchema as g, rampAccountingSubsidiarySchema as h, rampAccountingFieldListInputSchema as i, rampGlAccountGetInputSchema as j, rampAccountingVendorSchema as k, rampAccountingFieldOptionUploadInputSchema as l, rampAccountingSubsidiaryListSchema as m, rampAccountingFieldDeleteInputSchema as n, rampAccountingFieldOptionListInputSchema as o, rampAccountingSubsidiaryListInputSchema as p, rampAccountingFieldGetInputSchema as r, rampAccountingFieldOptionListSchema as s, rampAccountingFieldCreateInputSchema as t, rampAccountingFieldSchema as u, rampAccountingSyncGetInputSchema as v, rampAccountingTrackingCategoryListSchema as w, rampAccountingSyncSchema as x, rampAccountingSyncListInputSchema as y };