@metronome/sdk 0.1.0-alpha.0

package/src/error.ts

@@ -0,0 +1,146 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { castToError, Headers } from './core';
+
+export class MetronomeError extends Error {}
+
+export class APIError extends MetronomeError {
+  readonly status: number | undefined;
+  readonly headers: Headers | undefined;
+  readonly error: Object | undefined;
+
+  constructor(
+    status: number | undefined,
+    error: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    super(`${APIError.makeMessage(status, error, message)}`);
+    this.status = status;
+    this.headers = headers;
+    this.error = error;
+  }
+
+  private static makeMessage(status: number | undefined, error: any, message: string | undefined) {
+    const msg =
+      error?.message ?
+        typeof error.message === 'string' ?
+          error.message
+        : JSON.stringify(error.message)
+      : error ? JSON.stringify(error)
+      : message;
+
+    if (status && msg) {
+      return `${status} ${msg}`;
+    }
+    if (status) {
+      return `${status} status code (no body)`;
+    }
+    if (msg) {
+      return msg;
+    }
+    return '(no status code or body)';
+  }
+
+  static generate(
+    status: number | undefined,
+    errorResponse: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ) {
+    if (!status) {
+      return new APIConnectionError({ cause: castToError(errorResponse) });
+    }
+
+    const error = errorResponse as Record<string, any>;
+
+    if (status === 400) {
+      return new BadRequestError(status, error, message, headers);
+    }
+
+    if (status === 401) {
+      return new AuthenticationError(status, error, message, headers);
+    }
+
+    if (status === 403) {
+      return new PermissionDeniedError(status, error, message, headers);
+    }
+
+    if (status === 404) {
+      return new NotFoundError(status, error, message, headers);
+    }
+
+    if (status === 409) {
+      return new ConflictError(status, error, message, headers);
+    }
+
+    if (status === 422) {
+      return new UnprocessableEntityError(status, error, message, headers);
+    }
+
+    if (status === 429) {
+      return new RateLimitError(status, error, message, headers);
+    }
+
+    if (status >= 500) {
+      return new InternalServerError(status, error, message, headers);
+    }
+
+    return new APIError(status, error, message, headers);
+  }
+}
+
+export class APIUserAbortError extends APIError {
+  override readonly status: undefined = undefined;
+
+  constructor({ message }: { message?: string } = {}) {
+    super(undefined, undefined, message || 'Request was aborted.', undefined);
+  }
+}
+
+export class APIConnectionError extends APIError {
+  override readonly status: undefined = undefined;
+
+  constructor({ message, cause }: { message?: string; cause?: Error | undefined }) {
+    super(undefined, undefined, message || 'Connection error.', undefined);
+    // in some environments the 'cause' property is already declared
+    // @ts-ignore
+    if (cause) this.cause = cause;
+  }
+}
+
+export class APIConnectionTimeoutError extends APIConnectionError {
+  constructor({ message }: { message?: string } = {}) {
+    super({ message: message ?? 'Request timed out.' });
+  }
+}
+
+export class BadRequestError extends APIError {
+  override readonly status: 400 = 400;
+}
+
+export class AuthenticationError extends APIError {
+  override readonly status: 401 = 401;
+}
+
+export class PermissionDeniedError extends APIError {
+  override readonly status: 403 = 403;
+}
+
+export class NotFoundError extends APIError {
+  override readonly status: 404 = 404;
+}
+
+export class ConflictError extends APIError {
+  override readonly status: 409 = 409;
+}
+
+export class UnprocessableEntityError extends APIError {
+  override readonly status: 422 = 422;
+}
+
+export class RateLimitError extends APIError {
+  override readonly status: 429 = 429;
+}
+
+export class InternalServerError extends APIError {}

package/src/index.ts

