chargebee 3.0.1 → 3.1.0

package/types/resources/SubscriptionEntitlement.d.ts

@@ -0,0 +1,79 @@
+///<reference path='./../core.d.ts'/>
+///<reference path='./../index.d.ts'/>
+///<reference path='./filter.d.ts'/>
+declare module 'chargebee' {
+  export interface SubscriptionEntitlement {
+    subscription_id: string;
+    feature_id?: string;
+    feature_name?: string;
+    feature_unit?: string;
+    feature_type?: string;
+    value?: string;
+    name?: string;
+    is_overridden: boolean;
+    is_enabled: boolean;
+    effective_from?: number;
+    schedule_status?: 'activated' | 'scheduled' | 'failed';
+    expires_at?: number;
+    components?: SubscriptionEntitlement.Component;
+  }
+
+  export namespace SubscriptionEntitlement {
+    export class SubscriptionEntitlementResource {
+      subscriptionEntitlementsForSubscription(
+        subscription_id: string,
+        input?: SubscriptionEntitlementsForSubscriptionInputParam,
+        headers?: ChargebeeRequestHeader,
+      ): Promise<
+        ChargebeeResponse<SubscriptionEntitlementsForSubscriptionResponse>
+      >;
+
+      setSubscriptionEntitlementAvailability(
+        subscription_id: string,
+        input: SetSubscriptionEntitlementAvailabilityInputParam,
+        headers?: ChargebeeRequestHeader,
+      ): Promise<
+        ChargebeeResponse<SetSubscriptionEntitlementAvailabilityResponse>
+      >;
+    }
+
+    export interface SubscriptionEntitlementsForSubscriptionResponse {
+      list: { subscription_entitlement: SubscriptionEntitlement }[];
+      next_offset?: string;
+    }
+
+    export interface SetSubscriptionEntitlementAvailabilityResponse {
+      subscription_entitlement: SubscriptionEntitlement;
+    }
+
+    export interface Component {
+      entitlement_overrides?: EntitlementOverride;
+    }
+    // REQUEST PARAMS
+    //---------------
+
+    export interface SubscriptionEntitlementsForSubscriptionInputParam {
+      limit?: number;
+      offset?: string /**
+       * @deprecated Please refer API docs to use other attributes
+       */;
+
+      include_drafts?: boolean /**
+       * @deprecated Please refer API docs to use other attributes
+       */;
+
+      embed?: string /**
+       * @deprecated Please refer API docs to use other attributes
+       */;
+
+      include_scheduled_overrides?: boolean;
+    }
+    export interface SetSubscriptionEntitlementAvailabilityInputParam {
+      is_enabled: boolean;
+      subscription_entitlements?: SubscriptionEntitlementsSetSubscriptionEntitlementAvailabilityInputParam[];
+    }
+    export interface SubscriptionEntitlementsSetSubscriptionEntitlementAvailabilityInputParam {
+      feature_id: string;
+    }
+  }
+}

package/types/resources/SubscriptionEstimate.d.ts

@@ -0,0 +1,59 @@
+///<reference path='./../core.d.ts'/>
+///<reference path='./../index.d.ts'/>
+
+declare module 'chargebee' {
+  export interface SubscriptionEstimate {
+    id?: string;
+    currency_code: string;
+    status?:
+      | 'future'
+      | 'in_trial'
+      | 'active'
+      | 'non_renewing'
+      | 'paused'
+      | 'cancelled'
+      | 'transferred';
+    trial_end_action?: TrialEndActionEnum;
+    next_billing_at?: number;
+    pause_date?: number;
+    resume_date?: number;
+    shipping_address?: SubscriptionEstimate.ShippingAddress;
+    contract_term?: SubscriptionEstimate.ContractTerm;
+  }
+
+  export namespace SubscriptionEstimate {
+    export interface ShippingAddress {
+      first_name?: string;
+      last_name?: string;
+      email?: string;
+      company?: string;
+      phone?: string;
+      line1?: string;
+      line2?: string;
+      line3?: string;
+      city?: string;
+      state_code?: string;
+      state?: string;
+      country?: string;
+      zip?: string;
+      validation_status?: ValidationStatusEnum;
+      index: number;
+    }
+    export interface ContractTerm {
+      id: string;
+      status: 'active' | 'completed' | 'cancelled' | 'terminated';
+      contract_start: number;
+      contract_end: number;
+      billing_cycle: number;
+      action_at_term_end: 'renew' | 'evergreen' | 'cancel' | 'renew_once';
+      total_contract_value: number;
+      total_contract_value_before_tax: number;
+      cancellation_cutoff_period?: number;
+      created_at: number;
+      subscription_id: string;
+      remaining_billing_cycles?: number;
+    }
+    // REQUEST PARAMS
+    //---------------
+  }
+}

