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

package/dist/funcs/planAddons.js

@@ -1,47 +1,122 @@
 import { http } from '../core.js';
 import { request } from '../lib/request.js';
-import { encodePath, toURLSearchParams } from '../lib/encodings.js';
+import { toURLSearchParams } from '../lib/encodings.js';
+import { toWire, fromWire, assertValid } from '../lib/wire.js';
+import * as schemas from '../models/schemas.js';
 export function listPlanAddons(client, req, options) {
-    const searchParams = toURLSearchParams({
-        page: req.page,
+    return request(() => {
+        const path = `openmeter/plans/${(() => {
+            if (req.planId === undefined) {
+                throw new Error('missing path parameter: planId');
+            }
+            return encodeURIComponent(String(req.planId));
+        })()}/addons`;
+        const query = toWire({
+            page: req.page,
+        }, schemas.listPlanAddonsQueryParams);
+        if (client._options.validate) {
+            assertValid(schemas.listPlanAddonsQueryParamsWire, query);
+        }
+        const searchParams = toURLSearchParams(query);
+        return http(client)
+            .get(path, { ...options, searchParams })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.listPlanAddonsResponseWire, data);
+            }
+            return fromWire(data, schemas.listPlanAddonsResponse);
+        });
     });
-    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(() => {
+        const path = `openmeter/plans/${(() => {
+            if (req.planId === undefined) {
+                throw new Error('missing path parameter: planId');
+            }
+            return encodeURIComponent(String(req.planId));
+        })()}/addons`;
+        const body = toWire(req.body, schemas.createPlanAddonBody);
+        if (client._options.validate) {
+            assertValid(schemas.createPlanAddonBodyWire, body);
+        }
+        return http(client)
+            .post(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.createPlanAddonResponseWire, data);
+            }
+            return fromWire(data, schemas.createPlanAddonResponse);
+        });
     });
-    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(() => {
+        const path = `openmeter/plans/${(() => {
+            if (req.planId === undefined) {
+                throw new Error('missing path parameter: planId');
+            }
+            return encodeURIComponent(String(req.planId));
+        })()}/addons/${(() => {
+            if (req.planAddonId === undefined) {
+                throw new Error('missing path parameter: planAddonId');
+            }
+            return encodeURIComponent(String(req.planAddonId));
+        })()}`;
+        return http(client)
+            .get(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.getPlanAddonResponseWire, data);
+            }
+            return fromWire(data, schemas.getPlanAddonResponse);
+        });
     });
-    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(() => {
+        const path = `openmeter/plans/${(() => {
+            if (req.planId === undefined) {
+                throw new Error('missing path parameter: planId');
+            }
+            return encodeURIComponent(String(req.planId));
+        })()}/addons/${(() => {
+            if (req.planAddonId === undefined) {
+                throw new Error('missing path parameter: planAddonId');
+            }
+            return encodeURIComponent(String(req.planAddonId));
+        })()}`;
+        const body = toWire(req.body, schemas.updatePlanAddonBody);
+        if (client._options.validate) {
+            assertValid(schemas.updatePlanAddonBodyWire, body);
+        }
+        return http(client)
+            .put(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.updatePlanAddonResponseWire, data);
+            }
+            return fromWire(data, schemas.updatePlanAddonResponse);
+        });
     });
-    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 () => {
+        const path = `openmeter/plans/${(() => {
+            if (req.planId === undefined) {
+                throw new Error('missing path parameter: planId');
+            }
+            return encodeURIComponent(String(req.planId));
+        })()}/addons/${(() => {
+            if (req.planAddonId === undefined) {
+                throw new Error('missing path parameter: planAddonId');
+            }
+            return encodeURIComponent(String(req.planAddonId));
+        })()}`;
         await http(client).delete(path, options);
     });
 }

package/dist/funcs/plans.js

@@ -1,47 +1,136 @@
 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 listPlans(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.listPlansQueryParams);
+        if (client._options.validate) {
+            assertValid(schemas.listPlansQueryParamsWire, query);
+        }
+        const searchParams = toURLSearchParams(query);
+        return http(client)
+            .get('openmeter/plans', { ...options, searchParams })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.listPlansResponseWire, data);
+            }
+            return fromWire(data, schemas.listPlansResponse);
+        });
     });
