@openmeter/sdk 1.0.0-beta.212 → 1.0.0-beta.214

package/dist/src/client/notifications.d.ts

@@ -113,36 +113,152 @@ export declare class NotificationRules {
      * @param signal - An optional abort signal
      * @returns The created rule
      */
-    create(rule: NotificationRuleCreateRequest, options?: RequestOptions): Promise<{
-        readonly createdAt: Date;
-        readonly updatedAt: Date;
-        readonly deletedAt?: Date;
-        readonly id: string;
-        type: "entitlements.balance.threshold";
-        name: string;
-        disabled?: boolean;
-        channels: import("./schemas.js").components["schemas"]["NotificationChannelMeta"][];
-        thresholds: import("./schemas.js").components["schemas"]["NotificationRuleBalanceThresholdValue"][];
-        features?: import("./schemas.js").components["schemas"]["FeatureMeta"][];
-    }>;
+    create(rule: NotificationRuleCreateRequest, options?: RequestOptions): Promise<import("openapi-typescript-helpers").SuccessResponse<{
+        201: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./schemas.js").components["schemas"]["NotificationRule"];
+            };
+        };
+        400: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["BadRequestProblemResponse"];
+            };
+        };
+        401: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["UnauthorizedProblemResponse"];
+            };
+        };
+        403: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["ForbiddenProblemResponse"];
+            };
+        };
+        412: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["PreconditionFailedProblemResponse"];
+            };
+        };
+        500: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["InternalServerErrorProblemResponse"];
+            };
+        };
+        503: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["ServiceUnavailableProblemResponse"];
+            };
+        };
+        default: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["UnexpectedProblemResponse"];
+            };
+        };
+    }, `${string}/${string}`>>;
     /**
      * Get a notification rule by ID
      * @param id - The ID of the notification rule
      * @param signal - An optional abort signal
      * @returns The notification rule
      */
-    get(id: operations['getNotificationRule']['parameters']['path']['ruleId'], options?: RequestOptions): Promise<{
-        readonly createdAt: Date;
-        readonly updatedAt: Date;
-        readonly deletedAt?: Date;
-        readonly id: string;
-        type: "entitlements.balance.threshold";
-        name: string;
-        disabled?: boolean;
-        channels: import("./schemas.js").components["schemas"]["NotificationChannelMeta"][];
-        thresholds: import("./schemas.js").components["schemas"]["NotificationRuleBalanceThresholdValue"][];
-        features?: import("./schemas.js").components["schemas"]["FeatureMeta"][];
-    }>;
+    get(id: operations['getNotificationRule']['parameters']['path']['ruleId'], options?: RequestOptions): Promise<import("openapi-typescript-helpers").SuccessResponse<{
+        200: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./schemas.js").components["schemas"]["NotificationRule"];
+            };
+        };
+        400: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["BadRequestProblemResponse"];
+            };
+        };
+        401: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["UnauthorizedProblemResponse"];
+            };
+        };
+        403: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["ForbiddenProblemResponse"];
+            };
+        };
+        404: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["NotFoundProblemResponse"];
+            };
+        };
+        412: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["PreconditionFailedProblemResponse"];
+            };
+        };
+        500: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["InternalServerErrorProblemResponse"];
+            };
+        };
+        503: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["ServiceUnavailableProblemResponse"];
+            };
+        };
+        default: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["UnexpectedProblemResponse"];
+            };
+        };
+    }, `${string}/${string}`>>;
     /**
      * Update a notification rule
      * @param id - The ID of the notification rule
@@ -150,18 +266,80 @@ export declare class NotificationRules {
      * @param signal - An optional abort signal
      * @returns The updated rule
      */