package/types/resources/TaxWithheld.d.ts

@@ -0,0 +1,19 @@
+///<reference path='./../core.d.ts'/>
+///<reference path='./../index.d.ts'/>
+
+declare module 'chargebee' {
+  export interface TaxWithheld {
+    id: string;
+    user?: string;
+    reference_number?: string;
+    description?: string;
+    type: 'payment' | 'refund';
+    payment_method: 'cash' | 'check' | 'chargeback' | 'bank_transfer' | 'other';
+    date?: number;
+    currency_code: string;
+    amount?: number;
+    resource_version?: number;
+    updated_at?: number;
+    exchange_rate?: number;
+  }
+}

package/types/resources/ThirdPartyPaymentMethod.d.ts

@@ -0,0 +1,11 @@
+///<reference path='./../core.d.ts'/>
+///<reference path='./../index.d.ts'/>
+
+declare module 'chargebee' {
+  export interface ThirdPartyPaymentMethod {
+    type: TypeEnum;
+    gateway: GatewayEnum;
+    gateway_account_id?: string;
+    reference_id: string;
+  }
+}

package/types/resources/TimeMachine.d.ts

@@ -0,0 +1,57 @@
+///<reference path='./../core.d.ts'/>
+///<reference path='./../index.d.ts'/>
+
+declare module 'chargebee' {
+  export interface TimeMachine {
+    name: string;
+    time_travel_status: 'not_enabled' | 'in_progress' | 'succeeded' | 'failed';
+    genesis_time: number;
+    destination_time: number;
+    failure_code?: string;
+    failure_reason?: string;
+    error_json?: string;
+  }
+
+  export namespace TimeMachine {
+    export class TimeMachineResource {
+      retrieve(
+        time_machine_name: string,
+        headers?: ChargebeeRequestHeader,
+      ): Promise<ChargebeeResponse<RetrieveResponse>>;
+
+      startAfresh(
+        time_machine_name: string,
+        input?: StartAfreshInputParam,
+        headers?: ChargebeeRequestHeader,
+      ): Promise<ChargebeeResponse<StartAfreshResponse>>;
+
+      travelForward(
+        time_machine_name: string,
+        input?: TravelForwardInputParam,
+        headers?: ChargebeeRequestHeader,
+      ): Promise<ChargebeeResponse<TravelForwardResponse>>;
+    }
+
+    export interface RetrieveResponse {
+      time_machine: TimeMachine;
+    }
+
+    export interface StartAfreshResponse {
+      time_machine: TimeMachine;
+    }
+
+    export interface TravelForwardResponse {
+      time_machine: TimeMachine;
+    }
+
+    // REQUEST PARAMS
+    //---------------
+
+    export interface StartAfreshInputParam {
+      genesis_time?: number;
+    }
+    export interface TravelForwardInputParam {
+      destination_time?: number;
+    }
+  }
+}

package/types/resources/Token.d.ts

@@ -0,0 +1,19 @@
+///<reference path='./../core.d.ts'/>
+///<reference path='./../index.d.ts'/>
+
+declare module 'chargebee' {
+  export interface Token {
+    id: string;
+    gateway: GatewayEnum;
+    gateway_account_id: string;
+    payment_method_type: PaymentMethodTypeEnum;
+    status: 'new' | 'expired' | 'consumed';
+    id_at_vault: string;
+    vault: 'spreedly' | 'gateway';
+    ip_address?: string;
+    resource_version?: number;
+    updated_at?: number;
+    created_at: number;
+    expired_at?: number;
+  }
+}

package/types/resources/Transaction.d.ts

