orb-billing 1.20.2 → 1.22.0

package/resources/events/events.mjs

@@ -0,0 +1,327 @@
+// File generated from our OpenAPI spec by Stainless.
+import { APIResource } from 'orb-billing/resource';
+import { isRequestOptions } from 'orb-billing/core';
+import * as BackfillsAPI from 'orb-billing/resources/events/backfills';
+export class Events extends APIResource {
+    constructor() {
+        super(...arguments);
+        this.backfills = new BackfillsAPI.Backfills(this.client);
+    }
+    /**
+     * This endpoint is used to amend a single usage event with a given `event_id`.
+     * `event_id` refers to the `idempotency_key` passed in during ingestion. The event
+     * will maintain its existing `event_id` after the amendment.
+     *
+     * This endpoint will mark the existing event as ignored, and Orb will only use the
+     * new event passed in the body of this request as the source of truth for that
+     * `event_id`. Note that a single event can be amended any number of times, so the
+     * same event can be overwritten in subsequent calls to this endpoint, or
+     * overwritten using the [Amend customer usage](amend-usage) endpoint. Only a
+     * single event with a given `event_id` will be considered the source of truth at
+     * any given time.
+     *
+     * This is a powerful and audit-safe mechanism to retroactively update a single
+     * event in cases where you need to:
+     *
+     * - update an event with new metadata as you iterate on your pricing model
+     * - update an event based on the result of an external API call (ex. call to a
+     *   payment gateway succeeded or failed)
+     *
+     * This amendment API is always audit-safe. The process will still retain the
+     * original event, though it will be ignored for billing calculations. For auditing
+     * and data fidelity purposes, Orb never overwrites or permanently deletes ingested
+     * usage data.
+     *
+     * ## Request validation
+     *
+     * - The `timestamp` of the new event must match the `timestamp` of the existing
+     *   event already ingested. As with ingestion, all timestamps must be sent in
+     *   ISO8601 format with UTC timezone offset.
+     * - The `customer_id` or `external_customer_id` of the new event must match the
+     *   `customer_id` or `external_customer_id` of the existing event already
+     *   ingested. Exactly one of `customer_id` and `external_customer_id` should be
+     *   specified, and similar to ingestion, the ID must identify a Customer resource
+     *   within Orb. Unlike ingestion, for event amendment, we strictly enforce that
+     *   the Customer must be in the Orb system, even during the initial integration
+     *   period. We do not allow updating the `Customer` an event is associated with.
+     * - Orb does not accept an `idempotency_key` with the event in this endpoint,
+     *   since this request is by design idempotent. On retryable errors, you should
+     *   retry the request and assume the amendment operation has not succeeded until
+     *   receipt of a 2xx.
+     * - The event's `timestamp` must fall within the customer's current subscription's
+     *   billing period, or within the grace period of the customer's current
+     *   subscription's previous billing period.
+     */
+    update(eventId, body, options) {
+        return this.put(`/events/${eventId}`, { body, ...options });
+    }
+    /**
+     * This endpoint is used to deprecate a single usage event with a given `event_id`.
+     * `event_id` refers to the `idempotency_key` passed in during ingestion.
+     *
+     * This endpoint will mark the existing event as ignored. Note that if you attempt
+     * to re-ingest an event with the same `event_id` as a deprecated event, Orb will
+     * return an error.
+     *
+     * This is a powerful and audit-safe mechanism to retroactively deprecate a single
+     * event in cases where you need to:
+     *
+     * - no longer bill for an event that was improperly reported
+     * - no longer bill for an event based on the result of an external API call (ex.
+     *   call to a payment gateway failed and the user should not be billed)
+     *
+     * If you want to only change specific properties of an event, but keep the event
+     * as part of the billing calculation, use the [Amend single event](amend-event)
+     * endpoint instead.
+     *
+     * This API is always audit-safe. The process will still retain the deprecated
+     * event, though it will be ignored for billing calculations. For auditing and data
+     * fidelity purposes, Orb never overwrites or permanently deletes ingested usage
+     * data.
+     *
+     * ## Request validation
+     *
+     * - Orb does not accept an `idempotency_key` with the event in this endpoint,
+     *   since this request is by design idempotent. On retryable errors, you should
+     *   retry the request and assume the deprecation operation has not succeeded until
+     *   receipt of a 2xx.
+     * - The event's `timestamp` must fall within the customer's current subscription's
+     *   billing period, or within the grace period of the customer's current
+     *   subscription's previous billing period. Orb does not allow deprecating events
+     *   for billing periods that have already invoiced customers.
+     * - The `customer_id` or the `external_customer_id` of the original event
+     *   ingestion request must identify a Customer resource within Orb, even if this
+     *   event was ingested during the initial integration period. We do not allow
+     *   deprecating events for customers not in the Orb system.
+     */
+    deprecate(eventId, options) {
+        return this.put(`/events/${eventId}/deprecate`, options);
+    }
+    /**
+     * Orb's event ingestion model and API is designed around two core principles:
+     *
+     * 1. **Data fidelity**: The accuracy of your billing model depends on a robust
+     *    foundation of events. Orb's API protocol encourages usage patterns that
+     *    ensure that your data is consistently complete and correct.
+     * 2. **Fast integration**: Sending events into Orb requires no tedious setup steps
+     *    or explicit field schema for your event shape, making it instant to start
+     *    streaming in usage in real-time.
+     *
+     * ## Event shape
+     *
+     * Events are the starting point for all usage calculations in the system, and are
+     * simple at their core:
+     *
+     * ```json
+     * {
+     * // customer_id and external_customer_id are used to
+     * // attribute usage to a given Customer. Exactly one of these
+     * // should be specified in a given ingestion event.
+     *
+     * // `customer_id` is the Orb generated identifier for the Customer,
+     * // which is returned from the Create customer API call.
+     * customer_id: string,
+     *
+     * // external_customer_id is an alternate identifier which is associated
+     * // with a Customer at creation time. This is treated as an alias for
+     * // customer_id, and is usually set to an identifier native to your system.
+     * external_customer_id: string,
+     *
+     * // A string name identifying the event, usually a usage
+     * // action. By convention, this should not contain any whitespace.
+     * event_name: string,
+     *
+     * // An ISO 8601 format date with no timezone offset.
+     * // This should represent the time that usage occurred
+     * // and is important to attribute usage to a given
+     * // billing period. See the notes below on determining the timestamp.
+     * // e.g. 2020-12-09T16:09:53Z
+     * timestamp: string,
+     *
+     * // A unique value, generated by the client, that is
+     * // used to de-duplicate events.
+     * // Exactly one event with a given
+     * // idempotency key will be ingested, which allows for
+     * // safe request retries.
+     * idempotency_key: string
+     *
+     * // Optional custom metadata to attach to the event.
+     * // This might include a numeric value used for aggregation,
+     * // or a string/boolean value used for filtering.
+     * // The schema of this dictionary need not be pre-declared, and
+     * // properties can be added at any time.
+     * properties: {
+     * [key: string]?: string | number | boolean,
+     * },
+     * }
+     * ```
+     *
+     * ## Required fields
+     *
+     * Because events streamed to Orb are meant to be as flexible as possible, there
+     * are only a few required fields in every event.
+     *
+     * - We recommend that `idempotency_key` are unique strings that you generated with
+     *   V4 UUIDs, but only require that they uniquely identify an event (i.e. don’t
+     *   collide).
+     * - The `timestamp` field in the event body will be used to determine which
+     *   billable period a given event falls into. For example, with a monthly billing
+     *   cycle starting from the first of December, Orb will calculate metrics based on
+     *   events that fall into the range
+     *   `12-01 00:00:00 <= timestamp < 01-01 00:00:00`.
+     *
+     * ## Logging metadata
+     *
+     * Orb allows tagging events with metadata using a flexible properties dictionary.
+     * Since Orb does not enforce a rigid schema for this field-set, key-value pairs
+     * can be added dynamically as your events evolve.
+     *
+     * This dictionary can be helpful for a wide variety of use cases:
+     *
+     * - Numeric properties on events like `compute_time_ms` can later be inputs to our
+     *   flexible query engine to determine usage.
+     * - Logging a region or cluster with each event can help you provide customers
+     *   more granular visibility into their usage.
+     *
+     * We encourage logging this metadata with an eye towards future use cases to
+     * ensure full coverage for historical data. The datatype of the value in the
+     * properties dictionary is important for metric creation from an event source.
+     * Values that you wish to numerically aggregate should be of numeric type in the
+     * event.
+     *
+     * ## Determining event timestamp
+     *
+     * For cases where usage is being reported in real time as it is occurring,
+     * timestamp should correspond to the time that usage occurred.
+     *
+     * In cases where usage is reported in aggregate for a historical timeframe at a
+     * regular interval, we recommend setting the event `timestamp` to the midpoint of
+     * the interval. As an example, if you have an hourly reporter that sends data once
+     * an hour for the previous hour of usage, setting the `timestamp` to the half-hour
+     * mark will ensure that the usage is counted within the correct period.
+     *
+     * Note that other time-related fields (e.g. time elapsed) can be added to the
+     * properties dictionary as necessary.
+     *
+     * In cases where usage is reported in aggregate for a historical timeframe, the
+     * timestamp must be within the grace period set for your account. Events with
+     * `timestamp < current_time - grace_period` will not be accepted as a valid event,
+     * and will throw validation errors. Enforcing the grace period enables Orb to
+     * accurately map usage to the correct billing cycle and ensure that all usage is
+     * billed for in the corresponding billing period.
+     *
+     * ## Event validation
+     *
+     * Orb’s validation ensures that you recognize errors in your events as quickly as
+     * possible, and the API provides informative error messages to help you fix
+     * problems quickly.
+     *
+     * We validate the following:
+     *
+     * - Exactly one of `customer_id` and `external_customer_id` should be specified.
+     * - If specified, `customer_id` must identify a Customer resource within Orb. We
+     *   do not support sending events for customers that have not been provisioned.
+     *   Similarly, if specified, `external_customer_id` must be an identifier that is
+     *   associated with an Orb Customer resource. Note: During our initial integration
+     *   period, this enforcement will be temporarily turned into a warning to ensure
+     *   smooth customer migration.
+     * - `timestamp` must conform to ISO 8601 and represent a timestamp at most 1 hour
+     *   in the future. This timestamp should be sent in UTC timezone (no timezone
+     *   offset).
+     *
+     * ## Idempotency and retry semantics
+     *
+     * Orb's idempotency guarantees allow you to implement safe retry logic in the
+     * event of network or machine failures, ensuring data fidelity. Each event in the
+     * request payload is associated with an idempotency key, and Orb guarantees that a
+     * single idempotency key will be successfully ingested at most once.
+     *
+     * - Successful responses return a 200 HTTP status code. The response contains
+     *   information about previously processed events.
+     * - Requests that return a `4xx` HTTP status code indicate a payload error and
+     *   contain at least one event with a validation failure. An event with a
+     *   validation failure can be re-sent to the ingestion endpoint (after the payload
+     *   is fixed) with the original idempotency key since that key is not marked as
+     *   processed.
+     * - Requests that return a `5xx` HTTP status code indicate a server-side failure.
+     *   These requests should be retried in their entirety.
+     *
+     * ## API usage and limits
+     *
+     * The ingestion API is designed made for real-time streaming ingestion and
+     * architected for high throughput. Even if events are later deemed unnecessary or
+     * filtered out, we encourage you to log them to Orb if they may be relevant to
+     * billing calculations in the future.
+     *
+     * To take advantage of the real-time features of the Orb platform and avoid any
+     * chance of dropped events by producers, we recommend reporting events to Orb
+     * frequently. Optionally, events can also be briefly aggregated at the source, as
+     * this API accepts an array of event bodies.
+     *
+     * Orb does not currently enforce a hard rate-limit for API usage or a maximum
+     * request payload size, but please give us a heads up if you’re changing either of
+     * these factors by an order of magnitude from initial setup.
+     *
+     * ## Testing in debug mode
+     *
+     * The ingestion API supports a debug mode, which returns additional verbose output
+     * to indicate which event idempotency keys were newly ingested or duplicates from
+     * previous requests. To enable this mode, mark `debug=true` as a query parameter.
+     *
+     * If `debug=true` is not specified, the response will only contain
+     * `validation_failed`. Orb will still honor the idempotency guarantees set
+     * [here](../guides/events-and-metrics/event-ingestion#event-volume-and-concurrency)
+     * in all cases.
+     *
+     * We strongly recommend that you only use debug mode as part of testing your
+     * initial Orb integration. Once you're ready to switch to production, disable
+     * debug mode to take advantage of improved performance and maximal throughput.
+     *
+     * #### Example: ingestion response with `debug=true`
+     *
+     * ```json
+     * {
+     *   "debug": {
+     *     "duplicate": [],
+     *     "ingested": ["B7E83HDMfJPAunXW", "SJs5DQJ3TnwSqEZE", "8SivfDsNKwCeAXim"]
+     *   },
+     *   "validation_failed": []
+     * }
+     * ```
+     *
+     * #### Example: ingestion response with `debug=false`
+     *
+     * ```json
+     * {
+     *   "validation_failed": []
+     * }
+     * ```
+     */
+    ingest(params, options) {
+        const { backfill_id, debug, ...body } = params;
+        return this.post('/ingest', { query: { backfill_id, debug }, body, ...options });
+    }
+    search(params = {}, options) {
+        if (isRequestOptions(params)) {
+            return this.search({}, params);
+        }
+        const { cursor, limit, 'timestamp[gt]': timestampGt, 'timestamp[gte]': timestampGte, 'timestamp[lt]': timestampLt, 'timestamp[lte]': timestampLte, ...body } = params;
+        return this.post('/events/search', {
+            query: {
+                cursor,
+                limit,
+                'timestamp[gt]': timestampGt,
+                'timestamp[gte]': timestampGte,
+                'timestamp[lt]': timestampLt,
+                'timestamp[lte]': timestampLte,
+            },
+            body,
+            ...options,
+        });
+    }
+}
+(function (Events) {
+    Events.Backfills = BackfillsAPI.Backfills;
+    Events.BackfillListResponsesPage = BackfillsAPI.BackfillListResponsesPage;
+})(Events || (Events = {}));
+//# sourceMappingURL=events.mjs.map

