@openmeter/client 1.0.0-beta.228 → 1.0.0-beta.230

package/dist/funcs/customers.js

@@ -1,127 +1,440 @@
 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 createCustomer(client, req, options) {
-    return request(() => http(client)
-        .post('openmeter/customers', { ...options, json: req })
-        .json());
+    return request(() => {
+        const body = toWire(req, schemas.createCustomerBody);
+        if (client._options.validate) {
+            assertValid(schemas.createCustomerBodyWire, body);
+        }
+        return http(client)
+            .post('openmeter/customers', { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.createCustomerResponseWire, data);
+            }
+            return fromWire(data, schemas.createCustomerResponse);
+        });
+    });
 }
 export function getCustomer(client, req, options) {
-    const path = encodePath('openmeter/customers/{customerId}', { customerId: req.customerId });
-    return request(() => http(client)
-        .get(path, options)
-        .json());
+    return request(() => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}`;
+        return http(client)
+            .get(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.getCustomerResponseWire, data);
+            }
+            return fromWire(data, schemas.getCustomerResponse);
+        });
+    });
 }
 export function listCustomers(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.listCustomersQueryParams);
+        if (client._options.validate) {
+            assertValid(schemas.listCustomersQueryParamsWire, query);
+        }
+        const searchParams = toURLSearchParams(query);
+        return http(client)
+            .get('openmeter/customers', { ...options, searchParams })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.listCustomersResponseWire, data);
+            }
+            return fromWire(data, schemas.listCustomersResponse);
+        });
     });
-    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());
+    return request(() => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}`;
+        const body = toWire(req.body, schemas.upsertCustomerBody);
+        if (client._options.validate) {
+            assertValid(schemas.upsertCustomerBodyWire, body);
+        }
+        return http(client)
+            .put(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.upsertCustomerResponseWire, data);
+            }
+            return fromWire(data, schemas.upsertCustomerResponse);
+        });
+    });
 }
 export function deleteCustomer(client, req, options) {
-    const path = encodePath('openmeter/customers/{customerId}', { customerId: req.customerId });
     return request(async () => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}`;
         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());
+    return request(() => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}/billing`;
+        return http(client)
+            .get(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.getCustomerBillingResponseWire, data);
+            }
+            return fromWire(data, schemas.getCustomerBillingResponse);
+        });
+    });
 }
 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());
+    return request(() => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}/billing`;
+        const body = toWire(req.body, schemas.updateCustomerBillingBody);
+        if (client._options.validate) {
+            assertValid(schemas.updateCustomerBillingBodyWire, body);
+        }
+        return http(client)
+            .put(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.updateCustomerBillingResponseWire, data);
+            }
+            return fromWire(data, schemas.updateCustomerBillingResponse);
+        });
+    });
 }
 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());
+    return request(() => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}/billing/app-data`;
+        const body = toWire(req.body, schemas.updateCustomerBillingAppDataBody);
+        if (client._options.validate) {
+            assertValid(schemas.updateCustomerBillingAppDataBodyWire, body);
+        }
+        return http(client)
+            .put(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.updateCustomerBillingAppDataResponseWire, data);
+            }
+            return fromWire(data, schemas.updateCustomerBillingAppDataResponse);
+        });
+    });
 }
 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());
+    return request(() => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}/billing/stripe/checkout-sessions`;
+        const body = toWire(req.body, schemas.createCustomerStripeCheckoutSessionBody);
+        if (client._options.validate) {
+            assertValid(schemas.createCustomerStripeCheckoutSessionBodyWire, body);
+        }
+        return http(client)
+            .post(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.createCustomerStripeCheckoutSessionResponseWire, data);
+            }
+            return fromWire(data, schemas.createCustomerStripeCheckoutSessionResponse);
+        });
+    });
 }
 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());
+    return request(() => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}/billing/stripe/portal-sessions`;
+        const body = toWire(req.body, schemas.createCustomerStripePortalSessionBody);
+        if (client._options.validate) {
+            assertValid(schemas.createCustomerStripePortalSessionBodyWire, body);
+        }
+        return http(client)
+            .post(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.createCustomerStripePortalSessionResponseWire, data);
+            }
+            return fromWire(data, schemas.createCustomerStripePortalSessionResponse);
+        });
+    });
 }
 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());
