@openmeter/sdk 1.0.0-beta.23 → 1.0.0-beta.231

package/dist/cjs/src/client/notifications.d.cts

@@ -0,0 +1,412 @@
+import type { Client } from 'openapi-fetch';
+import type { RequestOptions } from './common.cjs';
+import type { NotificationChannel, NotificationRuleCreateRequest, operations, paths } from './schemas.cjs';
+/**
+ * Notifications
+ * @description Notifications provide automated triggers when specific entitlement balances and usage thresholds are reached, ensuring that your customers and sales teams are always informed. Notify customers and internal teams when specific conditions are met, like reaching 75%, 100%, and 150% of their monthly usage allowance.
+ */
+export declare class Notifications {
+    private client;
+    channels: NotificationChannels;
+    rules: NotificationRules;
+    events: NotificationEvents;
+    constructor(client: Client<paths, `${string}/${string}`>);
+}
+/**
+ * Notification Channels
+ * @description Notification channels are the destinations for notifications.
+ */
+export declare class NotificationChannels {
+    private client;
+    constructor(client: Client<paths, `${string}/${string}`>);
+    /**
+     * Create a notification channel
+     * @param notification - The notification to create
+     * @param signal - An optional abort signal
+     * @returns The created notification
+     */
+    create(notification: NotificationChannel, options?: RequestOptions): Promise<{
+        readonly createdAt: Date;
+        readonly updatedAt: Date;
+        readonly deletedAt?: Date;
+        readonly id: string;
+        type: "WEBHOOK";
+        name: string;
+        disabled?: boolean;
+        readonly annotations?: import("./schemas.cjs").components["schemas"]["Annotations"];
+        metadata?: import("./schemas.cjs").components["schemas"]["Metadata"] | null;
+        url: string;
+        customHeaders?: {
+            [key: string]: string;
+        };
+        signingSecret?: string;
+    } | undefined>;
+    /**
+     * Get a notification channel by ID
+     * @param id - The ID of the notification channel
+     * @param signal - An optional abort signal
+     * @returns The notification channel
+     */
+    get(id: operations['getNotificationChannel']['parameters']['path']['channelId'], options?: RequestOptions): Promise<{
+        readonly createdAt: Date;
+        readonly updatedAt: Date;
+        readonly deletedAt?: Date;
+        readonly id: string;
+        type: "WEBHOOK";
+        name: string;
+        disabled?: boolean;
+        readonly annotations?: import("./schemas.cjs").components["schemas"]["Annotations"];
+        metadata?: import("./schemas.cjs").components["schemas"]["Metadata"] | null;
+        url: string;
+        customHeaders?: {
+            [key: string]: string;
+        };
+        signingSecret?: string;
+    } | undefined>;
+    /**
+     * Update a notification channel
+     * @param id - The ID of the notification channel
+     * @param notification - The notification to update
+     * @param signal - An optional abort signal
+     * @returns The updated notification
+     */
+    update(id: operations['updateNotificationChannel']['parameters']['path']['channelId'], notification: NotificationChannel, options?: RequestOptions): Promise<{
+        readonly createdAt: Date;
+        readonly updatedAt: Date;
+        readonly deletedAt?: Date;
+        readonly id: string;
+        type: "WEBHOOK";
+        name: string;
+        disabled?: boolean;
+        readonly annotations?: import("./schemas.cjs").components["schemas"]["Annotations"];
+        metadata?: import("./schemas.cjs").components["schemas"]["Metadata"] | null;
+        url: string;
+        customHeaders?: {
+            [key: string]: string;
+        };
+        signingSecret?: string;
+    } | undefined>;
+    /**
+     * List notification channels
+     * @param query - The query parameters
+     * @param signal - An optional abort signal
+     * @returns The list of notification channels
+     */
+    list(query?: operations['listNotificationChannels']['parameters']['query'], options?: RequestOptions): Promise<{
+        totalCount: number;
+        page: number;
+        pageSize: number;
+        items: import("./schemas.cjs").components["schemas"]["NotificationChannel"][];
+    } | undefined>;
+    /**
+     * Delete a notification channel
+     * @param id - The ID of the notification channel
+     * @param signal - An optional abort signal
+     * @returns The deleted notification
+     */
+    delete(id: operations['deleteNotificationChannel']['parameters']['path']['channelId'], options?: RequestOptions): Promise<undefined>;
+}
+/**
+ * Notification Rules
+ * @description Notification rules are the conditions that trigger notifications.
+ */
+export declare class NotificationRules {
+    private client;
+    constructor(client: Client<paths, `${string}/${string}`>);
+    /**
+     * Create a notification rule
+     * @param rule - The rule to create
+     * @param signal - An optional abort signal
+     * @returns The created rule
+     */
+    create(rule: NotificationRuleCreateRequest, options?: RequestOptions): Promise<import("openapi-typescript-helpers").SuccessResponse<{
+        201: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./schemas.cjs").components["schemas"]["NotificationRule"];
+            };
+        };
+        400: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["BadRequestProblemResponse"];
+            };
+        };
+        401: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["UnauthorizedProblemResponse"];
+            };
+        };
+        403: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["ForbiddenProblemResponse"];
+            };
+        };
+        412: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["PreconditionFailedProblemResponse"];
+            };
+        };
+        500: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["InternalServerErrorProblemResponse"];
+            };
+        };
+        503: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["ServiceUnavailableProblemResponse"];
+            };
+        };
+        default: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["UnexpectedProblemResponse"];
+            };
+        };
+    }, `${string}/${string}`> | undefined>;
+    /**
+     * 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<import("openapi-typescript-helpers").SuccessResponse<{
+        200: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": import("./schemas.cjs").components["schemas"]["NotificationRule"];
+            };
+        };
+        400: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["BadRequestProblemResponse"];
+            };
+        };
+        401: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["UnauthorizedProblemResponse"];
+            };
+        };
+        403: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["ForbiddenProblemResponse"];
+            };
+        };
+        404: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["NotFoundProblemResponse"];
+            };
+        };
+        412: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["PreconditionFailedProblemResponse"];
+            };
+        };
+        500: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["InternalServerErrorProblemResponse"];
+            };
+        };
+        503: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["ServiceUnavailableProblemResponse"];
+            };
+        };
+        default: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["UnexpectedProblemResponse"];
+            };
+        };
+    }, `${string}/${string}`> | undefined>;
+    /**
+     * Update a notification rule
+     * @param id - The ID of the notification rule
+     * @param rule - The rule to update
+     * @param signal - An optional abort signal
+     * @returns The updated rule
+     */
+    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.cjs").components["schemas"]["NotificationRule"];
+            };
+        };
+        400: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["BadRequestProblemResponse"];
+            };
+        };
+        401: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["UnauthorizedProblemResponse"];
+            };
+        };
+        403: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["ForbiddenProblemResponse"];
+            };
+        };
+        404: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["NotFoundProblemResponse"];
+            };
+        };
+        412: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["PreconditionFailedProblemResponse"];
+            };
+        };
+        500: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["InternalServerErrorProblemResponse"];
+            };
+        };
+        503: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["ServiceUnavailableProblemResponse"];
+            };
+        };
+        default: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/problem+json": import("./schemas.cjs").components["schemas"]["UnexpectedProblemResponse"];
+            };
+        };
+    }, `${string}/${string}`> | undefined>;
+    /**
+     * List notification rules
+     * @param query - The query parameters
+     * @param signal - An optional abort signal
+     * @returns The list of notification rules
+     */
+    list(query?: operations['listNotificationRules']['parameters']['query'], options?: RequestOptions): Promise<{
+        totalCount: number;
+        page: number;
+        pageSize: number;
+        items: import("./schemas.cjs").components["schemas"]["NotificationRule"][];
+    } | undefined>;
+    /**
+     * Delete a notification rule
+     * @param id - The ID of the notification rule
+     * @param signal - An optional abort signal
+     * @returns The deleted notification
+     */
+    delete(id: operations['deleteNotificationRule']['parameters']['path']['ruleId'], options?: RequestOptions): Promise<undefined>;
+}
+/**
+ * Notification Events
+ * @description Notification events are the events that trigger notifications.
+ */
+export declare class NotificationEvents {
+    private client;
+    constructor(client: Client<paths, `${string}/${string}`>);
+    /**
+     * Get a notification event by ID
+     * @param id - The ID of the notification event
+     * @param signal - An optional abort signal
+     * @returns The notification event
+     */
+    get(id: operations['getNotificationEvent']['parameters']['path']['eventId'], options?: RequestOptions): Promise<{
+        readonly id: string;
+        readonly type: import("./schemas.cjs").components["schemas"]["NotificationEventType"];
+        readonly createdAt: Date;
+        readonly rule: import("./schemas.cjs").components["schemas"]["NotificationRule"];
+        readonly deliveryStatus: import("./schemas.cjs").components["schemas"]["NotificationEventDeliveryStatus"][];
+        readonly payload: import("./schemas.cjs").components["schemas"]["NotificationEventPayload"];
+        readonly annotations?: import("./schemas.cjs").components["schemas"]["Annotations"];
+    } | undefined>;
+    /**
+     * List notification events
+     * @param query - The query parameters
+     * @param signal - An optional abort signal
+     * @returns The list of notification events
+     */
+    list(query?: operations['listNotificationEvents']['parameters']['query'], options?: RequestOptions): Promise<{
+        totalCount: number;
+        page: number;
+        pageSize: number;
+        items: import("./schemas.cjs").components["schemas"]["NotificationEvent"][];
+    } | undefined>;
+    /**
+     * Resend a notification event
+     * @description Resend a notification event that has already been sent.
+     * @param id - The ID of the notification event
+     * @param channels - The channels to resend the notification event to, if not provided it will resend to all channels
+     * @param signal - An optional abort signal
+     * @returns The resent notification event
+     */
+    resend(id: operations['resendNotificationEvent']['parameters']['path']['eventId'], body?: operations['resendNotificationEvent']['requestBody']['content']['application/json'], options?: RequestOptions): Promise<undefined>;
+}