package/resources/events/events.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.mjs","sourceRoot":"","sources":["../../src/resources/events/events.ts"],"names":[],"mappings":"AAAA,qDAAqD;OAG9C,EAAE,WAAW,EAAE,MAAM,sBAAsB;OAC3C,EAAE,gBAAgB,EAAE,MAAM,kBAAkB;OAE5C,KAAK,YAAY,MAAM,wCAAwC;AAEtE,MAAM,OAAO,MAAO,SAAQ,WAAW;IAAvC;;QACE,cAAS,GAA2B,IAAI,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAqW9E,CAAC;IAnWC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,MAAM,CACJ,OAAe,EACf,IAAuB,EACvB,OAA6B;QAE7B,OAAO,IAAI,CAAC,GAAG,CAAC,WAAW,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,SAAS,CAAC,OAAe,EAAE,OAA6B;QACtD,OAAO,IAAI,CAAC,GAAG,CAAC,WAAW,OAAO,YAAY,EAAE,OAAO,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuMG;IACH,MAAM,CAAC,MAAyB,EAAE,OAA6B;QAC7D,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,GAAG,MAAM,CAAC;QAC/C,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,KAAK,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IACnF,CAAC;IA2BD,MAAM,CACJ,SAAkD,EAAE,EACpD,OAA6B;QAE7B,IAAI,gBAAgB,CAAC,MAAM,CAAC,EAAE;YAC5B,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;SAChC;QACD,MAAM,EACJ,MAAM,EACN,KAAK,EACL,eAAe,EAAE,WAAW,EAC5B,gBAAgB,EAAE,YAAY,EAC9B,eAAe,EAAE,WAAW,EAC5B,gBAAgB,EAAE,YAAY,EAC9B,GAAG,IAAI,EACR,GAAG,MAAM,CAAC;QACX,OAAO,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE;YACjC,KAAK,EAAE;gBACL,MAAM;gBACN,KAAK;gBACL,eAAe,EAAE,WAAW;gBAC5B,gBAAgB,EAAE,YAAY;gBAC9B,eAAe,EAAE,WAAW;gBAC5B,gBAAgB,EAAE,YAAY;aAC/B;YACD,IAAI;YACJ,GAAG,OAAO;SACX,CAAC,CAAC;IACL,CAAC;CACF;AA2PD,WAAiB,MAAM;IAQP,gBAAS,GAAG,YAAY,CAAC,SAAS,CAAC;IAMnC,gCAAyB,GAAG,YAAY,CAAC,yBAAyB,CAAC;AAGnF,CAAC,EAjBgB,MAAM,KAAN,MAAM,QAiBtB"}

