@openmeter/client 1.0.0-beta-4bc7392a70e6

package/dist/models/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/sdk/addons.d.ts

@@ -0,0 +1,15 @@
+import { type Client } from '../core.js';
+import { 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 class Addons {
+    private readonly _client;
+    constructor(_client: Client);
+    list(request?: ListAddonsRequest, options?: RequestOptions): Promise<ListAddonsResponse>;
+    create(request: CreateAddonRequest, options?: RequestOptions): Promise<CreateAddonResponse>;
+    update(request: UpdateAddonRequest, options?: RequestOptions): Promise<UpdateAddonResponse>;
+    get(request: GetAddonRequest, options?: RequestOptions): Promise<GetAddonResponse>;
+    delete(request: DeleteAddonRequest, options?: RequestOptions): Promise<DeleteAddonResponse>;
+    archive(request: ArchiveAddonRequest, options?: RequestOptions): Promise<ArchiveAddonResponse>;
+    publish(request: PublishAddonRequest, options?: RequestOptions): Promise<PublishAddonResponse>;
+}
+//# sourceMappingURL=addons.d.ts.map

package/dist/sdk/addons.js

@@ -0,0 +1,30 @@
+import { unwrap } from '../lib/types.js';
+import { listAddons, createAddon, updateAddon, getAddon, deleteAddon, archiveAddon, publishAddon, } from '../funcs/addons.js';
+export class Addons {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async list(request, options) {
+        return unwrap(await listAddons(this._client, request, options));
+    }
+    async create(request, options) {
+        return unwrap(await createAddon(this._client, request, options));
+    }
+    async update(request, options) {
+        return unwrap(await updateAddon(this._client, request, options));
+    }
+    async get(request, options) {
+        return unwrap(await getAddon(this._client, request, options));
+    }
+    async delete(request, options) {
+        return unwrap(await deleteAddon(this._client, request, options));
+    }
+    async archive(request, options) {
+        return unwrap(await archiveAddon(this._client, request, options));
+    }
+    async publish(request, options) {
+        return unwrap(await publishAddon(this._client, request, options));
+    }
+}
+//# sourceMappingURL=addons.js.map

package/dist/sdk/apps.d.ts

@@ -0,0 +1,10 @@
+import { type Client } from '../core.js';
+import { type RequestOptions } from '../lib/types.js';
+import type { ListAppsRequest, ListAppsResponse, GetAppRequest, GetAppResponse } from '../models/operations/apps.js';
+export declare class Apps {
+    private readonly _client;
+    constructor(_client: Client);
+    list(request?: ListAppsRequest, options?: RequestOptions): Promise<ListAppsResponse>;
+    get(request: GetAppRequest, options?: RequestOptions): Promise<GetAppResponse>;
+}
+//# sourceMappingURL=apps.d.ts.map

package/dist/sdk/apps.js

@@ -0,0 +1,15 @@
+import { unwrap } from '../lib/types.js';
+import { listApps, getApp } from '../funcs/apps.js';
+export class Apps {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async list(request, options) {
+        return unwrap(await listApps(this._client, request, options));
+    }
+    async get(request, options) {
+        return unwrap(await getApp(this._client, request, options));
+    }
+}
+//# sourceMappingURL=apps.js.map

package/dist/sdk/billing.d.ts

@@ -0,0 +1,13 @@
+import { type Client } from '../core.js';
+import { 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 class Billing {
+    private readonly _client;
+    constructor(_client: Client);
+    listProfiles(request?: ListBillingProfilesRequest, options?: RequestOptions): Promise<ListBillingProfilesResponse>;
+    createProfile(request: CreateBillingProfileRequest, options?: RequestOptions): Promise<CreateBillingProfileResponse>;
+    getProfile(request: GetBillingProfileRequest, options?: RequestOptions): Promise<GetBillingProfileResponse>;
+    updateProfile(request: UpdateBillingProfileRequest, options?: RequestOptions): Promise<UpdateBillingProfileResponse>;
+    deleteProfile(request: DeleteBillingProfileRequest, options?: RequestOptions): Promise<DeleteBillingProfileResponse>;
+}
+//# sourceMappingURL=billing.d.ts.map

package/dist/sdk/billing.js

@@ -0,0 +1,24 @@
+import { unwrap } from '../lib/types.js';
+import { listBillingProfiles, createBillingProfile, getBillingProfile, updateBillingProfile, deleteBillingProfile, } from '../funcs/billing.js';
+export class Billing {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async listProfiles(request, options) {
+        return unwrap(await listBillingProfiles(this._client, request, options));
+    }
+    async createProfile(request, options) {
+        return unwrap(await createBillingProfile(this._client, request, options));
+    }
+    async getProfile(request, options) {
+        return unwrap(await getBillingProfile(this._client, request, options));
+    }
+    async updateProfile(request, options) {
+        return unwrap(await updateBillingProfile(this._client, request, options));
+    }
+    async deleteProfile(request, options) {
+        return unwrap(await deleteBillingProfile(this._client, request, options));
+    }
+}
+//# sourceMappingURL=billing.js.map

package/dist/sdk/currencies.d.ts

@@ -0,0 +1,12 @@
+import { type Client } from '../core.js';
+import { type RequestOptions } from '../lib/types.js';
+import type { ListCurrenciesRequest, ListCurrenciesResponse, CreateCustomCurrencyRequest, CreateCustomCurrencyResponse, ListCostBasesRequest, ListCostBasesResponse, CreateCostBasisRequest, CreateCostBasisResponse } from '../models/operations/currencies.js';
+export declare class Currencies {
+    private readonly _client;
+    constructor(_client: Client);
+    list(request?: ListCurrenciesRequest, options?: RequestOptions): Promise<ListCurrenciesResponse>;
+    createCustomCurrency(request: CreateCustomCurrencyRequest, options?: RequestOptions): Promise<CreateCustomCurrencyResponse>;
+    listCostBases(request: ListCostBasesRequest, options?: RequestOptions): Promise<ListCostBasesResponse>;
+    createCostBasis(request: CreateCostBasisRequest, options?: RequestOptions): Promise<CreateCostBasisResponse>;
+}
+//# sourceMappingURL=currencies.d.ts.map

package/dist/sdk/currencies.js

@@ -0,0 +1,21 @@
+import { unwrap } from '../lib/types.js';
+import { listCurrencies, createCustomCurrency, listCostBases, createCostBasis, } from '../funcs/currencies.js';
+export class Currencies {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async list(request, options) {
+        return unwrap(await listCurrencies(this._client, request, options));
+    }
+    async createCustomCurrency(request, options) {
+        return unwrap(await createCustomCurrency(this._client, request, options));
+    }
+    async listCostBases(request, options) {
+        return unwrap(await listCostBases(this._client, request, options));
+    }
+    async createCostBasis(request, options) {
+        return unwrap(await createCostBasis(this._client, request, options));
+    }
+}
+//# sourceMappingURL=currencies.js.map

package/dist/sdk/customers.d.ts

@@ -0,0 +1,67 @@
+import { type Client } from '../core.js';
+import { 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 class Customers {
+    private readonly _client;
+    constructor(_client: Client);
+    create(request: CreateCustomerRequest, options?: RequestOptions): Promise<CreateCustomerResponse>;
+    get(request: GetCustomerRequest, options?: RequestOptions): Promise<GetCustomerResponse>;
+    list(request?: ListCustomersRequest, options?: RequestOptions): Promise<ListCustomersResponse>;
+    upsert(request: UpsertCustomerRequest, options?: RequestOptions): Promise<UpsertCustomerResponse>;
+    delete(request: DeleteCustomerRequest, options?: RequestOptions): Promise<DeleteCustomerResponse>;
+    private _billing?;
+    get billing(): CustomersBilling;
+    private _credits?;
+    get credits(): CustomersCredits;
+    private _charges?;
+    get charges(): CustomersCharges;
+}
+export declare class CustomersBilling {
+    private readonly _client;
+    constructor(_client: Client);
+    get(request: GetCustomerBillingRequest, options?: RequestOptions): Promise<GetCustomerBillingResponse>;
+    update(request: UpdateCustomerBillingRequest, options?: RequestOptions): Promise<UpdateCustomerBillingResponse>;
+    updateAppData(request: UpdateCustomerBillingAppDataRequest, options?: RequestOptions): Promise<UpdateCustomerBillingAppDataResponse>;
+    createStripeCheckoutSession(request: CreateCustomerStripeCheckoutSessionRequest, options?: RequestOptions): Promise<CreateCustomerStripeCheckoutSessionResponse>;
+    createStripePortalSession(request: CreateCustomerStripePortalSessionRequest, options?: RequestOptions): Promise<CreateCustomerStripePortalSessionResponse>;
+}
+export declare class CustomersCredits {
+    private readonly _client;
+    constructor(_client: Client);
+    private _grants?;
+    get grants(): CustomersCreditsGrants;
+    private _balance?;
+    get balance(): CustomersCreditsBalance;
+    private _adjustments?;
+    get adjustments(): CustomersCreditsAdjustments;
+    private _transactions?;
+    get transactions(): CustomersCreditsTransactions;
+}
+export declare class CustomersCreditsGrants {
+    private readonly _client;
+    constructor(_client: Client);
+    create(request: CreateCreditGrantRequest, options?: RequestOptions): Promise<CreateCreditGrantResponse>;
+    get(request: GetCreditGrantRequest, options?: RequestOptions): Promise<GetCreditGrantResponse>;
+    list(request: ListCreditGrantsRequest, options?: RequestOptions): Promise<ListCreditGrantsResponse>;
+}
+export declare class CustomersCreditsBalance {
+    private readonly _client;
+    constructor(_client: Client);
+    get(request: GetCustomerCreditBalanceRequest, options?: RequestOptions): Promise<GetCustomerCreditBalanceResponse>;
+}
+export declare class CustomersCreditsAdjustments {
+    private readonly _client;
+    constructor(_client: Client);
+    create(request: CreateCreditAdjustmentRequest, options?: RequestOptions): Promise<CreateCreditAdjustmentResponse>;
+}
+export declare class CustomersCreditsTransactions {
+    private readonly _client;
+    constructor(_client: Client);
+    list(request: ListCreditTransactionsRequest, options?: RequestOptions): Promise<ListCreditTransactionsResponse>;
+}
+export declare class CustomersCharges {
+    private readonly _client;
+    constructor(_client: Client);
+    list(request: ListCustomerChargesRequest, options?: RequestOptions): Promise<ListCustomerChargesResponse>;
+}
+//# sourceMappingURL=customers.d.ts.map

package/dist/sdk/customers.js

@@ -0,0 +1,130 @@
+import { unwrap } from '../lib/types.js';
+import { createCustomer, getCustomer, listCustomers, upsertCustomer, deleteCustomer, getCustomerBilling, updateCustomerBilling, updateCustomerBillingAppData, createCustomerStripeCheckoutSession, createCustomerStripePortalSession, createCreditGrant, getCreditGrant, listCreditGrants, getCustomerCreditBalance, createCreditAdjustment, listCreditTransactions, listCustomerCharges, } from '../funcs/customers.js';
+export class Customers {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async create(request, options) {
+        return unwrap(await createCustomer(this._client, request, options));
+    }
+    async get(request, options) {
+        return unwrap(await getCustomer(this._client, request, options));
+    }
+    async list(request, options) {
+        return unwrap(await listCustomers(this._client, request, options));
+    }
+    async upsert(request, options) {
+        return unwrap(await upsertCustomer(this._client, request, options));
+    }
+    async delete(request, options) {
+        return unwrap(await deleteCustomer(this._client, request, options));
+    }
+    _billing;
+    get billing() {
+        return (this._billing ??= new CustomersBilling(this._client));
+    }
+    _credits;
+    get credits() {
+        return (this._credits ??= new CustomersCredits(this._client));
+    }
+    _charges;
+    get charges() {
+        return (this._charges ??= new CustomersCharges(this._client));
+    }
+}
+export class CustomersBilling {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async get(request, options) {
+        return unwrap(await getCustomerBilling(this._client, request, options));
+    }
+    async update(request, options) {
+        return unwrap(await updateCustomerBilling(this._client, request, options));
+    }
+    async updateAppData(request, options) {
+        return unwrap(await updateCustomerBillingAppData(this._client, request, options));
+    }
+    async createStripeCheckoutSession(request, options) {
+        return unwrap(await createCustomerStripeCheckoutSession(this._client, request, options));
+    }
+    async createStripePortalSession(request, options) {
+        return unwrap(await createCustomerStripePortalSession(this._client, request, options));
+    }
+}
+export class CustomersCredits {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    _grants;
+    get grants() {
+        return (this._grants ??= new CustomersCreditsGrants(this._client));
+    }
+    _balance;
+    get balance() {
+        return (this._balance ??= new CustomersCreditsBalance(this._client));
+    }
+    _adjustments;
+    get adjustments() {
+        return (this._adjustments ??= new CustomersCreditsAdjustments(this._client));
+    }
+    _transactions;
+    get transactions() {
+        return (this._transactions ??= new CustomersCreditsTransactions(this._client));
+    }
+}
+export class CustomersCreditsGrants {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async create(request, options) {
+        return unwrap(await createCreditGrant(this._client, request, options));
+    }
+    async get(request, options) {
+        return unwrap(await getCreditGrant(this._client, request, options));
+    }
+    async list(request, options) {
+        return unwrap(await listCreditGrants(this._client, request, options));
+    }
+}
+export class CustomersCreditsBalance {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async get(request, options) {
+        return unwrap(await getCustomerCreditBalance(this._client, request, options));
+    }
+}
+export class CustomersCreditsAdjustments {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async create(request, options) {
+        return unwrap(await createCreditAdjustment(this._client, request, options));
+    }
+}
+export class CustomersCreditsTransactions {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async list(request, options) {
+        return unwrap(await listCreditTransactions(this._client, request, options));
+    }
+}
+export class CustomersCharges {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async list(request, options) {
+        return unwrap(await listCustomerCharges(this._client, request, options));
+    }
+}
+//# sourceMappingURL=customers.js.map

package/dist/sdk/defaults.d.ts

@@ -0,0 +1,10 @@
+import { type Client } from '../core.js';
+import { type RequestOptions } from '../lib/types.js';
+import type { GetOrganizationDefaultTaxCodesRequest, GetOrganizationDefaultTaxCodesResponse, UpdateOrganizationDefaultTaxCodesRequest, UpdateOrganizationDefaultTaxCodesResponse } from '../models/operations/defaults.js';
+export declare class Defaults {
+    private readonly _client;
+    constructor(_client: Client);
+    getOrganizationTaxCodes(request: GetOrganizationDefaultTaxCodesRequest, options?: RequestOptions): Promise<GetOrganizationDefaultTaxCodesResponse>;
+    updateOrganizationTaxCodes(request: UpdateOrganizationDefaultTaxCodesRequest, options?: RequestOptions): Promise<UpdateOrganizationDefaultTaxCodesResponse>;
+}
+//# sourceMappingURL=defaults.d.ts.map

package/dist/sdk/defaults.js

@@ -0,0 +1,15 @@
+import { unwrap } from '../lib/types.js';
+import { getOrganizationDefaultTaxCodes, updateOrganizationDefaultTaxCodes, } from '../funcs/defaults.js';
+export class Defaults {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async getOrganizationTaxCodes(request, options) {
+        return unwrap(await getOrganizationDefaultTaxCodes(this._client, request, options));
+    }
+    async updateOrganizationTaxCodes(request, options) {
+        return unwrap(await updateOrganizationDefaultTaxCodes(this._client, request, options));
+    }
+}
+//# sourceMappingURL=defaults.js.map

package/dist/sdk/entitlements.d.ts

@@ -0,0 +1,9 @@
+import { type Client } from '../core.js';
+import { type RequestOptions } from '../lib/types.js';
+import type { ListCustomerEntitlementAccessRequest, ListCustomerEntitlementAccessResponse } from '../models/operations/entitlements.js';
+export declare class Entitlements {
+    private readonly _client;
+    constructor(_client: Client);
+    listCustomerAccess(request: ListCustomerEntitlementAccessRequest, options?: RequestOptions): Promise<ListCustomerEntitlementAccessResponse>;
+}
+//# sourceMappingURL=entitlements.d.ts.map

package/dist/sdk/entitlements.js

@@ -0,0 +1,12 @@
+import { unwrap } from '../lib/types.js';
+import { listCustomerEntitlementAccess } from '../funcs/entitlements.js';
+export class Entitlements {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async listCustomerAccess(request, options) {
+        return unwrap(await listCustomerEntitlementAccess(this._client, request, options));
+    }
+}
+//# sourceMappingURL=entitlements.js.map

package/dist/sdk/events.d.ts

@@ -0,0 +1,10 @@
+import { type Client } from '../core.js';
+import { type RequestOptions } from '../lib/types.js';
+import type { ListMeteringEventsRequest, ListMeteringEventsResponse, IngestMeteringEventsRequest, IngestMeteringEventsResponse } from '../models/operations/events.js';
+export declare class Events {
+    private readonly _client;
+    constructor(_client: Client);
+    list(request?: ListMeteringEventsRequest, options?: RequestOptions): Promise<ListMeteringEventsResponse>;
+    ingest(request: IngestMeteringEventsRequest, options?: RequestOptions): Promise<IngestMeteringEventsResponse>;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/sdk/events.js

@@ -0,0 +1,15 @@
+import { unwrap } from '../lib/types.js';
+import { listMeteringEvents, ingestMeteringEvents } from '../funcs/events.js';
+export class Events {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async list(request, options) {
+        return unwrap(await listMeteringEvents(this._client, request, options));
+    }
+    async ingest(request, options) {
+        return unwrap(await ingestMeteringEvents(this._client, request, options));
+    }
+}
+//# sourceMappingURL=events.js.map

package/dist/sdk/features.d.ts

@@ -0,0 +1,14 @@
+import { type Client } from '../core.js';
+import { 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 class Features {
+    private readonly _client;
+    constructor(_client: Client);
+    list(request?: ListFeaturesRequest, options?: RequestOptions): Promise<ListFeaturesResponse>;
+    create(request: CreateFeatureRequest, options?: RequestOptions): Promise<CreateFeatureResponse>;
+    get(request: GetFeatureRequest, options?: RequestOptions): Promise<GetFeatureResponse>;
+    update(request: UpdateFeatureRequest, options?: RequestOptions): Promise<UpdateFeatureResponse>;
+    delete(request: DeleteFeatureRequest, options?: RequestOptions): Promise<DeleteFeatureResponse>;
+    queryCost(request: QueryFeatureCostRequest, options?: RequestOptions): Promise<QueryFeatureCostResponse>;
+}
+//# sourceMappingURL=features.d.ts.map

package/dist/sdk/features.js

@@ -0,0 +1,27 @@
+import { unwrap } from '../lib/types.js';
+import { listFeatures, createFeature, getFeature, updateFeature, deleteFeature, queryFeatureCost, } from '../funcs/features.js';
+export class Features {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async list(request, options) {
+        return unwrap(await listFeatures(this._client, request, options));
+    }
+    async create(request, options) {
+        return unwrap(await createFeature(this._client, request, options));
+    }
+    async get(request, options) {
+        return unwrap(await getFeature(this._client, request, options));
+    }
+    async update(request, options) {
+        return unwrap(await updateFeature(this._client, request, options));
+    }
+    async delete(request, options) {
+        return unwrap(await deleteFeature(this._client, request, options));
+    }
+    async queryCost(request, options) {
+        return unwrap(await queryFeatureCost(this._client, request, options));
+    }
+}
+//# sourceMappingURL=features.js.map

package/dist/sdk/governance.d.ts

@@ -0,0 +1,9 @@
+import { type Client } from '../core.js';
+import { type RequestOptions } from '../lib/types.js';
+import type { QueryGovernanceAccessRequest, QueryGovernanceAccessResponse } from '../models/operations/governance.js';
+export declare class Governance {
+    private readonly _client;
+    constructor(_client: Client);
+    queryAccess(request: QueryGovernanceAccessRequest, options?: RequestOptions): Promise<QueryGovernanceAccessResponse>;
+}
+//# sourceMappingURL=governance.d.ts.map

package/dist/sdk/governance.js

@@ -0,0 +1,12 @@
+import { unwrap } from '../lib/types.js';
+import { queryGovernanceAccess } from '../funcs/governance.js';
+export class Governance {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async queryAccess(request, options) {
+        return unwrap(await queryGovernanceAccess(this._client, request, options));
+    }
+}
+//# sourceMappingURL=governance.js.map

package/dist/sdk/llmCost.d.ts

@@ -0,0 +1,13 @@
+import { type Client } from '../core.js';
+import { 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 class LLMCost {
+    private readonly _client;
+    constructor(_client: Client);
+    listPrices(request?: ListLlmCostPricesRequest, options?: RequestOptions): Promise<ListLlmCostPricesResponse>;
+    getPrice(request: GetLlmCostPriceRequest, options?: RequestOptions): Promise<GetLlmCostPriceResponse>;
+    listOverrides(request?: ListLlmCostOverridesRequest, options?: RequestOptions): Promise<ListLlmCostOverridesResponse>;
+    createOverride(request: CreateLlmCostOverrideRequest, options?: RequestOptions): Promise<CreateLlmCostOverrideResponse>;
+    deleteOverride(request: DeleteLlmCostOverrideRequest, options?: RequestOptions): Promise<DeleteLlmCostOverrideResponse>;
+}
+//# sourceMappingURL=llmCost.d.ts.map

package/dist/sdk/llmCost.js

@@ -0,0 +1,24 @@
+import { unwrap } from '../lib/types.js';
+import { listLlmCostPrices, getLlmCostPrice, listLlmCostOverrides, createLlmCostOverride, deleteLlmCostOverride, } from '../funcs/llmCost.js';
+export class LLMCost {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async listPrices(request, options) {
+        return unwrap(await listLlmCostPrices(this._client, request, options));
+    }
+    async getPrice(request, options) {
+        return unwrap(await getLlmCostPrice(this._client, request, options));
+    }
+    async listOverrides(request, options) {
+        return unwrap(await listLlmCostOverrides(this._client, request, options));
+    }
+    async createOverride(request, options) {
+        return unwrap(await createLlmCostOverride(this._client, request, options));
+    }
+    async deleteOverride(request, options) {
+        return unwrap(await deleteLlmCostOverride(this._client, request, options));
+    }
+}
+//# sourceMappingURL=llmCost.js.map

package/dist/sdk/meters.d.ts

@@ -0,0 +1,14 @@
+import { type Client } from '../core.js';
+import { 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 class Meters {
+    private readonly _client;
+    constructor(_client: Client);
+    create(request: CreateMeterRequest, options?: RequestOptions): Promise<CreateMeterResponse>;
+    get(request: GetMeterRequest, options?: RequestOptions): Promise<GetMeterResponse>;
+    list(request?: ListMetersRequest, options?: RequestOptions): Promise<ListMetersResponse>;
+    update(request: UpdateMeterRequest, options?: RequestOptions): Promise<UpdateMeterResponse>;
+    delete(request: DeleteMeterRequest, options?: RequestOptions): Promise<DeleteMeterResponse>;
+    query(request: QueryMeterRequest, options?: RequestOptions): Promise<QueryMeterResponse>;
+}
+//# sourceMappingURL=meters.d.ts.map

package/dist/sdk/meters.js

@@ -0,0 +1,27 @@
+import { unwrap } from '../lib/types.js';
+import { createMeter, getMeter, listMeters, updateMeter, deleteMeter, queryMeter, } from '../funcs/meters.js';
+export class Meters {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async create(request, options) {
+        return unwrap(await createMeter(this._client, request, options));
+    }
+    async get(request, options) {
+        return unwrap(await getMeter(this._client, request, options));
+    }
+    async list(request, options) {
+        return unwrap(await listMeters(this._client, request, options));
+    }
+    async update(request, options) {
+        return unwrap(await updateMeter(this._client, request, options));
+    }
+    async delete(request, options) {
+        return unwrap(await deleteMeter(this._client, request, options));
+    }
+    async query(request, options) {
+        return unwrap(await queryMeter(this._client, request, options));
+    }
+}
+//# sourceMappingURL=meters.js.map

package/dist/sdk/planAddons.d.ts

@@ -0,0 +1,13 @@
+import { type Client } from '../core.js';
+import { 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 class PlanAddons {
+    private readonly _client;
+    constructor(_client: Client);
+    list(request: ListPlanAddonsRequest, options?: RequestOptions): Promise<ListPlanAddonsResponse>;
+    create(request: CreatePlanAddonRequest, options?: RequestOptions): Promise<CreatePlanAddonResponse>;
+    get(request: GetPlanAddonRequest, options?: RequestOptions): Promise<GetPlanAddonResponse>;
+    update(request: UpdatePlanAddonRequest, options?: RequestOptions): Promise<UpdatePlanAddonResponse>;
+    delete(request: DeletePlanAddonRequest, options?: RequestOptions): Promise<DeletePlanAddonResponse>;
+}
+//# sourceMappingURL=planAddons.d.ts.map

package/dist/sdk/planAddons.js

@@ -0,0 +1,24 @@
+import { unwrap } from '../lib/types.js';
+import { listPlanAddons, createPlanAddon, getPlanAddon, updatePlanAddon, deletePlanAddon, } from '../funcs/planAddons.js';
+export class PlanAddons {
+    _client;
+    constructor(_client) {
+        this._client = _client;
+    }
+    async list(request, options) {
+        return unwrap(await listPlanAddons(this._client, request, options));
+    }
+    async create(request, options) {
+        return unwrap(await createPlanAddon(this._client, request, options));
+    }
+    async get(request, options) {
+        return unwrap(await getPlanAddon(this._client, request, options));
+    }
+    async update(request, options) {
+        return unwrap(await updatePlanAddon(this._client, request, options));
+    }
+    async delete(request, options) {
+        return unwrap(await deletePlanAddon(this._client, request, options));
+    }
+}
+//# sourceMappingURL=planAddons.js.map

package/dist/sdk/plans.d.ts

@@ -0,0 +1,15 @@
+import { type Client } from '../core.js';
+import { 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 class Plans {
+    private readonly _client;
+    constructor(_client: Client);
+    list(request?: ListPlansRequest, options?: RequestOptions): Promise<ListPlansResponse>;
+    create(request: CreatePlanRequest, options?: RequestOptions): Promise<CreatePlanResponse>;
+    update(request: UpdatePlanRequest, options?: RequestOptions): Promise<UpdatePlanResponse>;
+    get(request: GetPlanRequest, options?: RequestOptions): Promise<GetPlanResponse>;
+    delete(request: DeletePlanRequest, options?: RequestOptions): Promise<DeletePlanResponse>;
+    archive(request: ArchivePlanRequest, options?: RequestOptions): Promise<ArchivePlanResponse>;
+    publish(request: PublishPlanRequest, options?: RequestOptions): Promise<PublishPlanResponse>;
+}
+//# sourceMappingURL=plans.d.ts.map