-    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());
+    return request(() => {
+        const body = toWire(req, schemas.createPlanBody);
+        if (client._options.validate) {
+            assertValid(schemas.createPlanBodyWire, body);
+        }
+        return http(client)
+            .post('openmeter/plans', { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.createPlanResponseWire, data);
+            }
+            return fromWire(data, schemas.createPlanResponse);
+        });
+    });
 }
 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());
+    return request(() => {
+        const path = `openmeter/plans/${(() => {
+            if (req.planId === undefined) {
+                throw new Error('missing path parameter: planId');
+            }
+            return encodeURIComponent(String(req.planId));
+        })()}`;
+        const body = toWire(req.body, schemas.updatePlanBody);
+        if (client._options.validate) {
+            assertValid(schemas.updatePlanBodyWire, body);
+        }
+        return http(client)
+            .put(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.updatePlanResponseWire, data);
+            }
+            return fromWire(data, schemas.updatePlanResponse);
+        });
+    });
 }
 export function getPlan(client, req, options) {
-    const path = encodePath('openmeter/plans/{planId}', { planId: req.planId });
-    return request(() => http(client).get(path, options).json());
+    return request(() => {
+        const path = `openmeter/plans/${(() => {
+            if (req.planId === undefined) {
+                throw new Error('missing path parameter: planId');
+            }
+            return encodeURIComponent(String(req.planId));
+        })()}`;
+        return http(client)
+            .get(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.getPlanResponseWire, data);
+            }
+            return fromWire(data, schemas.getPlanResponse);
+        });
+    });
 }
 export function deletePlan(client, req, options) {
-    const path = encodePath('openmeter/plans/{planId}', { planId: req.planId });
     return request(async () => {
+        const path = `openmeter/plans/${(() => {
+            if (req.planId === undefined) {
+                throw new Error('missing path parameter: planId');
+            }
+            return encodeURIComponent(String(req.planId));
+        })()}`;
         await http(client).delete(path, options);
     });
 }
 export function archivePlan(client, req, options) {
-    const path = encodePath('openmeter/plans/{planId}/archive', {
-        planId: req.planId,
+    return request(() => {
+        const path = `openmeter/plans/${(() => {
+            if (req.planId === undefined) {
+                throw new Error('missing path parameter: planId');
+            }
+            return encodeURIComponent(String(req.planId));
+        })()}/archive`;
+        return http(client)
+            .post(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.archivePlanResponseWire, data);
+            }
+            return fromWire(data, schemas.archivePlanResponse);
+        });
     });
-    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(() => {
+        const path = `openmeter/plans/${(() => {
+            if (req.planId === undefined) {
+                throw new Error('missing path parameter: planId');
+            }
+            return encodeURIComponent(String(req.planId));
+        })()}/publish`;
+        return http(client)
+            .post(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.publishPlanResponseWire, data);
+            }
+            return fromWire(data, schemas.publishPlanResponse);
+        });
     });
-    return request(() => http(client).post(path, options).json());
 }
 //# sourceMappingURL=plans.js.map

package/dist/funcs/subscriptions.js

@@ -1,72 +1,203 @@
 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 createSubscription(client, req, options) {
-    return request(() => http(client)
-        .post('openmeter/subscriptions', { ...options, json: req })
-        .json());
+    return request(() => {
+        const body = toWire(req, schemas.createSubscriptionBody);
+        if (client._options.validate) {
+            assertValid(schemas.createSubscriptionBodyWire, body);
+        }
+        return http(client)
+            .post('openmeter/subscriptions', { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.createSubscriptionResponseWire, data);
+            }
+            return fromWire(data, schemas.createSubscriptionResponse);
+        });
+    });
 }
 export function listSubscriptions(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.listSubscriptionsQueryParams);
+        if (client._options.validate) {
+            assertValid(schemas.listSubscriptionsQueryParamsWire, query);
+        }
+        const searchParams = toURLSearchParams(query);
+        return http(client)
+            .get('openmeter/subscriptions', { ...options, searchParams })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.listSubscriptionsResponseWire, data);
+            }
+            return fromWire(data, schemas.listSubscriptionsResponse);
+        });
     });
-    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(() => {
+        const path = `openmeter/subscriptions/${(() => {
+            if (req.subscriptionId === undefined) {
+                throw new Error('missing path parameter: subscriptionId');
+            }
+            return encodeURIComponent(String(req.subscriptionId));
+        })()}`;
+        return http(client)
+            .get(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.getSubscriptionResponseWire, data);
+            }
+            return fromWire(data, schemas.getSubscriptionResponse);
+        });
     });