package/resources/events/index.d.ts

@@ -0,0 +1,3 @@
+export { BackfillCreateResponse, BackfillListResponse, BackfillCloseResponse, BackfillFetchResponse, BackfillRevertResponse, BackfillCreateParams, BackfillListParams, BackfillListResponsesPage, Backfills, } from "./backfills.js";
+export { EventUpdateResponse, EventDeprecateResponse, EventIngestResponse, EventSearchResponse, EventUpdateParams, EventIngestParams, EventSearchParams, Events, } from "./events.js";
+//# sourceMappingURL=index.d.ts.map

package/resources/events/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resources/events/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,EACpB,kBAAkB,EAClB,yBAAyB,EACzB,SAAS,GACV,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,MAAM,GACP,MAAM,UAAU,CAAC"}

package/resources/events/index.js

@@ -0,0 +1,10 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Events = exports.Backfills = exports.BackfillListResponsesPage = void 0;
+var backfills_1 = require("./backfills.js");
+Object.defineProperty(exports, "BackfillListResponsesPage", { enumerable: true, get: function () { return backfills_1.BackfillListResponsesPage; } });
+Object.defineProperty(exports, "Backfills", { enumerable: true, get: function () { return backfills_1.Backfills; } });
+var events_1 = require("./events.js");
+Object.defineProperty(exports, "Events", { enumerable: true, get: function () { return events_1.Events; } });
+//# sourceMappingURL=index.js.map

