@d19n/youfibre-odin-sdk 2.0.52 → 2.0.53

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

@@ -0,0 +1,2070 @@
+/**
+ * Order Record Wrapper
+ *
+ * Provides typed action methods and link management.
+ * Works with both ApiProvider and DbProvider.
+ *
+ * All action methods return an ActionBuilder or FlowBuilder.
+ * Call .execute() to run or .dryRun() to get the payload for debugging.
+ *
+ * Can be instantiated with null record for create operations:
+ * ```typescript
+ * const record = odinClient.orders.new();
+ * await record.createOrder({ ... }).execute();
+ * ```
+ *
+ * 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 { RecordLinkManager } from '@d19n/odin-sdk-generator/dist/record-link-manager';
+import { OrderProperties } from '../entities-v2/Order';
+import { ActivateOrderProperties } from '../actions-v2/ActivateOrderDto';
+import { CreateChurnRequestProperties } from '../actions-v2/CancelActiveOrderDto';
+import { CreatePicRequestProperties } from '../actions-v2/CancelOrderPreInstallDto';
+import { ChangeBillingDayProperties } from '../actions-v2/ChangeBillingDayDto';
+import { ClearOrderDeactivateOnDateProperties } from '../actions-v2/ClearOrderDeactivateOnDateDto';
+import { CreateCollectionAmcoWorkOrderProperties } from '../actions-v2/CreateCollectionAmcoWorkOrderFromOrderDto';
+import { CreateCollectionWorkOrderProperties } from '../actions-v2/CreateCollectionWorkOrderFromOrderDto';
+import { CreateDispatchAmcoWorkOrderProperties } from '../actions-v2/CreateDispatchAmcoWorkOrderFromOrderDto';
+import { CreateRecontractOrderProperties } from '../actions-v2/CreateRecontractOrderDto';
+import { ManageCommisionProperties } from '../actions-v2/ManageCommisionDto';
+import { OderUpdateProperties } from '../actions-v2/OderUpdateDto';
+import { SetOrderCancelOnDateProperties } from '../actions-v2/SetOrderCancelOnDateDto';
+import { SetOrderDeactivateOnDateProperties } from '../actions-v2/SetOrderDeactivateOnDateDto';
+import { SetPendingAmcoWorkOrderProperties } from '../actions-v2/SetPendingAmcoWorkOrderDto';
+import { UpdateOrderProperties } from '../actions-v2/UpdateOrderDto';
+import { AddressRecord } from './AddressRecord';
+import { ActivityLogRecord } from './ActivityLogRecord';
+import { InvoiceRecord } from './InvoiceRecord';
+import { BillingAdjustmentRecord } from './BillingAdjustmentRecord';
+import { OrderKciRecord } from './OrderKciRecord';
+import { FieldServiceDispatchedProductRecord } from './FieldServiceDispatchedProductRecord';
+import { AccountRecord } from './AccountRecord';
+import { PICRequestRecord } from './PICRequestRecord';
+import { OrderItemRecord } from './OrderItemRecord';
+import { NoteRecord } from './NoteRecord';
+import { SmsMessageRecord } from './SmsMessageRecord';
+import { OneTouchSwitchRecord } from './OneTouchSwitchRecord';
+import { LeadRecord } from './LeadRecord';
+import { CustomerDeviceOntRecord } from './CustomerDeviceOntRecord';
+import { ContactIdentityRecord } from './ContactIdentityRecord';
+import { CustomerDeviceRouterRecord } from './CustomerDeviceRouterRecord';
+import { WorkOrderRecord } from './WorkOrderRecord';
+import { VisitRecord } from './VisitRecord';
+import { DiscountRecord } from './DiscountRecord';
+import { FileRecord } from './FileRecord';
+import { CaseRecord } from './CaseRecord';
+import { ContractBuyOutRecord } from './ContractBuyOutRecord';
+import { ContactRecord } from './ContactRecord';
+import { OrderCheckRecord } from './OrderCheckRecord';
+import { ChurnRequestRecord } from './ChurnRequestRecord';
+import { PaymentMethodRefundRecord } from './PaymentMethodRefundRecord';
+import { AppointmentRecord } from './AppointmentRecord';
+import { ActivityRecord } from './ActivityRecord';
+import { ReferralRecord } from './ReferralRecord';
+import { PushNotificationRecord } from './PushNotificationRecord';
+/**
+ * Builder for action execution with dryRun support
+ *
+ * Provides a consistent API across all action types:
+ * - `.execute()` - Execute the action and return results
+ * - `.dryRun()` - Return the payload without executing (for debugging)
+ */
+declare class ActionBuilder<T = IDbRecordCreateUpdateRes[]> {
+    private _provider;
+    private _moduleName;
+    private _entityName;
+    private _payload;
+    private _clearPendingLinks;
+    constructor(provider: IOdinProvider, moduleName: string, entityName: string, payload: Record<string, any>, clearPendingLinks: () => void);
+    /**
+     * Set an external system identifier for this record.
+     * Links the record to a corresponding entry in an external application.
+     *
+     * @param externalId - The ID in the external system
+     * @param externalAppId - The external application identifier
+     * @returns this (for chaining)
+     *
+     * @example
+     * ```typescript
+     * await record.createOrder({ ... }).withExternalId('SF-123', 'salesforce').execute();
+     * ```
+     */
+    withExternalId(externalId: string, externalAppId: string): this;
+    /**
+     * Set security/access groups for this record.
+     * Controls which user groups can access the record.
+     *
+     * @param groups - Array of group names
+     * @returns this (for chaining)
+     *
+     * @example
+     * ```typescript
+     * await record.createOrder({ ... }).withGroups(['TenantA', 'BillingTeam']).execute();
+     * ```
+     */
+    withGroups(groups: string[]): this;
+    /**
+     * Execute the action
+     * @returns The result from the API
+     */
+    execute(): Promise<T>;
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun(): Record<string, any>;
+    /**
+     * Prevents accidental `await actionBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then(): never;
+}
+/** Options for a flow step */
+export interface CancelActiveOrderFlowBuilderStepOptions {
+    /** Associations to create with this step */
+    associations?: Array<{
+        recordId?: string;
+        entity?: string;
+    }>;
+    /** Groups for this step */
+    groups?: string[];
+}
+/**
+ * FlowBuilder for CancelActiveOrder multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * This is a CREATE flow - no existing record required.
+ * Transitions to stage: OrderStageCancelled
+ */
+export declare class CancelActiveOrderFlowBuilder {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _options?;
+    private _groups;
+    private _steps;
+    constructor(record: OrderRecord<any>, provider: IOdinProvider, pendingLinks: OdinRecordLinkDto[], options?: {
+        journeyId?: string;
+    });
+    /**
+     * Add a group to the main action
+     * @param group - Group name to add
+     * @returns this (for method chaining)
+     */
+    addGroup(group: string): this;
+    /**
+     * Add CreateChurnRequest step to the flow
+     * @param properties - Properties for this step
+     * @param options - Optional step settings
+     * @returns this (for method chaining)
+     */
+    createChurnRequest(properties: CreateChurnRequestProperties, options?: CancelActiveOrderFlowBuilderStepOptions): this;
+    /**
+     * Execute the flow
+     * @returns The result from the API
+     */
+    execute(): Promise<IDbRecordCreateUpdateRes[]>;
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun(): Record<string, any>;
+    /**
+     * Prevents accidental `await flowBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then(): never;
+    /**
+     * Build the request payload for the action
+     * @private
+     */
+    private _buildRequestPayload;
+}
+/** Options for a flow step */
+export interface CancelOrderPreInstallFlowBuilderStepOptions {
+    /** Associations to create with this step */
+    associations?: Array<{
+        recordId?: string;
+        entity?: string;
+    }>;
+    /** Groups for this step */
+    groups?: string[];
+}
+/**
+ * FlowBuilder for CancelOrderPreInstall multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * This is a CREATE flow - no existing record required.
+ * Transitions to stage: OrderStageCancelled
+ */
+export declare class CancelOrderPreInstallFlowBuilder {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _options?;
+    private _groups;
+    private _steps;
+    constructor(record: OrderRecord<any>, provider: IOdinProvider, pendingLinks: OdinRecordLinkDto[], options?: {
+        journeyId?: string;
+    });
+    /**
+     * Add a group to the main action
+     * @param group - Group name to add
+     * @returns this (for method chaining)
+     */
+    addGroup(group: string): this;
+    /**
+     * Add CreatePICRequest step to the flow
+     * @param properties - Properties for this step
+     * @param options - Optional step settings
+     * @returns this (for method chaining)
+     */
+    createPicRequest(properties: CreatePicRequestProperties, options?: CancelOrderPreInstallFlowBuilderStepOptions): this;
+    /**
+     * Execute the flow
+     * @returns The result from the API
+     */
+    execute(): Promise<IDbRecordCreateUpdateRes[]>;
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun(): Record<string, any>;
+    /**
+     * Prevents accidental `await flowBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then(): never;
+    /**
+     * Build the request payload for the action
+     * @private
+     */
+    private _buildRequestPayload;
+}
+/** Options for a flow step */
+export interface CreateCollectionAmcoWorkOrderFromOrderFlowBuilderStepOptions {
+    /** Associations to create with this step */
+    associations?: Array<{
+        recordId?: string;
+        entity?: string;
+    }>;
+    /** Groups for this step */
+    groups?: string[];
+}
+/**
+ * FlowBuilder for CreateCollectionAmcoWorkOrderFromOrder multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * This is a CREATE flow - no existing record required.
+ */
+export declare class CreateCollectionAmcoWorkOrderFromOrderFlowBuilder {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _options?;
+    private _groups;
+    private _steps;
+    constructor(record: OrderRecord<any>, provider: IOdinProvider, pendingLinks: OdinRecordLinkDto[], options?: {
+        journeyId?: string;
+    });
+    /**
+     * Add a group to the main action
+     * @param group - Group name to add
+     * @returns this (for method chaining)
+     */
+    addGroup(group: string): this;
+    /**
+     * Add CreateCollectionAmcoWorkOrder step to the flow
+     * @param properties - Properties for this step
+     * @param options - Optional step settings
+     * @returns this (for method chaining)
+     */
+    createCollectionAmcoWorkOrder(properties: CreateCollectionAmcoWorkOrderProperties, options?: CreateCollectionAmcoWorkOrderFromOrderFlowBuilderStepOptions): this;
+    /**
+     * Execute the flow
+     * @returns The result from the API
+     */
+    execute(): Promise<IDbRecordCreateUpdateRes[]>;
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun(): Record<string, any>;
+    /**
+     * Prevents accidental `await flowBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then(): never;
+    /**
+     * Build the request payload for the action
+     * @private
+     */
+    private _buildRequestPayload;
+}
+/** Options for a flow step */
+export interface CreateCollectionWorkOrderFromOrderFlowBuilderStepOptions {
+    /** Associations to create with this step */
+    associations?: Array<{
+        recordId?: string;
+        entity?: string;
+    }>;
+    /** Groups for this step */
+    groups?: string[];
+}
+/**
+ * FlowBuilder for CreateCollectionWorkOrderFromOrder multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * This is a CREATE flow - no existing record required.
+ */
+export declare class CreateCollectionWorkOrderFromOrderFlowBuilder {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _options?;
+    private _groups;
+    private _steps;
+    constructor(record: OrderRecord<any>, provider: IOdinProvider, pendingLinks: OdinRecordLinkDto[], options?: {
+        journeyId?: string;
+    });
+    /**
+     * Add a group to the main action
+     * @param group - Group name to add
+     * @returns this (for method chaining)
+     */
+    addGroup(group: string): this;
+    /**
+     * Add CreateCollectionWorkOrder step to the flow
+     * @param properties - Properties for this step
+     * @param options - Optional step settings
+     * @returns this (for method chaining)
+     */
+    createCollectionWorkOrder(properties: CreateCollectionWorkOrderProperties, options?: CreateCollectionWorkOrderFromOrderFlowBuilderStepOptions): this;
+    /**
+     * Execute the flow
+     * @returns The result from the API
+     */
+    execute(): Promise<IDbRecordCreateUpdateRes[]>;
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun(): Record<string, any>;
+    /**
+     * Prevents accidental `await flowBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then(): never;
+    /**
+     * Build the request payload for the action
+     * @private
+     */
+    private _buildRequestPayload;
+}
+/** Options for a flow step */
+export interface CreateDispatchAmcoWorkOrderFromOrderFlowBuilderStepOptions {
+    /** Associations to create with this step */
+    associations?: Array<{
+        recordId?: string;
+        entity?: string;
+    }>;
+    /** Groups for this step */
+    groups?: string[];
+}
+/**
+ * FlowBuilder for CreateDispatchAmcoWorkOrderFromOrder multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * This is a CREATE flow - no existing record required.
+ */
+export declare class CreateDispatchAmcoWorkOrderFromOrderFlowBuilder {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _options?;
+    private _groups;
+    private _steps;
+    constructor(record: OrderRecord<any>, provider: IOdinProvider, pendingLinks: OdinRecordLinkDto[], options?: {
+        journeyId?: string;
+    });
+    /**
+     * Add a group to the main action
+     * @param group - Group name to add
+     * @returns this (for method chaining)
+     */
+    addGroup(group: string): this;
+    /**
+     * Add CreateDispatchAmcoWorkOrder step to the flow
+     * @param properties - Properties for this step
+     * @param options - Optional step settings
+     * @returns this (for method chaining)
+     */
+    createDispatchAmcoWorkOrder(properties: CreateDispatchAmcoWorkOrderProperties, options?: CreateDispatchAmcoWorkOrderFromOrderFlowBuilderStepOptions): this;
+    /**
+     * Execute the flow
+     * @returns The result from the API
+     */
+    execute(): Promise<IDbRecordCreateUpdateRes[]>;
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun(): Record<string, any>;
+    /**
+     * Prevents accidental `await flowBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then(): never;
+    /**
+     * Build the request payload for the action
+     * @private
+     */
+    private _buildRequestPayload;
+}
+/** Options for a flow step */
+export interface MoveOrderFromDeactivatedToCancelledFlowBuilderStepOptions {
+    /** Associations to create with this step */
+    associations?: Array<{
+        recordId?: string;
+        entity?: string;
+    }>;
+    /** Groups for this step */
+    groups?: string[];
+}
+/**
+ * FlowBuilder for MoveOrderFromDeactivatedToCancelled multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * This is a CREATE flow - no existing record required.
+ * Transitions to stage: OrderStageCancelled
+ */
+export declare class MoveOrderFromDeactivatedToCancelledFlowBuilder {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _options?;
+    private _groups;
+    private _steps;
+    constructor(record: OrderRecord<any>, provider: IOdinProvider, pendingLinks: OdinRecordLinkDto[], options?: {
+        journeyId?: string;
+    });
+    /**
+     * Add a group to the main action
+     * @param group - Group name to add
+     * @returns this (for method chaining)
+     */
+    addGroup(group: string): this;
+    /**
+     * Add CreateChurnRequest step to the flow
+     * @param properties - Properties for this step
+     * @param options - Optional step settings
+     * @returns this (for method chaining)
+     */
+    createChurnRequest(properties: CreateChurnRequestProperties, options?: MoveOrderFromDeactivatedToCancelledFlowBuilderStepOptions): this;
+    /**
+     * Execute the flow
+     * @returns The result from the API
+     */
+    execute(): Promise<IDbRecordCreateUpdateRes[]>;
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun(): Record<string, any>;
+    /**
+     * Prevents accidental `await flowBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then(): never;
+    /**
+     * Build the request payload for the action
+     * @private
+     */
+    private _buildRequestPayload;
+}
+/** Options for a flow step */
+export interface MoveOrderFromPendingCancellationToCancelledFlowBuilderStepOptions {
+    /** Associations to create with this step */
+    associations?: Array<{
+        recordId?: string;
+        entity?: string;
+    }>;
+    /** Groups for this step */
+    groups?: string[];
+}
+/**
+ * FlowBuilder for MoveOrderFromPendingCancellationToCancelled multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * This is a CREATE flow - no existing record required.
+ * Transitions to stage: OrderStageCancelled
+ */
+export declare class MoveOrderFromPendingCancellationToCancelledFlowBuilder {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _options?;
+    private _groups;
+    private _steps;
+    constructor(record: OrderRecord<any>, provider: IOdinProvider, pendingLinks: OdinRecordLinkDto[], options?: {
+        journeyId?: string;
+    });
+    /**
+     * Add a group to the main action
+     * @param group - Group name to add
+     * @returns this (for method chaining)
+     */
+    addGroup(group: string): this;
+    /**
+     * Add CreateChurnRequest step to the flow
+     * @param properties - Properties for this step
+     * @param options - Optional step settings
+     * @returns this (for method chaining)
+     */
+    createChurnRequest(properties: CreateChurnRequestProperties, options?: MoveOrderFromPendingCancellationToCancelledFlowBuilderStepOptions): this;
+    /**
+     * Execute the flow
+     * @returns The result from the API
+     */
+    execute(): Promise<IDbRecordCreateUpdateRes[]>;
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun(): Record<string, any>;
+    /**
+     * Prevents accidental `await flowBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then(): never;
+    /**
+     * Build the request payload for the action
+     * @private
+     */
+    private _buildRequestPayload;
+}
+/** Options for a flow step */
+export interface MoveOrderToActiveFlowBuilderStepOptions {
+    /** Associations to create with this step */
+    associations?: Array<{
+        recordId?: string;
+        entity?: string;
+    }>;
+    /** Groups for this step */
+    groups?: string[];
+}
+/**
+ * FlowBuilder for MoveOrderToActive multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * Transitions to stage: OrderStageActive
+ */
+export declare class MoveOrderToActiveFlowBuilder {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _options?;
+    private _groups;
+    private _steps;
+    constructor(record: OrderRecord<any>, provider: IOdinProvider, pendingLinks: OdinRecordLinkDto[], options?: {
+        journeyId?: string;
+    });
+    /**
+     * Add a group to the main action
+     * @param group - Group name to add
+     * @returns this (for method chaining)
+     */
+    addGroup(group: string): this;
+    /**
+     * Add ActivateOrder step to the flow
+     * @param id - ID of the record to update
+     * @param properties - Properties for this step
+     * @param options - Optional step settings
+     * @returns this (for method chaining)
+     */
+    activateOrder(id: string, properties: ActivateOrderProperties, options?: MoveOrderToActiveFlowBuilderStepOptions): this;
+    /**
+     * Execute the flow
+     * @returns The result from the API
+     */
+    execute(): Promise<IDbRecordCreateUpdateRes[]>;
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun(): Record<string, any>;
+    /**
+     * Prevents accidental `await flowBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then(): never;
+    /**
+     * Build the request payload for the action
+     * @private
+     */
+    private _buildRequestPayload;
+}
+export declare class OrderRecord<TProps = OrderProperties> {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _preGeneratedId;
+    private _addresses?;
+    private _activityLogs?;
+    private _invoices?;
+    private _billingAdjustments?;
+    private _orderKcis?;
+    private _fieldServiceDispatchedProducts?;
+    private _accounts?;
+    private _picRequests?;
+    private _orderItems?;
+    private _notes?;
+    private _smsMessages?;
+    private _oneTouchSwitches?;
+    private _leads?;
+    private _customerDeviceOnts?;
+    private _contactIdentities?;
+    private _customerDeviceRouters?;
+    private _workOrders?;
+    private _visits?;
+    private _discounts?;
+    private _files?;
+    private _cases?;
+    private _contractBuyOuts?;
+    private _contacts?;
+    private _orders?;
+    private _orderChecks?;
+    private _churnRequests?;
+    private _paymentMethodRefunds?;
+    private _appointments?;
+    private _activities?;
+    private _referrals?;
+    private _pushNotifications?;
+    /**
+     * Create a record wrapper.
+     * @param record - The underlying record, or null for create operations
+     * @param provider - The API or DB provider
+     * @param preGeneratedId - Optional pre-generated ID for new records (auto-generated if not provided)
+     */
+    constructor(record: OdinRecord<TProps> | null, provider: IOdinProvider, preGeneratedId?: string);
+    /** Returns true if this is a new (unsaved) record */
+    get isNew(): boolean;
+    /** Record ID - always available (pre-generated for new records) */
+    get id(): string;
+    get entity(): string;
+    get type(): string | undefined;
+    /** Record properties - empty object for new (unsaved) records */
+    get properties(): TProps;
+    get title(): string | undefined;
+    get recordNumber(): string | undefined;
+    get stage(): PipelineStageEntity | undefined;
+    get createdAt(): string | undefined;
+    get updatedAt(): string | undefined;
+    get externalId(): string | undefined;
+    get externalAppId(): string | undefined;
+    get groups(): string[];
+    /** Access the underlying OdinRecord (null for new records) */
+    get record(): OdinRecord<TProps> | null;
+    /** Valid labels for Address associations */
+    static readonly addressesLabels: readonly ["Order__Address"];
+    /**
+     * Access linked Address records
+     * @remarks Available labels: Order__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: 'Order__Address' });
+     * ```
+     */
+    get addresses(): RecordLinkManager<AddressRecord, typeof OrderRecord['addressesLabels'][number]>;
+    /** Valid labels for ActivityLog associations */
+    static readonly activityLogsLabels: readonly ["Order__ActivityLog"];
+    /**
+     * Access linked ActivityLog records
+     * @remarks Available labels: Order__ActivityLog
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked ActivityLog records
+     * const items = await record.activityLogs.list();
+     * const first = await record.activityLogs.first();
+     *
+     * // Filter by label
+     * const specific = await record.activityLogs.first({ label: 'Order__ActivityLog' });
+     * ```
+     */
+    get activityLogs(): RecordLinkManager<ActivityLogRecord, typeof OrderRecord['activityLogsLabels'][number]>;
+    /** Valid labels for Invoice associations */
+    static readonly invoicesLabels: readonly ["Order__Invoice"];
+    /**
+     * Access linked Invoice records
+     * @remarks Available labels: Order__Invoice
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Invoice records
+     * const items = await record.invoices.list();
+     * const first = await record.invoices.first();
+     *
+     * // Filter by label
+     * const specific = await record.invoices.first({ label: 'Order__Invoice' });
+     * ```
+     */
+    get invoices(): RecordLinkManager<InvoiceRecord, typeof OrderRecord['invoicesLabels'][number]>;
+    /** Valid labels for BillingAdjustment associations */
+    static readonly billingAdjustmentsLabels: readonly ["Order__BillingAdjustment"];
+    /**
+     * Access linked BillingAdjustment records
+     * @remarks Available labels: Order__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: 'Order__BillingAdjustment' });
+     * ```
+     */
+    get billingAdjustments(): RecordLinkManager<BillingAdjustmentRecord, typeof OrderRecord['billingAdjustmentsLabels'][number]>;
+    /** Valid labels for OrderKci associations */
+    static readonly orderKcisLabels: readonly ["Order__OrderKci"];
+    /**
+     * Access linked OrderKci records
+     * @remarks Available labels: Order__OrderKci
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked OrderKci records
+     * const items = await record.orderKcis.list();
+     * const first = await record.orderKcis.first();
+     *
+     * // Filter by label
+     * const specific = await record.orderKcis.first({ label: 'Order__OrderKci' });
+     * ```
+     */
+    get orderKcis(): RecordLinkManager<OrderKciRecord, typeof OrderRecord['orderKcisLabels'][number]>;
+    /** Valid labels for FieldServiceDispatchedProduct associations */
+    static readonly fieldServiceDispatchedProductsLabels: readonly ["FieldServiceDispatchedProduct__Order"];
+    /**
+     * Access linked FieldServiceDispatchedProduct records
+     * @remarks Available labels: FieldServiceDispatchedProduct__Order
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked FieldServiceDispatchedProduct records
+     * const items = await record.fieldServiceDispatchedProducts.list();
+     * const first = await record.fieldServiceDispatchedProducts.first();
+     *
+     * // Filter by label
+     * const specific = await record.fieldServiceDispatchedProducts.first({ label: 'FieldServiceDispatchedProduct__Order' });
+     * ```
+     */
+    get fieldServiceDispatchedProducts(): RecordLinkManager<FieldServiceDispatchedProductRecord, typeof OrderRecord['fieldServiceDispatchedProductsLabels'][number]>;
+    /** Valid labels for Account associations */
+    static readonly accountsLabels: readonly ["Account__Order"];
+    /**
+     * Access linked Account records
+     * @remarks Available labels: Account__Order
+     * @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__Order' });
+     * ```
+     */
+    get accounts(): RecordLinkManager<AccountRecord, typeof OrderRecord['accountsLabels'][number]>;
+    /** Valid labels for PICRequest associations */
+    static readonly picRequestsLabels: readonly ["PICRequest__Order"];
+    /**
+     * Access linked PICRequest records
+     * @remarks Available labels: PICRequest__Order
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked PICRequest records
+     * const items = await record.picRequests.list();
+     * const first = await record.picRequests.first();
+     *
+     * // Filter by label
+     * const specific = await record.picRequests.first({ label: 'PICRequest__Order' });
+     * ```
+     */
+    get picRequests(): RecordLinkManager<PICRequestRecord, typeof OrderRecord['picRequestsLabels'][number]>;
+    /** Valid labels for OrderItem associations */
+    static readonly orderItemsLabels: readonly ["Order_OrderItem"];
+    /**
+     * Access linked OrderItem records
+     * @remarks Available labels: Order_OrderItem
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked OrderItem records
+     * const items = await record.orderItems.list();
+     * const first = await record.orderItems.first();
+     *
+     * // Filter by label
+     * const specific = await record.orderItems.first({ label: 'Order_OrderItem' });
+     * ```
+     */
+    get orderItems(): RecordLinkManager<OrderItemRecord, typeof OrderRecord['orderItemsLabels'][number]>;
+    /** Valid labels for Note associations */
+    static readonly notesLabels: readonly ["Order__Note"];
+    /**
+     * Access linked Note records
+     * @remarks Available labels: Order__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: 'Order__Note' });
+     * ```
+     */
+    get notes(): RecordLinkManager<NoteRecord, typeof OrderRecord['notesLabels'][number]>;
+    /** Valid labels for SmsMessage associations */
+    static readonly smsMessagesLabels: readonly ["Order__SmsMessage"];
+    /**
+     * Access linked SmsMessage records
+     * @remarks Available labels: Order__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: 'Order__SmsMessage' });
+     * ```
+     */
+    get smsMessages(): RecordLinkManager<SmsMessageRecord, typeof OrderRecord['smsMessagesLabels'][number]>;
+    /** Valid labels for OneTouchSwitch associations */
+    static readonly oneTouchSwitchesLabels: readonly ["OneTouchSwitch__Order"];
+    /**
+     * Access linked OneTouchSwitch records
+     * @remarks Available labels: OneTouchSwitch__Order
+     * @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__Order' });
+     * ```
+     */
+    get oneTouchSwitches(): RecordLinkManager<OneTouchSwitchRecord, typeof OrderRecord['oneTouchSwitchesLabels'][number]>;
+    /** Valid labels for Lead associations */
+    static readonly leadsLabels: readonly ["Lead_Order"];
+    /**
+     * Access linked Lead records
+     * @remarks Available labels: Lead_Order
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Lead records
+     * const items = await record.leads.list();
+     * const first = await record.leads.first();
+     *
+     * // Filter by label
+     * const specific = await record.leads.first({ label: 'Lead_Order' });
+     * ```
+     */
+    get leads(): RecordLinkManager<LeadRecord, typeof OrderRecord['leadsLabels'][number]>;
+    /** Valid labels for CustomerDeviceOnt associations */
+    static readonly customerDeviceOntsLabels: readonly ["Order__CustomerDeviceOnt"];
+    /**
+     * Access linked CustomerDeviceOnt records
+     * @remarks Available labels: Order__CustomerDeviceOnt
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked CustomerDeviceOnt records
+     * const items = await record.customerDeviceOnts.list();
+     * const first = await record.customerDeviceOnts.first();
+     *
+     * // Filter by label
+     * const specific = await record.customerDeviceOnts.first({ label: 'Order__CustomerDeviceOnt' });
+     * ```
+     */
+    get customerDeviceOnts(): RecordLinkManager<CustomerDeviceOntRecord, typeof OrderRecord['customerDeviceOntsLabels'][number]>;
+    /** Valid labels for ContactIdentity associations */
+    static readonly contactIdentitiesLabels: readonly ["Order__ContactIdentity"];
+    /**
+     * Access linked ContactIdentity records
+     * @remarks Available labels: Order__ContactIdentity
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked ContactIdentity records
+     * const items = await record.contactIdentities.list();
+     * const first = await record.contactIdentities.first();
+     *
+     * // Filter by label
+     * const specific = await record.contactIdentities.first({ label: 'Order__ContactIdentity' });
+     * ```
+     */
+    get contactIdentities(): RecordLinkManager<ContactIdentityRecord, typeof OrderRecord['contactIdentitiesLabels'][number]>;
+    /** Valid labels for CustomerDeviceRouter associations */
+    static readonly customerDeviceRoutersLabels: readonly ["Order__CustomerDeviceRouter"];
+    /**
+     * Access linked CustomerDeviceRouter records
+     * @remarks Available labels: Order__CustomerDeviceRouter
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked CustomerDeviceRouter records
+     * const items = await record.customerDeviceRouters.list();
+     * const first = await record.customerDeviceRouters.first();
+     *
+     * // Filter by label
+     * const specific = await record.customerDeviceRouters.first({ label: 'Order__CustomerDeviceRouter' });
+     * ```
+     */
+    get customerDeviceRouters(): RecordLinkManager<CustomerDeviceRouterRecord, typeof OrderRecord['customerDeviceRoutersLabels'][number]>;
+    /** Valid labels for WorkOrder associations */
+    static readonly workOrdersLabels: readonly ["Order__WorkOrder"];
+    /**
+     * Access linked WorkOrder records
+     * @remarks Available labels: Order__WorkOrder
+     * @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: 'Order__WorkOrder' });
+     * ```
+     */
+    get workOrders(): RecordLinkManager<WorkOrderRecord, typeof OrderRecord['workOrdersLabels'][number]>;
+    /** Valid labels for Visit associations */
+    static readonly visitsLabels: readonly ["Order__Visit"];
+    /**
+     * Access linked Visit records
+     * @remarks Available labels: Order__Visit
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Visit records
+     * const items = await record.visits.list();
+     * const first = await record.visits.first();
+     *
+     * // Filter by label
+     * const specific = await record.visits.first({ label: 'Order__Visit' });
+     * ```
+     */
+    get visits(): RecordLinkManager<VisitRecord, typeof OrderRecord['visitsLabels'][number]>;
+    /** Valid labels for Discount associations */
+    static readonly discountsLabels: readonly ["Order__Discount"];
+    /**
+     * Access linked Discount records
+     * @remarks Available labels: Order__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: 'Order__Discount' });
+     * ```
+     */
+    get discounts(): RecordLinkManager<DiscountRecord, typeof OrderRecord['discountsLabels'][number]>;
+    /** Valid labels for File associations */
+    static readonly filesLabels: readonly ["Order__File"];
+    /**
+     * Access linked File records
+     * @remarks Available labels: Order__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: 'Order__File' });
+     * ```
+     */
+    get files(): RecordLinkManager<FileRecord, typeof OrderRecord['filesLabels'][number]>;
+    /** Valid labels for Case associations */
+    static readonly casesLabels: readonly ["Case__Order"];
+    /**
+     * Access linked Case records
+     * @remarks Available labels: Case__Order
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Case records
+     * const items = await record.cases.list();
+     * const first = await record.cases.first();
+     *
+     * // Filter by label
+     * const specific = await record.cases.first({ label: 'Case__Order' });
+     * ```
+     */
+    get cases(): RecordLinkManager<CaseRecord, typeof OrderRecord['casesLabels'][number]>;
+    /** Valid labels for ContractBuyOut associations */
+    static readonly contractBuyOutsLabels: readonly ["Order__ContractBuyOut"];
+    /**
+     * Access linked ContractBuyOut records
+     * @remarks Available labels: Order__ContractBuyOut
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked ContractBuyOut records
+     * const items = await record.contractBuyOuts.list();
+     * const first = await record.contractBuyOuts.first();
+     *
+     * // Filter by label
+     * const specific = await record.contractBuyOuts.first({ label: 'Order__ContractBuyOut' });
+     * ```
+     */
+    get contractBuyOuts(): RecordLinkManager<ContractBuyOutRecord, typeof OrderRecord['contractBuyOutsLabels'][number]>;
+    /** Valid labels for Contact associations */
+    static readonly contactsLabels: readonly ["Order__Contact"];
+    /**
+     * Access linked Contact records
+     * @remarks Available labels: Order__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: 'Order__Contact' });
+     * ```
+     */
+    get contacts(): RecordLinkManager<ContactRecord, typeof OrderRecord['contactsLabels'][number]>;
+    /** Valid labels for Order associations */
+    static readonly ordersLabels: readonly ["Order__Order"];
+    /**
+     * Access linked Order records
+     * @remarks Available labels: Order__Order
+     * @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__Order' });
+     * ```
+     */
+    get orders(): RecordLinkManager<OrderRecord, typeof OrderRecord['ordersLabels'][number]>;
+    /** Valid labels for OrderCheck associations */
+    static readonly orderChecksLabels: readonly ["Order__OrderCheck"];
+    /**
+     * Access linked OrderCheck records
+     * @remarks Available labels: Order__OrderCheck
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked OrderCheck records
+     * const items = await record.orderChecks.list();
+     * const first = await record.orderChecks.first();
+     *
+     * // Filter by label
+     * const specific = await record.orderChecks.first({ label: 'Order__OrderCheck' });
+     * ```
+     */
+    get orderChecks(): RecordLinkManager<OrderCheckRecord, typeof OrderRecord['orderChecksLabels'][number]>;
+    /** Valid labels for ChurnRequest associations */
+    static readonly churnRequestsLabels: readonly ["ChurnRequest__Order"];
+    /**
+     * Access linked ChurnRequest records
+     * @remarks Available labels: ChurnRequest__Order
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked ChurnRequest records
+     * const items = await record.churnRequests.list();
+     * const first = await record.churnRequests.first();
+     *
+     * // Filter by label
+     * const specific = await record.churnRequests.first({ label: 'ChurnRequest__Order' });
+     * ```
+     */
+    get churnRequests(): RecordLinkManager<ChurnRequestRecord, typeof OrderRecord['churnRequestsLabels'][number]>;
+    /** Valid labels for PaymentMethodRefund associations */
+    static readonly paymentMethodRefundsLabels: readonly ["PaymentMethodRefund__Order"];
+    /**
+     * Access linked PaymentMethodRefund records
+     * @remarks Available labels: PaymentMethodRefund__Order
+     * @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__Order' });
+     * ```
+     */
+    get paymentMethodRefunds(): RecordLinkManager<PaymentMethodRefundRecord, typeof OrderRecord['paymentMethodRefundsLabels'][number]>;
+    /** Valid labels for Appointment associations */
+    static readonly appointmentsLabels: readonly ["Order__Appointment"];
+    /**
+     * Access linked Appointment records
+     * @remarks Available labels: Order__Appointment
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Appointment records
+     * const items = await record.appointments.list();
+     * const first = await record.appointments.first();
+     *
+     * // Filter by label
+     * const specific = await record.appointments.first({ label: 'Order__Appointment' });
+     * ```
+     */
+    get appointments(): RecordLinkManager<AppointmentRecord, typeof OrderRecord['appointmentsLabels'][number]>;
+    /** Valid labels for Activity associations */
+    static readonly activitiesLabels: readonly ["Order__Activity"];
+    /**
+     * Access linked Activity records
+     * @remarks Available labels: Order__Activity
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Activity records
+     * const items = await record.activities.list();
+     * const first = await record.activities.first();
+     *
+     * // Filter by label
+     * const specific = await record.activities.first({ label: 'Order__Activity' });
+     * ```
+     */
+    get activities(): RecordLinkManager<ActivityRecord, typeof OrderRecord['activitiesLabels'][number]>;
+    /** Valid labels for Referral associations */
+    static readonly referralsLabels: readonly ["OrderReferral"];
+    /**
+     * Access linked Referral records
+     * @remarks Available labels: OrderReferral
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Referral records
+     * const items = await record.referrals.list();
+     * const first = await record.referrals.first();
+     *
+     * // Filter by label
+     * const specific = await record.referrals.first({ label: 'OrderReferral' });
+     * ```
+     */
+    get referrals(): RecordLinkManager<ReferralRecord, typeof OrderRecord['referralsLabels'][number]>;
+    /** Valid labels for PushNotification associations */
+    static readonly pushNotificationsLabels: readonly ["Order__PushNotification"];
+    /**
+     * Access linked PushNotification records
+     * @remarks Available labels: Order__PushNotification
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked PushNotification records
+     * const items = await record.pushNotifications.list();
+     * const first = await record.pushNotifications.first();
+     *
+     * // Filter by label
+     * const specific = await record.pushNotifications.first({ label: 'Order__PushNotification' });
+     * ```
+     */
+    get pushNotifications(): RecordLinkManager<PushNotificationRecord, typeof OrderRecord['pushNotificationsLabels'][number]>;
+    /**
+     * Queue a link to be created with the next action.
+     * Works for both create and update actions.
+     * @returns this (for chaining)
+     */
+    link(target: OdinRecord<any> | {
+        id: string;
+        entity: string;
+    }): this;
+    /** Get the currently queued links */
+    get pendingLinks(): OdinRecordLinkDto[];
+    /** Clear pending links without executing an action */
+    clearPendingLinks(): this;
+    /**
+     * Immediately unlink a record (API call).
+     * Unlike link(), this executes immediately.
+     * @throws Error if called on a new (unsaved) record
+     */
+    unlink(target: OdinRecord<any> | {
+        id: string;
+    } | string): Promise<void>;
+    /**
+     * CreateRecontractOrder
+     *
+     * Creates a new Order record with the specified properties.
+     * Returns an ActionBuilder - call .execute() to create or .dryRun() for debugging.
+     *
+     * @param properties - The properties for the new record
+     * @param options - Optional settings
+     * @param options.type - Override the record type
+     * @param options.journeyId - Associate with a journey
+     * @param options.stageKey - Set initial pipeline stage
+     * @returns ActionBuilder - call .execute() to create or .dryRun() for payload
+     *
+     * @example
+     * ```typescript
+     * // Create with properties
+     * const record = odinClient.orders.new();
+     * await record.createRecontractOrder({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.createRecontractOrder({ ... }).dryRun();
+     * ```
+     */
+    createRecontractOrder(properties: CreateRecontractOrderProperties, options?: {
+        type?: string;
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * ActivateOrder
+     *
+     * Updates this Order record with the specified properties.
+     * Returns an ActionBuilder - call .execute() to update or .dryRun() for debugging.
+     *
+     * @param properties - Required properties for this action
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @param options.stageKey - Transition to pipeline stage
+     * @returns ActionBuilder - call .execute() to update or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.activateOrder({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.activateOrder({ ... }).dryRun();
+     * ```
+     */
+    activateOrder(properties: ActivateOrderProperties, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * ActivateRecontractOrder
+     *
+     * Transitions this Order record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: OrderStageActive
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns ActionBuilder - call .execute() to transition or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.activateRecontractOrder().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.activateRecontractOrder().dryRun();
+     * ```
+     */
+    activateRecontractOrder(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * CancelActiveOrder
+     *
+     * Starts a stage transition flow on this Order record.
+     * Chain step methods and call .execute() to run the flow.
+     *
+     * @remarks Transitions to stage: OrderStageCancelled
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns FlowBuilder for chaining step methods
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.cancelActiveOrder()
+     *   .createChurnRequest({ ... })
+     *   .execute();
+     * ```
+     */
+    cancelActiveOrder(options?: {
+        journeyId?: string;
+    }): CancelActiveOrderFlowBuilder;
+    /**
+     * CancelOrderForRecontract
+     *
+     * Transitions this Order record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: OrderStageCancelled
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns ActionBuilder - call .execute() to transition or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.cancelOrderForRecontract().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.cancelOrderForRecontract().dryRun();
+     * ```
+     */
+    cancelOrderForRecontract(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * CancelOrderForRollback
+     *
+     * Transitions this Order record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: OrderStageCancelled
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns ActionBuilder - call .execute() to transition or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.cancelOrderForRollback().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.cancelOrderForRollback().dryRun();
+     * ```
+     */
+    cancelOrderForRollback(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * CancelOrderPreInstall
+     *
+     * Starts a stage transition flow on this Order record.
+     * Chain step methods and call .execute() to run the flow.
+     *
+     * @remarks Transitions to stage: OrderStageCancelled
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns FlowBuilder for chaining step methods
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.cancelOrderPreInstall()
+     *   .createPicRequest({ ... })
+     *   .execute();
+     * ```
+     */
+    cancelOrderPreInstall(options?: {
+        journeyId?: string;
+    }): CancelOrderPreInstallFlowBuilder;
+    /**
+     * ChangeBillingDay
+     *
+     * Updates this Order record with the specified properties.
+     * Returns an ActionBuilder - call .execute() to update or .dryRun() for debugging.
+     *
+     * @param properties - Required properties for this action
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @param options.stageKey - Transition to pipeline stage
+     * @returns ActionBuilder - call .execute() to update or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.changeBillingDay({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.changeBillingDay({ ... }).dryRun();
+     * ```
+     */
+    changeBillingDay(properties: ChangeBillingDayProperties, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * ClearOrderDeactivateOnDate
+     *
+     * Updates this Order record.
+     * Returns an ActionBuilder - call .execute() to update or .dryRun() for debugging.
+     *
+     * @param propertiesOrOptions - Properties to update, or options object
+     * @param options - Optional settings (journeyId, stageKey)
+     * @returns ActionBuilder - call .execute() to update or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.clearOrderDeactivateOnDate({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.clearOrderDeactivateOnDate({ ... }).dryRun();
+     * ```
+     */
+    clearOrderDeactivateOnDate(propertiesOrOptions?: ClearOrderDeactivateOnDateProperties | {
+        journeyId?: string;
+        stageKey?: string;
+    }, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * CreateCollectionAmcoWorkOrderFromOrder
+     *
+     * Starts a multi-step flow action on this Order record.
+     * Chain step methods and call .execute() to run the flow.
+     * Individual steps determine their own ID requirements (CREATE vs UPDATE).
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns FlowBuilder for chaining step methods
+     *
+     * @example
+     * ```typescript
+     * // Can be called on new() or get() - steps determine ID requirements
+     * const record = odinClient.orders.new();
+     * await record.createCollectionAmcoWorkOrderFromOrder()
+     *   .createCollectionAmcoWorkOrder({ ... })
+     *   .execute();
+     * ```
+     */
+    createCollectionAmcoWorkOrderFromOrder(options?: {
+        journeyId?: string;
+    }): CreateCollectionAmcoWorkOrderFromOrderFlowBuilder;
+    /**
+     * CreateCollectionWorkOrderFromOrder
+     *
+     * Starts a multi-step flow action on this Order record.
+     * Chain step methods and call .execute() to run the flow.
+     * Individual steps determine their own ID requirements (CREATE vs UPDATE).
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns FlowBuilder for chaining step methods
+     *
+     * @example
+     * ```typescript
+     * // Can be called on new() or get() - steps determine ID requirements
+     * const record = odinClient.orders.new();
+     * await record.createCollectionWorkOrderFromOrder()
+     *   .createCollectionWorkOrder({ ... })
+     *   .execute();
+     * ```
+     */
+    createCollectionWorkOrderFromOrder(options?: {
+        journeyId?: string;
+    }): CreateCollectionWorkOrderFromOrderFlowBuilder;
+    /**
+     * CreateDispatchAmcoWorkOrderFromOrder
+     *
+     * Starts a multi-step flow action on this Order record.
+     * Chain step methods and call .execute() to run the flow.
+     * Individual steps determine their own ID requirements (CREATE vs UPDATE).
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns FlowBuilder for chaining step methods
+     *
+     * @example
+     * ```typescript
+     * // Can be called on new() or get() - steps determine ID requirements
+     * const record = odinClient.orders.new();
+     * await record.createDispatchAmcoWorkOrderFromOrder()
+     *   .createDispatchAmcoWorkOrder({ ... })
+     *   .execute();
+     * ```
+     */
+    createDispatchAmcoWorkOrderFromOrder(options?: {
+        journeyId?: string;
+    }): CreateDispatchAmcoWorkOrderFromOrderFlowBuilder;
+    /**
+     * DeactivateOrderDunning
+     *
+     * Transitions this Order record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: OrderStageDeactivated
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns ActionBuilder - call .execute() to transition or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.deactivateOrderDunning().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.deactivateOrderDunning().dryRun();
+     * ```
+     */
+    deactivateOrderDunning(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * ManageCommision
+     *
+     * Updates this Order record with the specified properties.
+     * Returns an ActionBuilder - call .execute() to update or .dryRun() for debugging.
+     *
+     * @param properties - Required properties for this action
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @param options.stageKey - Transition to pipeline stage
+     * @returns ActionBuilder - call .execute() to update or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.manageCommision({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.manageCommision({ ... }).dryRun();
+     * ```
+     */
+    manageCommision(properties: ManageCommisionProperties, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * MoveOrderFromAcceptedToScheduled
+     *
+     * Transitions this Order record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: OrderStageSupply
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns ActionBuilder - call .execute() to transition or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.moveOrderFromAcceptedToScheduled().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveOrderFromAcceptedToScheduled().dryRun();
+     * ```
+     */
+    moveOrderFromAcceptedToScheduled(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * MoveOrderFromActiveToPendingCancellation
+     *
+     * Transitions this Order record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: OrderStagePendingCancellation
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns ActionBuilder - call .execute() to transition or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.moveOrderFromActiveToPendingCancellation().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveOrderFromActiveToPendingCancellation().dryRun();
+     * ```
+     */
+    moveOrderFromActiveToPendingCancellation(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * MoveOrderFromCancelledToActive
+     *
+     * Transitions this Order record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: OrderStageActive
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns ActionBuilder - call .execute() to transition or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.moveOrderFromCancelledToActive().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveOrderFromCancelledToActive().dryRun();
+     * ```
+     */
+    moveOrderFromCancelledToActive(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * MoveOrderFromDeactivatedToActive
+     *
+     * Transitions this Order record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: OrderStageActive
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns ActionBuilder - call .execute() to transition or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.moveOrderFromDeactivatedToActive().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveOrderFromDeactivatedToActive().dryRun();
+     * ```
+     */
+    moveOrderFromDeactivatedToActive(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * MoveOrderFromDeactivatedToCancelled
+     *
+     * Starts a stage transition flow on this Order record.
+     * Chain step methods and call .execute() to run the flow.
+     *
+     * @remarks Transitions to stage: OrderStageCancelled
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns FlowBuilder for chaining step methods
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.moveOrderFromDeactivatedToCancelled()
+     *   .createChurnRequest({ ... })
+     *   .execute();
+     * ```
+     */
+    moveOrderFromDeactivatedToCancelled(options?: {
+        journeyId?: string;
+    }): MoveOrderFromDeactivatedToCancelledFlowBuilder;
+    /**
+     * MoveOrderFromDraftToAnyStage
+     *
+     * Transitions this Order record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: OrderStageSupply
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns ActionBuilder - call .execute() to transition or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.moveOrderFromDraftToAnyStage().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveOrderFromDraftToAnyStage().dryRun();
+     * ```
+     */
+    moveOrderFromDraftToAnyStage(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * MoveOrderFromPendingCancellationToActive
+     *
+     * Transitions this Order record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: OrderStageActive
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns ActionBuilder - call .execute() to transition or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.moveOrderFromPendingCancellationToActive().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveOrderFromPendingCancellationToActive().dryRun();
+     * ```
+     */
+    moveOrderFromPendingCancellationToActive(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * MoveOrderFromPendingCancellationToCancelled
+     *
+     * Starts a stage transition flow on this Order record.
+     * Chain step methods and call .execute() to run the flow.
+     *
+     * @remarks Transitions to stage: OrderStageCancelled
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns FlowBuilder for chaining step methods
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.moveOrderFromPendingCancellationToCancelled()
+     *   .createChurnRequest({ ... })
+     *   .execute();
+     * ```
+     */
+    moveOrderFromPendingCancellationToCancelled(options?: {
+        journeyId?: string;
+    }): MoveOrderFromPendingCancellationToCancelledFlowBuilder;
+    /**
+     * MoveOrderFromPreOrderToCancelled
+     *
+     * Transitions this Order record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: OrderStageCancelled
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns ActionBuilder - call .execute() to transition or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.moveOrderFromPreOrderToCancelled().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveOrderFromPreOrderToCancelled().dryRun();
+     * ```
+     */
+    moveOrderFromPreOrderToCancelled(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * MoveOrderFromSupplyToCancelled
+     *
+     * Transitions this Order record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: OrderStageCancelled
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns ActionBuilder - call .execute() to transition or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.moveOrderFromSupplyToCancelled().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveOrderFromSupplyToCancelled().dryRun();
+     * ```
+     */
+    moveOrderFromSupplyToCancelled(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * MoveOrderToActive
+     *
+     * Starts a stage transition flow on this Order record.
+     * Chain step methods and call .execute() to run the flow.
+     *
+     * @remarks Transitions to stage: OrderStageActive
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns FlowBuilder for chaining step methods
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.moveOrderToActive()
+     *   .activateOrder(recordId, { ... })
+     *   .execute();
+     * ```
+     */
+    moveOrderToActive(options?: {
+        journeyId?: string;
+    }): MoveOrderToActiveFlowBuilder;
+    /**
+     * MoveOrderToDeactivatedFromActive
+     *
+     * Transitions this Order record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: OrderStageDeactivated
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns ActionBuilder - call .execute() to transition or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.moveOrderToDeactivatedFromActive().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveOrderToDeactivatedFromActive().dryRun();
+     * ```
+     */
+    moveOrderToDeactivatedFromActive(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * OderUpdate
+     *
+     * Updates this Order record.
+     * Returns an ActionBuilder - call .execute() to update or .dryRun() for debugging.
+     *
+     * @param propertiesOrOptions - Properties to update, or options object
+     * @param options - Optional settings (journeyId, stageKey)
+     * @returns ActionBuilder - call .execute() to update or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.oderUpdate({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.oderUpdate({ ... }).dryRun();
+     * ```
+     */
+    oderUpdate(propertiesOrOptions?: OderUpdateProperties | {
+        journeyId?: string;
+        stageKey?: string;
+    }, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * ReactivateOrderAfterRollback
+     *
+     * Transitions this Order record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: OrderStageActive
+     *
+     * @param options - Optional settings
+     * @param options.journeyId - Associate with a journey
+     * @returns ActionBuilder - call .execute() to transition or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.reactivateOrderAfterRollback().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.reactivateOrderAfterRollback().dryRun();
+     * ```
+     */
+    reactivateOrderAfterRollback(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * SetOrderCancelOnDate
+     *
+     * Updates this Order record.
+     * Returns an ActionBuilder - call .execute() to update or .dryRun() for debugging.
+     *
+     * @param propertiesOrOptions - Properties to update, or options object
+     * @param options - Optional settings (journeyId, stageKey)
+     * @returns ActionBuilder - call .execute() to update or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.setOrderCancelOnDate({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.setOrderCancelOnDate({ ... }).dryRun();
+     * ```
+     */
+    setOrderCancelOnDate(propertiesOrOptions?: SetOrderCancelOnDateProperties | {
+        journeyId?: string;
+        stageKey?: string;
+    }, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * SetOrderDeactivateOnDate
+     *
+     * Updates this Order record.
+     * Returns an ActionBuilder - call .execute() to update or .dryRun() for debugging.
+     *
+     * @param propertiesOrOptions - Properties to update, or options object
+     * @param options - Optional settings (journeyId, stageKey)
+     * @returns ActionBuilder - call .execute() to update or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.setOrderDeactivateOnDate({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.setOrderDeactivateOnDate({ ... }).dryRun();
+     * ```
+     */
+    setOrderDeactivateOnDate(propertiesOrOptions?: SetOrderDeactivateOnDateProperties | {
+        journeyId?: string;
+        stageKey?: string;
+    }, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * SetPendingAmcoWorkOrder
+     *
+     * Updates this Order record.
+     * Returns an ActionBuilder - call .execute() to update or .dryRun() for debugging.
+     *
+     * @param propertiesOrOptions - Properties to update, or options object
+     * @param options - Optional settings (journeyId, stageKey)
+     * @returns ActionBuilder - call .execute() to update or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.setPendingAmcoWorkOrder({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.setPendingAmcoWorkOrder({ ... }).dryRun();
+     * ```
+     */
+    setPendingAmcoWorkOrder(propertiesOrOptions?: SetPendingAmcoWorkOrderProperties | {
+        journeyId?: string;
+        stageKey?: string;
+    }, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * UpdateOrder
+     *
+     * Updates this Order record.
+     * Returns an ActionBuilder - call .execute() to update or .dryRun() for debugging.
+     *
+     * @param propertiesOrOptions - Properties to update, or options object
+     * @param options - Optional settings (journeyId, stageKey)
+     * @returns ActionBuilder - call .execute() to update or .dryRun() for payload
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * const record = await odinClient.orders.get(id);
+     * await record.updateOrder({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.updateOrder({ ... }).dryRun();
+     * ```
+     */
+    updateOrder(propertiesOrOptions?: UpdateOrderProperties | {
+        journeyId?: string;
+        stageKey?: string;
+    }, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+}
+/** Type guard to check if an object is a OrderRecord */
+export declare function isOrderRecord(obj: any): obj is OrderRecord;
+export {};