+    return request(() => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}/credits/grants`;
+        const body = toWire(req.body, schemas.createCreditGrantBody);
+        if (client._options.validate) {
+            assertValid(schemas.createCreditGrantBodyWire, body);
+        }
+        return http(client)
+            .post(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.createCreditGrantResponseWire, data);
+            }
+            return fromWire(data, schemas.createCreditGrantResponse);
+        });
+    });
 }
 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());
+    return request(() => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}/credits/grants/${(() => {
+            if (req.creditGrantId === undefined) {
+                throw new Error('missing path parameter: creditGrantId');
+            }
+            return encodeURIComponent(String(req.creditGrantId));
+        })()}`;
+        return http(client)
+            .get(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.getCreditGrantResponseWire, data);
+            }
+            return fromWire(data, schemas.getCreditGrantResponse);
+        });
+    });
 }
 export function listCreditGrants(client, req, options) {
-    const searchParams = toURLSearchParams({
-        page: req.page,
-        filter: req.filter,
+    return request(() => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}/credits/grants`;
+        const query = toWire({
+            page: req.page,
+            filter: req.filter,
+        }, schemas.listCreditGrantsQueryParams);
+        if (client._options.validate) {
+            assertValid(schemas.listCreditGrantsQueryParamsWire, query);
+        }
+        const searchParams = toURLSearchParams(query);
+        return http(client)
+            .get(path, { ...options, searchParams })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.listCreditGrantsResponseWire, data);
+            }
+            return fromWire(data, schemas.listCreditGrantsResponse);
+        });
     });
-    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,
+    return request(() => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}/credits/balance`;
+        const query = toWire({
+            timestamp: req.timestamp,
+            filter: req.filter,
+        }, schemas.getCustomerCreditBalanceQueryParams);
+        if (client._options.validate) {
+            assertValid(schemas.getCustomerCreditBalanceQueryParamsWire, query);
+        }
+        const searchParams = toURLSearchParams(query);
+        return http(client)
+            .get(path, { ...options, searchParams })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.getCustomerCreditBalanceResponseWire, data);
+            }
+            return fromWire(data, schemas.getCustomerCreditBalanceResponse);
+        });
     });
