@metronome/sdk 0.1.0-alpha.0

package/src/resources/audit-logs.ts

@@ -0,0 +1,116 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import * as Core from "../core";
+import { APIResource } from "../resource";
+import { isRequestOptions } from "../core";
+import * as AuditLogsAPI from "./audit-logs";
+
+export class AuditLogs extends APIResource {
+  /**
+   * Retrieves a range of audit logs. If no further audit logs are currently
+   * available, the data array will be empty. As new audit logs are created,
+   * subsequent requests using the same next_page value will be in the returned data
+   * array, ensuring a continuous and uninterrupted reading of audit logs.
+   */
+  list(query?: AuditLogListParams, options?: Core.RequestOptions): Core.APIPromise<AuditLogListResponse>;
+  list(options?: Core.RequestOptions): Core.APIPromise<AuditLogListResponse>;
+  list(
+    query: AuditLogListParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<AuditLogListResponse> {
+    if (isRequestOptions(query)) {
+      return this.list({}, query);
+    }
+    return this._client.get('/auditLogs', { query, ...options });
+  }
+}
+
+export interface AuditLogListResponse {
+  data: Array<AuditLogListResponse.Data>;
+
+  /**
+   * The next_page parameter is always returned to support ongoing log retrieval. It
+   * enables continuous querying, even when some requests return no new data. Save
+   * the next_page token from each response and use it for future requests to ensure
+   * no logs are missed. This setup is ideal for regular updates via automated
+   * processes, like cron jobs, to fetch logs continuously as they become available.
+   * When you receive an empty data array, it indicates a temporary absence of new
+   * logs, but subsequent requests might return new data.
+   */
+  next_page: string | null;
+}
+
+export namespace AuditLogListResponse {
+  export interface Data {
+    id: string;
+
+    timestamp: string;
+
+    action?: string;
+
+    actor?: Data.Actor;
+
+    description?: string;
+
+    resource_id?: string;
+
+    resource_type?: string;
+
+    status?: 'success' | 'failure' | 'pending';
+  }
+
+  export namespace Data {
+    export interface Actor {
+      id: string;
+
+      name: string;
+
+      email?: string;
+    }
+  }
+}
+
+export interface AuditLogListParams {
+  /**
+   * RFC 3339 timestamp (exclusive). Cannot be used with 'next_page'.
+   */
+  ending_before?: string;
+
+  /**
+   * Max number of results that should be returned
+   */
+  limit?: number;
+
+  /**
+   * Cursor that indicates where the next page of results should start.
+   */
+  next_page?: string;
+
+  /**
+   * Optional parameter that can be used to filter which audit logs are returned. If
+   * you specify resource_id, you must also specify resource_type.
+   */
+  resource_id?: string;
+
+  /**
+   * Optional parameter that can be used to filter which audit logs are returned. If
+   * you specify resource_type, you must also specify resource_id.
+   */
+  resource_type?: string;
+
+  /**
+   * Sort order by timestamp, e.g. date_asc or date_desc. Defaults to date_asc.
+   */
+  sort?: 'date_asc' | 'date_desc';
+
+  /**
+   * RFC 3339 timestamp of the earliest audit log to return. Cannot be used with
+   * 'next_page'.
+   */
+  starting_on?: string;
+}
+
+export namespace AuditLogs {
+  export import AuditLogListResponse = AuditLogsAPI.AuditLogListResponse;
+  export import AuditLogListParams = AuditLogsAPI.AuditLogListParams;
+}

package/src/resources/billable-metrics.ts

@@ -0,0 +1,341 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import * as Core from "../core";
+import { APIResource } from "../resource";
+import { isRequestOptions } from "../core";
+import * as BillableMetricsAPI from "./billable-metrics";
+import * as Shared from "./shared";
+
+export class BillableMetrics extends APIResource {
+  /**
+   * Creates a new Billable Metric.
+   */
+  create(
+    body: BillableMetricCreateParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<BillableMetricCreateResponse> {
+    return this._client.post('/billable-metrics/create', { body, ...options });
+  }
+
+  /**
+   * Get a billable metric
+   */
+  retrieve(
+    billableMetricId: string,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<BillableMetricRetrieveResponse> {
+    return this._client.get(`/billable-metrics/${billableMetricId}`, options);
+  }
+
+  /**
+   * List all billable metrics.
+   */
+  list(
+    customerId: string,
+    query?: BillableMetricListParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<BillableMetricListResponse>;
+  list(customerId: string, options?: Core.RequestOptions): Core.APIPromise<BillableMetricListResponse>;
+  list(
+    customerId: string,
+    query: BillableMetricListParams | Core.RequestOptions = {},
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<BillableMetricListResponse> {
+    if (isRequestOptions(query)) {
+      return this.list(customerId, {}, query);
+    }
+    return this._client.get(`/customers/${customerId}/billable-metrics`, { query, ...options });
+  }
+
+  /**
+   * Archive an existing billable metric
+   */
+  archive(
+    body: BillableMetricArchiveParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<BillableMetricArchiveResponse> {
+    return this._client.post('/billable-metrics/archive', { body, ...options });
+  }
+}
+
+export interface BillableMetricCreateResponse {
+  data: Shared.ID;
+}
+
+export interface BillableMetricRetrieveResponse {
+  data: BillableMetricRetrieveResponse.Data;
+}
+
+export namespace BillableMetricRetrieveResponse {
+  export interface Data {
+    /**
+     * ID of the billable metric
+     */
+    id: string;
+
+    /**
+     * Specifies the type of aggregation performed on matching events.
+     */
+    aggregation_type:
+      | 'count'
+      | 'Count'
+      | 'COUNT'
+      | 'latest'
+      | 'Latest'
+      | 'LATEST'
+      | 'max'
+      | 'Max'
+      | 'MAX'
+      | 'sum'
+      | 'Sum'
+      | 'SUM'
+      | 'unique'
+      | 'Unique'
+      | 'UNIQUE';
+
+    /**
+     * The display name of the billable metric.
+     */
+    name: string;
+
+    /**
+     * A key that specifies which property of the event is used to aggregate data. This
+     * key must be one of the property filter names and is not applicable when the
+     * aggregation type is 'count'.
+     */
+    aggregation_key?: string;
+
+    custom_fields?: Record<string, string>;
+
+    /**
+     * An optional filtering rule to match the 'event_type' property of an event.
+     */
+    event_type_filter?: Data.EventTypeFilter;
+
+    /**
+     * Property names that are used to group usage costs on an invoice. Each entry
+     * represents a set of properties used to slice events into distinct buckets.
+     */
+    group_keys?: Array<Array<string>>;
+
+    /**
+     * A list of filters to match events to this billable metric. Each filter defines a
+     * rule on an event property. All rules must pass for the event to match the
+     * billable metric.
+     */
+    property_filters?: Array<Data.PropertyFilter>;
+  }
+
+  export namespace Data {
+    /**
+     * An optional filtering rule to match the 'event_type' property of an event.
+     */
+    export interface EventTypeFilter {
+      /**
+       * A list of event types that are explicitly included in the billable metric. If
+       * specified, only events of these types will match the billable metric. Must be
+       * non-empty if present.
+       */
+      in_values?: Array<string>;
+
+      /**
+       * A list of event types that are explicitly excluded from the billable metric. If
+       * specified, events of these types will not match the billable metric. Must be
+       * non-empty if present.
+       */
+      not_in_values?: Array<string>;
+    }
+
+    export interface PropertyFilter {
+      /**
+       * The name of the event property.
+       */
+      name: string;
+
+      /**
+       * Determines whether the property must exist in the event. If true, only events
+       * with this property will pass the filter. If false, only events without this
+       * property will pass the filter. If null or omitted, the existence of the property
+       * is optional.
+       */
+      exists?: boolean;
+
+      /**
+       * Specifies the allowed values for the property to match an event. An event will
+       * pass the filter only if its property value is included in this list. If
+       * undefined, all property values will pass the filter. Must be non-empty if
+       * present.
+       */
+      in_values?: Array<string>;
+
+      /**
+       * Specifies the values that prevent an event from matching the filter. An event
+       * will not pass the filter if its property value is included in this list. If null
+       * or empty, all property values will pass the filter. Must be non-empty if
+       * present.
+       */
+      not_in_values?: Array<string>;
+    }
+  }
+}
+
+export interface BillableMetricListResponse {
+  data: Array<BillableMetricListResponse.Data>;
+
+  next_page: string | null;
+}
+
+export namespace BillableMetricListResponse {
+  export interface Data {
+    id: string;
+
+    name: string;
+
+    group_by?: Array<string>;
+  }
+}
+
+export interface BillableMetricArchiveResponse {
+  data: Shared.ID;
+}
+
+export interface BillableMetricCreateParams {
+  /**
+   * Specifies the type of aggregation performed on matching events.
+   */
+  aggregation_type:
+    | 'count'
+    | 'Count'
+    | 'COUNT'
+    | 'latest'
+    | 'Latest'
+    | 'LATEST'
+    | 'max'
+    | 'Max'
+    | 'MAX'
+    | 'sum'
+    | 'Sum'
+    | 'SUM'
+    | 'unique'
+    | 'Unique'
+    | 'UNIQUE';
+
+  /**
+   * The display name of the billable metric.
+   */
+  name: string;
+
+  /**
+   * A key that specifies which property of the event is used to aggregate data. This
+   * key must be one of the property filter names and is not applicable when the
+   * aggregation type is 'count'.
+   */
+  aggregation_key?: string;
+
+  /**
+   * Custom fields to attach to the billable metric.
+   */
+  custom_fields?: Record<string, string>;
+
+  /**
+   * An optional filtering rule to match the 'event_type' property of an event.
+   */
+  event_type_filter?: BillableMetricCreateParams.EventTypeFilter;
+
+  /**
+   * Property names that are used to group usage costs on an invoice. Each entry
+   * represents a set of properties used to slice events into distinct buckets.
+   */
+  group_keys?: Array<Array<string>>;
+
+  /**
+   * A list of filters to match events to this billable metric. Each filter defines a
+   * rule on an event property. All rules must pass for the event to match the
+   * billable metric.
+   */
+  property_filters?: Array<BillableMetricCreateParams.PropertyFilter>;
+}
+
+export namespace BillableMetricCreateParams {
+  /**
+   * An optional filtering rule to match the 'event_type' property of an event.
+   */
+  export interface EventTypeFilter {
+    /**
+     * A list of event types that are explicitly included in the billable metric. If
+     * specified, only events of these types will match the billable metric. Must be
+     * non-empty if present.
+     */
+    in_values?: Array<string>;
+
+    /**
+     * A list of event types that are explicitly excluded from the billable metric. If
+     * specified, events of these types will not match the billable metric. Must be
+     * non-empty if present.
+     */
+    not_in_values?: Array<string>;
+  }
+
+  export interface PropertyFilter {
+    /**
+     * The name of the event property.
+     */
+    name: string;
+
+    /**
+     * Determines whether the property must exist in the event. If true, only events
+     * with this property will pass the filter. If false, only events without this
+     * property will pass the filter. If null or omitted, the existence of the property
+     * is optional.
+     */
+    exists?: boolean;
+
+    /**
+     * Specifies the allowed values for the property to match an event. An event will
+     * pass the filter only if its property value is included in this list. If
+     * undefined, all property values will pass the filter. Must be non-empty if
+     * present.
+     */
+    in_values?: Array<string>;
+
+    /**
+     * Specifies the values that prevent an event from matching the filter. An event
+     * will not pass the filter if its property value is included in this list. If null
+     * or empty, all property values will pass the filter. Must be non-empty if
+     * present.
+     */
+    not_in_values?: Array<string>;
+  }
+}
+
+export interface BillableMetricListParams {
+  /**
+   * Max number of results that should be returned
+   */
+  limit?: number;
+
+  /**
+   * Cursor that indicates where the next page of results should start.
+   */
+  next_page?: string;
+
+  /**
+   * If true, the list of metrics will be filtered to just ones that are on the
+   * customer's current plan
+   */
+  on_current_plan?: boolean;
+}
+
+export interface BillableMetricArchiveParams {
+  id: string;
+}
+
+export namespace BillableMetrics {
+  export import BillableMetricCreateResponse = BillableMetricsAPI.BillableMetricCreateResponse;
+  export import BillableMetricRetrieveResponse = BillableMetricsAPI.BillableMetricRetrieveResponse;
+  export import BillableMetricListResponse = BillableMetricsAPI.BillableMetricListResponse;
+  export import BillableMetricArchiveResponse = BillableMetricsAPI.BillableMetricArchiveResponse;
+  export import BillableMetricCreateParams = BillableMetricsAPI.BillableMetricCreateParams;
+  export import BillableMetricListParams = BillableMetricsAPI.BillableMetricListParams;
+  export import BillableMetricArchiveParams = BillableMetricsAPI.BillableMetricArchiveParams;
+}