@openmeter/client 1.0.0-beta.228

package/dist/funcs/customers.js

@@ -0,0 +1,127 @@
+import { http } from '../core.js';
+import { request } from '../lib/request.js';
+import { encodePath, toURLSearchParams, encodeSort } from '../lib/encodings.js';
+export function createCustomer(client, req, options) {
+    return request(() => http(client)
+        .post('openmeter/customers', { ...options, json: req })
+        .json());
+}
+export function getCustomer(client, req, options) {
+    const path = encodePath('openmeter/customers/{customerId}', { customerId: req.customerId });
+    return request(() => http(client)
+        .get(path, options)
+        .json());
+}
+export function listCustomers(client, req = {}, options) {
+    const searchParams = toURLSearchParams({
+        page: req.page,
+        sort: encodeSort(req.sort),
+        filter: req.filter,
+    });
+    return request(() => http(client)
+        .get('openmeter/customers', { ...options, searchParams })
+        .json());
+}
+export function upsertCustomer(client, req, options) {
+    const path = encodePath('openmeter/customers/{customerId}', { customerId: req.customerId });
+    return request(() => http(client)
+        .put(path, { ...options, json: req.body })
+        .json());
+}
+export function deleteCustomer(client, req, options) {
+    const path = encodePath('openmeter/customers/{customerId}', { customerId: req.customerId });
+    return request(async () => {
+        await http(client).delete(path, options);
+    });
+}
+export function getCustomerBilling(client, req, options) {
+    const path = encodePath('openmeter/customers/{customerId}/billing', { customerId: req.customerId });
+    return request(() => http(client)
+        .get(path, options)
+        .json());
+}
+export function updateCustomerBilling(client, req, options) {
+    const path = encodePath('openmeter/customers/{customerId}/billing', { customerId: req.customerId });
+    return request(() => http(client)
+        .put(path, { ...options, json: req.body })
+        .json());
+}
+export function updateCustomerBillingAppData(client, req, options) {
+    const path = encodePath('openmeter/customers/{customerId}/billing/app-data', { customerId: req.customerId });
+    return request(() => http(client)
+        .put(path, { ...options, json: req.body })
+        .json());
+}
+export function createCustomerStripeCheckoutSession(client, req, options) {
+    const path = encodePath('openmeter/customers/{customerId}/billing/stripe/checkout-sessions', { customerId: req.customerId });
+    return request(() => http(client)
+        .post(path, { ...options, json: req.body })
+        .json());
+}
+export function createCustomerStripePortalSession(client, req, options) {
+    const path = encodePath('openmeter/customers/{customerId}/billing/stripe/portal-sessions', { customerId: req.customerId });
+    return request(() => http(client)
+        .post(path, { ...options, json: req.body })
+        .json());
+}
+export function createCreditGrant(client, req, options) {
+    const path = encodePath('openmeter/customers/{customerId}/credits/grants', { customerId: req.customerId });
+    return request(() => http(client)
+        .post(path, { ...options, json: req.body })
+        .json());
+}
+export function getCreditGrant(client, req, options) {
+    const path = encodePath('openmeter/customers/{customerId}/credits/grants/{creditGrantId}', { customerId: req.customerId, creditGrantId: req.creditGrantId });
+    return request(() => http(client)
+        .get(path, options)
+        .json());
+}
+export function listCreditGrants(client, req, options) {
+    const searchParams = toURLSearchParams({
+        page: req.page,
+        filter: req.filter,
+    });
+    const path = encodePath('openmeter/customers/{customerId}/credits/grants', { customerId: req.customerId });
+    return request(() => http(client)
+        .get(path, { ...options, searchParams })
+        .json());
+}
+export function getCustomerCreditBalance(client, req, options) {
+    const searchParams = toURLSearchParams({
+        timestamp: req.timestamp,
+        filter: req.filter,
+    });
+    const path = encodePath('openmeter/customers/{customerId}/credits/balance', { customerId: req.customerId });
+    return request(() => http(client)
+        .get(path, { ...options, searchParams })
+        .json());
+}
+export function createCreditAdjustment(client, req, options) {
+    const path = encodePath('openmeter/customers/{customerId}/credits/adjustments', { customerId: req.customerId });
+    return request(() => http(client)
+        .post(path, { ...options, json: req.body })
+        .json());
+}
+export function listCreditTransactions(client, req, options) {
+    const searchParams = toURLSearchParams({
+        page: req.page,
+        filter: req.filter,
+    });
+    const path = encodePath('openmeter/customers/{customerId}/credits/transactions', { customerId: req.customerId });
+    return request(() => http(client)
+        .get(path, { ...options, searchParams })
+        .json());
+}
+export function listCustomerCharges(client, req, options) {
+    const searchParams = toURLSearchParams({
+        page: req.page,
+        sort: encodeSort(req.sort),
+        filter: req.filter,
+        expand: req.expand,
+    });
+    const path = encodePath('openmeter/customers/{customerId}/charges', { customerId: req.customerId });
+    return request(() => http(client)
+        .get(path, { ...options, searchParams })
+        .json());
+}
+//# sourceMappingURL=customers.js.map