@@ -0,0 +1,303 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import * as Core from './core';
+import * as Errors from './error';
+import { type Agent } from './_shims/index';
+import * as Uploads from './uploads';
+import * as qs from 'qs';
+import * as API from "./resources/index";
+
+export interface ClientOptions {
+  /**
+   * Defaults to process.env['METRONOME_BEARER_TOKEN'].
+   */
+  bearerToken?: string | undefined;
+
+  /**
+   * Defaults to process.env['METRONOME_WEBHOOK_SECRET'].
+   */
+  webhookSecret?: string | null | undefined;
+
+  /**
+   * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
+   *
+   * Defaults to process.env['METRONOME_BASE_URL'].
+   */
+  baseURL?: string | null | undefined;
+
+  /**
+   * The maximum amount of time (in milliseconds) that the client should wait for a response
+   * from the server before timing out a single request.
+   *
+   * Note that request timeouts are retried by default, so in a worst-case scenario you may wait
+   * much longer than this timeout before the promise succeeds or fails.
+   */
+  timeout?: number;
+
+  /**
+   * An HTTP agent used to manage HTTP(S) connections.
+   *
+   * If not provided, an agent will be constructed by default in the Node.js environment,
+   * otherwise no agent is used.
+   */
+  httpAgent?: Agent;
+
+  /**
+   * Specify a custom `fetch` function implementation.
+   *
+   * If not provided, we use `node-fetch` on Node.js and otherwise expect that `fetch` is
+   * defined globally.
+   */
+  fetch?: Core.Fetch | undefined;
+
+  /**
+   * The maximum number of times that the client will retry a request in case of a
+   * temporary failure, like a network error or a 5XX error from the server.
+   *
+   * @default 2
+   */
+  maxRetries?: number;
+
+  /**
+   * Default headers to include with every request to the API.
+   *
+   * These can be removed in individual requests by explicitly setting the
+   * header to `undefined` or `null` in request options.
+   */
+  defaultHeaders?: Core.Headers;
+
+  /**
+   * Default query parameters to include with every request to the API.
+   *
+   * These can be removed in individual requests by explicitly setting the
+   * param to `undefined` in request options.
+   */
+  defaultQuery?: Core.DefaultQuery;
+}
+
+/** API Client for interfacing with the Metronome API. */
+export class Metronome extends Core.APIClient {
+  bearerToken: string;
+  webhookSecret: string | null;
+
+  private _options: ClientOptions;
+
+  /**
+   * API Client for interfacing with the Metronome API.
+   *
+   * @param {string | undefined} [opts.bearerToken=process.env['METRONOME_BEARER_TOKEN'] ?? undefined]
+   * @param {string | null | undefined} [opts.webhookSecret=process.env['METRONOME_WEBHOOK_SECRET'] ?? null]
+   * @param {string} [opts.baseURL=process.env['METRONOME_BASE_URL'] ?? https://api.metronome.com/v1] - Override the default base URL for the API.
+   * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
+   * @param {number} [opts.httpAgent] - An HTTP agent used to manage HTTP(s) connections.
+   * @param {Core.Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
+   * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
+   * @param {Core.Headers} opts.defaultHeaders - Default headers to include with every request to the API.
+   * @param {Core.DefaultQuery} opts.defaultQuery - Default query parameters to include with every request to the API.
+   */
+  constructor({
+    baseURL = Core.readEnv('METRONOME_BASE_URL'),
+    bearerToken = Core.readEnv('METRONOME_BEARER_TOKEN'),
+    webhookSecret = Core.readEnv('METRONOME_WEBHOOK_SECRET') ?? null,
+    ...opts
+  }: ClientOptions = {}) {
+    if (bearerToken === undefined) {
+      throw new Errors.MetronomeError(
+        "The METRONOME_BEARER_TOKEN environment variable is missing or empty; either provide it, or instantiate the Metronome client with an bearerToken option, like new Metronome({ bearerToken: 'My Bearer Token' }).",
+      );
+    }
+
+    const options: ClientOptions = {
+      bearerToken,
+      webhookSecret,
+      ...opts,
+      baseURL: baseURL || `https://api.metronome.com/v1`,
+    };
+
+    super({
+      baseURL: options.baseURL!,
+      timeout: options.timeout ?? 60000 /* 1 minute */,
+      httpAgent: options.httpAgent,
+      maxRetries: options.maxRetries,
+      fetch: options.fetch,
+    });
+    this._options = options;
+
+    this.bearerToken = bearerToken;
+    this.webhookSecret = webhookSecret;
+  }
+
+  alerts: API.Alerts = new API.Alerts(this);
+  plans: API.Plans = new API.Plans(this);
+  creditGrants: API.CreditGrants = new API.CreditGrants(this);
+  customers: API.Customers = new API.Customers(this);
+  dashboards: API.Dashboards = new API.Dashboards(this);
+  webhooks: API.Webhooks = new API.Webhooks(this);
+  usage: API.Usage = new API.Usage(this);
+  auditLogs: API.AuditLogs = new API.AuditLogs(this);
+  customFields: API.CustomFields = new API.CustomFields(this);
+  billableMetrics: API.BillableMetrics = new API.BillableMetrics(this);
+  services: API.Services = new API.Services(this);
+
+  protected override defaultQuery(): Core.DefaultQuery | undefined {
+    return this._options.defaultQuery;
+  }
+
+  protected override defaultHeaders(opts: Core.FinalRequestOptions): Core.Headers {
+    return {
+      ...super.defaultHeaders(opts),
+      ...this._options.defaultHeaders,
+    };
+  }
+
+  protected override authHeaders(opts: Core.FinalRequestOptions): Core.Headers {
+    return { Authorization: `Bearer ${this.bearerToken}` };
+  }
+
+  protected override stringifyQuery(query: Record<string, unknown>): string {
+    return qs.stringify(query, { arrayFormat: 'comma' });
+  }
+
+  static Metronome = this;
+
+  static MetronomeError = Errors.MetronomeError;
+  static APIError = Errors.APIError;
+  static APIConnectionError = Errors.APIConnectionError;
+  static APIConnectionTimeoutError = Errors.APIConnectionTimeoutError;
+  static APIUserAbortError = Errors.APIUserAbortError;
+  static NotFoundError = Errors.NotFoundError;
+  static ConflictError = Errors.ConflictError;
+  static RateLimitError = Errors.RateLimitError;
+  static BadRequestError = Errors.BadRequestError;
+  static AuthenticationError = Errors.AuthenticationError;
+  static InternalServerError = Errors.InternalServerError;
+  static PermissionDeniedError = Errors.PermissionDeniedError;
+  static UnprocessableEntityError = Errors.UnprocessableEntityError;
+
+  static toFile = Uploads.toFile;
+  static fileFromPath = Uploads.fileFromPath;
+}
+
+export const {
+  MetronomeError,
+  APIError,
+  APIConnectionError,
+  APIConnectionTimeoutError,
+  APIUserAbortError,
+  NotFoundError,
+  ConflictError,
+  RateLimitError,
+  BadRequestError,
+  AuthenticationError,
+  InternalServerError,
+  PermissionDeniedError,
+  UnprocessableEntityError,
+} = Errors;
+
+export import toFile = Uploads.toFile;
+export import fileFromPath = Uploads.fileFromPath;
+
+export namespace Metronome {
+  export import RequestOptions = Core.RequestOptions;
+
+  export import Alerts = API.Alerts;
+  export import AlertCreateResponse = API.AlertCreateResponse;
+  export import AlertArchiveResponse = API.AlertArchiveResponse;
+  export import AlertCreateParams = API.AlertCreateParams;
+  export import AlertArchiveParams = API.AlertArchiveParams;
+
+  export import Plans = API.Plans;
+  export import PlanDetail = API.PlanDetail;
+  export import PlanListResponse = API.PlanListResponse;
+  export import PlanGetDetailsResponse = API.PlanGetDetailsResponse;
+  export import PlanListChargesResponse = API.PlanListChargesResponse;
+  export import PlanListCustomersResponse = API.PlanListCustomersResponse;
+  export import PlanListParams = API.PlanListParams;
+  export import PlanListChargesParams = API.PlanListChargesParams;
+  export import PlanListCustomersParams = API.PlanListCustomersParams;
+
+  export import CreditGrants = API.CreditGrants;
+  export import CreditLedgerEntry = API.CreditLedgerEntry;
+  export import RolloverAmountMaxAmount = API.RolloverAmountMaxAmount;
+  export import RolloverAmountMaxPercentage = API.RolloverAmountMaxPercentage;
+  export import CreditGrantCreateResponse = API.CreditGrantCreateResponse;
+  export import CreditGrantListResponse = API.CreditGrantListResponse;
+  export import CreditGrantEditResponse = API.CreditGrantEditResponse;
+  export import CreditGrantListCreditTypesResponse = API.CreditGrantListCreditTypesResponse;
+  export import CreditGrantListEntriesResponse = API.CreditGrantListEntriesResponse;
+  export import CreditGrantVoidResponse = API.CreditGrantVoidResponse;
+  export import CreditGrantCreateParams = API.CreditGrantCreateParams;
+  export import CreditGrantListParams = API.CreditGrantListParams;
+  export import CreditGrantEditParams = API.CreditGrantEditParams;
+  export import CreditGrantListCreditTypesParams = API.CreditGrantListCreditTypesParams;
+  export import CreditGrantListEntriesParams = API.CreditGrantListEntriesParams;
+  export import CreditGrantVoidParams = API.CreditGrantVoidParams;
+
+  export import Customers = API.Customers;
+  export import Customer = API.Customer;
+  export import CustomerDetail = API.CustomerDetail;
+  export import CustomerCreateResponse = API.CustomerCreateResponse;
+  export import CustomerRetrieveResponse = API.CustomerRetrieveResponse;
+  export import CustomerListResponse = API.CustomerListResponse;
+  export import CustomerArchiveResponse = API.CustomerArchiveResponse;
+  export import CustomerListBillableMetricsResponse = API.CustomerListBillableMetricsResponse;
+  export import CustomerListCostsResponse = API.CustomerListCostsResponse;
+  export import CustomerSetNameResponse = API.CustomerSetNameResponse;
+  export import CustomerCreateParams = API.CustomerCreateParams;
+  export import CustomerListParams = API.CustomerListParams;
+  export import CustomerArchiveParams = API.CustomerArchiveParams;
+  export import CustomerListBillableMetricsParams = API.CustomerListBillableMetricsParams;
+  export import CustomerListCostsParams = API.CustomerListCostsParams;
+  export import CustomerSetIngestAliasesParams = API.CustomerSetIngestAliasesParams;
+  export import CustomerSetNameParams = API.CustomerSetNameParams;
+  export import CustomerUpdateConfigParams = API.CustomerUpdateConfigParams;
+
+  export import Dashboards = API.Dashboards;
+  export import DashboardGetEmbeddableURLResponse = API.DashboardGetEmbeddableURLResponse;
+  export import DashboardGetEmbeddableURLParams = API.DashboardGetEmbeddableURLParams;
+
+  export import Webhooks = API.Webhooks;
+
+  export import Usage = API.Usage;
+  export import UsageListResponse = API.UsageListResponse;
+  export import UsageListWithGroupsResponse = API.UsageListWithGroupsResponse;
+  export import UsageListParams = API.UsageListParams;
+  export import UsageIngestParams = API.UsageIngestParams;
+  export import UsageListWithGroupsParams = API.UsageListWithGroupsParams;
+
+  export import AuditLogs = API.AuditLogs;
+  export import AuditLogListResponse = API.AuditLogListResponse;
+  export import AuditLogListParams = API.AuditLogListParams;
+
+  export import CustomFields = API.CustomFields;
+  export import CustomFieldListKeysResponse = API.CustomFieldListKeysResponse;
+  export import CustomFieldAddKeyParams = API.CustomFieldAddKeyParams;
+  export import CustomFieldDeleteValuesParams = API.CustomFieldDeleteValuesParams;
+  export import CustomFieldListKeysParams = API.CustomFieldListKeysParams;
+  export import CustomFieldRemoveKeyParams = API.CustomFieldRemoveKeyParams;
+  export import CustomFieldSetValuesParams = API.CustomFieldSetValuesParams;
+
+  export import BillableMetrics = API.BillableMetrics;
+  export import BillableMetricCreateResponse = API.BillableMetricCreateResponse;
+  export import BillableMetricRetrieveResponse = API.BillableMetricRetrieveResponse;
+  export import BillableMetricListResponse = API.BillableMetricListResponse;
+  export import BillableMetricArchiveResponse = API.BillableMetricArchiveResponse;
+  export import BillableMetricCreateParams = API.BillableMetricCreateParams;
+  export import BillableMetricListParams = API.BillableMetricListParams;
+  export import BillableMetricArchiveParams = API.BillableMetricArchiveParams;
+
+  export import Services = API.Services;
+  export import ServiceListResponse = API.ServiceListResponse;
+
+  export import Commit = API.Commit;
+  export import ContractWithoutAmendments = API.ContractWithoutAmendments;
+  export import CreditType = API.CreditType;
+  export import Discount = API.Discount;
+  export import ID = API.ID;
+  export import Override = API.Override;
+  export import Rate = API.Rate;
+  export import SchedulePointInTime = API.SchedulePointInTime;
+  export import ScheduledCharge = API.ScheduledCharge;
+}
+
+export default Metronome;

