@d19n/youfibre-odin-sdk 2.0.13-beta.1 → 2.0.13

package/dist/records-v2/InvoiceRecord.d.ts

@@ -13,13 +13,16 @@
  * await record.createInvoice({ ... }).execute();
  * ```
  *
+ * Entity Types: DEFAULT, ETF
+ *
  * AUTO-GENERATED - DO NOT EDIT DIRECTLY
  */
 import { OdinRecord, OdinRecordLinkDto } from '@d19n/odin-types/dist/core';
 import { PipelineStageEntity } from '@d19n/odin-types/dist/core';
 import { IDbRecordCreateUpdateRes } from '@d19n/odin-types/dist/core/interfaces/v1.db.interfaces';
 import { IOdinProvider } from '@d19n/odin-sdk-generator/dist/odin-sdk-types';
-import { InvoiceProperties } from '../entities-v2/Invoice';
+import { RecordLinkManager } from '@d19n/odin-sdk-generator/dist/record-link-manager';
+import { InvoiceProperties, EtfInvoiceProperties } from '../entities-v2/Invoice';
 import { InvoiceCreateProperties } from '../actions-v2/InvoiceCreateDto';
 import { InvoiceUpdateProperties } from '../actions-v2/InvoiceUpdateDto';
 import { SetInvoiceDunningBrqRequestProperties } from '../actions-v2/SetInvoiceDunningBrqRequestDto';
@@ -28,6 +31,26 @@ import { SetInvoiceDunningPaymentFailedProperties } from '../actions-v2/SetInvoi
 import { SetInvoiceFinalDunningReminderProperties } from '../actions-v2/SetInvoiceFinalDunningReminderDto';
 import { SetInvoiceInitialDunningReminderProperties } from '../actions-v2/SetInvoiceInitialDunningReminderDto';
 import { SetInvoicePaidFromOtpProperties } from '../actions-v2/SetInvoicePaidFromOtpDto';
+import { OrderRecord } from './OrderRecord';
+import { AccountRecord } from './AccountRecord';
+import { AddressRecord } from './AddressRecord';
+import { OneTouchSwitchRecord } from './OneTouchSwitchRecord';
+import { BillingRequestRecord } from './BillingRequestRecord';
+import { ContactRecord } from './ContactRecord';
+import { WorkOrderRecord } from './WorkOrderRecord';
+import { PaymentRecord } from './PaymentRecord';
+import { SmsMessageRecord } from './SmsMessageRecord';
+import { CreditNoteRecord } from './CreditNoteRecord';
+import { DiscountRecord } from './DiscountRecord';
+import { PaymentMethodRefundRecord } from './PaymentMethodRefundRecord';
+import { BillingAdjustmentRecord } from './BillingAdjustmentRecord';
+import { FileRecord } from './FileRecord';
+import { InvoiceItemRecord } from './InvoiceItemRecord';
+import { NoteRecord } from './NoteRecord';
+import { TransactionRecord } from './TransactionRecord';
+import { AccountCreditRecord } from './AccountCreditRecord';
+/** Valid entity types for Invoice */
+export declare type InvoiceType = 'DEFAULT' | 'ETF';
 /**
  * Builder for action execution with dryRun support
  *
@@ -91,6 +114,24 @@ export declare class InvoiceRecord<TProps = InvoiceProperties> {
     private _provider;
     private _pendingLinks;
     private _preGeneratedId;
+    private _orders?;
+    private _accounts?;
+    private _addresses?;
+    private _oneTouchSwitches?;
+    private _billingRequests?;
+    private _contacts?;
+    private _workOrders?;
+    private _payments?;
+    private _smsMessages?;
+    private _creditNotes?;
+    private _discounts?;
+    private _paymentMethodRefunds?;
+    private _billingAdjustments?;
+    private _files?;
+    private _invoiceItems?;
+    private _notes?;
+    private _transactions?;
+    private _accountCredits?;
     /**
      * Create a record wrapper.
      * @param record - The underlying record, or null for create operations
@@ -103,7 +144,7 @@ export declare class InvoiceRecord<TProps = InvoiceProperties> {
     /** Record ID - always available (pre-generated for new records) */
     get id(): string;
     get entity(): string;
-    get type(): string | undefined;
+    get type(): InvoiceType | undefined;
     /** Record properties - empty object for new (unsaved) records */
     get properties(): TProps;
     get title(): string | undefined;
@@ -116,6 +157,362 @@ export declare class InvoiceRecord<TProps = InvoiceProperties> {
     get groups(): string[];
     /** Access the underlying OdinRecord (null for new records) */
     get record(): OdinRecord<TProps> | null;
+    /**
+     * Type guard: check if this record is of type DEFAULT
+     *
+     * When this returns true, TypeScript automatically narrows the type,
+     * giving you access to DEFAULT-specific properties.
+     *
+     * @example
+     * ```typescript
+     * if (record.isDefault()) {
+     *   // TypeScript knows record.properties is InvoiceProperties
+     *   console.log(record.properties.SomeTypeSpecificField);
+     * }
+     * ```
+     * @remarks This is the default record type
+     */
+    isDefault(): this is InvoiceRecord<InvoiceProperties>;
+    /**
+     * Type guard: check if this record is of type ETF
+     *
+     * When this returns true, TypeScript automatically narrows the type,
+     * giving you access to ETF-specific properties.
+     *
+     * @example
+     * ```typescript
+     * if (record.isEtf()) {
+     *   // TypeScript knows record.properties is EtfInvoiceProperties
+     *   console.log(record.properties.SomeTypeSpecificField);
+     * }
+     * ```
+     * @remarks Early Termination Fee Invoices
+     */
+    isEtf(): this is InvoiceRecord<EtfInvoiceProperties>;
+    /** Valid labels for Order associations */
+    static readonly ordersLabels: readonly ["Order__Invoice"];
+    /**
+     * Access linked Order records
+     * @remarks Available labels: Order__Invoice
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Order records
+     * const items = await record.orders.list();
+     * const first = await record.orders.first();
+     *
+     * // Filter by label
+     * const specific = await record.orders.first({ label: 'Order__Invoice' });
+     * ```
+     */
+    get orders(): RecordLinkManager<OrderRecord, typeof InvoiceRecord['ordersLabels'][number]>;
+    /** Valid labels for Account associations */
+    static readonly accountsLabels: readonly ["Account__Invoice"];
+    /**
+     * Access linked Account records
+     * @remarks Available labels: Account__Invoice
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Account records
+     * const items = await record.accounts.list();
+     * const first = await record.accounts.first();
+     *
+     * // Filter by label
+     * const specific = await record.accounts.first({ label: 'Account__Invoice' });
+     * ```
+     */
+    get accounts(): RecordLinkManager<AccountRecord, typeof InvoiceRecord['accountsLabels'][number]>;
+    /** Valid labels for Address associations */
+    static readonly addressesLabels: readonly ["Invoice__Address"];
+    /**
+     * Access linked Address records
+     * @remarks Available labels: Invoice__Address
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Address records
+     * const items = await record.addresses.list();
+     * const first = await record.addresses.first();
+     *
+     * // Filter by label
+     * const specific = await record.addresses.first({ label: 'Invoice__Address' });
+     * ```
+     */
+    get addresses(): RecordLinkManager<AddressRecord, typeof InvoiceRecord['addressesLabels'][number]>;
+    /** Valid labels for OneTouchSwitch associations */
+    static readonly oneTouchSwitchesLabels: readonly ["OneTouchSwitch__Invoice"];
+    /**
+     * Access linked OneTouchSwitch records
+     * @remarks Available labels: OneTouchSwitch__Invoice
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked OneTouchSwitch records
+     * const items = await record.oneTouchSwitches.list();
+     * const first = await record.oneTouchSwitches.first();
+     *
+     * // Filter by label
+     * const specific = await record.oneTouchSwitches.first({ label: 'OneTouchSwitch__Invoice' });
+     * ```
+     */
+    get oneTouchSwitches(): RecordLinkManager<OneTouchSwitchRecord, typeof InvoiceRecord['oneTouchSwitchesLabels'][number]>;
+    /** Valid labels for BillingRequest associations */
+    static readonly billingRequestsLabels: readonly ["BillingRequest__Invoice"];
+    /**
+     * Access linked BillingRequest records
+     * @remarks Available labels: BillingRequest__Invoice
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked BillingRequest records
+     * const items = await record.billingRequests.list();
+     * const first = await record.billingRequests.first();
+     *
+     * // Filter by label
+     * const specific = await record.billingRequests.first({ label: 'BillingRequest__Invoice' });
+     * ```
+     */
+    get billingRequests(): RecordLinkManager<BillingRequestRecord, typeof InvoiceRecord['billingRequestsLabels'][number]>;
+    /** Valid labels for Contact associations */
+    static readonly contactsLabels: readonly ["Invoice__Contact"];
+    /**
+     * Access linked Contact records
+     * @remarks Available labels: Invoice__Contact
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Contact records
+     * const items = await record.contacts.list();
+     * const first = await record.contacts.first();
+     *
+     * // Filter by label
+     * const specific = await record.contacts.first({ label: 'Invoice__Contact' });
+     * ```
+     */
+    get contacts(): RecordLinkManager<ContactRecord, typeof InvoiceRecord['contactsLabels'][number]>;
+    /** Valid labels for WorkOrder associations */
+    static readonly workOrdersLabels: readonly ["WorkOrder__Invoice"];
+    /**
+     * Access linked WorkOrder records
+     * @remarks Available labels: WorkOrder__Invoice
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked WorkOrder records
+     * const items = await record.workOrders.list();
+     * const first = await record.workOrders.first();
+     *
+     * // Filter by label
+     * const specific = await record.workOrders.first({ label: 'WorkOrder__Invoice' });
+     * ```
+     */
+    get workOrders(): RecordLinkManager<WorkOrderRecord, typeof InvoiceRecord['workOrdersLabels'][number]>;
+    /** Valid labels for Payment associations */
+    static readonly paymentsLabels: readonly ["Payment_Invoice"];
+    /**
+     * Access linked Payment records
+     * @remarks Available labels: Payment_Invoice
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Payment records
+     * const items = await record.payments.list();
+     * const first = await record.payments.first();
+     *
+     * // Filter by label
+     * const specific = await record.payments.first({ label: 'Payment_Invoice' });
+     * ```
+     */
+    get payments(): RecordLinkManager<PaymentRecord, typeof InvoiceRecord['paymentsLabels'][number]>;
+    /** Valid labels for SmsMessage associations */
+    static readonly smsMessagesLabels: readonly ["Invoice__SmsMessage"];
+    /**
+     * Access linked SmsMessage records
+     * @remarks Available labels: Invoice__SmsMessage
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked SmsMessage records
+     * const items = await record.smsMessages.list();
+     * const first = await record.smsMessages.first();
+     *
+     * // Filter by label
+     * const specific = await record.smsMessages.first({ label: 'Invoice__SmsMessage' });
+     * ```
+     */
+    get smsMessages(): RecordLinkManager<SmsMessageRecord, typeof InvoiceRecord['smsMessagesLabels'][number]>;
+    /** Valid labels for CreditNote associations */
+    static readonly creditNotesLabels: readonly ["Invoice__CreditNote"];
+    /**
+     * Access linked CreditNote records
+     * @remarks Available labels: Invoice__CreditNote
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked CreditNote records
+     * const items = await record.creditNotes.list();
+     * const first = await record.creditNotes.first();
+     *
+     * // Filter by label
+     * const specific = await record.creditNotes.first({ label: 'Invoice__CreditNote' });
+     * ```
+     */
+    get creditNotes(): RecordLinkManager<CreditNoteRecord, typeof InvoiceRecord['creditNotesLabels'][number]>;
+    /** Valid labels for Discount associations */
+    static readonly discountsLabels: readonly ["Invoice__Discount"];
+    /**
+     * Access linked Discount records
+     * @remarks Available labels: Invoice__Discount
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Discount records
+     * const items = await record.discounts.list();
+     * const first = await record.discounts.first();
+     *
+     * // Filter by label
+     * const specific = await record.discounts.first({ label: 'Invoice__Discount' });
+     * ```
+     */
+    get discounts(): RecordLinkManager<DiscountRecord, typeof InvoiceRecord['discountsLabels'][number]>;
+    /** Valid labels for PaymentMethodRefund associations */
+    static readonly paymentMethodRefundsLabels: readonly ["PaymentMethodRefund__Invoice"];
+    /**
+     * Access linked PaymentMethodRefund records
+     * @remarks Available labels: PaymentMethodRefund__Invoice
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked PaymentMethodRefund records
+     * const items = await record.paymentMethodRefunds.list();
+     * const first = await record.paymentMethodRefunds.first();
+     *
+     * // Filter by label
+     * const specific = await record.paymentMethodRefunds.first({ label: 'PaymentMethodRefund__Invoice' });
+     * ```
+     */
+    get paymentMethodRefunds(): RecordLinkManager<PaymentMethodRefundRecord, typeof InvoiceRecord['paymentMethodRefundsLabels'][number]>;
+    /** Valid labels for BillingAdjustment associations */
+    static readonly billingAdjustmentsLabels: readonly ["Invoice__BillingAdjustment"];
+    /**
+     * Access linked BillingAdjustment records
+     * @remarks Available labels: Invoice__BillingAdjustment
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked BillingAdjustment records
+     * const items = await record.billingAdjustments.list();
+     * const first = await record.billingAdjustments.first();
+     *
+     * // Filter by label
+     * const specific = await record.billingAdjustments.first({ label: 'Invoice__BillingAdjustment' });
+     * ```
+     */
+    get billingAdjustments(): RecordLinkManager<BillingAdjustmentRecord, typeof InvoiceRecord['billingAdjustmentsLabels'][number]>;
+    /** Valid labels for File associations */
+    static readonly filesLabels: readonly ["Invoice__File"];
+    /**
+     * Access linked File records
+     * @remarks Available labels: Invoice__File
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked File records
+     * const items = await record.files.list();
+     * const first = await record.files.first();
+     *
+     * // Filter by label
+     * const specific = await record.files.first({ label: 'Invoice__File' });
+     * ```
+     */
+    get files(): RecordLinkManager<FileRecord, typeof InvoiceRecord['filesLabels'][number]>;
+    /** Valid labels for InvoiceItem associations */
+    static readonly invoiceItemsLabels: readonly ["Invoice__InvoiceItem"];
+    /**
+     * Access linked InvoiceItem records
+     * @remarks Available labels: Invoice__InvoiceItem
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked InvoiceItem records
+     * const items = await record.invoiceItems.list();
+     * const first = await record.invoiceItems.first();
+     *
+     * // Filter by label
+     * const specific = await record.invoiceItems.first({ label: 'Invoice__InvoiceItem' });
+     * ```
+     */
+    get invoiceItems(): RecordLinkManager<InvoiceItemRecord, typeof InvoiceRecord['invoiceItemsLabels'][number]>;
+    /** Valid labels for Note associations */
+    static readonly notesLabels: readonly ["Invoice__Note"];
+    /**
+     * Access linked Note records
+     * @remarks Available labels: Invoice__Note
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Note records
+     * const items = await record.notes.list();
+     * const first = await record.notes.first();
+     *
+     * // Filter by label
+     * const specific = await record.notes.first({ label: 'Invoice__Note' });
+     * ```
+     */
+    get notes(): RecordLinkManager<NoteRecord, typeof InvoiceRecord['notesLabels'][number]>;
+    /** Valid labels for Transaction associations */
+    static readonly transactionsLabels: readonly ["Invoice__Transaction"];
+    /**
+     * Access linked Transaction records
+     * @remarks Available labels: Invoice__Transaction
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Transaction records
+     * const items = await record.transactions.list();
+     * const first = await record.transactions.first();
+     *
+     * // Filter by label
+     * const specific = await record.transactions.first({ label: 'Invoice__Transaction' });
+     * ```
+     */
+    get transactions(): RecordLinkManager<TransactionRecord, typeof InvoiceRecord['transactionsLabels'][number]>;
+    /** Valid labels for AccountCredit associations */
+    static readonly accountCreditsLabels: readonly ["AccountCredit__Invoice"];
+    /**
+     * Access linked AccountCredit records
+     * @remarks Available labels: AccountCredit__Invoice
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked AccountCredit records
+     * const items = await record.accountCredits.list();
+     * const first = await record.accountCredits.first();
+     *
+     * // Filter by label
+     * const specific = await record.accountCredits.first({ label: 'AccountCredit__Invoice' });
+     * ```
+     */
+    get accountCredits(): RecordLinkManager<AccountCreditRecord, typeof InvoiceRecord['accountCreditsLabels'][number]>;
     /**
      * Queue a link to be created with the next action.
      * Works for both create and update actions.