@openmeter/client 1.0.0-beta-4bc7392a70e6

package/README.md

@@ -0,0 +1,318 @@
+# OpenMeter SDK
+
+TypeScript client for the OpenMeter API — usage metering and billing for
+AI and DevTool companies. This package is generated from the OpenMeter
+TypeSpec definitions and ships fully-typed request and response models.
+
+> [!IMPORTANT]
+> This SDK is a work in progress.
+>
+> This SDK targets the [OpenMeter API v3](https://openmeter.io/docs/api/v3),
+> a rewrite of the OpenMeter API following AIP (API Improvement Proposal)
+> standardization.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Initialization](#initialization)
+- [Usage](#usage)
+- [Available Resources and Operations](#available-resources-and-operations)
+  - [Events](#events)
+  - [Meters](#meters)
+  - [Customers](#customers)
+  - [Entitlements](#entitlements)
+  - [Subscriptions](#subscriptions)
+  - [Apps](#apps)
+  - [Billing](#billing)
+  - [Tax](#tax)
+  - [Currencies](#currencies)
+  - [Features](#features)
+  - [LLMCost](#llmcost)
+  - [Plans](#plans)
+  - [Addons](#addons)
+  - [PlanAddons](#planaddons)
+  - [Defaults](#defaults)
+  - [Governance](#governance)
+- [Error Handling](#error-handling)
+- [Standalone Functions](#standalone-functions)
+
+## Installation
+
+```bash
+npm install @openmeter/client
+```
+
+Or with your package manager of choice:
+
+```bash
+pnpm add @openmeter/client
+yarn add @openmeter/client
+```
+
+## Initialization
+
+Create a client with a base URL and an API key. The API key is sent as a
+`Bearer` token on every request.
+
+```typescript
+import { OpenMeter } from '@openmeter/client'
+
+const client = new OpenMeter({
+  baseUrl: 'https://openmeter.cloud/api/v3',
+  apiKey: process.env.OPENMETER_API_KEY,
+})
+```
+
+Konnect regions are addressed with a server template and a `region`
+variable:
+
+```typescript
+import { OpenMeter, ServerList } from '@openmeter/client'
+
+const client = new OpenMeter({
+  baseUrl: ServerList[0],
+  serverVariables: { region: 'eu' },
+  apiKey: process.env.OPENMETER_API_KEY,
+})
+```
+
+The `apiKey` may also be a function returning a `string` or
+`Promise<string>`, so tokens can be refreshed per request.
+
+## Usage
+
+Every operation is reachable through a fluent, namespaced client and
+returns a typed response (or throws an `HTTPError` on a non-2xx status).
+
+```typescript
+import { OpenMeter } from '@openmeter/client'
+
+const client = new OpenMeter({
+  baseUrl: 'https://openmeter.cloud/api/v3',
+  apiKey: process.env.OPENMETER_API_KEY,
+})
+
+const meter = await client.meters.create({
+  name: 'Tokens',
+  key: 'tokens',
+  aggregation: 'sum',
+  event_type: 'request',
+  value_property: '$.tokens',
+})
+
+const meters = await client.meters.list()
+```
+
+Each method takes the request object as its first argument and an optional
+per-request options object (`RequestOptions`) as its second.
+
+## Available Resources and Operations
+
+Operations are grouped by resource and exposed as methods on the client.
+The full call path, HTTP route, and a short description are listed below.
+
+### Events
+
+| Method                 | HTTP                     | Description                                                                  |
+| ---------------------- | ------------------------ | ---------------------------------------------------------------------------- |
+| `client.events.list`   | `GET /openmeter/events`  | List ingested events.                                                        |
+| `client.events.ingest` | `POST /openmeter/events` | Ingests an event or batch of events following the CloudEvents specification. |
+
+### Meters
+
+| Method                 | HTTP                                     | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| ---------------------- | ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `client.meters.create` | `POST /openmeter/meters`                 | Create a meter.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `client.meters.get`    | `GET /openmeter/meters/{meterId}`        | Get a meter by ID.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `client.meters.list`   | `GET /openmeter/meters`                  | List meters.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `client.meters.update` | `PUT /openmeter/meters/{meterId}`        | Update a meter.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `client.meters.delete` | `DELETE /openmeter/meters/{meterId}`     | Delete a meter.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `client.meters.query`  | `POST /openmeter/meters/{meterId}/query` | Query a meter for usage. Set `Accept: application/json` (the default) to get a structured JSON response. Set `Accept: text/csv` to download the same data as a CSV file suitable for spreadsheets. The CSV columns, in order, are: `from, to, [subject,] [customer_id, customer_key, customer_name,] <dimensions...>, value` The `subject` column is emitted only when `subject` is in the query's `group_by_dimensions`. The three `customer_*` columns are emitted together only when `customer_id` is in the query's `group_by_dimensions`. |
+
+### Customers
+
+| Method                                                 | HTTP                                                                      | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| ------------------------------------------------------ | ------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `client.customers.create`                              | `POST /openmeter/customers`                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `client.customers.get`                                 | `GET /openmeter/customers/{customerId}`                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `client.customers.list`                                | `GET /openmeter/customers`                                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `client.customers.upsert`                              | `PUT /openmeter/customers/{customerId}`                                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `client.customers.delete`                              | `DELETE /openmeter/customers/{customerId}`                                |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `client.customers.billing.get`                         | `GET /openmeter/customers/{customerId}/billing`                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `client.customers.billing.update`                      | `PUT /openmeter/customers/{customerId}/billing`                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `client.customers.billing.updateAppData`               | `PUT /openmeter/customers/{customerId}/billing/app-data`                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `client.customers.billing.createStripeCheckoutSession` | `POST /openmeter/customers/{customerId}/billing/stripe/checkout-sessions` | Create a [Stripe Checkout Session](https://docs.stripe.com/payments/checkout) for the customer. Creates a Checkout Session for collecting payment method information from customers. The session operates in "setup" mode, which collects payment details without charging the customer immediately. The collected payment method can be used for future subscription billing. For hosted checkout sessions, redirect customers to the returned URL. For embedded sessions, use the client_secret to initialize Stripe.js in your application. |
+| `client.customers.billing.createStripePortalSession`   | `POST /openmeter/customers/{customerId}/billing/stripe/portal-sessions`   | Create Stripe Customer Portal Session. Useful to redirect the customer to the Stripe Customer Portal to manage their payment methods, change their billing address and access their invoice history. Only returns URL if the customer billing profile is linked to a stripe app and customer.                                                                                                                                                                                                                                                  |
+| `client.customers.credits.grants.create`               | `POST /openmeter/customers/{customerId}/credits/grants`                   | Create a new credit grant. A credit grant represents an allocation of prepaid credits to a customer.                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `client.customers.credits.grants.get`                  | `GET /openmeter/customers/{customerId}/credits/grants/{creditGrantId}`    | Get a credit grant.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `client.customers.credits.grants.list`                 | `GET /openmeter/customers/{customerId}/credits/grants`                    | List credit grants.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `client.customers.credits.balance.get`                 | `GET /openmeter/customers/{customerId}/credits/balance`                   | Get a credit balance.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `client.customers.credits.adjustments.create`          | `POST /openmeter/customers/{customerId}/credits/adjustments`              | A credit adjustment can be used to make manual adjustments to a customer's credit balance. Supported use-cases: - Usage correction                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `client.customers.credits.transactions.list`           | `GET /openmeter/customers/{customerId}/credits/transactions`              | List credit transactions for a customer. Returns an immutable, chronological record of credit movements: funded credits and consumed credits. Transactions are returned in reverse chronological order by default.                                                                                                                                                                                                                                                                                                                             |
+| `client.customers.charges.list`                        | `GET /openmeter/customers/{customerId}/charges`                           | List customer charges. Returns the customer's charges that are represented as either flat fee or usage-based charges.                                                                                                                                                                                                                                                                                                                                                                                                                          |
+
+### Entitlements
+
+| Method                                   | HTTP                                                       | Description |
+| ---------------------------------------- | ---------------------------------------------------------- | ----------- |
+| `client.entitlements.listCustomerAccess` | `GET /openmeter/customers/{customerId}/entitlement-access` |             |
+
+### Subscriptions
+
+| Method                                       | HTTP                                                                         | Description                                                                                                                                    |
+| -------------------------------------------- | ---------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| `client.subscriptions.create`                | `POST /openmeter/subscriptions`                                              |                                                                                                                                                |
+| `client.subscriptions.list`                  | `GET /openmeter/subscriptions`                                               |                                                                                                                                                |
+| `client.subscriptions.get`                   | `GET /openmeter/subscriptions/{subscriptionId}`                              |                                                                                                                                                |
+| `client.subscriptions.cancel`                | `POST /openmeter/subscriptions/{subscriptionId}/cancel`                      | Cancels the subscription. Will result in a scheduling conflict if there are other subscriptions scheduled to start after the cancelation time. |
+| `client.subscriptions.unscheduleCancelation` | `POST /openmeter/subscriptions/{subscriptionId}/unschedule-cancelation`      | Unschedules the subscription cancelation.                                                                                                      |
+| `client.subscriptions.change`                | `POST /openmeter/subscriptions/{subscriptionId}/change`                      | Closes a running subscription and starts a new one according to the specification. Can be used for upgrades, downgrades, and plan changes.     |
+| `client.subscriptions.listAddons`            | `GET /openmeter/subscriptions/{subscriptionId}/addons`                       | List the addons of a subscription.                                                                                                             |
+| `client.subscriptions.getAddon`              | `GET /openmeter/subscriptions/{subscriptionId}/addons/{subscriptionAddonId}` | Get an add-on association for a subscription.                                                                                                  |
+
+### Apps
+
+| Method             | HTTP                          | Description           |
+| ------------------ | ----------------------------- | --------------------- |
+| `client.apps.list` | `GET /openmeter/apps`         | List installed apps.  |
+| `client.apps.get`  | `GET /openmeter/apps/{appId}` | Get an installed app. |
+
+### Billing
+
+| Method                         | HTTP                              | Description                                                                                                                                                                                                                                                                                                              |
+| ------------------------------ | --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `client.billing.listProfiles`  | `GET /openmeter/profiles`         | List billing profiles.                                                                                                                                                                                                                                                                                                   |
+| `client.billing.createProfile` | `POST /openmeter/profiles`        | Create a new billing profile. Billing profiles contain the settings for billing and controls invoice generation. An organization can have multiple billing profiles defined. A billing profile is linked to a specific app. This association is established during the billing profile's creation and remains immutable. |
+| `client.billing.getProfile`    | `GET /openmeter/profiles/{id}`    | Get a billing profile.                                                                                                                                                                                                                                                                                                   |
+| `client.billing.updateProfile` | `PUT /openmeter/profiles/{id}`    | Update a billing profile.                                                                                                                                                                                                                                                                                                |
+| `client.billing.deleteProfile` | `DELETE /openmeter/profiles/{id}` | Delete a billing profile. Only such billing profiles can be deleted that are: - not the default profile - not pinned to any customer using customer overrides - only have finalized invoices                                                                                                                             |
+
+### Tax
+
+| Method                  | HTTP                                      | Description |
+| ----------------------- | ----------------------------------------- | ----------- |
+| `client.tax.createCode` | `POST /openmeter/tax-codes`               |             |
+| `client.tax.getCode`    | `GET /openmeter/tax-codes/{taxCodeId}`    |             |
+| `client.tax.listCodes`  | `GET /openmeter/tax-codes`                |             |
+| `client.tax.upsertCode` | `PUT /openmeter/tax-codes/{taxCodeId}`    |             |
+| `client.tax.deleteCode` | `DELETE /openmeter/tax-codes/{taxCodeId}` |             |
+
+### Currencies
+
+| Method                                   | HTTP                                                        | Description                                                                                                                    |
+| ---------------------------------------- | ----------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
+| `client.currencies.list`                 | `GET /openmeter/currencies`                                 | List currencies supported by the billing system.                                                                               |
+| `client.currencies.createCustomCurrency` | `POST /openmeter/currencies/custom`                         | Create a custom currency. This operation allows defining your own custom currency for billing purposes.                        |
+| `client.currencies.listCostBases`        | `GET /openmeter/currencies/custom/{currencyId}/cost-bases`  | List cost bases for a currency. For custom currencies, there can be multiple cost bases with different `effective_from` dates. |
+| `client.currencies.createCostBasis`      | `POST /openmeter/currencies/custom/{currencyId}/cost-bases` | Create a cost basis for a currency.                                                                                            |
+
+### Features
+
+| Method                      | HTTP                                              | Description                                                                |
+| --------------------------- | ------------------------------------------------- | -------------------------------------------------------------------------- |
+| `client.features.list`      | `GET /openmeter/features`                         | List all features.                                                         |
+| `client.features.create`    | `POST /openmeter/features`                        | Create a feature.                                                          |
+| `client.features.get`       | `GET /openmeter/features/{featureId}`             | Get a feature by id.                                                       |
+| `client.features.update`    | `PATCH /openmeter/features/{featureId}`           | Update a feature by id. Currently only the unit_cost field can be updated. |
+| `client.features.delete`    | `DELETE /openmeter/features/{featureId}`          | Delete a feature by id.                                                    |
+| `client.features.queryCost` | `POST /openmeter/features/{featureId}/cost/query` | Query the cost of a feature.                                               |
+
+### LLMCost
+
+| Method                          | HTTP                                             | Description                                                                           |
+| ------------------------------- | ------------------------------------------------ | ------------------------------------------------------------------------------------- |
+| `client.llmCost.listPrices`     | `GET /openmeter/llm-cost/prices`                 | List global LLM cost prices. Returns prices with overrides applied if any.            |
+| `client.llmCost.getPrice`       | `GET /openmeter/llm-cost/prices/{priceId}`       | Get a specific LLM cost price by ID. Returns the price with overrides applied if any. |
+| `client.llmCost.listOverrides`  | `GET /openmeter/llm-cost/overrides`              | List per-namespace price overrides.                                                   |
+| `client.llmCost.createOverride` | `POST /openmeter/llm-cost/overrides`             | Create a per-namespace price override.                                                |
+| `client.llmCost.deleteOverride` | `DELETE /openmeter/llm-cost/overrides/{priceId}` | Delete a per-namespace price override.                                                |
+
+### Plans
+
+| Method                 | HTTP                                     | Description             |
+| ---------------------- | ---------------------------------------- | ----------------------- |
+| `client.plans.list`    | `GET /openmeter/plans`                   | List all plans.         |
+| `client.plans.create`  | `POST /openmeter/plans`                  | Create a new plan.      |
+| `client.plans.update`  | `PUT /openmeter/plans/{planId}`          | Update a plan by id.    |
+| `client.plans.get`     | `GET /openmeter/plans/{planId}`          | Get a plan by id.       |
+| `client.plans.delete`  | `DELETE /openmeter/plans/{planId}`       | Delete a plan by id.    |
+| `client.plans.archive` | `POST /openmeter/plans/{planId}/archive` | Archive a plan version. |
+| `client.plans.publish` | `POST /openmeter/plans/{planId}/publish` | Publish a plan version. |
+
+### Addons
+
+| Method                  | HTTP                                       | Description                |
+| ----------------------- | ------------------------------------------ | -------------------------- |
+| `client.addons.list`    | `GET /openmeter/addons`                    | List all add-ons.          |
+| `client.addons.create`  | `POST /openmeter/addons`                   | Create a new add-on.       |
+| `client.addons.update`  | `PUT /openmeter/addons/{addonId}`          | Update an add-on by id.    |
+| `client.addons.get`     | `GET /openmeter/addons/{addonId}`          | Get add-on by id.          |
+| `client.addons.delete`  | `DELETE /openmeter/addons/{addonId}`       | Soft delete add-on by id.  |
+| `client.addons.archive` | `POST /openmeter/addons/{addonId}/archive` | Archive an add-on version. |
+| `client.addons.publish` | `POST /openmeter/addons/{addonId}/publish` | Publish an add-on version. |
+
+### PlanAddons
+
+| Method                     | HTTP                                                    | Description                              |
+| -------------------------- | ------------------------------------------------------- | ---------------------------------------- |
+| `client.planAddons.list`   | `GET /openmeter/plans/{planId}/addons`                  | List add-ons associated with a plan.     |
+| `client.planAddons.create` | `POST /openmeter/plans/{planId}/addons`                 | Add an add-on to a plan.                 |
+| `client.planAddons.get`    | `GET /openmeter/plans/{planId}/addons/{planAddonId}`    | Get an add-on association for a plan.    |
+| `client.planAddons.update` | `PUT /openmeter/plans/{planId}/addons/{planAddonId}`    | Update an add-on association for a plan. |
+| `client.planAddons.delete` | `DELETE /openmeter/plans/{planId}/addons/{planAddonId}` | Remove an add-on from a plan.            |
+
+### Defaults
+
+| Method                                       | HTTP                                | Description |
+| -------------------------------------------- | ----------------------------------- | ----------- |
+| `client.defaults.getOrganizationTaxCodes`    | `GET /openmeter/defaults/tax-codes` |             |
+| `client.defaults.updateOrganizationTaxCodes` | `PUT /openmeter/defaults/tax-codes` |             |
+
+### Governance
+
+| Method                          | HTTP                               | Description                                                                                                                                                                                                                                                                                                          |
+| ------------------------------- | ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `client.governance.queryAccess` | `POST /openmeter/governance/query` | Query feature access for a list of customers. The endpoint resolves each provided identifier to a customer and returns the access status for the requested features, plus optional credit balance availability. _Designed to be called on a fixed refresh interval and the query response is intended to be cached._ |
+
+## Error Handling
+
+A non-2xx response rejects with an `HTTPError` carrying the problem-details
+fields (`status`, `type`, `title`, `url`) from the response.
+
+```typescript
+import { OpenMeter, HTTPError } from '@openmeter/client'
+
+const client = new OpenMeter({
+  baseUrl: 'https://openmeter.cloud/api/v3',
+  apiKey: process.env.OPENMETER_API_KEY,
+})
+
+try {
+  await client.meters.get({ meterId: 'unknown' })
+} catch (error) {
+  if (error instanceof HTTPError) {
+    console.error(error.status, error.title, error.type)
+  }
+}
+```
+
+## Standalone Functions
+
+Every method is also available as a standalone, tree-shakeable function
+that takes a `Client` and returns a `Result` instead of throwing.
+
+```typescript
+import { Client, funcs } from '@openmeter/client'
+
+const client = new Client({
+  baseUrl: 'https://openmeter.cloud/api/v3',
+  apiKey: process.env.OPENMETER_API_KEY,
+})
+
+const result = await funcs.listMeters(client)
+if (result.ok) {
+  console.log(result.value)
+} else {
+  console.error(result.error)
+}
+```

package/dist/core.d.ts

@@ -0,0 +1,10 @@
+import { type KyInstance as HTTPClient } from 'ky';
+import { type SDKOptions } from './lib/config.js';
+export declare class Client {
+    readonly _options: SDKOptions;
+    readonly _http: HTTPClient;
+    constructor(options: SDKOptions);
+}
+export declare function http(client: Client): HTTPClient;
+export type { HTTPClient };
+//# sourceMappingURL=core.d.ts.map

package/dist/core.js

@@ -0,0 +1,38 @@
+import ky from 'ky';
+import { encodePath } from './lib/encodings.js';
+export class Client {
+    _options;
+    _http;
+    constructor(options) {
+        this._options = options;
+        let baseUrl = typeof options.baseUrl === 'string'
+            ? encodePath(options.baseUrl, options.serverVariables ?? {})
+            : String(options.baseUrl);
+        if (!baseUrl.endsWith('/')) {
+            baseUrl = `${baseUrl}/`;
+        }
+        this._http = ky.create({
+            ...options,
+            baseUrl,
+            prefix: undefined,
+            hooks: {
+                ...options.hooks,
+                beforeRequest: [
+                    ...(options.hooks?.beforeRequest ?? []),
+                    async ({ request }) => {
+                        const token = typeof options.apiKey === 'function'
+                            ? await options.apiKey()
+                            : options.apiKey;
+                        if (token) {
+                            request.headers.set('Authorization', `Bearer ${token}`);
+                        }
+                    },
+                ],
+            },
+        });
+    }
+}
+export function http(client) {
+    return client._http;
+}
+//# sourceMappingURL=core.js.map

package/dist/funcs/addons.d.ts

@@ -0,0 +1,11 @@
+import { type Client } from '../core.js';
+import { type Result, type RequestOptions } from '../lib/types.js';
+import type { ListAddonsRequest, ListAddonsResponse, CreateAddonRequest, CreateAddonResponse, UpdateAddonRequest, UpdateAddonResponse, GetAddonRequest, GetAddonResponse, DeleteAddonRequest, DeleteAddonResponse, ArchiveAddonRequest, ArchiveAddonResponse, PublishAddonRequest, PublishAddonResponse } from '../models/operations/addons.js';
+export declare function listAddons(client: Client, req?: ListAddonsRequest, options?: RequestOptions): Promise<Result<ListAddonsResponse>>;
+export declare function createAddon(client: Client, req: CreateAddonRequest, options?: RequestOptions): Promise<Result<CreateAddonResponse>>;
+export declare function updateAddon(client: Client, req: UpdateAddonRequest, options?: RequestOptions): Promise<Result<UpdateAddonResponse>>;
+export declare function getAddon(client: Client, req: GetAddonRequest, options?: RequestOptions): Promise<Result<GetAddonResponse>>;
+export declare function deleteAddon(client: Client, req: DeleteAddonRequest, options?: RequestOptions): Promise<Result<DeleteAddonResponse>>;
+export declare function archiveAddon(client: Client, req: ArchiveAddonRequest, options?: RequestOptions): Promise<Result<ArchiveAddonResponse>>;
+export declare function publishAddon(client: Client, req: PublishAddonRequest, options?: RequestOptions): Promise<Result<PublishAddonResponse>>;
+//# sourceMappingURL=addons.d.ts.map

package/dist/funcs/addons.js

@@ -0,0 +1,53 @@
+import { http } from '../core.js';
+import { request } from '../lib/request.js';
+import { encodePath, toURLSearchParams, encodeSort } from '../lib/encodings.js';
+export function listAddons(client, req = {}, options) {
+    const searchParams = toURLSearchParams({
+        page: req.page,
+        sort: encodeSort(req.sort),
+        filter: req.filter,
+    });
+    return request(() => http(client)
+        .get('openmeter/addons', { ...options, searchParams })
+        .json());
+}
+export function createAddon(client, req, options) {
+    return request(() => http(client)
+        .post('openmeter/addons', { ...options, json: req })
+        .json());
+}
+export function updateAddon(client, req, options) {
+    const path = encodePath('openmeter/addons/{addonId}', {
+        addonId: req.addonId,
+    });
+    return request(() => http(client)
+        .put(path, { ...options, json: req.body })
+        .json());
+}
+export function getAddon(client, req, options) {
+    const path = encodePath('openmeter/addons/{addonId}', {
+        addonId: req.addonId,
+    });
+    return request(() => http(client).get(path, options).json());
+}
+export function deleteAddon(client, req, options) {
+    const path = encodePath('openmeter/addons/{addonId}', {
+        addonId: req.addonId,
+    });
+    return request(async () => {
+        await http(client).delete(path, options);
+    });
+}
+export function archiveAddon(client, req, options) {
+    const path = encodePath('openmeter/addons/{addonId}/archive', {
+        addonId: req.addonId,
+    });
+    return request(() => http(client).post(path, options).json());
+}
+export function publishAddon(client, req, options) {
+    const path = encodePath('openmeter/addons/{addonId}/publish', {
+        addonId: req.addonId,
+    });
+    return request(() => http(client).post(path, options).json());
+}
+//# sourceMappingURL=addons.js.map

package/dist/funcs/apps.d.ts

@@ -0,0 +1,6 @@
+import { type Client } from '../core.js';
+import { type Result, type RequestOptions } from '../lib/types.js';
+import type { ListAppsRequest, ListAppsResponse, GetAppRequest, GetAppResponse } from '../models/operations/apps.js';
+export declare function listApps(client: Client, req?: ListAppsRequest, options?: RequestOptions): Promise<Result<ListAppsResponse>>;
+export declare function getApp(client: Client, req: GetAppRequest, options?: RequestOptions): Promise<Result<GetAppResponse>>;
+//# sourceMappingURL=apps.d.ts.map

package/dist/funcs/apps.js

@@ -0,0 +1,16 @@
+import { http } from '../core.js';
+import { request } from '../lib/request.js';
+import { encodePath, toURLSearchParams } from '../lib/encodings.js';
+export function listApps(client, req = {}, options) {
+    const searchParams = toURLSearchParams({
+        page: req.page,
+    });
+    return request(() => http(client)
+        .get('openmeter/apps', { ...options, searchParams })
+        .json());
+}
+export function getApp(client, req, options) {
+    const path = encodePath('openmeter/apps/{appId}', { appId: req.appId });
+    return request(() => http(client).get(path, options).json());
+}
+//# sourceMappingURL=apps.js.map

package/dist/funcs/billing.d.ts

@@ -0,0 +1,9 @@
+import { type Client } from '../core.js';
+import { type Result, type RequestOptions } from '../lib/types.js';
+import type { ListBillingProfilesRequest, ListBillingProfilesResponse, CreateBillingProfileRequest, CreateBillingProfileResponse, GetBillingProfileRequest, GetBillingProfileResponse, UpdateBillingProfileRequest, UpdateBillingProfileResponse, DeleteBillingProfileRequest, DeleteBillingProfileResponse } from '../models/operations/billing.js';
+export declare function listBillingProfiles(client: Client, req?: ListBillingProfilesRequest, options?: RequestOptions): Promise<Result<ListBillingProfilesResponse>>;
+export declare function createBillingProfile(client: Client, req: CreateBillingProfileRequest, options?: RequestOptions): Promise<Result<CreateBillingProfileResponse>>;
+export declare function getBillingProfile(client: Client, req: GetBillingProfileRequest, options?: RequestOptions): Promise<Result<GetBillingProfileResponse>>;
+export declare function updateBillingProfile(client: Client, req: UpdateBillingProfileRequest, options?: RequestOptions): Promise<Result<UpdateBillingProfileResponse>>;
+export declare function deleteBillingProfile(client: Client, req: DeleteBillingProfileRequest, options?: RequestOptions): Promise<Result<DeleteBillingProfileResponse>>;
+//# sourceMappingURL=billing.d.ts.map

package/dist/funcs/billing.js

@@ -0,0 +1,33 @@
+import { http } from '../core.js';
+import { request } from '../lib/request.js';
+import { encodePath, toURLSearchParams } from '../lib/encodings.js';
+export function listBillingProfiles(client, req = {}, options) {
+    const searchParams = toURLSearchParams({
+        page: req.page,
+    });
+    return request(() => http(client)
+        .get('openmeter/profiles', { ...options, searchParams })
+        .json());
+}
+export function createBillingProfile(client, req, options) {
+    return request(() => http(client)
+        .post('openmeter/profiles', { ...options, json: req })
+        .json());
+}
+export function getBillingProfile(client, req, options) {
+    const path = encodePath('openmeter/profiles/{id}', { id: req.id });
+    return request(() => http(client).get(path, options).json());
+}
+export function updateBillingProfile(client, req, options) {
+    const path = encodePath('openmeter/profiles/{id}', { id: req.id });
+    return request(() => http(client)
+        .put(path, { ...options, json: req.body })
+        .json());
+}
+export function deleteBillingProfile(client, req, options) {
+    const path = encodePath('openmeter/profiles/{id}', { id: req.id });
+    return request(async () => {
+        await http(client).delete(path, options);
+    });
+}
+//# sourceMappingURL=billing.js.map

package/dist/funcs/currencies.d.ts

@@ -0,0 +1,8 @@
+import { type Client } from '../core.js';
+import { type Result, type RequestOptions } from '../lib/types.js';
+import type { ListCurrenciesRequest, ListCurrenciesResponse, CreateCustomCurrencyRequest, CreateCustomCurrencyResponse, ListCostBasesRequest, ListCostBasesResponse, CreateCostBasisRequest, CreateCostBasisResponse } from '../models/operations/currencies.js';
+export declare function listCurrencies(client: Client, req?: ListCurrenciesRequest, options?: RequestOptions): Promise<Result<ListCurrenciesResponse>>;
+export declare function createCustomCurrency(client: Client, req: CreateCustomCurrencyRequest, options?: RequestOptions): Promise<Result<CreateCustomCurrencyResponse>>;
+export declare function listCostBases(client: Client, req: ListCostBasesRequest, options?: RequestOptions): Promise<Result<ListCostBasesResponse>>;
+export declare function createCostBasis(client: Client, req: CreateCostBasisRequest, options?: RequestOptions): Promise<Result<CreateCostBasisResponse>>;
+//# sourceMappingURL=currencies.d.ts.map

package/dist/funcs/currencies.js

@@ -0,0 +1,35 @@
+import { http } from '../core.js';
+import { request } from '../lib/request.js';
+import { encodePath, toURLSearchParams, encodeSort } from '../lib/encodings.js';
+export function listCurrencies(client, req = {}, options) {
+    const searchParams = toURLSearchParams({
+        page: req.page,
+        sort: encodeSort(req.sort),
+        filter: req.filter,
+    });
+    return request(() => http(client)
+        .get('openmeter/currencies', { ...options, searchParams })
+        .json());
+}
+export function createCustomCurrency(client, req, options) {
+    return request(() => http(client)
+        .post('openmeter/currencies/custom', { ...options, json: req })
+        .json());
+}
+export function listCostBases(client, req, options) {
+    const searchParams = toURLSearchParams({
+        filter: req.filter,
+        page: req.page,
+    });
+    const path = encodePath('openmeter/currencies/custom/{currencyId}/cost-bases', { currencyId: req.currencyId });
+    return request(() => http(client)
+        .get(path, { ...options, searchParams })
+        .json());
+}
+export function createCostBasis(client, req, options) {
+    const path = encodePath('openmeter/currencies/custom/{currencyId}/cost-bases', { currencyId: req.currencyId });
+    return request(() => http(client)
+        .post(path, { ...options, json: req.body })
+        .json());
+}
+//# sourceMappingURL=currencies.js.map

package/dist/funcs/customers.d.ts

@@ -0,0 +1,21 @@
+import { type Client } from '../core.js';
+import { type Result, type RequestOptions } from '../lib/types.js';
+import type { CreateCustomerRequest, CreateCustomerResponse, GetCustomerRequest, GetCustomerResponse, ListCustomersRequest, ListCustomersResponse, UpsertCustomerRequest, UpsertCustomerResponse, DeleteCustomerRequest, DeleteCustomerResponse, GetCustomerBillingRequest, GetCustomerBillingResponse, UpdateCustomerBillingRequest, UpdateCustomerBillingResponse, UpdateCustomerBillingAppDataRequest, UpdateCustomerBillingAppDataResponse, CreateCustomerStripeCheckoutSessionRequest, CreateCustomerStripeCheckoutSessionResponse, CreateCustomerStripePortalSessionRequest, CreateCustomerStripePortalSessionResponse, CreateCreditGrantRequest, CreateCreditGrantResponse, GetCreditGrantRequest, GetCreditGrantResponse, ListCreditGrantsRequest, ListCreditGrantsResponse, GetCustomerCreditBalanceRequest, GetCustomerCreditBalanceResponse, CreateCreditAdjustmentRequest, CreateCreditAdjustmentResponse, ListCreditTransactionsRequest, ListCreditTransactionsResponse, ListCustomerChargesRequest, ListCustomerChargesResponse } from '../models/operations/customers.js';
+export declare function createCustomer(client: Client, req: CreateCustomerRequest, options?: RequestOptions): Promise<Result<CreateCustomerResponse>>;
+export declare function getCustomer(client: Client, req: GetCustomerRequest, options?: RequestOptions): Promise<Result<GetCustomerResponse>>;
+export declare function listCustomers(client: Client, req?: ListCustomersRequest, options?: RequestOptions): Promise<Result<ListCustomersResponse>>;
+export declare function upsertCustomer(client: Client, req: UpsertCustomerRequest, options?: RequestOptions): Promise<Result<UpsertCustomerResponse>>;
+export declare function deleteCustomer(client: Client, req: DeleteCustomerRequest, options?: RequestOptions): Promise<Result<DeleteCustomerResponse>>;
+export declare function getCustomerBilling(client: Client, req: GetCustomerBillingRequest, options?: RequestOptions): Promise<Result<GetCustomerBillingResponse>>;
+export declare function updateCustomerBilling(client: Client, req: UpdateCustomerBillingRequest, options?: RequestOptions): Promise<Result<UpdateCustomerBillingResponse>>;
+export declare function updateCustomerBillingAppData(client: Client, req: UpdateCustomerBillingAppDataRequest, options?: RequestOptions): Promise<Result<UpdateCustomerBillingAppDataResponse>>;
+export declare function createCustomerStripeCheckoutSession(client: Client, req: CreateCustomerStripeCheckoutSessionRequest, options?: RequestOptions): Promise<Result<CreateCustomerStripeCheckoutSessionResponse>>;
+export declare function createCustomerStripePortalSession(client: Client, req: CreateCustomerStripePortalSessionRequest, options?: RequestOptions): Promise<Result<CreateCustomerStripePortalSessionResponse>>;
+export declare function createCreditGrant(client: Client, req: CreateCreditGrantRequest, options?: RequestOptions): Promise<Result<CreateCreditGrantResponse>>;
+export declare function getCreditGrant(client: Client, req: GetCreditGrantRequest, options?: RequestOptions): Promise<Result<GetCreditGrantResponse>>;
+export declare function listCreditGrants(client: Client, req: ListCreditGrantsRequest, options?: RequestOptions): Promise<Result<ListCreditGrantsResponse>>;
+export declare function getCustomerCreditBalance(client: Client, req: GetCustomerCreditBalanceRequest, options?: RequestOptions): Promise<Result<GetCustomerCreditBalanceResponse>>;
+export declare function createCreditAdjustment(client: Client, req: CreateCreditAdjustmentRequest, options?: RequestOptions): Promise<Result<CreateCreditAdjustmentResponse>>;
+export declare function listCreditTransactions(client: Client, req: ListCreditTransactionsRequest, options?: RequestOptions): Promise<Result<ListCreditTransactionsResponse>>;
+export declare function listCustomerCharges(client: Client, req: ListCustomerChargesRequest, options?: RequestOptions): Promise<Result<ListCustomerChargesResponse>>;
+//# sourceMappingURL=customers.d.ts.map