package/dist/funcs/defaults.d.ts

@@ -0,0 +1,6 @@
+import { type Client } from '../core.js';
+import { type Result, type RequestOptions } from '../lib/types.js';
+import type { GetOrganizationDefaultTaxCodesRequest, GetOrganizationDefaultTaxCodesResponse, UpdateOrganizationDefaultTaxCodesRequest, UpdateOrganizationDefaultTaxCodesResponse } from '../models/operations/defaults.js';
+export declare function getOrganizationDefaultTaxCodes(client: Client, req: GetOrganizationDefaultTaxCodesRequest, options?: RequestOptions): Promise<Result<GetOrganizationDefaultTaxCodesResponse>>;
+export declare function updateOrganizationDefaultTaxCodes(client: Client, req: UpdateOrganizationDefaultTaxCodesRequest, options?: RequestOptions): Promise<Result<UpdateOrganizationDefaultTaxCodesResponse>>;
+//# sourceMappingURL=defaults.d.ts.map

package/dist/funcs/defaults.js

@@ -0,0 +1,13 @@
+import { http } from '../core.js';
+import { request } from '../lib/request.js';
+export function getOrganizationDefaultTaxCodes(client, req, options) {
+    return request(() => http(client)
+        .get('openmeter/defaults/tax-codes', options)
+        .json());
+}
+export function updateOrganizationDefaultTaxCodes(client, req, options) {
+    return request(() => http(client)
+        .put('openmeter/defaults/tax-codes', { ...options, json: req })
+        .json());
+}
+//# sourceMappingURL=defaults.js.map

package/dist/funcs/entitlements.d.ts

@@ -0,0 +1,5 @@
+import { type Client } from '../core.js';
+import { type Result, type RequestOptions } from '../lib/types.js';
+import type { ListCustomerEntitlementAccessRequest, ListCustomerEntitlementAccessResponse } from '../models/operations/entitlements.js';
+export declare function listCustomerEntitlementAccess(client: Client, req: ListCustomerEntitlementAccessRequest, options?: RequestOptions): Promise<Result<ListCustomerEntitlementAccessResponse>>;
+//# sourceMappingURL=entitlements.d.ts.map

package/dist/funcs/entitlements.js

@@ -0,0 +1,10 @@
+import { http } from '../core.js';
+import { request } from '../lib/request.js';
+import { encodePath } from '../lib/encodings.js';
+export function listCustomerEntitlementAccess(client, req, options) {
+    const path = encodePath('openmeter/customers/{customerId}/entitlement-access', { customerId: req.customerId });
+    return request(() => http(client)
+        .get(path, options)
+        .json());
+}
+//# sourceMappingURL=entitlements.js.map

package/dist/funcs/events.d.ts

@@ -0,0 +1,6 @@
+import { type Client } from '../core.js';
+import { type Result, type RequestOptions } from '../lib/types.js';
+import type { ListMeteringEventsRequest, ListMeteringEventsResponse, IngestMeteringEventsRequest, IngestMeteringEventsResponse } from '../models/operations/events.js';
+export declare function listMeteringEvents(client: Client, req?: ListMeteringEventsRequest, options?: RequestOptions): Promise<Result<ListMeteringEventsResponse>>;
+export declare function ingestMeteringEvents(client: Client, req: IngestMeteringEventsRequest, options?: RequestOptions): Promise<Result<IngestMeteringEventsResponse>>;
+//# sourceMappingURL=events.d.ts.map

