@openmeter/client 1.0.0-beta-4ffb0202fcfc → 1.0.0-beta-be2666bd959f

package/dist/funcs/features.js

@@ -1,49 +1,121 @@
 import { http } from '../core.js';
 import { request } from '../lib/request.js';
-import { encodePath, toURLSearchParams, encodeSort } from '../lib/encodings.js';
+import { toURLSearchParams, encodeSort } from '../lib/encodings.js';
+import { toWire, fromWire, assertValid, toSnakeCase } from '../lib/wire.js';
+import * as schemas from '../models/schemas.js';
 export function listFeatures(client, req = {}, options) {
-    const searchParams = toURLSearchParams({
-        page: req.page,
-        sort: encodeSort(req.sort),
-        filter: req.filter,
+    return request(() => {
+        const query = toWire({
+            page: req.page,
+            sort: encodeSort(req.sort, toSnakeCase),
+            filter: req.filter,
+        }, schemas.listFeaturesQueryParams);
+        if (client._options.validate) {
+            assertValid(schemas.listFeaturesQueryParamsWire, query);
+        }
+        const searchParams = toURLSearchParams(query);
+        return http(client)
+            .get('openmeter/features', { ...options, searchParams })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.listFeaturesResponseWire, data);
+            }
+            return fromWire(data, schemas.listFeaturesResponse);
+        });
     });
-    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());
+    return request(() => {
+        const body = toWire(req, schemas.createFeatureBody);
+        if (client._options.validate) {
+            assertValid(schemas.createFeatureBodyWire, body);
+        }
+        return http(client)
+            .post('openmeter/features', { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.createFeatureResponseWire, data);
+            }
+            return fromWire(data, schemas.createFeatureResponse);
+        });
+    });
 }
 export function getFeature(client, req, options) {
-    const path = encodePath('openmeter/features/{featureId}', {
-        featureId: req.featureId,
+    return request(() => {
+        const path = `openmeter/features/${(() => {
+            if (req.featureId === undefined) {
+                throw new Error('missing path parameter: featureId');
+            }
+            return encodeURIComponent(String(req.featureId));
+        })()}`;
+        return http(client)
+            .get(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.getFeatureResponseWire, data);
+            }
+            return fromWire(data, schemas.getFeatureResponse);
+        });
     });
-    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(() => {
+        const path = `openmeter/features/${(() => {
+            if (req.featureId === undefined) {
+                throw new Error('missing path parameter: featureId');
+            }
+            return encodeURIComponent(String(req.featureId));
+        })()}`;
+        const body = toWire(req.body, schemas.updateFeatureBody);
+        if (client._options.validate) {
+            assertValid(schemas.updateFeatureBodyWire, body);
+        }
+        return http(client)
+            .patch(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.updateFeatureResponseWire, data);
+            }
+            return fromWire(data, schemas.updateFeatureResponse);
+        });
     });
-    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 () => {
+        const path = `openmeter/features/${(() => {
+            if (req.featureId === undefined) {
+                throw new Error('missing path parameter: featureId');
+            }
+            return encodeURIComponent(String(req.featureId));
+        })()}`;
         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(() => {
+        const path = `openmeter/features/${(() => {
+            if (req.featureId === undefined) {
+                throw new Error('missing path parameter: featureId');
+            }
+            return encodeURIComponent(String(req.featureId));
+        })()}/cost/query`;
+        const body = toWire(req.body, schemas.queryFeatureCostBody);
+        if (client._options.validate) {
+            assertValid(schemas.queryFeatureCostBodyWire, body);
+        }
+        return http(client)
+            .post(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.queryFeatureCostResponseWire, data);
+            }
+            return fromWire(data, schemas.queryFeatureCostResponse);
+        });
     });
-    return request(() => http(client)
-        .post(path, { ...options, json: req.body })
-        .json());
 }
 //# sourceMappingURL=features.js.map

package/dist/funcs/governance.js

@@ -1,16 +1,34 @@
 import { http } from '../core.js';
 import { request } from '../lib/request.js';
 import { toURLSearchParams } from '../lib/encodings.js';