-    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());
+    return request(() => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}/credits/adjustments`;
+        const body = toWire(req.body, schemas.createCreditAdjustmentBody);
+        if (client._options.validate) {
+            assertValid(schemas.createCreditAdjustmentBodyWire, body);
+        }
+        return http(client)
+            .post(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.createCreditAdjustmentResponseWire, data);
+            }
+            return fromWire(data, schemas.createCreditAdjustmentResponse);
+        });
+    });
+}
+export function updateCreditGrantExternalSettlement(client, req, options) {
+    return request(() => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}/credits/grants/${(() => {
+            if (req.creditGrantId === undefined) {
+                throw new Error('missing path parameter: creditGrantId');
+            }
+            return encodeURIComponent(String(req.creditGrantId));
+        })()}/settlement/external`;
+        const body = toWire(req.body, schemas.updateCreditGrantExternalSettlementBody);
+        if (client._options.validate) {
+            assertValid(schemas.updateCreditGrantExternalSettlementBodyWire, body);
+        }
+        return http(client)
+            .post(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.updateCreditGrantExternalSettlementResponseWire, data);
+            }
+            return fromWire(data, schemas.updateCreditGrantExternalSettlementResponse);
+        });
+    });
 }
 export function listCreditTransactions(client, req, options) {
-    const searchParams = toURLSearchParams({
-        page: req.page,
-        filter: req.filter,
+    return request(() => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}/credits/transactions`;
+        const query = toWire({
+            page: req.page,
+            filter: req.filter,
+        }, schemas.listCreditTransactionsQueryParams);
+        if (client._options.validate) {
+            assertValid(schemas.listCreditTransactionsQueryParamsWire, query);
+        }
+        const searchParams = toURLSearchParams(query);
+        return http(client)
+            .get(path, { ...options, searchParams })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.listCreditTransactionsResponseWire, data);
+            }
+            return fromWire(data, schemas.listCreditTransactionsResponse);
+        });
     });
-    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());
+    return request(() => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}/charges`;
+        const query = toWire({
+            page: req.page,
+            sort: encodeSort(req.sort, toSnakeCase),
+            filter: req.filter,
+            expand: req.expand,
+        }, schemas.listCustomerChargesQueryParams);
+        if (client._options.validate) {
+            assertValid(schemas.listCustomerChargesQueryParamsWire, query);
+        }
+        const searchParams = toURLSearchParams(query);
+        return http(client)
+            .get(path, { ...options, searchParams })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.listCustomerChargesResponseWire, data);
+            }
+            return fromWire(data, schemas.listCustomerChargesResponse);
+        });
+    });
+}
+export function createCustomerCharges(client, req, options) {
+    return request(() => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}/charges`;
+        const body = toWire(req.body, schemas.createCustomerChargesBody);
+        if (client._options.validate) {
+            assertValid(schemas.createCustomerChargesBodyWire, body);
+        }
+        return http(client)
+            .post(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.createCustomerChargesResponseWire, data);
+            }
+            return fromWire(data, schemas.createCustomerChargesResponse);
+        });
+    });
 }
 //# sourceMappingURL=customers.js.map

package/dist/funcs/defaults.js

@@ -1,13 +1,33 @@
 import { http } from '../core.js';
 import { request } from '../lib/request.js';
+import { toWire, fromWire, assertValid } from '../lib/wire.js';
+import * as schemas from '../models/schemas.js';
 export function getOrganizationDefaultTaxCodes(client, req, options) {
     return request(() => http(client)
         .get('openmeter/defaults/tax-codes', options)
-        .json());
+        .json()
+        .then((data) => {
+        if (client._options.validate) {
+            assertValid(schemas.getOrganizationDefaultTaxCodesResponseWire, data);
+        }
+        return fromWire(data, schemas.getOrganizationDefaultTaxCodesResponse);
+    }));
 }
 export function updateOrganizationDefaultTaxCodes(client, req, options) {
-    return request(() => http(client)
-        .put('openmeter/defaults/tax-codes', { ...options, json: req })
-        .json());
+    return request(() => {
+        const body = toWire(req, schemas.updateOrganizationDefaultTaxCodesBody);
+        if (client._options.validate) {
+            assertValid(schemas.updateOrganizationDefaultTaxCodesBodyWire, body);
+        }
+        return http(client)
+            .put('openmeter/defaults/tax-codes', { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.updateOrganizationDefaultTaxCodesResponseWire, data);
+            }
+            return fromWire(data, schemas.updateOrganizationDefaultTaxCodesResponse);
+        });
+    });
 }
 //# sourceMappingURL=defaults.js.map

package/dist/funcs/entitlements.js

@@ -1,10 +1,24 @@
 import { http } from '../core.js';
 import { request } from '../lib/request.js';
-import { encodePath } from '../lib/encodings.js';
+import { fromWire, assertValid } from '../lib/wire.js';
+import * as schemas from '../models/schemas.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());
+    return request(() => {
+        const path = `openmeter/customers/${(() => {
+            if (req.customerId === undefined) {
+                throw new Error('missing path parameter: customerId');
+            }
+            return encodeURIComponent(String(req.customerId));
+        })()}/entitlement-access`;
+        return http(client)
+            .get(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.listCustomerEntitlementAccessResponseWire, data);
+            }
+            return fromWire(data, schemas.listCustomerEntitlementAccessResponse);
+        });
+    });
 }
 //# sourceMappingURL=entitlements.js.map

package/dist/funcs/events.js

@@ -1,19 +1,37 @@
 import { http } from '../core.js';
 import { request } from '../lib/request.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 listMeteringEvents(client, req = {}, options) {
-    const searchParams = toURLSearchParams({
-        page: req.page,
-        filter: req.filter,
-        sort: encodeSort(req.sort),
+    return request(() => {
+        const query = toWire({
+            page: req.page,
+            filter: req.filter,
+            sort: encodeSort(req.sort, toSnakeCase),
+        }, schemas.listMeteringEventsQueryParams);
+        if (client._options.validate) {
+            assertValid(schemas.listMeteringEventsQueryParamsWire, query);
+        }
+        const searchParams = toURLSearchParams(query);
+        return http(client)
+            .get('openmeter/events', { ...options, searchParams })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.listMeteringEventsResponseWire, data);
+            }
+            return fromWire(data, schemas.listMeteringEventsResponse);
+        });
     });
-    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 });
+        const body = toWire(req, schemas.ingestMeteringEventsBody);
+        if (client._options.validate) {
+            assertValid(schemas.ingestMeteringEventsBodyWire, body);
+        }
+        await http(client).post('openmeter/events', { ...options, json: body });
     });
 }
 //# sourceMappingURL=events.js.map