package/dist/funcs/events.js

@@ -0,0 +1,19 @@
+import { http } from '../core.js';
+import { request } from '../lib/request.js';
+import { toURLSearchParams, encodeSort } from '../lib/encodings.js';
+export function listMeteringEvents(client, req = {}, options) {
+    const searchParams = toURLSearchParams({
+        page: req.page,
+        filter: req.filter,
+        sort: encodeSort(req.sort),
+    });
+    return request(() => http(client)
+        .get('openmeter/events', { ...options, searchParams })
+        .json());
+}
+export function ingestMeteringEvents(client, req, options) {
+    return request(async () => {
+        await http(client).post('openmeter/events', { ...options, json: req });
+    });
+}
+//# sourceMappingURL=events.js.map

package/dist/funcs/features.d.ts

@@ -0,0 +1,10 @@
+import { type Client } from '../core.js';
+import { type Result, type RequestOptions } from '../lib/types.js';
+import type { ListFeaturesRequest, ListFeaturesResponse, CreateFeatureRequest, CreateFeatureResponse, GetFeatureRequest, GetFeatureResponse, UpdateFeatureRequest, UpdateFeatureResponse, DeleteFeatureRequest, DeleteFeatureResponse, QueryFeatureCostRequest, QueryFeatureCostResponse } from '../models/operations/features.js';
+export declare function listFeatures(client: Client, req?: ListFeaturesRequest, options?: RequestOptions): Promise<Result<ListFeaturesResponse>>;
+export declare function createFeature(client: Client, req: CreateFeatureRequest, options?: RequestOptions): Promise<Result<CreateFeatureResponse>>;
+export declare function getFeature(client: Client, req: GetFeatureRequest, options?: RequestOptions): Promise<Result<GetFeatureResponse>>;
+export declare function updateFeature(client: Client, req: UpdateFeatureRequest, options?: RequestOptions): Promise<Result<UpdateFeatureResponse>>;
+export declare function deleteFeature(client: Client, req: DeleteFeatureRequest, options?: RequestOptions): Promise<Result<DeleteFeatureResponse>>;
+export declare function queryFeatureCost(client: Client, req: QueryFeatureCostRequest, options?: RequestOptions): Promise<Result<QueryFeatureCostResponse>>;
+//# sourceMappingURL=features.d.ts.map

package/dist/funcs/features.js

@@ -0,0 +1,43 @@
+import { http } from '../core.js';
+import { request } from '../lib/request.js';
+import { encodePath, toURLSearchParams, encodeSort } from '../lib/encodings.js';
+export function listFeatures(client, req = {}, options) {
+    const searchParams = toURLSearchParams({
+        page: req.page,
+        sort: encodeSort(req.sort),
+        filter: req.filter,
+    });
+    return request(() => http(client)
+        .get('openmeter/features', { ...options, searchParams })
+        .json());
+}
+export function createFeature(client, req, options) {
+    return request(() => http(client)
+        .post('openmeter/features', { ...options, json: req })
+        .json());
+}
+export function getFeature(client, req, options) {
+    const path = encodePath('openmeter/features/{featureId}', { featureId: req.featureId });
+    return request(() => http(client)
+        .get(path, options)
+        .json());
+}
+export function updateFeature(client, req, options) {
+    const path = encodePath('openmeter/features/{featureId}', { featureId: req.featureId });
+    return request(() => http(client)
+        .patch(path, { ...options, json: req.body })
+        .json());
+}
+export function deleteFeature(client, req, options) {
+    const path = encodePath('openmeter/features/{featureId}', { featureId: req.featureId });
+    return request(async () => {
+        await http(client).delete(path, options);
+    });
+}
+export function queryFeatureCost(client, req, options) {
+    const path = encodePath('openmeter/features/{featureId}/cost/query', { featureId: req.featureId });
+    return request(() => http(client)
+        .post(path, { ...options, json: req.body })
+        .json());
+}
+//# sourceMappingURL=features.js.map

package/dist/funcs/governance.d.ts