-    update(id: operations['updateNotificationRule']['parameters']['path']['ruleId'], rule: NotificationRuleCreateRequest, options?: RequestOptions): Promise<{
-        readonly createdAt: Date;
-        readonly updatedAt: Date;
-        readonly deletedAt?: Date;
-        readonly id: string;
-        type: "entitlements.balance.threshold";
-        name: string;
-        disabled?: boolean;
-        channels: import("./schemas.js").components["schemas"]["NotificationChannelMeta"][];
-        thresholds: import("./schemas.js").components["schemas"]["NotificationRuleBalanceThresholdValue"][];
-        features?: import("./schemas.js").components["schemas"]["FeatureMeta"][];
-    }>;
+    update(id: operations['updateNotificationRule']['parameters']['path']['ruleId'], rule: NotificationRuleCreateRequest, options?: RequestOptions): Promise<import("openapi-typescript-helpers").SuccessResponse<{
+        200: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./schemas.js").components["schemas"]["NotificationRule"];
+            };
+        };
+        400: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["BadRequestProblemResponse"];
+            };
+        };
+        401: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["UnauthorizedProblemResponse"];
+            };
+        };
+        403: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["ForbiddenProblemResponse"];
+            };
+        };
+        404: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["NotFoundProblemResponse"];
+            };
+        };
+        412: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["PreconditionFailedProblemResponse"];
+            };
+        };
+        500: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["InternalServerErrorProblemResponse"];
+            };
+        };
+        503: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["ServiceUnavailableProblemResponse"];
+            };
+        };
+        default: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.js").components["schemas"]["UnexpectedProblemResponse"];
+            };
+        };
+    }, `${string}/${string}`>>;
     /**
      * List notification rules
      * @param query - The query parameters

package/dist/src/client/plans.d.ts

@@ -1,13 +1,18 @@
 import type { RequestOptions } from './common.js';
 import type { operations, paths, PlanCreate, PlanReplaceUpdate } from './schemas.js';
 import type { Client } from 'openapi-fetch';
+/**
+ * Plans
+ * Manage customer subscription plans and addon assignments.
+ */
 export declare class Plans {
     private client;
+    addons: PlanAddons;
     constructor(client: Client<paths, `${string}/${string}`>);
     /**
      * Create a plan
      * @param plan - The plan to create
-     * @param signal - An optional abort signal
+     * @param options - Optional request options
      * @returns The created plan
      */
     create(plan: PlanCreate, options?: RequestOptions): Promise<{
@@ -22,18 +27,22 @@ export declare class Plans {
         alignment?: import("./schemas.js").components["schemas"]["Alignment"];
         readonly version: number;
         currency: import("./schemas.js").components["schemas"]["CurrencyCode"];
+        billingCadence: string;
+        proRatingConfig?: import("./schemas.js").components["schemas"]["ProRatingConfig"];
         readonly effectiveFrom?: Date;
         readonly effectiveTo?: Date;
         readonly status: import("./schemas.js").components["schemas"]["PlanStatus"];
         phases: import("./schemas.js").components["schemas"]["PlanPhase"][];
+        readonly validationErrors: import("./schemas.js").components["schemas"]["ValidationError"][] | null;
     }>;
     /**
-     * Get a plan by ID or key
-     * @param idOrKey - The ID or key of the plan
-     * @param signal - An optional abort signal
+     * Get a plan by ID
+     * @param planId - The ID of the plan to retrieve
+     * @param params - Optional query parameters
+     * @param options - Optional request options
      * @returns The plan
      */
-    get(id: operations['getPlan']['parameters']['path']['planId'], options?: RequestOptions): Promise<{
+    get(planId: operations['getPlan']['parameters']['path']['planId'], params?: operations['getPlan']['parameters']['query'], options?: RequestOptions): Promise<{
         readonly id: string;
         name: string;
         description?: string;
@@ -45,18 +54,21 @@ export declare class Plans {
         alignment?: import("./schemas.js").components["schemas"]["Alignment"];
         readonly version: number;
         currency: import("./schemas.js").components["schemas"]["CurrencyCode"];
+        billingCadence: string;
+        proRatingConfig?: import("./schemas.js").components["schemas"]["ProRatingConfig"];
         readonly effectiveFrom?: Date;
         readonly effectiveTo?: Date;
         readonly status: import("./schemas.js").components["schemas"]["PlanStatus"];
         phases: import("./schemas.js").components["schemas"]["PlanPhase"][];
+        readonly validationErrors: import("./schemas.js").components["schemas"]["ValidationError"][] | null;
     }>;
     /**
      * List plans
-     * @param query - The query parameters
-     * @param signal - An optional abort signal
-     * @returns The list of plans
+     * @param params - Optional parameters for listing plans
+     * @param options - Optional request options
+     * @returns A list of plans
      */
-    list(query?: operations['listPlans']['parameters']['query'], options?: RequestOptions): Promise<{
+    list(params?: operations['listPlans']['parameters']['query'], options?: RequestOptions): Promise<{
         totalCount: number;
         page: number;
         pageSize: number;
@@ -64,12 +76,12 @@ export declare class Plans {
     }>;
     /**
      * Update a plan
-     * @param id - The ID of the plan
-     * @param plan - The plan to update
-     * @param signal - An optional abort signal
+     * @param planId - The ID of the plan to update
+     * @param plan - The plan data to update
+     * @param options - Optional request options
      * @returns The updated plan
      */
-    update(id: operations['updatePlan']['parameters']['path']['planId'], plan: PlanReplaceUpdate, options?: RequestOptions): Promise<{
+    update(planId: operations['updatePlan']['parameters']['path']['planId'], plan: PlanReplaceUpdate, options?: RequestOptions): Promise<{
         readonly id: string;
         name: string;
         description?: string;
@@ -81,25 +93,28 @@ export declare class Plans {
         alignment?: import("./schemas.js").components["schemas"]["Alignment"];
         readonly version: number;
         currency: import("./schemas.js").components["schemas"]["CurrencyCode"];
+        billingCadence: string;
+        proRatingConfig?: import("./schemas.js").components["schemas"]["ProRatingConfig"];
         readonly effectiveFrom?: Date;
         readonly effectiveTo?: Date;
         readonly status: import("./schemas.js").components["schemas"]["PlanStatus"];
         phases: import("./schemas.js").components["schemas"]["PlanPhase"][];
+        readonly validationErrors: import("./schemas.js").components["schemas"]["ValidationError"][] | null;
     }>;
     /**
-     * Delete a plan
-     * @param id - The ID of the plan
-     * @param signal - An optional abort signal
-     * @returns The deleted plan
+     * Delete a plan by ID
+     * @param planId - The ID of the plan to delete
+     * @param options - Optional request options
+     * @returns void or standard error response structure
      */
-    delete(id: operations['deletePlan']['parameters']['path']['planId'], options?: RequestOptions): Promise<undefined>;
+    delete(planId: operations['deletePlan']['parameters']['path']['planId'], options?: RequestOptions): Promise<undefined>;
     /**
      * Archive a plan
-     * @param id - The ID of the plan
-     * @param signal - An optional abort signal
+     * @param planId - The ID of the plan to archive
+     * @param options - Optional request options
      * @returns The archived plan
      */
-    archive(id: operations['archivePlan']['parameters']['path']['planId'], options?: RequestOptions): Promise<{
+    archive(planId: operations['archivePlan']['parameters']['path']['planId'], options?: RequestOptions): Promise<{
         readonly id: string;
         name: string;
         description?: string;
@@ -111,18 +126,21 @@ export declare class Plans {
         alignment?: import("./schemas.js").components["schemas"]["Alignment"];
         readonly version: number;
         currency: import("./schemas.js").components["schemas"]["CurrencyCode"];
+        billingCadence: string;
+        proRatingConfig?: import("./schemas.js").components["schemas"]["ProRatingConfig"];
         readonly effectiveFrom?: Date;
         readonly effectiveTo?: Date;
         readonly status: import("./schemas.js").components["schemas"]["PlanStatus"];
         phases: import("./schemas.js").components["schemas"]["PlanPhase"][];
+        readonly validationErrors: import("./schemas.js").components["schemas"]["ValidationError"][] | null;
     }>;
     /**
      * Publish a plan
-     * @param id - The ID of the plan
-     * @param signal - An optional abort signal
+     * @param planId - The ID of the plan to publish
+     * @param options - Optional request options
      * @returns The published plan
      */
-    publish(id: operations['publishPlan']['parameters']['path']['planId'], options?: RequestOptions): Promise<{
+    publish(planId: operations['publishPlan']['parameters']['path']['planId'], options?: RequestOptions): Promise<{
         readonly id: string;
         name: string;
         description?: string;
@@ -134,9 +152,96 @@ export declare class Plans {
         alignment?: import("./schemas.js").components["schemas"]["Alignment"];
         readonly version: number;
         currency: import("./schemas.js").components["schemas"]["CurrencyCode"];
+        billingCadence: string;
+        proRatingConfig?: import("./schemas.js").components["schemas"]["ProRatingConfig"];
         readonly effectiveFrom?: Date;
         readonly effectiveTo?: Date;
         readonly status: import("./schemas.js").components["schemas"]["PlanStatus"];
         phases: import("./schemas.js").components["schemas"]["PlanPhase"][];
+        readonly validationErrors: import("./schemas.js").components["schemas"]["ValidationError"][] | null;
     }>;
 }
+/**
+ * Plan Addons
+ * Manage addon assignments for plans.
+ */
+export declare class PlanAddons {
+    private client;
+    constructor(client: Client<paths, `${string}/${string}`>);
+    /**
+     * List plan addons
+     * @param planId - The ID of the plan
+     * @param params - Optional query parameters
+     * @param options - Optional request options
+     * @returns A list of plan addons
+     */
+    list(planId: operations['listPlanAddons']['parameters']['path']['planId'], params?: operations['listPlanAddons']['parameters']['query'], options?: RequestOptions): Promise<{
+        totalCount: number;
+        page: number;
+        pageSize: number;
+        items: import("./schemas.js").components["schemas"]["PlanAddon"][];
+    }>;
+    /**
+     * Create a plan addon
+     * @param planId - The ID of the plan
+     * @param planAddon - The plan addon to create
+     * @param options - Optional request options
+     * @returns The created plan addon
+     */
+    create(planId: operations['createPlanAddon']['parameters']['path']['planId'], planAddon: operations['createPlanAddon']['requestBody']['content']['application/json'], options?: RequestOptions): Promise<{
+        readonly createdAt: Date;
+        readonly updatedAt: Date;
+        readonly deletedAt?: Date;
+        readonly annotations?: import("./schemas.js").components["schemas"]["Annotations"];
+        metadata?: import("./schemas.js").components["schemas"]["Metadata"];
+        readonly addon: import("./schemas.js").components["schemas"]["Addon"];
+        fromPlanPhase: string;
+        maxQuantity?: number;
+        readonly validationErrors: import("./schemas.js").components["schemas"]["ValidationError"][] | null;
+    }>;
+    /**
+     * Get a plan addon by ID
+     * @param planId - The ID of the plan
+     * @param planAddonId - The ID of the plan addon
+     * @param options - Optional request options
+     * @returns The plan addon
+     */
+    get(planId: operations['getPlanAddon']['parameters']['path']['planId'], planAddonId: operations['getPlanAddon']['parameters']['path']['planAddonId'], options?: RequestOptions): Promise<{
+        readonly createdAt: Date;
+        readonly updatedAt: Date;
+        readonly deletedAt?: Date;
+        readonly annotations?: import("./schemas.js").components["schemas"]["Annotations"];
+        metadata?: import("./schemas.js").components["schemas"]["Metadata"];
+        readonly addon: import("./schemas.js").components["schemas"]["Addon"];
+        fromPlanPhase: string;
+        maxQuantity?: number;
+        readonly validationErrors: import("./schemas.js").components["schemas"]["ValidationError"][] | null;
+    }>;
+    /**
+     * Update a plan addon
+     * @param planId - The ID of the plan
+     * @param planAddonId - The ID of the plan addon to update
+     * @param planAddon - The plan addon data to update
+     * @param options - Optional request options
+     * @returns The updated plan addon
+     */
+    update(planId: operations['updatePlanAddon']['parameters']['path']['planId'], planAddonId: operations['updatePlanAddon']['parameters']['path']['planAddonId'], planAddon: operations['updatePlanAddon']['requestBody']['content']['application/json'], options?: RequestOptions): Promise<{
+        readonly createdAt: Date;
+        readonly updatedAt: Date;
+        readonly deletedAt?: Date;
+        readonly annotations?: import("./schemas.js").components["schemas"]["Annotations"];
+        metadata?: import("./schemas.js").components["schemas"]["Metadata"];
+        readonly addon: import("./schemas.js").components["schemas"]["Addon"];
+        fromPlanPhase: string;
+        maxQuantity?: number;
+        readonly validationErrors: import("./schemas.js").components["schemas"]["ValidationError"][] | null;
+    }>;
+    /**
+     * Delete a plan addon by ID
+     * @param planId - The ID of the plan
+     * @param planAddonId - The ID of the plan addon to delete
+     * @param options - Optional request options
+     * @returns void or standard error response structure
+     */
+    delete(planId: operations['deletePlanAddon']['parameters']['path']['planId'], planAddonId: operations['deletePlanAddon']['parameters']['path']['planAddonId'], options?: RequestOptions): Promise<undefined>;
+}