package/resources/events/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/resources/events/index.ts"],"names":[],"mappings":";AAAA,qDAAqD;;;AAErD,4CAUqB;AAFnB,sHAAA,yBAAyB,OAAA;AACzB,sGAAA,SAAS,OAAA;AAEX,sCASkB;AADhB,gGAAA,MAAM,OAAA"}

package/resources/events/index.mjs

@@ -0,0 +1,4 @@
+// File generated from our OpenAPI spec by Stainless.
+export { BackfillListResponsesPage, Backfills, } from "./backfills.mjs";
+export { Events, } from "./events.mjs";
+//# sourceMappingURL=index.mjs.map

package/resources/events/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/resources/events/index.ts"],"names":[],"mappings":"AAAA,qDAAqD;OAE9C,EAQL,yBAAyB,EACzB,SAAS,GACV;OACM,EAQL,MAAM,GACP"}

package/resources/index.d.ts

@@ -0,0 +1,13 @@
+export { Coupon, CouponCreateParams, CouponListParams, CouponsPage, Coupons } from "./coupons/coupons.js";
+export { CreditNote, CreditNoteListParams, CreditNotesPage, CreditNotes } from "./credit-notes.js";
+export { Customer, CustomerCreateParams, CustomerUpdateParams, CustomerListParams, CustomerUpdateByExternalIDParams, CustomersPage, Customers, } from "./customers/customers.js";
+export { Discount, Price, PriceCreateParams, PriceListParams, PricesPage, Prices } from "./prices/prices.js";
+export { EventUpdateResponse, EventDeprecateResponse, EventIngestResponse, EventSearchResponse, EventUpdateParams, EventIngestParams, EventSearchParams, Events, } from "./events/events.js";
+export { Invoice, InvoiceDiscount, InvoiceFetchUpcomingResponse, InvoiceCreateParams, InvoiceListParams, InvoiceFetchUpcomingParams, InvoiceMarkPaidParams, InvoicesPage, Invoices, } from "./invoices.js";
+export { InvoiceLineItemCreateResponse, InvoiceLineItemCreateParams, InvoiceLineItems, } from "./invoice-line-items.js";
+export { ItemListResponse, ItemFetchResponse, ItemListParams, ItemListResponsesPage, Items } from "./items.js";
+export { MetricCreateResponse, MetricListResponse, MetricFetchResponse, MetricCreateParams, MetricListParams, MetricListResponsesPage, Metrics, } from "./metrics.js";
+export { Plan, PlanCreateParams, PlanUpdateParams, PlanListParams, PlansPage, Plans } from "./plans/plans.js";
+export { Subscription, Subscriptions, SubscriptionUsage, SubscriptionFetchCostsResponse, SubscriptionFetchScheduleResponse, SubscriptionCreateParams, SubscriptionListParams, SubscriptionCancelParams, SubscriptionFetchCostsParams, SubscriptionFetchScheduleParams, SubscriptionFetchUsageParams, SubscriptionPriceIntervalsParams, SubscriptionSchedulePlanChangeParams, SubscriptionTriggerPhaseParams, SubscriptionUnscheduleFixedFeeQuantityUpdatesParams, SubscriptionUpdateFixedFeeQuantityParams, SubscriptionsPage, SubscriptionFetchScheduleResponsesPage, } from "./subscriptions.js";
+export { TopLevelPingResponse, TopLevel } from "./top-level.js";
+//# sourceMappingURL=index.d.ts.map