@@ -0,0 +1,5 @@
+import { type Client } from '../core.js';
+import { type Result, type RequestOptions } from '../lib/types.js';
+import type { QueryGovernanceAccessRequest, QueryGovernanceAccessResponse } from '../models/operations/governance.js';
+export declare function queryGovernanceAccess(client: Client, req: QueryGovernanceAccessRequest, options?: RequestOptions): Promise<Result<QueryGovernanceAccessResponse>>;
+//# sourceMappingURL=governance.d.ts.map

package/dist/funcs/governance.js

@@ -0,0 +1,12 @@
+import { http } from '../core.js';
+import { request } from '../lib/request.js';
+import { toURLSearchParams } from '../lib/encodings.js';
+export function queryGovernanceAccess(client, req, options) {
+    const searchParams = toURLSearchParams({
+        page: req.page,
+    });
+    return request(() => http(client)
+        .post('openmeter/governance/query', { ...options, searchParams, json: req.body })
+        .json());
+}
+//# sourceMappingURL=governance.js.map

package/dist/funcs/index.d.ts

@@ -0,0 +1,17 @@
+export * from './events.js';
+export * from './meters.js';
+export * from './customers.js';
+export * from './entitlements.js';
+export * from './subscriptions.js';
+export * from './apps.js';
+export * from './billing.js';
+export * from './tax.js';
+export * from './currencies.js';
+export * from './features.js';
+export * from './llmCost.js';
+export * from './plans.js';
+export * from './addons.js';
+export * from './planAddons.js';
+export * from './defaults.js';
+export * from './governance.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/funcs/index.js

@@ -0,0 +1,17 @@
+export * from './events.js';
+export * from './meters.js';
+export * from './customers.js';
+export * from './entitlements.js';
+export * from './subscriptions.js';
+export * from './apps.js';
+export * from './billing.js';
+export * from './tax.js';
+export * from './currencies.js';
+export * from './features.js';
+export * from './llmCost.js';
+export * from './plans.js';
+export * from './addons.js';
+export * from './planAddons.js';
+export * from './defaults.js';
+export * from './governance.js';
+//# sourceMappingURL=index.js.map

package/dist/funcs/llmCost.d.ts

@@ -0,0 +1,9 @@
+import { type Client } from '../core.js';
+import { type Result, type RequestOptions } from '../lib/types.js';
+import type { ListLlmCostPricesRequest, ListLlmCostPricesResponse, GetLlmCostPriceRequest, GetLlmCostPriceResponse, ListLlmCostOverridesRequest, ListLlmCostOverridesResponse, CreateLlmCostOverrideRequest, CreateLlmCostOverrideResponse, DeleteLlmCostOverrideRequest, DeleteLlmCostOverrideResponse } from '../models/operations/llmCost.js';
+export declare function listLlmCostPrices(client: Client, req?: ListLlmCostPricesRequest, options?: RequestOptions): Promise<Result<ListLlmCostPricesResponse>>;
+export declare function getLlmCostPrice(client: Client, req: GetLlmCostPriceRequest, options?: RequestOptions): Promise<Result<GetLlmCostPriceResponse>>;
+export declare function listLlmCostOverrides(client: Client, req?: ListLlmCostOverridesRequest, options?: RequestOptions): Promise<Result<ListLlmCostOverridesResponse>>;
+export declare function createLlmCostOverride(client: Client, req: CreateLlmCostOverrideRequest, options?: RequestOptions): Promise<Result<CreateLlmCostOverrideResponse>>;
+export declare function deleteLlmCostOverride(client: Client, req: DeleteLlmCostOverrideRequest, options?: RequestOptions): Promise<Result<DeleteLlmCostOverrideResponse>>;
+//# sourceMappingURL=llmCost.d.ts.map

package/dist/funcs/llmCost.js