package/dist/cjs/src/client/plans.cjs

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanAddons = exports.Plans = void 0;
+const utils_js_1 = require("./utils.cjs");
+/**
+ * Plans
+ * Manage customer subscription plans and addon assignments.
+ */
+class Plans {
+    client;
+    addons;
+    constructor(client) {
+        this.client = client;
+        this.addons = new PlanAddons(this.client);
+    }
+    /**
+     * Create a plan
+     * @param plan - The plan to create
+     * @param options - Optional request options
+     * @returns The created plan
+     */
+    async create(plan, options) {
+        const resp = await this.client.POST('/api/v1/plans', {
+            body: plan,
+            ...options,
+        });
+        return (0, utils_js_1.transformResponse)(resp);
+    }
+    /**
+     * 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
+     */
+    async get(planId, params, options) {
+        const resp = await this.client.GET('/api/v1/plans/{planId}', {
+            params: {
+                path: { planId },
+                query: params,
+            },
+            ...options,
+        });
+        return (0, utils_js_1.transformResponse)(resp);
+    }
+    /**
+     * List plans
+     * @param params - Optional parameters for listing plans
+     * @param options - Optional request options
+     * @returns A list of plans
+     */
+    async list(params, options) {
+        const resp = await this.client.GET('/api/v1/plans', {
+            params: { query: params },
+            ...options,
+        });
+        return (0, utils_js_1.transformResponse)(resp);
+    }
+    /**
+     * Update a plan
+     * @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
+     */
+    async update(planId, plan, options) {
+        const resp = await this.client.PUT('/api/v1/plans/{planId}', {
+            body: plan,
+            params: { path: { planId } },
+            ...options,
+        });
+        return (0, utils_js_1.transformResponse)(resp);
+    }
+    /**
+     * 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
+     */
+    async delete(planId, options) {
+        const resp = await this.client.DELETE('/api/v1/plans/{planId}', {
+            params: { path: { planId } },
+            ...options,
+        });
+        return (0, utils_js_1.transformResponse)(resp);
+    }
+    /**
+     * Archive a plan
+     * @param planId - The ID of the plan to archive
+     * @param options - Optional request options
+     * @returns The archived plan
+     */
+    async archive(planId, options) {
+        const resp = await this.client.POST('/api/v1/plans/{planId}/archive', {
+            params: { path: { planId } },
+            ...options,
+        });
+        return (0, utils_js_1.transformResponse)(resp);
+    }
+    /**
+     * Publish a plan
+     * @param planId - The ID of the plan to publish
+     * @param options - Optional request options
+     * @returns The published plan
+     */
+    async publish(planId, options) {
+        const resp = await this.client.POST('/api/v1/plans/{planId}/publish', {
+            params: { path: { planId } },
+            ...options,
+        });
+        return (0, utils_js_1.transformResponse)(resp);
+    }
+}
+exports.Plans = Plans;
+/**
+ * Plan Addons
+ * Manage addon assignments for plans.
+ */
+class PlanAddons {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * 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
+     */
+    async list(planId, params, options) {
+        const resp = await this.client.GET('/api/v1/plans/{planId}/addons', {
+            params: {
+                path: { planId },
+                query: params,
+            },
+            ...options,
+        });
+        return (0, utils_js_1.transformResponse)(resp);
+    }
+    /**
+     * 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
+     */
+    async create(planId, planAddon, options) {
+        const resp = await this.client.POST('/api/v1/plans/{planId}/addons', {
+            body: planAddon,
+            params: { path: { planId } },
+            ...options,
+        });
+        return (0, utils_js_1.transformResponse)(resp);
+    }
+    /**
+     * 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
+     */
+    async get(planId, planAddonId, options) {
+        const resp = await this.client.GET('/api/v1/plans/{planId}/addons/{planAddonId}', {
+            params: {
+                path: { planAddonId, planId },
+            },
+            ...options,
+        });
+        return (0, utils_js_1.transformResponse)(resp);
+    }
+    /**
+     * 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
+     */
+    async update(planId, planAddonId, planAddon, options) {
+        const resp = await this.client.PUT('/api/v1/plans/{planId}/addons/{planAddonId}', {
+            body: planAddon,
+            params: { path: { planAddonId, planId } },
+            ...options,
+        });
+        return (0, utils_js_1.transformResponse)(resp);
+    }
+    /**
+     * 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
+     */
+    async delete(planId, planAddonId, options) {
+        const resp = await this.client.DELETE('/api/v1/plans/{planId}/addons/{planAddonId}', {
+            params: { path: { planAddonId, planId } },
+            ...options,
+        });
+        return (0, utils_js_1.transformResponse)(resp);
+    }
+}
+exports.PlanAddons = PlanAddons;
+//# sourceMappingURL=plans.cjs.map