+import { toWire, fromWire, assertValid } from '../lib/wire.js';
+import * as schemas from '../models/schemas.js';
 export function queryGovernanceAccess(client, req, options) {
-    const searchParams = toURLSearchParams({
-        page: req.page,
+    return request(() => {
+        const body = toWire(req.body, schemas.queryGovernanceAccessBody);
+        if (client._options.validate) {
+            assertValid(schemas.queryGovernanceAccessBodyWire, body);
+        }
+        const query = toWire({
+            page: req.page,
+        }, schemas.queryGovernanceAccessQueryParams);
+        if (client._options.validate) {
+            assertValid(schemas.queryGovernanceAccessQueryParamsWire, query);
+        }
+        const searchParams = toURLSearchParams(query);
+        return http(client)
+            .post('openmeter/governance/query', {
+            ...options,
+            searchParams,
+            json: body,
+        })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.queryGovernanceAccessResponseWire, data);
+            }
+            return fromWire(data, schemas.queryGovernanceAccessResponse);
+        });
     });
-    return request(() => http(client)
-        .post('openmeter/governance/query', {
-        ...options,
-        searchParams,
-        json: req.body,
-    })
-        .json());
 }
 //# sourceMappingURL=governance.js.map

package/dist/funcs/invoices.d.ts

@@ -1,6 +1,7 @@
 import { type Client } from '../core.js';
 import { type Result, type RequestOptions } from '../lib/types.js';
-import type { ListInvoicesRequest, ListInvoicesResponse, GetInvoiceRequest, GetInvoiceResponse } from '../models/operations/invoices.js';
+import type { ListInvoicesRequest, ListInvoicesResponse, GetInvoiceRequest, GetInvoiceResponse, UpdateInvoiceRequest, UpdateInvoiceResponse } from '../models/operations/invoices.js';
 export declare function listInvoices(client: Client, req?: ListInvoicesRequest, options?: RequestOptions): Promise<Result<ListInvoicesResponse>>;
 export declare function getInvoice(client: Client, req: GetInvoiceRequest, options?: RequestOptions): Promise<Result<GetInvoiceResponse>>;
+export declare function updateInvoice(client: Client, req: UpdateInvoiceRequest, options?: RequestOptions): Promise<Result<UpdateInvoiceResponse>>;
 //# sourceMappingURL=invoices.d.ts.map

package/dist/funcs/invoices.js

@@ -1,20 +1,70 @@
 import { http } from '../core.js';
 import { request } from '../lib/request.js';
-import { encodePath, toURLSearchParams, encodeSort } from '../lib/encodings.js';
+import { toURLSearchParams, encodeSort } from '../lib/encodings.js';
+import { toWire, fromWire, assertValid, toSnakeCase } from '../lib/wire.js';
+import * as schemas from '../models/schemas.js';
 export function listInvoices(client, req = {}, options) {
-    const searchParams = toURLSearchParams({
-        page: req.page,
-        sort: encodeSort(req.sort),
-        filter: req.filter,
+    return request(() => {
+        const query = toWire({
+            page: req.page,
+            sort: encodeSort(req.sort, toSnakeCase),
+            filter: req.filter,
+        }, schemas.listInvoicesQueryParams);
+        if (client._options.validate) {
+            assertValid(schemas.listInvoicesQueryParamsWire, query);
+        }
+        const searchParams = toURLSearchParams(query);
+        return http(client)
+            .get('openmeter/billing/invoices', { ...options, searchParams })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.listInvoicesResponseWire, data);
+            }
+            return fromWire(data, schemas.listInvoicesResponse);
+        });
     });
-    return request(() => http(client)
-        .get('openmeter/billing/invoices', { ...options, searchParams })
-        .json());
 }
 export function getInvoice(client, req, options) {
-    const path = encodePath('openmeter/billing/invoices/{invoiceId}', {
-        invoiceId: req.invoiceId,
+    return request(() => {
+        const path = `openmeter/billing/invoices/${(() => {
+            if (req.invoiceId === undefined) {
+                throw new Error('missing path parameter: invoiceId');
+            }
+            return encodeURIComponent(String(req.invoiceId));
+        })()}`;
+        return http(client)
+            .get(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.getInvoiceResponseWire, data);
+            }
+            return fromWire(data, schemas.getInvoiceResponse);
+        });
+    });
+}
+export function updateInvoice(client, req, options) {
+    return request(() => {
+        const path = `openmeter/billing/invoices/${(() => {
+            if (req.invoiceId === undefined) {
+                throw new Error('missing path parameter: invoiceId');
+            }
+            return encodeURIComponent(String(req.invoiceId));
+        })()}`;
+        const body = toWire(req.body, schemas.updateInvoiceBody);
+        if (client._options.validate) {
+            assertValid(schemas.updateInvoiceBodyWire, body);
+        }
+        return http(client)
+            .put(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.updateInvoiceResponseWire, data);
+            }
+            return fromWire(data, schemas.updateInvoiceResponse);
+        });
     });