@@ -0,0 +1,40 @@
+import { http } from '../core.js';
+import { request } from '../lib/request.js';
+import { encodePath, toURLSearchParams, encodeSort } from '../lib/encodings.js';
+export function listLlmCostPrices(client, req = {}, options) {
+    const searchParams = toURLSearchParams({
+        filter: req.filter,
+        sort: encodeSort(req.sort),
+        page: req.page,
+    });
+    return request(() => http(client)
+        .get('openmeter/llm-cost/prices', { ...options, searchParams })
+        .json());
+}
+export function getLlmCostPrice(client, req, options) {
+    const path = encodePath('openmeter/llm-cost/prices/{priceId}', { priceId: req.priceId });
+    return request(() => http(client)
+        .get(path, options)
+        .json());
+}
+export function listLlmCostOverrides(client, req = {}, options) {
+    const searchParams = toURLSearchParams({
+        filter: req.filter,
+        page: req.page,
+    });
+    return request(() => http(client)
+        .get('openmeter/llm-cost/overrides', { ...options, searchParams })
+        .json());
+}
+export function createLlmCostOverride(client, req, options) {
+    return request(() => http(client)
+        .post('openmeter/llm-cost/overrides', { ...options, json: req })
+        .json());
+}
+export function deleteLlmCostOverride(client, req, options) {
+    const path = encodePath('openmeter/llm-cost/overrides/{priceId}', { priceId: req.priceId });
+    return request(async () => {
+        await http(client).delete(path, options);
+    });
+}
+//# sourceMappingURL=llmCost.js.map

package/dist/funcs/meters.d.ts

@@ -0,0 +1,10 @@
+import { type Client } from '../core.js';
+import { type Result, type RequestOptions } from '../lib/types.js';
+import type { CreateMeterRequest, CreateMeterResponse, GetMeterRequest, GetMeterResponse, ListMetersRequest, ListMetersResponse, UpdateMeterRequest, UpdateMeterResponse, DeleteMeterRequest, DeleteMeterResponse, QueryMeterRequest, QueryMeterResponse } from '../models/operations/meters.js';
+export declare function createMeter(client: Client, req: CreateMeterRequest, options?: RequestOptions): Promise<Result<CreateMeterResponse>>;
+export declare function getMeter(client: Client, req: GetMeterRequest, options?: RequestOptions): Promise<Result<GetMeterResponse>>;
+export declare function listMeters(client: Client, req?: ListMetersRequest, options?: RequestOptions): Promise<Result<ListMetersResponse>>;
+export declare function updateMeter(client: Client, req: UpdateMeterRequest, options?: RequestOptions): Promise<Result<UpdateMeterResponse>>;
+export declare function deleteMeter(client: Client, req: DeleteMeterRequest, options?: RequestOptions): Promise<Result<DeleteMeterResponse>>;
+export declare function queryMeter(client: Client, req: QueryMeterRequest, options?: RequestOptions): Promise<Result<QueryMeterResponse>>;
+//# sourceMappingURL=meters.d.ts.map

package/dist/funcs/meters.js

@@ -0,0 +1,43 @@
+import { http } from '../core.js';
+import { request } from '../lib/request.js';
+import { encodePath, toURLSearchParams, encodeSort } from '../lib/encodings.js';
+export function createMeter(client, req, options) {
+    return request(() => http(client)
+        .post('openmeter/meters', { ...options, json: req })
+        .json());
+}
+export function getMeter(client, req, options) {
+    const path = encodePath('openmeter/meters/{meterId}', { meterId: req.meterId });
+    return request(() => http(client)
+        .get(path, options)
+        .json());
+}
+export function listMeters(client, req = {}, options) {
+    const searchParams = toURLSearchParams({
+        page: req.page,
+        sort: encodeSort(req.sort),
+        filter: req.filter,
+    });
+    return request(() => http(client)
+        .get('openmeter/meters', { ...options, searchParams })
+        .json());
+}
+export function updateMeter(client, req, options) {
+    const path = encodePath('openmeter/meters/{meterId}', { meterId: req.meterId });
+    return request(() => http(client)
+        .put(path, { ...options, json: req.body })
+        .json());
+}
+export function deleteMeter(client, req, options) {
+    const path = encodePath('openmeter/meters/{meterId}', { meterId: req.meterId });
+    return request(async () => {
+        await http(client).delete(path, options);
+    });
+}
+export function queryMeter(client, req, options) {
+    const path = encodePath('openmeter/meters/{meterId}/query', { meterId: req.meterId });
+    return request(() => http(client)
+        .post(path, { ...options, json: req.body })
+        .json());
+}
+//# sourceMappingURL=meters.js.map

package/dist/funcs/planAddons.d.ts

