@paid-ai/paid-node 1.8.0 → 2.0.0

package/dist/esm/api/types/ProductUsageGraduatedInput.d.mts

@@ -4,6 +4,7 @@ export interface ProductUsageGraduatedInput {
     signalType?: ProductUsageGraduatedInput.SignalType;
     billingFrequency?: ProductUsageGraduatedInput.BillingFrequency;
     billingFrequencyCustomMonths?: number;
+    /** When usage is billed. Usage must use Arrears, prepaid credits included; to sell credits up front, add a credit benefit to a recurring, seat or one-time attribute. */
     billingType?: ProductUsageGraduatedInput.BillingType;
     pricePoints: Paid.ProductTieredPricePoint[];
 }
@@ -21,6 +22,7 @@ export declare namespace ProductUsageGraduatedInput {
         readonly Custom: "Custom";
     };
     type BillingFrequency = (typeof BillingFrequency)[keyof typeof BillingFrequency];
+    /** When usage is billed. Usage must use Arrears, prepaid credits included; to sell credits up front, add a credit benefit to a recurring, seat or one-time attribute. */
     const BillingType: {
         readonly Advance: "Advance";
         readonly Arrears: "Arrears";

package/dist/esm/api/types/ProductUsageGraduatedInput.mjs

@@ -12,6 +12,7 @@ export var ProductUsageGraduatedInput;
         Annual: "Annual",
         Custom: "Custom",
     };