-    return request(() => http(client).get(path, options).json());
 }
 //# sourceMappingURL=invoices.js.map

package/dist/funcs/llmCost.js

@@ -1,41 +1,95 @@
 import { http } from '../core.js';
 import { request } from '../lib/request.js';
-import { encodePath, toURLSearchParams, encodeSort } from '../lib/encodings.js';
+import { toURLSearchParams, encodeSort } from '../lib/encodings.js';
+import { toWire, fromWire, assertValid, toSnakeCase } from '../lib/wire.js';
+import * as schemas from '../models/schemas.js';
 export function listLlmCostPrices(client, req = {}, options) {
-    const searchParams = toURLSearchParams({
-        filter: req.filter,
-        sort: encodeSort(req.sort),
-        page: req.page,
+    return request(() => {
+        const query = toWire({
+            filter: req.filter,
+            sort: encodeSort(req.sort, toSnakeCase),
+            page: req.page,
+        }, schemas.listLlmCostPricesQueryParams);
+        if (client._options.validate) {
+            assertValid(schemas.listLlmCostPricesQueryParamsWire, query);
+        }
+        const searchParams = toURLSearchParams(query);
+        return http(client)
+            .get('openmeter/llm-cost/prices', { ...options, searchParams })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.listLlmCostPricesResponseWire, data);
+            }
+            return fromWire(data, schemas.listLlmCostPricesResponse);
+        });
     });
-    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(() => {
+        const path = `openmeter/llm-cost/prices/${(() => {
+            if (req.priceId === undefined) {
+                throw new Error('missing path parameter: priceId');
+            }
+            return encodeURIComponent(String(req.priceId));
+        })()}`;
+        return http(client)
+            .get(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.getLlmCostPriceResponseWire, data);
+            }
+            return fromWire(data, schemas.getLlmCostPriceResponse);
+        });
     });
-    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(() => {
+        const query = toWire({
+            filter: req.filter,
+            page: req.page,
+        }, schemas.listLlmCostOverridesQueryParams);
+        if (client._options.validate) {
+            assertValid(schemas.listLlmCostOverridesQueryParamsWire, query);
+        }
+        const searchParams = toURLSearchParams(query);
+        return http(client)
+            .get('openmeter/llm-cost/overrides', { ...options, searchParams })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.listLlmCostOverridesResponseWire, data);
+            }
+            return fromWire(data, schemas.listLlmCostOverridesResponse);
+        });
     });
-    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());
+    return request(() => {
+        const body = toWire(req, schemas.createLlmCostOverrideBody);
+        if (client._options.validate) {
+            assertValid(schemas.createLlmCostOverrideBodyWire, body);
+        }
+        return http(client)
+            .post('openmeter/llm-cost/overrides', { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.createLlmCostOverrideResponseWire, data);
+            }
+            return fromWire(data, schemas.createLlmCostOverrideResponse);
+        });
+    });
 }
 export function deleteLlmCostOverride(client, req, options) {
-    const path = encodePath('openmeter/llm-cost/overrides/{priceId}', {
-        priceId: req.priceId,
-    });
     return request(async () => {
+        const path = `openmeter/llm-cost/overrides/${(() => {
+            if (req.priceId === undefined) {
+                throw new Error('missing path parameter: priceId');
+            }
+            return encodeURIComponent(String(req.priceId));
+        })()}`;
         await http(client).delete(path, options);
     });
 }

package/dist/funcs/meters.js

@@ -1,59 +1,140 @@
 import { http } from '../core.js';
 import { request } from '../lib/request.js';