@@ -0,0 +1,9 @@
+import { type Client } from '../core.js';
+import { type Result, type RequestOptions } from '../lib/types.js';
+import type { ListPlanAddonsRequest, ListPlanAddonsResponse, CreatePlanAddonRequest, CreatePlanAddonResponse, GetPlanAddonRequest, GetPlanAddonResponse, UpdatePlanAddonRequest, UpdatePlanAddonResponse, DeletePlanAddonRequest, DeletePlanAddonResponse } from '../models/operations/planAddons.js';
+export declare function listPlanAddons(client: Client, req: ListPlanAddonsRequest, options?: RequestOptions): Promise<Result<ListPlanAddonsResponse>>;
+export declare function createPlanAddon(client: Client, req: CreatePlanAddonRequest, options?: RequestOptions): Promise<Result<CreatePlanAddonResponse>>;
+export declare function getPlanAddon(client: Client, req: GetPlanAddonRequest, options?: RequestOptions): Promise<Result<GetPlanAddonResponse>>;
+export declare function updatePlanAddon(client: Client, req: UpdatePlanAddonRequest, options?: RequestOptions): Promise<Result<UpdatePlanAddonResponse>>;
+export declare function deletePlanAddon(client: Client, req: DeletePlanAddonRequest, options?: RequestOptions): Promise<Result<DeletePlanAddonResponse>>;
+//# sourceMappingURL=planAddons.d.ts.map

package/dist/funcs/planAddons.js

@@ -0,0 +1,37 @@
+import { http } from '../core.js';
+import { request } from '../lib/request.js';
+import { encodePath, toURLSearchParams } from '../lib/encodings.js';
+export function listPlanAddons(client, req, options) {
+    const searchParams = toURLSearchParams({
+        page: req.page,
+    });
+    const path = encodePath('openmeter/plans/{planId}/addons', { planId: req.planId });
+    return request(() => http(client)
+        .get(path, { ...options, searchParams })
+        .json());
+}
+export function createPlanAddon(client, req, options) {
+    const path = encodePath('openmeter/plans/{planId}/addons', { planId: req.planId });
+    return request(() => http(client)
+        .post(path, { ...options, json: req.body })
+        .json());
+}
+export function getPlanAddon(client, req, options) {
+    const path = encodePath('openmeter/plans/{planId}/addons/{planAddonId}', { planId: req.planId, planAddonId: req.planAddonId });
+    return request(() => http(client)
+        .get(path, options)
+        .json());
+}
+export function updatePlanAddon(client, req, options) {
+    const path = encodePath('openmeter/plans/{planId}/addons/{planAddonId}', { planId: req.planId, planAddonId: req.planAddonId });
+    return request(() => http(client)
+        .put(path, { ...options, json: req.body })
+        .json());
+}
+export function deletePlanAddon(client, req, options) {
+    const path = encodePath('openmeter/plans/{planId}/addons/{planAddonId}', { planId: req.planId, planAddonId: req.planAddonId });
+    return request(async () => {
+        await http(client).delete(path, options);
+    });
+}
+//# sourceMappingURL=planAddons.js.map

package/dist/funcs/plans.d.ts

@@ -0,0 +1,11 @@
+import { type Client } from '../core.js';
+import { type Result, type RequestOptions } from '../lib/types.js';
+import type { ListPlansRequest, ListPlansResponse, CreatePlanRequest, CreatePlanResponse, UpdatePlanRequest, UpdatePlanResponse, GetPlanRequest, GetPlanResponse, DeletePlanRequest, DeletePlanResponse, ArchivePlanRequest, ArchivePlanResponse, PublishPlanRequest, PublishPlanResponse } from '../models/operations/plans.js';
+export declare function listPlans(client: Client, req?: ListPlansRequest, options?: RequestOptions): Promise<Result<ListPlansResponse>>;
+export declare function createPlan(client: Client, req: CreatePlanRequest, options?: RequestOptions): Promise<Result<CreatePlanResponse>>;
+export declare function updatePlan(client: Client, req: UpdatePlanRequest, options?: RequestOptions): Promise<Result<UpdatePlanResponse>>;
+export declare function getPlan(client: Client, req: GetPlanRequest, options?: RequestOptions): Promise<Result<GetPlanResponse>>;
+export declare function deletePlan(client: Client, req: DeletePlanRequest, options?: RequestOptions): Promise<Result<DeletePlanResponse>>;
+export declare function archivePlan(client: Client, req: ArchivePlanRequest, options?: RequestOptions): Promise<Result<ArchivePlanResponse>>;
+export declare function publishPlan(client: Client, req: PublishPlanRequest, options?: RequestOptions): Promise<Result<PublishPlanResponse>>;
+//# sourceMappingURL=plans.d.ts.map