@@ -0,0 +1,316 @@
+///<reference path='./../core.d.ts'/>
+///<reference path='./../index.d.ts'/>
+///<reference path='./filter.d.ts'/>
+declare module 'chargebee' {
+  export interface Transaction {
+    id: string;
+    customer_id?: string;
+    subscription_id?: string;
+    gateway_account_id?: string;
+    payment_source_id?: string;
+    payment_method: PaymentMethodEnum;
+    reference_number?: string;
+    gateway: GatewayEnum;
+    type: 'authorization' | 'payment' | 'refund' | 'payment_reversal';
+    date?: number;
+    settled_at?: number;
+    exchange_rate?: number;
+    currency_code: string;
+    amount?: number;
+    id_at_gateway?: string;
+    status?:
+      | 'in_progress'
+      | 'success'
+      | 'voided'
+      | 'failure'
+      | 'timeout'
+      | 'needs_attention'
+      | 'late_failure';
+    fraud_flag?: 'safe' | 'suspicious' | 'fraudulent';
+    initiator_type?: 'customer' | 'merchant';
+    three_d_secure?: boolean;
+    authorization_reason?: 'blocking_funds' | 'verification';
+    error_code?: string;
+    error_text?: string;
+    voided_at?: number;
+    resource_version?: number;
+    updated_at?: number;
+    fraud_reason?: string;
+    custom_payment_method_id?: string;
+    amount_unused?: number;
+    masked_card_number?: string;
+    reference_transaction_id?: string;
+    refunded_txn_id?: string;
+    reference_authorization_id?: string;
+    amount_capturable?: number;
+    reversal_transaction_id?: string;
+    linked_invoices?: Transaction.LinkedInvoice[];
+    linked_credit_notes?: Transaction.LinkedCreditNote[];
+    linked_refunds?: Transaction.LinkedRefund[];
+    linked_payments?: Transaction.LinkedPayment[];
+    deleted: boolean;
+    iin?: string;
+    last4?: string;
+    merchant_reference_id?: string;
+    business_entity_id?: string;
+    payment_method_details?: string;
+    error_detail?: Transaction.GatewayErrorDetail;
+    custom_payment_method_name?: string;
+  }
+
+  export namespace Transaction {
+    export class TransactionResource {
+      createAuthorization(
+        input: CreateAuthorizationInputParam,
+        headers?: ChargebeeRequestHeader,
+      ): Promise<ChargebeeResponse<CreateAuthorizationResponse>>;
+
+      voidTransaction(
+        transaction_id: string,
+        headers?: ChargebeeRequestHeader,
+      ): Promise<ChargebeeResponse<VoidTransactionResponse>>;
+
+      recordRefund(
+        transaction_id: string,
+        input: RecordRefundInputParam,
+        headers?: ChargebeeRequestHeader,
+      ): Promise<ChargebeeResponse<RecordRefundResponse>>;
+
+      reconcile(
+        transaction_id: string,
+        input?: ReconcileInputParam,
+        headers?: ChargebeeRequestHeader,
+      ): Promise<ChargebeeResponse<ReconcileResponse>>;
+
+      refund(
+        transaction_id: string,
+        input?: RefundInputParam,
+        headers?: ChargebeeRequestHeader,
+      ): Promise<ChargebeeResponse<RefundResponse>>;
+
+      list(
+        input?: ListInputParam,
+        headers?: ChargebeeRequestHeader,
+      ): Promise<ChargebeeResponse<ListResponse>>;
+
+      transactionsForCustomer(
+        customer_id: string,
+        input?: TransactionsForCustomerInputParam,
+        headers?: ChargebeeRequestHeader,
+      ): Promise<ChargebeeResponse<TransactionsForCustomerResponse>>;
+
+      transactionsForSubscription(
+        subscription_id: string,
+        input?: TransactionsForSubscriptionInputParam,
+        headers?: ChargebeeRequestHeader,
+      ): Promise<ChargebeeResponse<TransactionsForSubscriptionResponse>>;
+
+      paymentsForInvoice(
+        invoice_id: string,
+        input?: PaymentsForInvoiceInputParam,
+        headers?: ChargebeeRequestHeader,
+      ): Promise<ChargebeeResponse<PaymentsForInvoiceResponse>>;
+
+      retrieve(
+        transaction_id: string,
+        headers?: ChargebeeRequestHeader,
+      ): Promise<ChargebeeResponse<RetrieveResponse>>;
+
+      deleteOfflineTransaction(
+        transaction_id: string,
+        input?: DeleteOfflineTransactionInputParam,
+        headers?: ChargebeeRequestHeader,
+      ): Promise<ChargebeeResponse<DeleteOfflineTransactionResponse>>;
+    }
+
+    export interface CreateAuthorizationResponse {
+      transaction: Transaction;
+    }
+
+    export interface VoidTransactionResponse {
+      transaction: Transaction;
+    }
+
+    export interface RecordRefundResponse {
+      transaction: Transaction;
+    }
+
+    export interface ReconcileResponse {
+      transaction: Transaction;
+    }
+
+    export interface RefundResponse {
+      transaction: Transaction;
+    }
+
+    export interface ListResponse {
+      list: { transaction: Transaction }[];
+      next_offset?: string;
+    }
+
+    export interface TransactionsForCustomerResponse {
+      list: { transaction: Transaction }[];
+      next_offset?: string;
+    }
+
+    export interface TransactionsForSubscriptionResponse {
+      list: { transaction: Transaction }[];
+      next_offset?: string;
+    }
+
+    export interface PaymentsForInvoiceResponse {
+      list: { transaction: Transaction }[];
+      next_offset?: string;
+    }
+
+    export interface RetrieveResponse {
+      transaction: Transaction;
+    }
+
+    export interface DeleteOfflineTransactionResponse {
+      transaction: Transaction;
+    }
+
+    export interface LinkedInvoice {
+      invoice_id: string;
+      applied_amount: number;
+      applied_at: number;
+      invoice_date?: number;
+      invoice_total?: number;
+      invoice_status:
+        | 'paid'
+        | 'posted'
+        | 'payment_due'
+        | 'not_paid'
+        | 'voided'
+        | 'pending';
+    }
+    export interface LinkedCreditNote {
+      cn_id: string;
+      applied_amount: number;
+      applied_at: number;
+      cn_reason_code?:
+        | 'write_off'
+        | 'subscription_change'
+        | 'subscription_cancellation'
+        | 'subscription_pause'
+        | 'chargeback'
+        | 'product_unsatisfactory'
+        | 'service_unsatisfactory'
+        | 'order_change'
+        | 'order_cancellation'
+        | 'waiver'
+        | 'other'
+        | 'fraudulent';
+      cn_create_reason_code?: string;
+      cn_date?: number;
+      cn_total?: number;
+      cn_status: 'adjusted' | 'refunded' | 'refund_due' | 'voided';
+      cn_reference_invoice_id?: string;
+    }
+    export interface LinkedRefund {
+      txn_id: string;
+      txn_status:
+        | 'in_progress'
+        | 'success'
+        | 'voided'
+        | 'failure'
+        | 'timeout'
+        | 'needs_attention'
+        | 'late_failure';
+      txn_date: number;
+      txn_amount: number;
+    }
+    export interface LinkedPayment {
+      id: string;
+      status?:
+        | 'in_progress'
+        | 'success'
+        | 'voided'
+        | 'failure'
+        | 'timeout'
+        | 'needs_attention'
+        | 'late_failure';
+      amount?: number;
+      date?: number;
+    }
+    export interface GatewayErrorDetail {
+      request_id?: string;
+      error_category?: string;
+      error_code?: string;
+      error_message?: string;
+      decline_code?: string;
+      decline_message?: string;
+      network_error_code?: string;
+      network_error_message?: string;
+      error_field?: string;
+      recommendation_code?: string;
+      recommendation_message?: string;
+      processor_error_code?: string;
+      processor_error_message?: string;
+    }
+    // REQUEST PARAMS
+    //---------------
+
+    export interface CreateAuthorizationInputParam {
+      customer_id: string;
+      payment_source_id?: string;
+      currency_code?: string;
+      amount: number;
+    }
+    export interface RecordRefundInputParam {
+      amount?: number;
+      payment_method: PaymentMethodEnum;
+      date: number;
+      reference_number?: string;
+      custom_payment_method_id?: string;
+      comment?: string;
+    }
+    export interface ReconcileInputParam {
+      id_at_gateway?: string;
+      customer_id?: string;
+      status?: 'success' | 'failure';
+    }
+    export interface RefundInputParam {
+      amount?: number;
+      comment?: string;
+    }
+    export interface ListInputParam {
+      limit?: number;
+      offset?: string;
+      include_deleted?: boolean;
+      id?: filter.String;
+      customer_id?: filter.String;
+      subscription_id?: filter.String;
+      payment_source_id?: filter.String;
+      payment_method?: filter.Enum;
+      gateway?: filter.Enum;
+      gateway_account_id?: filter.String;
+      id_at_gateway?: filter.String;
+      reference_number?: filter.String;
+      type?: filter.Enum;
+      date?: filter.Timestamp;
+      amount?: filter.Number;
+      amount_capturable?: filter.Number;
+      status?: filter.Enum;
+      updated_at?: filter.Timestamp;
+      'sort_by[asc]'?: string;
+      'sort_by[desc]'?: string;
+    }
+    export interface TransactionsForCustomerInputParam {
+      limit?: number;
+      offset?: string;
+    }
+    export interface TransactionsForSubscriptionInputParam {
+      limit?: number;
+      offset?: string;
+    }
+    export interface PaymentsForInvoiceInputParam {
+      limit?: number;
+      offset?: string;
+    }
+    export interface DeleteOfflineTransactionInputParam {
+      comment?: string;
+    }
+  }
+}