-import { encodePath, toURLSearchParams, encodeSort } from '../lib/encodings.js';
+import { toURLSearchParams, encodeSort } from '../lib/encodings.js';
+import { toWire, fromWire, assertValid, toSnakeCase } from '../lib/wire.js';
+import * as schemas from '../models/schemas.js';
 export function createMeter(client, req, options) {
-    return request(() => http(client)
-        .post('openmeter/meters', { ...options, json: req })
-        .json());
+    return request(() => {
+        const body = toWire(req, schemas.createMeterBody);
+        if (client._options.validate) {
+            assertValid(schemas.createMeterBodyWire, body);
+        }
+        return http(client)
+            .post('openmeter/meters', { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.createMeterResponseWire, data);
+            }
+            return fromWire(data, schemas.createMeterResponse);
+        });
+    });
 }
 export function getMeter(client, req, options) {
-    const path = encodePath('openmeter/meters/{meterId}', {
-        meterId: req.meterId,
+    return request(() => {
+        const path = `openmeter/meters/${(() => {
+            if (req.meterId === undefined) {
+                throw new Error('missing path parameter: meterId');
+            }
+            return encodeURIComponent(String(req.meterId));
+        })()}`;
+        return http(client)
+            .get(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.getMeterResponseWire, data);
+            }
+            return fromWire(data, schemas.getMeterResponse);
+        });
     });
-    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(() => {
+        const query = toWire({
+            page: req.page,
+            sort: encodeSort(req.sort, toSnakeCase),
+            filter: req.filter,
+        }, schemas.listMetersQueryParams);
+        if (client._options.validate) {
+            assertValid(schemas.listMetersQueryParamsWire, query);
+        }
+        const searchParams = toURLSearchParams(query);
+        return http(client)
+            .get('openmeter/meters', { ...options, searchParams })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.listMetersResponseWire, data);
+            }
+            return fromWire(data, schemas.listMetersResponse);
+        });
     });
-    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(() => {
+        const path = `openmeter/meters/${(() => {
+            if (req.meterId === undefined) {
+                throw new Error('missing path parameter: meterId');
+            }
+            return encodeURIComponent(String(req.meterId));
+        })()}`;
+        const body = toWire(req.body, schemas.updateMeterBody);
+        if (client._options.validate) {
+            assertValid(schemas.updateMeterBodyWire, body);
+        }
+        return http(client)
+            .put(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.updateMeterResponseWire, data);
+            }
+            return fromWire(data, schemas.updateMeterResponse);
+        });
     });
-    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 () => {
+        const path = `openmeter/meters/${(() => {
+            if (req.meterId === undefined) {
+                throw new Error('missing path parameter: meterId');
+            }
+            return encodeURIComponent(String(req.meterId));
+        })()}`;
         await http(client).delete(path, options);
     });
 }
 export function queryMeter(client, req, options) {
-    const path = encodePath('openmeter/meters/{meterId}/query', {
-        meterId: req.meterId,
+    return request(() => {
+        const path = `openmeter/meters/${(() => {
+            if (req.meterId === undefined) {
+                throw new Error('missing path parameter: meterId');
+            }
+            return encodeURIComponent(String(req.meterId));
+        })()}/query`;
+        const body = toWire(req.body, schemas.queryMeterBody);
+        if (client._options.validate) {
+            assertValid(schemas.queryMeterBodyWire, body);
+        }
+        return http(client)
+            .post(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.queryMeterResponseWire, data);
+            }
+            return fromWire(data, schemas.queryMeterResponse);
+        });
     });
-    return request(() => http(client)
-        .post(path, { ...options, json: req.body })
-        .json());
 }
 export function queryMeterCsv(client, req, options) {
     const headers = new Headers(options?.headers);
     headers.set('accept', 'text/csv');
-    const path = encodePath('openmeter/meters/{meterId}/query', {
-        meterId: req.meterId,
+    return request(() => {
+        const path = `openmeter/meters/${(() => {
+            if (req.meterId === undefined) {
+                throw new Error('missing path parameter: meterId');
+            }
+            return encodeURIComponent(String(req.meterId));
+        })()}/query`;
+        const body = toWire(req.body, schemas.queryMeterCsvBody);
+        if (client._options.validate) {
+            assertValid(schemas.queryMeterCsvBodyWire, body);
+        }
+        return http(client)
+            .post(path, { ...options, json: body, headers })
+            .text();
     });
-    return request(() => http(client)
-        .post(path, { ...options, json: req.body, headers })
-        .text());
 }
 //# sourceMappingURL=meters.js.map