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

package/dist/funcs/planAddons.js

@@ -1,36 +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(() => http(client)
-        .post(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));
+        })()}/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);
+        });
+    });
 }
 export function getPlanAddon(client, req, options) {
-    const path = encodePath('openmeter/plans/{planId}/addons/{planAddonId}', { planId: req.planId, planAddonId: req.planAddonId });
-    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));
+        })()}/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);
+        });
+    });
 }
 export function updatePlanAddon(client, req, options) {
-    const path = encodePath('openmeter/plans/{planId}/addons/{planAddonId}', { planId: req.planId, planAddonId: req.planAddonId });
-    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));
+        })()}/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);
+        });
+    });
 }
 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,49 +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(() => http(client)
-        .post(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));
+        })()}/archive`;
+        return http(client)
+            .post(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.archivePlanResponseWire, data);
+            }
+            return fromWire(data, schemas.archivePlanResponse);
+        });
+    });
 }
 export function publishPlan(client, req, options) {
-    const path = encodePath('openmeter/plans/{planId}/publish', { planId: req.planId });
-    return request(() => http(client)
-        .post(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));
+        })()}/publish`;
+        return http(client)
+            .post(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.publishPlanResponseWire, data);
+            }
+            return fromWire(data, schemas.publishPlanResponse);
+        });
+    });
 }
 //# 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

package/dist/funcs/subscriptions.js

@@ -1,59 +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(() => http(client)
-        .get(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));
+        })()}`;
+        return http(client)
+            .get(path, options)
+            .json()
+            .then((data) => {
+            if (client._options.validate) {
+                assertValid(schemas.getSubscriptionResponseWire, data);
+            }
+            return fromWire(data, schemas.getSubscriptionResponse);
+        });
+    });
 }
 export function cancelSubscription(client, req, options) {
-    const path = encodePath('openmeter/subscriptions/{subscriptionId}/cancel', { subscriptionId: req.subscriptionId });
-    return request(() => http(client)
-        .post(path, { ...options, json: req.body })
-        .json());
+    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);
+        });
+    });
 }
 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(() => http(client)
-        .post(path, { ...options, json: req.body })
-        .json());
+    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);
+        });
+    });
+}
+export function createSubscriptionAddon(client, req, options) {
+    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);
+        });
+    });
 }
 export function listSubscriptionAddons(client, req, options) {
-    const searchParams = toURLSearchParams({
-        page: req.page,
-        sort: encodeSort(req.sort),
+    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);
+        });
     });
-    const path = encodePath('openmeter/subscriptions/{subscriptionId}/addons', { subscriptionId: req.subscriptionId });
-    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(() => http(client)
-        .get(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));
+        })()}/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);
+        });
+    });
 }
 //# sourceMappingURL=subscriptions.js.map