package/resources/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/resources/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACvG,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAChG,OAAO,EACL,QAAQ,EACR,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,gCAAgC,EAChC,aAAa,EACb,SAAS,GACV,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC1G,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,MAAM,GACP,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,OAAO,EACP,eAAe,EACf,4BAA4B,EAC5B,mBAAmB,EACnB,iBAAiB,EACjB,0BAA0B,EAC1B,qBAAqB,EACrB,YAAY,EACZ,QAAQ,GACT,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,6BAA6B,EAC7B,2BAA2B,EAC3B,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,cAAc,EAAE,qBAAqB,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAC5G,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,uBAAuB,EACvB,OAAO,GACR,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,cAAc,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3G,OAAO,EACL,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,8BAA8B,EAC9B,iCAAiC,EACjC,wBAAwB,EACxB,sBAAsB,EACtB,wBAAwB,EACxB,4BAA4B,EAC5B,+BAA+B,EAC/B,4BAA4B,EAC5B,gCAAgC,EAChC,oCAAoC,EACpC,8BAA8B,EAC9B,mDAAmD,EACnD,wCAAwC,EACxC,iBAAiB,EACjB,sCAAsC,GACvC,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC"}

package/resources/index.js

@@ -0,0 +1,39 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopLevel = exports.SubscriptionFetchScheduleResponsesPage = exports.SubscriptionsPage = exports.Subscriptions = exports.Plans = exports.PlansPage = exports.Metrics = exports.MetricListResponsesPage = exports.Items = exports.ItemListResponsesPage = exports.InvoiceLineItems = exports.Invoices = exports.InvoicesPage = exports.Events = exports.Prices = exports.PricesPage = exports.Customers = exports.CustomersPage = exports.CreditNotes = exports.CreditNotesPage = exports.Coupons = exports.CouponsPage = void 0;
+var coupons_1 = require("./coupons/coupons.js");
+Object.defineProperty(exports, "CouponsPage", { enumerable: true, get: function () { return coupons_1.CouponsPage; } });
+Object.defineProperty(exports, "Coupons", { enumerable: true, get: function () { return coupons_1.Coupons; } });
+var credit_notes_1 = require("./credit-notes.js");
+Object.defineProperty(exports, "CreditNotesPage", { enumerable: true, get: function () { return credit_notes_1.CreditNotesPage; } });
+Object.defineProperty(exports, "CreditNotes", { enumerable: true, get: function () { return credit_notes_1.CreditNotes; } });
+var customers_1 = require("./customers/customers.js");
+Object.defineProperty(exports, "CustomersPage", { enumerable: true, get: function () { return customers_1.CustomersPage; } });
+Object.defineProperty(exports, "Customers", { enumerable: true, get: function () { return customers_1.Customers; } });
+var prices_1 = require("./prices/prices.js");
+Object.defineProperty(exports, "PricesPage", { enumerable: true, get: function () { return prices_1.PricesPage; } });
+Object.defineProperty(exports, "Prices", { enumerable: true, get: function () { return prices_1.Prices; } });
+var events_1 = require("./events/events.js");
+Object.defineProperty(exports, "Events", { enumerable: true, get: function () { return events_1.Events; } });
+var invoices_1 = require("./invoices.js");
+Object.defineProperty(exports, "InvoicesPage", { enumerable: true, get: function () { return invoices_1.InvoicesPage; } });
+Object.defineProperty(exports, "Invoices", { enumerable: true, get: function () { return invoices_1.Invoices; } });
+var invoice_line_items_1 = require("./invoice-line-items.js");
+Object.defineProperty(exports, "InvoiceLineItems", { enumerable: true, get: function () { return invoice_line_items_1.InvoiceLineItems; } });
+var items_1 = require("./items.js");
+Object.defineProperty(exports, "ItemListResponsesPage", { enumerable: true, get: function () { return items_1.ItemListResponsesPage; } });
+Object.defineProperty(exports, "Items", { enumerable: true, get: function () { return items_1.Items; } });
+var metrics_1 = require("./metrics.js");
+Object.defineProperty(exports, "MetricListResponsesPage", { enumerable: true, get: function () { return metrics_1.MetricListResponsesPage; } });
+Object.defineProperty(exports, "Metrics", { enumerable: true, get: function () { return metrics_1.Metrics; } });
+var plans_1 = require("./plans/plans.js");
+Object.defineProperty(exports, "PlansPage", { enumerable: true, get: function () { return plans_1.PlansPage; } });
+Object.defineProperty(exports, "Plans", { enumerable: true, get: function () { return plans_1.Plans; } });
+var subscriptions_1 = require("./subscriptions.js");
+Object.defineProperty(exports, "Subscriptions", { enumerable: true, get: function () { return subscriptions_1.Subscriptions; } });
+Object.defineProperty(exports, "SubscriptionsPage", { enumerable: true, get: function () { return subscriptions_1.SubscriptionsPage; } });
+Object.defineProperty(exports, "SubscriptionFetchScheduleResponsesPage", { enumerable: true, get: function () { return subscriptions_1.SubscriptionFetchScheduleResponsesPage; } });
+var top_level_1 = require("./top-level.js");
+Object.defineProperty(exports, "TopLevel", { enumerable: true, get: function () { return top_level_1.TopLevel; } });
+//# sourceMappingURL=index.js.map