package/dist/funcs/plans.js

@@ -0,0 +1,49 @@
+import { http } from '../core.js';
+import { request } from '../lib/request.js';
+import { encodePath, toURLSearchParams, encodeSort } from '../lib/encodings.js';
+export function listPlans(client, req = {}, options) {
+    const searchParams = toURLSearchParams({
+        page: req.page,
+        sort: encodeSort(req.sort),
+        filter: req.filter,
+    });
+    return request(() => http(client)
+        .get('openmeter/plans', { ...options, searchParams })
+        .json());
+}
+export function createPlan(client, req, options) {
+    return request(() => http(client)
+        .post('openmeter/plans', { ...options, json: req })
+        .json());
+}
+export function updatePlan(client, req, options) {
+    const path = encodePath('openmeter/plans/{planId}', { planId: req.planId });
+    return request(() => http(client)
+        .put(path, { ...options, json: req.body })
+        .json());
+}
+export function getPlan(client, req, options) {
+    const path = encodePath('openmeter/plans/{planId}', { planId: req.planId });
+    return request(() => http(client)
+        .get(path, options)
+        .json());
+}
+export function deletePlan(client, req, options) {
+    const path = encodePath('openmeter/plans/{planId}', { planId: req.planId });
+    return request(async () => {
+        await http(client).delete(path, options);
+    });
+}
+export function archivePlan(client, req, options) {
+    const path = encodePath('openmeter/plans/{planId}/archive', { planId: req.planId });
+    return request(() => http(client)
+        .post(path, options)
+        .json());
+}
+export function publishPlan(client, req, options) {
+    const path = encodePath('openmeter/plans/{planId}/publish', { planId: req.planId });
+    return request(() => http(client)
+        .post(path, options)
+        .json());
+}
+//# sourceMappingURL=plans.js.map

package/dist/funcs/subscriptions.d.ts

@@ -0,0 +1,12 @@
+import { type Client } from '../core.js';
+import { type Result, type RequestOptions } from '../lib/types.js';
+import type { CreateSubscriptionRequest, CreateSubscriptionResponse, ListSubscriptionsRequest, ListSubscriptionsResponse, GetSubscriptionRequest, GetSubscriptionResponse, CancelSubscriptionRequest, CancelSubscriptionResponse, UnscheduleCancelationRequest, UnscheduleCancelationResponse, ChangeSubscriptionRequest, ChangeSubscriptionResponse, ListSubscriptionAddonsRequest, ListSubscriptionAddonsResponse, GetSubscriptionAddonRequest, GetSubscriptionAddonResponse } from '../models/operations/subscriptions.js';
+export declare function createSubscription(client: Client, req: CreateSubscriptionRequest, options?: RequestOptions): Promise<Result<CreateSubscriptionResponse>>;
+export declare function listSubscriptions(client: Client, req?: ListSubscriptionsRequest, options?: RequestOptions): Promise<Result<ListSubscriptionsResponse>>;
+export declare function getSubscription(client: Client, req: GetSubscriptionRequest, options?: RequestOptions): Promise<Result<GetSubscriptionResponse>>;
+export declare function cancelSubscription(client: Client, req: CancelSubscriptionRequest, options?: RequestOptions): Promise<Result<CancelSubscriptionResponse>>;
+export declare function unscheduleCancelation(client: Client, req: UnscheduleCancelationRequest, options?: RequestOptions): Promise<Result<UnscheduleCancelationResponse>>;
+export declare function changeSubscription(client: Client, req: ChangeSubscriptionRequest, options?: RequestOptions): Promise<Result<ChangeSubscriptionResponse>>;
+export declare function listSubscriptionAddons(client: Client, req: ListSubscriptionAddonsRequest, options?: RequestOptions): Promise<Result<ListSubscriptionAddonsResponse>>;
+export declare function getSubscriptionAddon(client: Client, req: GetSubscriptionAddonRequest, options?: RequestOptions): Promise<Result<GetSubscriptionAddonResponse>>;
+//# sourceMappingURL=subscriptions.d.ts.map