+    /** When usage is billed. Usage must use Arrears, prepaid credits included; to sell credits up front, add a credit benefit to a recurring, seat or one-time attribute. */
     ProductUsageGraduatedInput.BillingType = {
         Advance: "Advance",
         Arrears: "Arrears",

package/dist/esm/api/types/ProductUsagePerUnitInput.d.mts

@@ -4,6 +4,7 @@ export interface ProductUsagePerUnitInput {
     signalType?: ProductUsagePerUnitInput.SignalType;
     billingFrequency?: ProductUsagePerUnitInput.BillingFrequency;
     billingFrequencyCustomMonths?: number;
+    /** When usage is billed. Usage must use Arrears, prepaid credits included; to sell credits up front, add a credit benefit to a recurring, seat or one-time attribute. */
     billingType?: ProductUsagePerUnitInput.BillingType;
     pricePoints: Paid.ProductSimplePricePoint[];
 }
@@ -21,6 +22,7 @@ export declare namespace ProductUsagePerUnitInput {
         readonly Custom: "Custom";
     };
     type BillingFrequency = (typeof BillingFrequency)[keyof typeof BillingFrequency];
+    /** When usage is billed. Usage must use Arrears, prepaid credits included; to sell credits up front, add a credit benefit to a recurring, seat or one-time attribute. */
     const BillingType: {
         readonly Advance: "Advance";
         readonly Arrears: "Arrears";

package/dist/esm/api/types/ProductUsagePerUnitInput.mjs

@@ -12,6 +12,7 @@ export var ProductUsagePerUnitInput;
         Annual: "Annual",
         Custom: "Custom",
     };
+    /** When usage is billed. Usage must use Arrears, prepaid credits included; to sell credits up front, add a credit benefit to a recurring, seat or one-time attribute. */
     ProductUsagePerUnitInput.BillingType = {
         Advance: "Advance",
         Arrears: "Arrears",

package/dist/esm/api/types/ProductUsagePrepaidCreditsInput.d.mts

@@ -6,9 +6,13 @@ export interface ProductUsagePrepaidCreditsInput {
     /** Credit amount, exact to at most 6 decimal places. */
     creditCost: number;
     unitValue?: number;
+    overageUnitPrice?: number;
+    /** Overage price per credit in the currency's minor units (40 is $0.40 for USD, ¥40 for JPY, 0.040 KWD for KWD), keyed by uppercase ISO 4217 currency code. On an invoice, an entry for the invoice currency on any of the order's pricing or credit benefits beats every overageUnitPrice; overageUnitPrice applies only when no holder has an entry for that currency. Writes keep the two consistent for the primary currency (the organization's default when the product is priced in it, else the product's only pricing currency; an order line's own currency): a map entry for it sets overageUnitPrice, winning when a write sends both, and an overageUnitPrice sent without the map updates an existing entry for it. A write that sends only overageUnitPrice never creates a map. */
+    overageUnitPrices?: Record<string, number | null> | null;
     pricingInput?: ProductUsagePrepaidCreditsInput.PricingInput;
     billingFrequency?: ProductUsagePrepaidCreditsInput.BillingFrequency;
     billingFrequencyCustomMonths?: number;
+    /** When usage is billed. Usage must use Arrears, prepaid credits included; to sell credits up front, add a credit benefit to a recurring, seat or one-time attribute. */
     billingType?: ProductUsagePrepaidCreditsInput.BillingType;
     pricePoints?: Paid.ProductSimplePricePoint[];
 }
@@ -37,6 +41,7 @@ export declare namespace ProductUsagePrepaidCreditsInput {
         readonly Custom: "Custom";
     };
     type BillingFrequency = (typeof BillingFrequency)[keyof typeof BillingFrequency];
+    /** When usage is billed. Usage must use Arrears, prepaid credits included; to sell credits up front, add a credit benefit to a recurring, seat or one-time attribute. */
     const BillingType: {
         readonly Advance: "Advance";
         readonly Arrears: "Arrears";

package/dist/esm/api/types/ProductUsagePrepaidCreditsInput.mjs

@@ -18,6 +18,7 @@ export var ProductUsagePrepaidCreditsInput;
         Annual: "Annual",
         Custom: "Custom",
     };
+    /** When usage is billed. Usage must use Arrears, prepaid credits included; to sell credits up front, add a credit benefit to a recurring, seat or one-time attribute. */
     ProductUsagePrepaidCreditsInput.BillingType = {
         Advance: "Advance",
         Arrears: "Arrears",

package/dist/esm/api/types/ProductUsageVolumeInput.d.mts

@@ -4,6 +4,7 @@ export interface ProductUsageVolumeInput {
     signalType?: ProductUsageVolumeInput.SignalType;
     billingFrequency?: ProductUsageVolumeInput.BillingFrequency;
     billingFrequencyCustomMonths?: number;
+    /** When usage is billed. Usage must use Arrears, prepaid credits included; to sell credits up front, add a credit benefit to a recurring, seat or one-time attribute. */
     billingType?: ProductUsageVolumeInput.BillingType;
     pricePoints: Paid.ProductTieredPricePoint[];
 }
@@ -21,6 +22,7 @@ export declare namespace ProductUsageVolumeInput {
         readonly Custom: "Custom";
     };
     type BillingFrequency = (typeof BillingFrequency)[keyof typeof BillingFrequency];
+    /** When usage is billed. Usage must use Arrears, prepaid credits included; to sell credits up front, add a credit benefit to a recurring, seat or one-time attribute. */
     const BillingType: {
         readonly Advance: "Advance";
         readonly Arrears: "Arrears";

package/dist/esm/api/types/ProductUsageVolumeInput.mjs

@@ -12,6 +12,7 @@ export var ProductUsageVolumeInput;
         Annual: "Annual",
         Custom: "Custom",
     };
+    /** When usage is billed. Usage must use Arrears, prepaid credits included; to sell credits up front, add a credit benefit to a recurring, seat or one-time attribute. */
     ProductUsageVolumeInput.BillingType = {
         Advance: "Advance",
         Arrears: "Arrears",

package/dist/esm/api/types/ProvisionBillingFrequencyOverride.d.mts

@@ -0,0 +1,14 @@
+export interface ProvisionBillingFrequencyOverride {
+    frequency: ProvisionBillingFrequencyOverride.Frequency;
+    customMonths?: number | null;
+}
+export declare namespace ProvisionBillingFrequencyOverride {
+    const Frequency: {
+        readonly Monthly: "monthly";
+        readonly Quarterly: "quarterly";
+        readonly SemiAnnually: "semiAnnually";
+        readonly Annual: "annual";
+        readonly Custom: "custom";
+    };
+    type Frequency = (typeof Frequency)[keyof typeof Frequency];
+}

package/dist/esm/api/types/ProvisionBillingFrequencyOverride.mjs

@@ -0,0 +1,11 @@
+// This file was auto-generated by Fern from our API Definition.
+export var ProvisionBillingFrequencyOverride;
+(function (ProvisionBillingFrequencyOverride) {
+    ProvisionBillingFrequencyOverride.Frequency = {
+        Monthly: "monthly",
+        Quarterly: "quarterly",
+        SemiAnnually: "semiAnnually",
+        Annual: "annual",
+        Custom: "custom",
+    };
+})(ProvisionBillingFrequencyOverride || (ProvisionBillingFrequencyOverride = {}));

package/dist/esm/api/types/ProvisionContact.d.mts

@@ -0,0 +1,20 @@
+import type * as Paid from "../index.mjs";
+export interface ProvisionContact {
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+    phone?: string | null;
+    billingAddress?: Paid.ContactBillingAddress | null;
+    roles?: ProvisionContact.Roles.Item[];
+    externalId: string;
+}
+export declare namespace ProvisionContact {
+    type Roles = Roles.Item[];
+    namespace Roles {
+        const Item: {
+            readonly Billing: "BILLING";
+            readonly AccountsPayable: "ACCOUNTS_PAYABLE";
+        };
+        type Item = (typeof Item)[keyof typeof Item];
+    }
+}

package/dist/esm/api/types/ProvisionContact.mjs

@@ -0,0 +1,11 @@
+// This file was auto-generated by Fern from our API Definition.
+export var ProvisionContact;
+(function (ProvisionContact) {
+    let Roles;
+    (function (Roles) {
+        Roles.Item = {
+            Billing: "BILLING",
+            AccountsPayable: "ACCOUNTS_PAYABLE",
+        };
+    })(Roles = ProvisionContact.Roles || (ProvisionContact.Roles = {}));
+})(ProvisionContact || (ProvisionContact = {}));

package/dist/esm/api/types/ProvisionCreatedContact.d.mts

@@ -0,0 +1,14 @@
+export interface ProvisionCreatedContact {
+    id: string;
+    /** created: the entity was created; updated: the entity was updated */
+    provisionStatus: ProvisionCreatedContact.ProvisionStatus;
+    createdAt: string;
+}
+export declare namespace ProvisionCreatedContact {
+    /** created: the entity was created; updated: the entity was updated */
+    const ProvisionStatus: {
+        readonly Created: "created";
+        readonly Updated: "updated";
+    };
+    type ProvisionStatus = (typeof ProvisionStatus)[keyof typeof ProvisionStatus];
+}

package/dist/esm/api/types/ProvisionCreatedContact.mjs

@@ -0,0 +1,9 @@
+// This file was auto-generated by Fern from our API Definition.
+export var ProvisionCreatedContact;
+(function (ProvisionCreatedContact) {
+    /** created: the entity was created; updated: the entity was updated */
+    ProvisionCreatedContact.ProvisionStatus = {
+        Created: "created",
+        Updated: "updated",
+    };
+})(ProvisionCreatedContact || (ProvisionCreatedContact = {}));

package/dist/esm/api/types/ProvisionCreatedCustomer.d.mts

@@ -0,0 +1,14 @@
+export interface ProvisionCreatedCustomer {
+    id: string;
+    /** created: the entity was created; updated: the entity was updated */
+    provisionStatus: ProvisionCreatedCustomer.ProvisionStatus;
+    createdAt: string;
+}
+export declare namespace ProvisionCreatedCustomer {
+    /** created: the entity was created; updated: the entity was updated */
+    const ProvisionStatus: {
+        readonly Created: "created";
+        readonly Updated: "updated";
+    };
+    type ProvisionStatus = (typeof ProvisionStatus)[keyof typeof ProvisionStatus];
+}

package/dist/esm/api/types/ProvisionCreatedCustomer.mjs

@@ -0,0 +1,9 @@
+// This file was auto-generated by Fern from our API Definition.
+export var ProvisionCreatedCustomer;
+(function (ProvisionCreatedCustomer) {
+    /** created: the entity was created; updated: the entity was updated */
+    ProvisionCreatedCustomer.ProvisionStatus = {
+        Created: "created",
+        Updated: "updated",
+    };
+})(ProvisionCreatedCustomer || (ProvisionCreatedCustomer = {}));

package/dist/esm/api/types/ProvisionCreatedOrder.d.mts

@@ -0,0 +1,17 @@
+import type * as Paid from "../index.mjs";
+export interface ProvisionCreatedOrder {
+    id: string;
+    lines: Paid.ProvisionCreatedOrderLine[];
+    /** created: the entity was created; updated: the entity was updated */
+    provisionStatus: ProvisionCreatedOrder.ProvisionStatus;
+    createdAt: string;
+    billingFrequencyOverride?: Paid.ProvisionBillingFrequencyOverride;
+}
+export declare namespace ProvisionCreatedOrder {
+    /** created: the entity was created; updated: the entity was updated */
+    const ProvisionStatus: {
+        readonly Created: "created";
+        readonly Updated: "updated";
+    };
+    type ProvisionStatus = (typeof ProvisionStatus)[keyof typeof ProvisionStatus];
+}

package/dist/esm/api/types/ProvisionCreatedOrder.mjs

@@ -0,0 +1,9 @@
+// This file was auto-generated by Fern from our API Definition.
+export var ProvisionCreatedOrder;
+(function (ProvisionCreatedOrder) {
+    /** created: the entity was created; updated: the entity was updated */
+    ProvisionCreatedOrder.ProvisionStatus = {
+        Created: "created",
+        Updated: "updated",
+    };
+})(ProvisionCreatedOrder || (ProvisionCreatedOrder = {}));

package/dist/esm/api/types/ProvisionCreatedOrderLine.d.mts

@@ -0,0 +1,17 @@
+import type * as Paid from "../index.mjs";
+export interface ProvisionCreatedOrderLine {
+    id: string;
+    externalId: string;
+    /** created: the entity was created; updated: the entity was updated */
+    provisionStatus: ProvisionCreatedOrderLine.ProvisionStatus;
+    createdAt: string;
+    lineType: Paid.ProvisionOrderLineType;
+}
+export declare namespace ProvisionCreatedOrderLine {
+    /** created: the entity was created; updated: the entity was updated */
+    const ProvisionStatus: {
+        readonly Created: "created";
+        readonly Updated: "updated";
+    };
+    type ProvisionStatus = (typeof ProvisionStatus)[keyof typeof ProvisionStatus];
+}

package/dist/esm/api/types/ProvisionCreatedOrderLine.mjs

@@ -0,0 +1,9 @@
+// This file was auto-generated by Fern from our API Definition.
+export var ProvisionCreatedOrderLine;
+(function (ProvisionCreatedOrderLine) {
+    /** created: the entity was created; updated: the entity was updated */
+    ProvisionCreatedOrderLine.ProvisionStatus = {
+        Created: "created",
+        Updated: "updated",
+    };
+})(ProvisionCreatedOrderLine || (ProvisionCreatedOrderLine = {}));

package/dist/esm/api/types/ProvisionCreditBenefit.d.mts

@@ -0,0 +1,44 @@
+export interface ProvisionCreditBenefit {
+    /** The `key` of the credits currency. */
+    creditsCurrencyKey: string;
+    /** Credits granted per allocation period. Must be greater than 0, with at most 6 decimal places. For an unlimited grant, set `isInfiniteTotal: true` and send any positive amount. */
+    amount: number;
+    recipient?: ProvisionCreditBenefit.Recipient;
+    isInfiniteTotal?: boolean;
+    allocationCadence?: ProvisionCreditBenefit.AllocationCadence;
+    creditGrantTiming?: ProvisionCreditBenefit.CreditGrantTiming | null;
+    overageUnitPrice?: number | null;
+    /** Overage price per credit in the currency's minor units (40 is $0.40 for USD, ¥40 for JPY, 0.040 KWD for KWD), keyed by uppercase ISO 4217 currency code. On an invoice, an entry for the invoice currency on any of the order's pricing or credit benefits beats every overageUnitPrice; overageUnitPrice applies only when no holder has an entry for that currency. Writes keep the two consistent for the primary currency (the organization's default when the product is priced in it, else the product's only pricing currency; an order line's own currency): a map entry for it sets overageUnitPrice, winning when a write sends both, and an overageUnitPrice sent without the map updates an existing entry for it. A write that sends only overageUnitPrice never creates a map. */
+    overageUnitPrices?: Record<string, number | null> | null;
+    /** Credit amount, exact to at most 6 decimal places. */
+    rolloverAmount?: number | null;
+    rolloverDuration?: number | null;
+    rolloverDurationUnit?: ProvisionCreditBenefit.RolloverDurationUnit | null;
+    /** When true, Paid adds a usage line to the order that draws down this credit currency: one credit for each signal whose event name is the `creditsCurrencyKey`. The line uses a product named `Paid Usage - <creditsCurrencyKey>`, with external ID `paid:usage:<creditsCurrencyKey>`, which Paid creates if it does not exist. An order gets one such line per credit currency, even when several benefits set this flag. */
+    createUsageLine?: boolean;
+}
+export declare namespace ProvisionCreditBenefit {
+    const Recipient: {
+        readonly Organization: "organization";
+        readonly Seat: "seat";
+    };
+    type Recipient = (typeof Recipient)[keyof typeof Recipient];
+    const AllocationCadence: {
+        readonly Upfront: "upfront";
+        readonly Monthly: "monthly";
+        readonly Quarterly: "quarterly";
+        readonly SemiAnnually: "semi_annually";
+    };
+    type AllocationCadence = (typeof AllocationCadence)[keyof typeof AllocationCadence];
+    const CreditGrantTiming: {
+        readonly OnOrderActivation: "on_order_activation";
+        readonly OnPayment: "on_payment";
+        readonly OnInvoicePosted: "on_invoice_posted";
+    };
+    type CreditGrantTiming = (typeof CreditGrantTiming)[keyof typeof CreditGrantTiming];
+    const RolloverDurationUnit: {
+        readonly Days: "days";
+        readonly Months: "months";
+    };
+    type RolloverDurationUnit = (typeof RolloverDurationUnit)[keyof typeof RolloverDurationUnit];
+}

package/dist/esm/api/types/ProvisionCreditBenefit.mjs

@@ -0,0 +1,23 @@
+// This file was auto-generated by Fern from our API Definition.
+export var ProvisionCreditBenefit;
+(function (ProvisionCreditBenefit) {
+    ProvisionCreditBenefit.Recipient = {
+        Organization: "organization",
+        Seat: "seat",
+    };
+    ProvisionCreditBenefit.AllocationCadence = {
+        Upfront: "upfront",
+        Monthly: "monthly",
+        Quarterly: "quarterly",
+        SemiAnnually: "semi_annually",
+    };
+    ProvisionCreditBenefit.CreditGrantTiming = {
+        OnOrderActivation: "on_order_activation",
+        OnPayment: "on_payment",
+        OnInvoicePosted: "on_invoice_posted",
+    };
+    ProvisionCreditBenefit.RolloverDurationUnit = {
+        Days: "days",
+        Months: "months",
+    };
+})(ProvisionCreditBenefit || (ProvisionCreditBenefit = {}));

package/dist/esm/api/types/ProvisionCustomer.d.mts

@@ -0,0 +1,23 @@
+import type * as Paid from "../index.mjs";
+export interface ProvisionCustomer {
+    name: string;
+    legalName?: string | null;
+    email?: string;
+    phone?: string;
+    website?: string;
+    billingAddress?: Paid.CustomerBillingAddressInput | null;
+    /** The customer state, `draft` or `active`. Defaults to `active`. */
+    creationState?: ProvisionCustomer.CreationState;
+    vatNumber?: string | null;
+    metadata?: Record<string, unknown> | null;
+    defaultCurrency?: string;
+    externalId: string;
+}
+export declare namespace ProvisionCustomer {
+    /** The customer state, `draft` or `active`. Defaults to `active`. */
+    const CreationState: {
+        readonly Draft: "draft";
+        readonly Active: "active";
+    };
+    type CreationState = (typeof CreationState)[keyof typeof CreationState];
+}

package/dist/esm/api/types/ProvisionCustomer.mjs

@@ -0,0 +1,9 @@
+// This file was auto-generated by Fern from our API Definition.
+export var ProvisionCustomer;
+(function (ProvisionCustomer) {
+    /** The customer state, `draft` or `active`. Defaults to `active`. */
+    ProvisionCustomer.CreationState = {
+        Draft: "draft",
+        Active: "active",
+    };
+})(ProvisionCustomer || (ProvisionCustomer = {}));

package/dist/esm/api/types/ProvisionExternalReference.d.mts

@@ -0,0 +1,16 @@
+export interface ProvisionExternalReference {
+    /** The system that sends the provision. Use `standard` for an integration you build yourself: it has no source-specific behaviour, and neither do `hubspot` and `salesbricks`. With `salesforce`, a recurring or seat-based line price is the value for the whole line term, and Paid bills it once, as one billing period that spans the line. For that reason `salesforce` cannot be combined with `order.billingFrequencyOverride`. */
+    source: ProvisionExternalReference.Source;
+    /** Free-form details from the source system, such as its record IDs. Paid stores the whole `externalReference` object, `source` included, on the order's `metadata` under the `externalReference` key. Each provision of the order replaces it, and other `metadata` keys are kept. */
+    metadata?: Record<string, unknown>;
+}
+export declare namespace ProvisionExternalReference {
+    /** The system that sends the provision. Use `standard` for an integration you build yourself: it has no source-specific behaviour, and neither do `hubspot` and `salesbricks`. With `salesforce`, a recurring or seat-based line price is the value for the whole line term, and Paid bills it once, as one billing period that spans the line. For that reason `salesforce` cannot be combined with `order.billingFrequencyOverride`. */
+    const Source: {
+        readonly Salesforce: "salesforce";
+        readonly Hubspot: "hubspot";
+        readonly Salesbricks: "salesbricks";
+        readonly Standard: "standard";
+    };
+    type Source = (typeof Source)[keyof typeof Source];
+}

package/dist/esm/api/types/ProvisionExternalReference.mjs

@@ -0,0 +1,11 @@
+// This file was auto-generated by Fern from our API Definition.
+export var ProvisionExternalReference;
+(function (ProvisionExternalReference) {
+    /** The system that sends the provision. Use `standard` for an integration you build yourself: it has no source-specific behaviour, and neither do `hubspot` and `salesbricks`. With `salesforce`, a recurring or seat-based line price is the value for the whole line term, and Paid bills it once, as one billing period that spans the line. For that reason `salesforce` cannot be combined with `order.billingFrequencyOverride`. */
+    ProvisionExternalReference.Source = {
+        Salesforce: "salesforce",
+        Hubspot: "hubspot",
+        Salesbricks: "salesbricks",
+        Standard: "standard",
+    };
+})(ProvisionExternalReference || (ProvisionExternalReference = {}));

package/dist/esm/api/types/ProvisionOrder.d.mts

@@ -0,0 +1,39 @@
+import type * as Paid from "../index.mjs";
+/**
+ * The order, matched by `externalId`. Its lines are set from this payload each time you provision it. A draft order can have no lines; an active order needs at least one.
+ */
+export interface ProvisionOrder {
+    /** Currency code for the order, such as `USD`. A price point can set its own currency. */
+    currency: string;
+    startDate: string;
+    endDate?: string;
+    /** Defaults to `active`, which activates the order and starts billing. Send `draft` to create or update the order without billing it; you can provision it again later with `active`. An active order cannot go back to `draft`. */
+    status?: ProvisionOrder.Status;
+    billingAnchor?: number | null;
+    billingCustomerExternalId?: string;
+    billingContactExternalIds?: string[];
+    paymentTerms?: ProvisionOrder.PaymentTerms;
+    name?: string;
+    externalId: string;
+    lines: Paid.ProvisionOrderLine[];
+    billingFrequencyOverride?: Paid.ProvisionBillingFrequencyOverride;
+    /** For migrating an order that another system has already billed. ISO 8601 timestamp in UTC. Paid creates no invoices or payments for billing cycles that fall due on or before this time, and bills normally after it. Use it with a past `startDate` so the order does not bill again for periods the other system already billed. */
+    historicalReplayUntil?: string;
+}
+export declare namespace ProvisionOrder {
+    /** Defaults to `active`, which activates the order and starts billing. Send `draft` to create or update the order without billing it; you can provision it again later with `active`. An active order cannot go back to `draft`. */
+    const Status: {
+        readonly Draft: "draft";
+        readonly Active: "active";
+    };
+    type Status = (typeof Status)[keyof typeof Status];
+    const PaymentTerms: {
+        readonly DueOnReceipt: "DueOnReceipt";
+        readonly Net15: "Net15";
+        readonly Net30: "Net30";
+        readonly Net45: "Net45";
+        readonly Net60: "Net60";
+        readonly Net90: "Net90";
+    };
+    type PaymentTerms = (typeof PaymentTerms)[keyof typeof PaymentTerms];
+}

package/dist/esm/api/types/ProvisionOrder.mjs

@@ -0,0 +1,17 @@
+// This file was auto-generated by Fern from our API Definition.
+export var ProvisionOrder;
+(function (ProvisionOrder) {
+    /** Defaults to `active`, which activates the order and starts billing. Send `draft` to create or update the order without billing it; you can provision it again later with `active`. An active order cannot go back to `draft`. */
+    ProvisionOrder.Status = {
+        Draft: "draft",
+        Active: "active",
+    };
+    ProvisionOrder.PaymentTerms = {
+        DueOnReceipt: "DueOnReceipt",
+        Net15: "Net15",
+        Net30: "Net30",
+        Net45: "Net45",
+        Net60: "Net60",
+        Net90: "Net90",
+    };
+})(ProvisionOrder || (ProvisionOrder = {}));

package/dist/esm/api/types/ProvisionOrderLine.d.mts

@@ -0,0 +1,12 @@
+import type * as Paid from "../index.mjs";
+export interface ProvisionOrderLine {
+    product: Paid.ProvisionProduct;
+    name?: string;
+    description?: string;
+    startDate: string;
+    endDate?: string;
+    /** If not provided, pricing is pulled from the provisioned product attributes. */
+    attributes?: Paid.ProvisionOrderLineAttribute[];
+    externalId: string;
+    lineType?: Paid.WritableProvisionOrderLineType;
+}

package/dist/esm/api/types/ProvisionOrderLine.mjs

@@ -0,0 +1,2 @@
+// This file was auto-generated by Fern from our API Definition.
+export {};

package/dist/esm/api/types/ProvisionOrderLineAttribute.d.mts

@@ -0,0 +1,96 @@
+export interface ProvisionOrderLineAttribute {
+    name: string;
+    quantity?: number;
+    /** When omitted, the line uses the pricing of the product attribute with the same name, unchanged. This includes pricing models that this request cannot express. Send pricing only to override the catalog price for this order. */
+    pricing?: ProvisionOrderLineAttribute.Pricing;
+    /** Overrides the credit amount on every credit benefit this attribute carries onto the order line. Paid grants creditAmount × quantity per allocation. When omitted, the product attribute's configured benefit amount applies. */
+    creditAmount?: number | null;
+    /** Overrides the overage unit price, in the currency's minor units, for credits consumed beyond the granted balance, on this attribute only: applied to every credit benefit this attribute carries onto the order line, or to the attribute's pricing when it carries no benefits, and it replaces this attribute's per-currency price for the order currency, so it is what this attribute bills in every currency. Other attributes on the order that price the same credits currency keep their own overage prices, and the invoice bills the highest entry for its currency across all of them. When omitted, the product attribute's configured overage applies; null clears it, so the attribute takes its order-currency per-currency price, or none if it has no map. */
+    overageUnitPrice?: number | null;
+    /** Overrides this attribute's per-currency overage prices, in each currency's minor units keyed by uppercase ISO 4217 currency code, wherever overageUnitPrice would land. An entry for the order currency also becomes the attribute's overageUnitPrice. Keys must be currencies the product is priced in. When omitted, the product attribute's configured per-currency prices apply; null removes them, leaving only the scalar overage. */
+    overageUnitPrices?: Record<string, number | null> | null;
+    discountType?: ProvisionOrderLineAttribute.DiscountType;
+    /** Percentage discount, greater than 0 and at most 100, with at most 2 decimal places. Required when `discountType` is `percentage`. */
+    discountPercent?: number;
+    /** Fixed discount in minor currency units (cents). Required when `discountType` is `fixed`. */
+    discountAmount?: number;
+}
+export declare namespace ProvisionOrderLineAttribute {
+    /**
+     * When omitted, the line uses the pricing of the product attribute with the same name, unchanged. This includes pricing models that this request cannot express. Send pricing only to override the catalog price for this order.
+     */
+    interface Pricing {
+        eventName?: string;
+        chargeType: Pricing.ChargeType;
+        pricePoints: Pricing.PricePoints;
+        pricingModel: Pricing.PricingModel;
+        billingFrequency?: Pricing.BillingFrequency;
+        billingFrequencyCustomMonths?: number;
+        /** When the charge is billed. Usage charges must use arrears. */
+        billingType?: Pricing.BillingType;
+    }
+    namespace Pricing {
+        const ChargeType: {
+            readonly Usage: "usage";
+            readonly Recurring: "recurring";
+            readonly OneTime: "oneTime";
+            readonly SeatBased: "seatBased";
+        };
+        type ChargeType = (typeof ChargeType)[keyof typeof ChargeType];
+        interface PricePoints {
+            currency?: string;
+            /** Price per unit, as a whole number in minor currency units (cents): 4900 is $49.00. Must be 0 or more. For a discount or credit, send a positive price on a line with `lineType: CREDIT`. */
+            unitPrice: number;
+            /** Optional pricing tiers for volume/graduated pricing models. When provided, overrides the default flat unitPrice structure. */
+            tiers?: PricePoints.Tiers.Item[];
+        }
+        namespace PricePoints {
+            type Tiers = Tiers.Item[];
+            namespace Tiers {
+                interface Item {
+                    /** Flat fee for this tier, in minor currency units (cents). Must be 0 or more. */
+                    flatAmount?: number;
+                    index?: number;
+                    lowerBound: number;
+                    number?: number;
+                    tierBillingType?: Item.TierBillingType;
+                    /** Price per unit in this tier, in minor currency units (cents). Must be 0 or more. */
+                    unitAmount?: number;
+                    upperBound?: number;
+                }
+                namespace Item {
+                    const TierBillingType: {
+                        readonly Flat: "flat";
+                        readonly PerUnit: "perUnit";
+                    };
+                    type TierBillingType = (typeof TierBillingType)[keyof typeof TierBillingType];
+                }
+            }
+        }
+        const PricingModel: {
+            readonly PerUnit: "perUnit";
+            readonly VolumePricing: "volumePricing";
+            readonly GraduatedPricing: "graduatedPricing";
+        };
+        type PricingModel = (typeof PricingModel)[keyof typeof PricingModel];
+        const BillingFrequency: {
+            readonly Monthly: "monthly";
+            readonly Quarterly: "quarterly";
+            readonly SemiAnnually: "semiAnnually";
+            readonly Annual: "annual";
+            readonly Custom: "custom";
+        };
+        type BillingFrequency = (typeof BillingFrequency)[keyof typeof BillingFrequency];
+        /** When the charge is billed. Usage charges must use arrears. */
+        const BillingType: {
+            readonly Advance: "advance";
+            readonly Arrears: "arrears";
+        };
+        type BillingType = (typeof BillingType)[keyof typeof BillingType];
+    }
+    const DiscountType: {
+        readonly Percentage: "percentage";
+        readonly Fixed: "fixed";
+    };
+    type DiscountType = (typeof DiscountType)[keyof typeof DiscountType];
+}

package/dist/esm/api/types/ProvisionOrderLineAttribute.mjs

@@ -0,0 +1,47 @@
+// This file was auto-generated by Fern from our API Definition.
+export var ProvisionOrderLineAttribute;
+(function (ProvisionOrderLineAttribute) {
+    let Pricing;
+    (function (Pricing) {
+        Pricing.ChargeType = {
+            Usage: "usage",
+            Recurring: "recurring",
+            OneTime: "oneTime",
+            SeatBased: "seatBased",
+        };
+        let PricePoints;
+        (function (PricePoints) {
+            let Tiers;
+            (function (Tiers) {
+                let Item;
+                (function (Item) {
+                    Item.TierBillingType = {
+                        Flat: "flat",
+                        PerUnit: "perUnit",
+                    };
+                })(Item = Tiers.Item || (Tiers.Item = {}));
+            })(Tiers = PricePoints.Tiers || (PricePoints.Tiers = {}));
+        })(PricePoints = Pricing.PricePoints || (Pricing.PricePoints = {}));
+        Pricing.PricingModel = {
+            PerUnit: "perUnit",
+            VolumePricing: "volumePricing",
+            GraduatedPricing: "graduatedPricing",
+        };
+        Pricing.BillingFrequency = {
+            Monthly: "monthly",
+            Quarterly: "quarterly",
+            SemiAnnually: "semiAnnually",
+            Annual: "annual",
+            Custom: "custom",
+        };
+        /** When the charge is billed. Usage charges must use arrears. */
+        Pricing.BillingType = {
+            Advance: "advance",
+            Arrears: "arrears",
+        };
+    })(Pricing = ProvisionOrderLineAttribute.Pricing || (ProvisionOrderLineAttribute.Pricing = {}));
+    ProvisionOrderLineAttribute.DiscountType = {
+        Percentage: "percentage",
+        Fixed: "fixed",
+    };
+})(ProvisionOrderLineAttribute || (ProvisionOrderLineAttribute = {}));