@openmeter/sdk 1.0.0-alpha.4 → 1.0.0-beta-7b2d9ed372e3

package/dist/src/meters.d.ts

@@ -0,0 +1,184 @@
+import type { MeterCreate, operations, paths } from './schemas.js';
+import type { Client } from 'openapi-fetch';
+/**
+ * Meters
+ * @description Meters are used to track and manage usage of your application.
+ */
+export declare class Meters {
+    private client;
+    constructor(client: Client<paths, `${string}/${string}`>);
+    /**
+     * Create a meter
+     * @param meter - The meter to create
+     * @param signal - An optional abort signal
+     * @returns The created meter
+     */
+    create(meter: MeterCreate, signal?: AbortSignal): Promise<{
+        data?: never;
+        error: import("./utils.js").Problem;
+        response: Response;
+    } | {
+        data: {
+            readonly id: string;
+            slug: string;
+            description?: string;
+            aggregation: import("./schemas.js").components["schemas"]["MeterAggregation"];
+            windowSize: import("./schemas.js").components["schemas"]["WindowSize"];
+            eventType: string;
+            valueProperty?: string;
+            groupBy?: {
+                [key: string]: string;
+            };
+        };
+        error?: never;
+        response: Response;
+    }>;
+    /**
+     * Get a meter by ID or slug
+     * @param idOrSlug - The ID or slug of the meter
+     * @param signal - An optional abort signal
+     * @returns The meter
+     */
+    get(idOrSlug: operations['getMeter']['parameters']['path']['meterIdOrSlug'], signal?: AbortSignal): Promise<{
+        data?: never;
+        error: import("./utils.js").Problem;
+        response: Response;
+    } | {
+        data: {
+            readonly id: string;
+            slug: string;
+            description?: string;
+            aggregation: import("./schemas.js").components["schemas"]["MeterAggregation"];
+            windowSize: import("./schemas.js").components["schemas"]["WindowSize"];
+            eventType: string;
+            valueProperty?: string;
+            groupBy?: {
+                [key: string]: string;
+            };
+        };
+        error?: never;
+        response: Response;
+    }>;
+    /**
+     * List meters
+     * @param signal - An optional abort signal
+     * @returns The meters
+     */
+    list(signal?: AbortSignal): Promise<{
+        data?: never;
+        error: import("./utils.js").Problem;
+        response: Response;
+    } | {
+        data: {
+            readonly id: string;
+            slug: string;
+            description?: string;
+            aggregation: import("./schemas.js").components["schemas"]["MeterAggregation"];
+            windowSize: import("./schemas.js").components["schemas"]["WindowSize"];
+            eventType: string;
+            valueProperty?: string;
+            groupBy?: {
+                [key: string]: string;
+            };
+        }[];
+        error?: never;
+        response: Response;
+    }>;
+    /**
+     * Query usage data for a meter by ID or slug
+     * @param idOrSlug - The ID or slug of the meter
+     * @param query - The query parameters
+     * @param signal - An optional abort signal
+     * @returns The meter data
+     */
+    query(idOrSlug: operations['queryMeter']['parameters']['path']['meterIdOrSlug'], query?: operations['queryMeter']['parameters']['query'], signal?: AbortSignal): Promise<{
+        data?: never;
+        error: import("./utils.js").Problem;
+        response: Response;
+    } | {
+        data: import("openapi-typescript-helpers").SuccessResponse<{
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import("./schemas.js").components["schemas"]["MeterQueryResult"];
+                    "text/csv": string;
+                };
+            };
+            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"];
+                };
+            };
+            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}`>;
+        error?: never;
+        response: Response;
+    }>;
+    /**
+     * Delete a meter by ID or slug
+     * @param idOrSlug - The ID or slug of the meter
+     * @param signal - An optional abort signal
+     * @returns The deleted meter
+     */
+    delete(idOrSlug: operations['deleteMeter']['parameters']['path']['meterIdOrSlug'], signal?: AbortSignal): Promise<{
+        data?: never;
+        error: import("./utils.js").Problem;
+        response: Response;
+    } | {
+        data: undefined;
+        error?: never;
+        response: Response;
+    }>;
+}

package/dist/src/meters.js

@@ -0,0 +1,89 @@
+import { transformResponse } from './utils.js';
+/**
+ * Meters
+ * @description Meters are used to track and manage usage of your application.
+ */
+export class Meters {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Create a meter
+     * @param meter - The meter to create
+     * @param signal - An optional abort signal
+     * @returns The created meter
+     */
+    async create(meter, signal) {
+        const resp = await this.client.POST('/api/v1/meters', {
+            signal,
+            body: meter,
+        });
+        return transformResponse(resp);
+    }
+    /**
+     * Get a meter by ID or slug
+     * @param idOrSlug - The ID or slug of the meter
+     * @param signal - An optional abort signal
+     * @returns The meter
+     */
+    async get(idOrSlug, signal) {
+        const resp = await this.client.GET('/api/v1/meters/{meterIdOrSlug}', {
+            signal,
+            params: {
+                path: {
+                    meterIdOrSlug: idOrSlug,
+                },
+            },
+        });
+        return transformResponse(resp);
+    }
+    /**
+     * List meters
+     * @param signal - An optional abort signal
+     * @returns The meters
+     */
+    async list(signal) {
+        const resp = await this.client.GET('/api/v1/meters', {
+            signal,
+        });
+        return transformResponse(resp);
+    }
+    /**
+     * Query usage data for a meter by ID or slug
+     * @param idOrSlug - The ID or slug of the meter
+     * @param query - The query parameters
+     * @param signal - An optional abort signal
+     * @returns The meter data
+     */
+    async query(idOrSlug, query, signal) {
+        const resp = await this.client.GET('/api/v1/meters/{meterIdOrSlug}/query', {
+            signal,
+            params: {
+                path: {
+                    meterIdOrSlug: idOrSlug,
+                },
+                query,
+            },
+        });
+        return transformResponse(resp);
+    }
+    /**
+     * Delete a meter by ID or slug
+     * @param idOrSlug - The ID or slug of the meter
+     * @param signal - An optional abort signal
+     * @returns The deleted meter
+     */
+    async delete(idOrSlug, signal) {
+        const resp = await this.client.DELETE('/api/v1/meters/{meterIdOrSlug}', {
+            signal,
+            params: {
+                path: {
+                    meterIdOrSlug: idOrSlug,
+                },
+            },
+        });
+        return transformResponse(resp);
+    }
+}
+//# sourceMappingURL=meters.js.map

package/dist/src/meters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"meters.js","sourceRoot":"","sources":["../../src/meters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAI9C;;;GAGG;AACH,MAAM,OAAO,MAAM;IACG;IAApB,YAAoB,MAA4C;QAA5C,WAAM,GAAN,MAAM,CAAsC;IAAG,CAAC;IAEpE;;;;;OAKG;IACI,KAAK,CAAC,MAAM,CAAC,KAAkB,EAAE,MAAoB;QAC1D,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE;YACpD,MAAM;YACN,IAAI,EAAE,KAAK;SACZ,CAAC,CAAA;QAEF,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAA;IAChC,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,GAAG,CACd,QAAuE,EACvE,MAAoB;QAEpB,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,gCAAgC,EAAE;YACnE,MAAM;YACN,MAAM,EAAE;gBACN,IAAI,EAAE;oBACJ,aAAa,EAAE,QAAQ;iBACxB;aACF;SACF,CAAC,CAAA;QAEF,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAA;IAChC,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,IAAI,CAAC,MAAoB;QACpC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,gBAAgB,EAAE;YACnD,MAAM;SACP,CAAC,CAAA;QAEF,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAA;IAChC,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,KAAK,CAChB,QAAyE,EACzE,KAAuD,EACvD,MAAoB;QAEpB,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,sCAAsC,EAAE;YACzE,MAAM;YACN,MAAM,EAAE;gBACN,IAAI,EAAE;oBACJ,aAAa,EAAE,QAAQ;iBACxB;gBACD,KAAK;aACN;SACF,CAAC,CAAA;QAEF,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAA;IAChC,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,MAAM,CACjB,QAA0E,EAC1E,MAAoB;QAEpB,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,gCAAgC,EAAE;YACtE,MAAM;YACN,MAAM,EAAE;gBACN,IAAI,EAAE;oBACJ,aAAa,EAAE,QAAQ;iBACxB;aACF;SACF,CAAC,CAAA;QAEF,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAA;IAChC,CAAC;CACF"}

package/dist/src/notifications.d.ts

@@ -0,0 +1,314 @@
+import type { NotificationChannel, NotificationRuleCreateRequest, operations, paths } from './schemas.js';
+import type { Client } from 'openapi-fetch';
+/**
+ * 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, signal?: AbortSignal): Promise<{
+        data?: never;
+        error: import("./utils.js").Problem;
+        response: Response;
+    } | {
+        data: {
+            readonly createdAt: Date;
+            readonly updatedAt: Date;
+            readonly deletedAt?: Date;
+            readonly id: string;
+            type: "WEBHOOK";
+            name: string;
+            disabled?: boolean;
+            url: string;
+            customHeaders?: {
+                [key: string]: string;
+            };
+            signingSecret?: string;
+        };
+        error?: never;
+        response: Response;
+    }>;
+    /**
+     * 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'], signal?: AbortSignal): Promise<{
+        data?: never;
+        error: import("./utils.js").Problem;
+        response: Response;
+    } | {
+        data: {
+            readonly createdAt: Date;
+            readonly updatedAt: Date;
+            readonly deletedAt?: Date;
+            readonly id: string;
+            type: "WEBHOOK";
+            name: string;
+            disabled?: boolean;
+            url: string;
+            customHeaders?: {
+                [key: string]: string;
+            };
+            signingSecret?: string;
+        };
+        error?: never;
+        response: Response;
+    }>;
+    /**
+     * 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, signal?: AbortSignal): Promise<{
+        data?: never;
+        error: import("./utils.js").Problem;
+        response: Response;
+    } | {
+        data: {
+            readonly createdAt: Date;
+            readonly updatedAt: Date;
+            readonly deletedAt?: Date;
+            readonly id: string;
+            type: "WEBHOOK";
+            name: string;
+            disabled?: boolean;
+            url: string;
+            customHeaders?: {
+                [key: string]: string;
+            };
+            signingSecret?: string;
+        };
+        error?: never;
+        response: Response;
+    }>;
+    /**
+     * 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'], signal?: AbortSignal): Promise<{
+        data?: never;
+        error: import("./utils.js").Problem;
+        response: Response;
+    } | {
+        data: {
+            totalCount: number;
+            page: number;
+            pageSize: number;
+            items: import("./schemas.js").components["schemas"]["NotificationChannel"][];
+        };
+        error?: never;
+        response: Response;
+    }>;
+    /**
+     * 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'], signal?: AbortSignal): Promise<{
+        data?: never;
+        error: import("./utils.js").Problem;
+        response: Response;
+    } | {
+        data: undefined;
+        error?: never;
+        response: Response;
+    }>;
+}
+/**
+ * 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, signal?: AbortSignal): Promise<{
+        data?: never;
+        error: import("./utils.js").Problem;
+        response: Response;
+    } | {
+        data: {
+            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"][];
+        };
+        error?: never;
+        response: Response;
+    }>;
+    /**
+     * 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'], signal?: AbortSignal): Promise<{
+        data?: never;
+        error: import("./utils.js").Problem;
+        response: Response;
+    } | {
+        data: {
+            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"][];
+        };
+        error?: never;
+        response: Response;
+    }>;
+    /**
+     * 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, signal?: AbortSignal): Promise<{
+        data?: never;
+        error: import("./utils.js").Problem;
+        response: Response;
+    } | {
+        data: {
+            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"][];
+        };
+        error?: never;
+        response: Response;
+    }>;
+    /**
+     * 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'], signal?: AbortSignal): Promise<{
+        data?: never;
+        error: import("./utils.js").Problem;
+        response: Response;
+    } | {
+        data: {
+            totalCount: number;
+            page: number;
+            pageSize: number;
+            items: import("./schemas.js").components["schemas"]["NotificationRule"][];
+        };
+        error?: never;
+        response: Response;
+    }>;
+    /**
+     * 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'], signal?: AbortSignal): Promise<{
+        data?: never;
+        error: import("./utils.js").Problem;
+        response: Response;
+    } | {
+        data: undefined;
+        error?: never;
+        response: Response;
+    }>;
+}
+/**
+ * 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'], signal?: AbortSignal): Promise<{
+        data?: never;
+        error: import("./utils.js").Problem;
+        response: Response;
+    } | {
+        data: {
+            readonly id: string;
+            readonly type: import("./schemas.js").components["schemas"]["NotificationEventType"];
+            readonly createdAt: Date;
+            readonly rule: import("./schemas.js").components["schemas"]["NotificationRule"];
+            readonly deliveryStatus: import("./schemas.js").components["schemas"]["NotificationEventDeliveryStatus"][];
+            readonly payload: import("./schemas.js").components["schemas"]["NotificationEventPayload"];
+            readonly annotations?: import("./schemas.js").components["schemas"]["Annotations"];
+        };
+        error?: never;
+        response: Response;
+    }>;
+    /**
+     * 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'], signal?: AbortSignal): Promise<{
+        data?: never;
+        error: import("./utils.js").Problem;
+        response: Response;
+    } | {
+        data: {
+            totalCount: number;
+            page: number;
+            pageSize: number;
+            items: import("./schemas.js").components["schemas"]["NotificationEvent"][];
+        };
+        error?: never;
+        response: Response;
+    }>;
+}