package/dist/funcs/subscriptions.js

@@ -0,0 +1,59 @@
+import { http } from '../core.js';
+import { request } from '../lib/request.js';
+import { encodePath, toURLSearchParams, encodeSort } from '../lib/encodings.js';
+export function createSubscription(client, req, options) {
+    return request(() => http(client)
+        .post('openmeter/subscriptions', { ...options, json: req })
+        .json());
+}
+export function listSubscriptions(client, req = {}, options) {
+    const searchParams = toURLSearchParams({
+        page: req.page,
+        sort: encodeSort(req.sort),
+        filter: req.filter,
+    });
+    return request(() => http(client)
+        .get('openmeter/subscriptions', { ...options, searchParams })
+        .json());
+}
+export function getSubscription(client, req, options) {
+    const path = encodePath('openmeter/subscriptions/{subscriptionId}', { subscriptionId: req.subscriptionId });
+    return request(() => http(client)
+        .get(path, options)
+        .json());
+}
+export function cancelSubscription(client, req, options) {
+    const path = encodePath('openmeter/subscriptions/{subscriptionId}/cancel', { subscriptionId: req.subscriptionId });
+    return request(() => http(client)
+        .post(path, { ...options, json: req.body })
+        .json());
+}
+export function unscheduleCancelation(client, req, options) {
+    const path = encodePath('openmeter/subscriptions/{subscriptionId}/unschedule-cancelation', { subscriptionId: req.subscriptionId });
+    return request(() => http(client)
+        .post(path, options)
+        .json());
+}
+export function changeSubscription(client, req, options) {
+    const path = encodePath('openmeter/subscriptions/{subscriptionId}/change', { subscriptionId: req.subscriptionId });
+    return request(() => http(client)
+        .post(path, { ...options, json: req.body })
+        .json());
+}
+export function listSubscriptionAddons(client, req, options) {
+    const searchParams = toURLSearchParams({
+        page: req.page,
+        sort: encodeSort(req.sort),
+    });
+    const path = encodePath('openmeter/subscriptions/{subscriptionId}/addons', { subscriptionId: req.subscriptionId });
+    return request(() => http(client)
+        .get(path, { ...options, searchParams })
+        .json());
+}
+export function getSubscriptionAddon(client, req, options) {
+    const path = encodePath('openmeter/subscriptions/{subscriptionId}/addons/{subscriptionAddonId}', { subscriptionId: req.subscriptionId, subscriptionAddonId: req.subscriptionAddonId });
+    return request(() => http(client)
+        .get(path, options)
+        .json());
+}
+//# sourceMappingURL=subscriptions.js.map

package/dist/funcs/tax.d.ts

@@ -0,0 +1,9 @@
+import { type Client } from '../core.js';
+import { type Result, type RequestOptions } from '../lib/types.js';
+import type { CreateTaxCodeRequest, CreateTaxCodeResponse, GetTaxCodeRequest, GetTaxCodeResponse, ListTaxCodesRequest, ListTaxCodesResponse, UpsertTaxCodeRequest, UpsertTaxCodeResponse, DeleteTaxCodeRequest, DeleteTaxCodeResponse } from '../models/operations/tax.js';
+export declare function createTaxCode(client: Client, req: CreateTaxCodeRequest, options?: RequestOptions): Promise<Result<CreateTaxCodeResponse>>;
+export declare function getTaxCode(client: Client, req: GetTaxCodeRequest, options?: RequestOptions): Promise<Result<GetTaxCodeResponse>>;
+export declare function listTaxCodes(client: Client, req?: ListTaxCodesRequest, options?: RequestOptions): Promise<Result<ListTaxCodesResponse>>;
+export declare function upsertTaxCode(client: Client, req: UpsertTaxCodeRequest, options?: RequestOptions): Promise<Result<UpsertTaxCodeResponse>>;
+export declare function deleteTaxCode(client: Client, req: DeleteTaxCodeRequest, options?: RequestOptions): Promise<Result<DeleteTaxCodeResponse>>;
+//# sourceMappingURL=tax.d.ts.map