package/resources/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/resources/index.ts"],"names":[],"mappings":";AAAA,qDAAqD;;;AAErD,gDAAuG;AAAhD,sGAAA,WAAW,OAAA;AAAE,kGAAA,OAAO,OAAA;AAC3E,kDAAgG;AAArD,+GAAA,eAAe,OAAA;AAAE,2GAAA,WAAW,OAAA;AACvE,sDAQ+B;AAF7B,0GAAA,aAAa,OAAA;AACb,sGAAA,SAAS,OAAA;AAEX,6CAA0G;AAA5C,oGAAA,UAAU,OAAA;AAAE,gGAAA,MAAM,OAAA;AAChF,6CASyB;AADvB,gGAAA,MAAM,OAAA;AAER,0CAUoB;AAFlB,wGAAA,YAAY,OAAA;AACZ,oGAAA,QAAQ,OAAA;AAEV,8DAI8B;AAD5B,sHAAA,gBAAgB,OAAA;AAElB,oCAA4G;AAA9C,8GAAA,qBAAqB,OAAA;AAAE,8FAAA,KAAK,OAAA;AAC1F,wCAQmB;AAFjB,kHAAA,uBAAuB,OAAA;AACvB,kGAAA,OAAO,OAAA;AAET,0CAA2G;AAAxC,kGAAA,SAAS,OAAA;AAAE,8FAAA,KAAK,OAAA;AACnF,oDAmByB;AAjBvB,8GAAA,aAAa,OAAA;AAeb,kHAAA,iBAAiB,OAAA;AACjB,uIAAA,sCAAsC,OAAA;AAExC,4CAA6D;AAA9B,qGAAA,QAAQ,OAAA"}

