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

package/dist/funcs/meters.js

@@ -1,49 +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);
+        });
+    });
+}
+export function queryMeterCsv(client, req, options) {
+    const headers = new Headers(options?.headers);
+    headers.set('accept', 'text/csv');
+    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 })
-        .json());
 }
 //# sourceMappingURL=meters.js.map

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.d.ts

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