-    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(() => {
+        const path = `openmeter/subscriptions/${(() => {
+            if (req.subscriptionId === undefined) {
+                throw new Error('missing path parameter: subscriptionId');
+            }
+            return encodeURIComponent(String(req.subscriptionId));
+        })()}/cancel`;
+        const body = toWire(req.body, schemas.cancelSubscriptionBody);
+        if (client._options.validate) {
+            assertValid(schemas.cancelSubscriptionBodyWire, body);
+        }
+        return http(client)
+            .post(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.cancelSubscriptionResponseWire, data);
+            }
+            return fromWire(data, schemas.cancelSubscriptionResponse);
+        });
     });
-    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());
+    return request(() => {
+        const path = `openmeter/subscriptions/${(() => {
+            if (req.subscriptionId === undefined) {
+                throw new Error('missing path parameter: subscriptionId');
+            }
+            return encodeURIComponent(String(req.subscriptionId));
+        })()}/unschedule-cancelation`;
+        return http(client)
+            .post(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.unscheduleCancelationResponseWire, data);
+            }
+            return fromWire(data, schemas.unscheduleCancelationResponse);
+        });
+    });
 }
 export function changeSubscription(client, req, options) {
-    const path = encodePath('openmeter/subscriptions/{subscriptionId}/change', {
-        subscriptionId: req.subscriptionId,
+    return request(() => {
+        const path = `openmeter/subscriptions/${(() => {
+            if (req.subscriptionId === undefined) {
+                throw new Error('missing path parameter: subscriptionId');
+            }
+            return encodeURIComponent(String(req.subscriptionId));
+        })()}/change`;
+        const body = toWire(req.body, schemas.changeSubscriptionBody);
+        if (client._options.validate) {
+            assertValid(schemas.changeSubscriptionBodyWire, body);
+        }
+        return http(client)
+            .post(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.changeSubscriptionResponseWire, data);
+            }
+            return fromWire(data, schemas.changeSubscriptionResponse);
+        });
     });
-    return request(() => http(client)
-        .post(path, { ...options, json: req.body })
-        .json());
 }
 export function createSubscriptionAddon(client, req, options) {
-    const path = encodePath('openmeter/subscriptions/{subscriptionId}/addons', {
-        subscriptionId: req.subscriptionId,
+    return request(() => {
+        const path = `openmeter/subscriptions/${(() => {
+            if (req.subscriptionId === undefined) {
+                throw new Error('missing path parameter: subscriptionId');
+            }
+            return encodeURIComponent(String(req.subscriptionId));
+        })()}/addons`;
+        const body = toWire(req.body, schemas.createSubscriptionAddonBody);
+        if (client._options.validate) {
+            assertValid(schemas.createSubscriptionAddonBodyWire, body);
+        }
+        return http(client)
+            .post(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.createSubscriptionAddonResponseWire, data);
+            }
+            return fromWire(data, schemas.createSubscriptionAddonResponse);
+        });
     });
-    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(() => {
+        const path = `openmeter/subscriptions/${(() => {
+            if (req.subscriptionId === undefined) {
+                throw new Error('missing path parameter: subscriptionId');
+            }
+            return encodeURIComponent(String(req.subscriptionId));
+        })()}/addons`;
+        const query = toWire({
+            page: req.page,
+            sort: encodeSort(req.sort, toSnakeCase),
+        }, schemas.listSubscriptionAddonsQueryParams);
+        if (client._options.validate) {
+            assertValid(schemas.listSubscriptionAddonsQueryParamsWire, query);
+        }
+        const searchParams = toURLSearchParams(query);
+        return http(client)
+            .get(path, { ...options, searchParams })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.listSubscriptionAddonsResponseWire, data);
+            }
+            return fromWire(data, schemas.listSubscriptionAddonsResponse);
+        });
     });
-    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(() => {
+        const path = `openmeter/subscriptions/${(() => {
+            if (req.subscriptionId === undefined) {
+                throw new Error('missing path parameter: subscriptionId');
+            }
+            return encodeURIComponent(String(req.subscriptionId));
+        })()}/addons/${(() => {
+            if (req.subscriptionAddonId === undefined) {
+                throw new Error('missing path parameter: subscriptionAddonId');
+            }
+            return encodeURIComponent(String(req.subscriptionAddonId));
+        })()}`;
+        return http(client)
+            .get(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.getSubscriptionAddonResponseWire, data);
+            }
+            return fromWire(data, schemas.getSubscriptionAddonResponse);
+        });
     });