package/resources/index.mjs

@@ -0,0 +1,14 @@
+// File generated from our OpenAPI spec by Stainless.
+export { CouponsPage, Coupons } from "./coupons/coupons.mjs";
+export { CreditNotesPage, CreditNotes } from "./credit-notes.mjs";
+export { CustomersPage, Customers, } from "./customers/customers.mjs";
+export { PricesPage, Prices } from "./prices/prices.mjs";
+export { Events, } from "./events/events.mjs";
+export { InvoicesPage, Invoices, } from "./invoices.mjs";
+export { InvoiceLineItems, } from "./invoice-line-items.mjs";
+export { ItemListResponsesPage, Items } from "./items.mjs";
+export { MetricListResponsesPage, Metrics, } from "./metrics.mjs";
+export { PlansPage, Plans } from "./plans/plans.mjs";
+export { Subscriptions, SubscriptionsPage, SubscriptionFetchScheduleResponsesPage, } from "./subscriptions.mjs";
+export { TopLevel } from "./top-level.mjs";
+//# sourceMappingURL=index.mjs.map

package/resources/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/resources/index.ts"],"names":[],"mappings":"AAAA,qDAAqD;OAE9C,EAAgD,WAAW,EAAE,OAAO,EAAE;OACtE,EAAoC,eAAe,EAAE,WAAW,EAAE;OAClE,EAML,aAAa,EACb,SAAS,GACV;OACM,EAAuD,UAAU,EAAE,MAAM,EAAE;OAC3E,EAQL,MAAM,GACP;OACM,EAQL,YAAY,EACZ,QAAQ,GACT;OACM,EAGL,gBAAgB,GACjB;OACM,EAAuD,qBAAqB,EAAE,KAAK,EAAE;OACrF,EAML,uBAAuB,EACvB,OAAO,GACR;OACM,EAA4D,SAAS,EAAE,KAAK,EAAE;OAC9E,EAEL,aAAa,EAeb,iBAAiB,EACjB,sCAAsC,GACvC;OACM,EAAwB,QAAQ,EAAE"}