package/src/lib/.keep

@@ -0,0 +1,4 @@
+File generated from our OpenAPI spec by Stainless.
+
+This directory can be used to store custom files to expand the SDK.
+It is ignored by Stainless code generation and its content (other than this keep file) won't be touched.

package/src/resource.ts

@@ -0,0 +1,11 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import type { Metronome } from './index';
+
+export class APIResource {
+  protected _client: Metronome;
+
+  constructor(client: Metronome) {
+    this._client = client;
+  }
+}

package/src/resources/alerts.ts

@@ -0,0 +1,144 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import * as Core from "../core";
+import { APIResource } from "../resource";
+import * as AlertsAPI from "./alerts";
+import * as Shared from "./shared";
+
+export class Alerts extends APIResource {
+  /**
+   * Create a new alert
+   */
+  create(body: AlertCreateParams, options?: Core.RequestOptions): Core.APIPromise<AlertCreateResponse> {
+    return this._client.post('/alerts/create', { body, ...options });
+  }
+
+  /**
+   * Archive an existing alert
+   */
+  archive(body: AlertArchiveParams, options?: Core.RequestOptions): Core.APIPromise<AlertArchiveResponse> {
+    return this._client.post('/alerts/archive', { body, ...options });
+  }
+}
+
+export interface AlertCreateResponse {
+  data: Shared.ID;
+}
+
+export interface AlertArchiveResponse {
+  data: Shared.ID;
+}
+
+export interface AlertCreateParams {
+  /**
+   * Type of the alert
+   */
+  alert_type:
+    | 'low_credit_balance_reached'
+    | 'spend_threshold_reached'
+    | 'monthly_invoice_total_spend_threshold_reached'
+    | 'low_remaining_days_in_plan_reached'
+    | 'low_remaining_credit_percentage_reached'
+    | 'usage_threshold_reached'
+    | 'low_remaining_days_for_commit_segment_reached'
+    | 'low_remaining_commit_balance_reached'
+    | 'low_remaining_commit_percentage_reached'
+    | 'low_remaining_days_for_contract_credit_segment_reached'
+    | 'low_remaining_contract_credit_balance_reached'
+    | 'low_remaining_contract_credit_percentage_reached'
+    | 'invoice_total_reached';
+
+  /**
+   * Name of the alert
+   */
+  name: string;
+
+  /**
+   * Threshold value of the alert policy
+   */
+  threshold: number;
+
+  /**
+   * For alerts of type `usage_threshold_reached`, specifies which billable metric to
+   * track the usage for.
+   */
+  billable_metric_id?: string;
+
+  credit_type_id?: string;
+
+  /**
+   * Only present for beta contract invoices. This field's availability is dependent
+   * on your client's configuration. A list of custom field filters for alert types
+   * that support advanced filtering
+   */
+  custom_field_filters?: Array<AlertCreateParams.CustomFieldFilter>;
+
+  /**
+   * If provided, will create this alert for this specific customer. To create an
+   * alert for all customers, do not specify `customer_id` or `plan_id`.
+   */
+  customer_id?: string;
+
+  /**
+   * If true, the alert will evaluate immediately on customers that already meet the
+   * alert threshold. If false, it will only evaluate on future customers that
+   * trigger the alert threshold. Defaults to true.
+   */
+  evaluate_on_create?: boolean;
+
+  /**
+   * Scopes alert evaluation to a specific presentation group key on individual line
+   * items. Only present for spend alerts.
+   */
+  group_key_filter?: AlertCreateParams.GroupKeyFilter;
+
+  /**
+   * Only supported for invoice_total_reached alerts. A list of invoice types to
+   * evaluate.
+   */
+  invoice_types_filter?: Array<string>;
+
+  /**
+   * If provided, will create this alert for this specific plan. To create an alert
+   * for all customers, do not specify `customer_id` or `plan_id`.
+   */
+  plan_id?: string;
+
+  /**
+   * Prevents the creation of duplicates. If a request to create a record is made
+   * with a previously used uniqueness key, a new record will not be created and the
+   * request will fail with a 409 error.
+   */
+  uniqueness_key?: string;
+}
+
+export namespace AlertCreateParams {
+  export interface CustomFieldFilter {
+    entity: 'Contract' | 'Commit' | 'ContractCredit';
+
+    key: string;
+
+    value: string;
+  }
+
+  /**
+   * Scopes alert evaluation to a specific presentation group key on individual line
+   * items. Only present for spend alerts.
+   */
+  export interface GroupKeyFilter {
+    key: string;
+
+    value: string;
+  }
+}
+
+export interface AlertArchiveParams {
+  id: string;
+}
+
+export namespace Alerts {
+  export import AlertCreateResponse = AlertsAPI.AlertCreateResponse;
+  export import AlertArchiveResponse = AlertsAPI.AlertArchiveResponse;
+  export import AlertCreateParams = AlertsAPI.AlertCreateParams;
+  export import AlertArchiveParams = AlertsAPI.AlertArchiveParams;
+}