-    return request(() => http(client).get(path, options).json());
 }
 //# sourceMappingURL=subscriptions.js.map

package/dist/funcs/tax.js

@@ -1,39 +1,96 @@
 import { http } from '../core.js';
 import { request } from '../lib/request.js';
-import { encodePath, toURLSearchParams } from '../lib/encodings.js';
+import { toURLSearchParams } from '../lib/encodings.js';
+import { toWire, fromWire, assertValid } from '../lib/wire.js';
+import * as schemas from '../models/schemas.js';
 export function createTaxCode(client, req, options) {
-    return request(() => http(client)
-        .post('openmeter/tax-codes', { ...options, json: req })
-        .json());
+    return request(() => {
+        const body = toWire(req, schemas.createTaxCodeBody);
+        if (client._options.validate) {
+            assertValid(schemas.createTaxCodeBodyWire, body);
+        }
+        return http(client)
+            .post('openmeter/tax-codes', { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.createTaxCodeResponseWire, data);
+            }
+            return fromWire(data, schemas.createTaxCodeResponse);
+        });
+    });
 }
 export function getTaxCode(client, req, options) {
-    const path = encodePath('openmeter/tax-codes/{taxCodeId}', {
-        taxCodeId: req.taxCodeId,
+    return request(() => {
+        const path = `openmeter/tax-codes/${(() => {
+            if (req.taxCodeId === undefined) {
+                throw new Error('missing path parameter: taxCodeId');
+            }
+            return encodeURIComponent(String(req.taxCodeId));
+        })()}`;
+        return http(client)
+            .get(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.getTaxCodeResponseWire, data);
+            }
+            return fromWire(data, schemas.getTaxCodeResponse);
+        });
     });
-    return request(() => http(client).get(path, options).json());
 }
 export function listTaxCodes(client, req = {}, options) {
-    const searchParams = toURLSearchParams({
-        page: req.page,
-        include_deleted: req.include_deleted,
+    return request(() => {
+        const query = toWire({
+            page: req.page,
+            includeDeleted: req.includeDeleted,
+        }, schemas.listTaxCodesQueryParams);
+        if (client._options.validate) {
+            assertValid(schemas.listTaxCodesQueryParamsWire, query);
+        }
+        const searchParams = toURLSearchParams(query);
+        return http(client)
+            .get('openmeter/tax-codes', { ...options, searchParams })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.listTaxCodesResponseWire, data);
+            }
+            return fromWire(data, schemas.listTaxCodesResponse);
+        });
     });
-    return request(() => http(client)
-        .get('openmeter/tax-codes', { ...options, searchParams })
-        .json());
 }
 export function upsertTaxCode(client, req, options) {
-    const path = encodePath('openmeter/tax-codes/{taxCodeId}', {
-        taxCodeId: req.taxCodeId,
+    return request(() => {
+        const path = `openmeter/tax-codes/${(() => {
+            if (req.taxCodeId === undefined) {
+                throw new Error('missing path parameter: taxCodeId');
+            }
+            return encodeURIComponent(String(req.taxCodeId));
+        })()}`;
+        const body = toWire(req.body, schemas.upsertTaxCodeBody);
+        if (client._options.validate) {
+            assertValid(schemas.upsertTaxCodeBodyWire, body);
+        }
+        return http(client)
+            .put(path, { ...options, json: body })
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.upsertTaxCodeResponseWire, data);
+            }
+            return fromWire(data, schemas.upsertTaxCodeResponse);
+        });
     });
-    return request(() => http(client)
-        .put(path, { ...options, json: req.body })
-        .json());
 }
 export function deleteTaxCode(client, req, options) {
-    const path = encodePath('openmeter/tax-codes/{taxCodeId}', {
-        taxCodeId: req.taxCodeId,
-    });
     return request(async () => {
+        const path = `openmeter/tax-codes/${(() => {
+            if (req.taxCodeId === undefined) {
+                throw new Error('missing path parameter: taxCodeId');
+            }
+            return encodeURIComponent(String(req.taxCodeId));
+        })()}`;
         await http(client).delete(path, options);
     });
 }