@d19n/youfibre-odin-sdk 2.0.14 → 2.0.16

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

@@ -0,0 +1,1973 @@
+/**
+ * Case 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.cases.new();
+ * await record.createCase({ ... }).execute();
+ * ```
+ *
+ * Entity Types: DEFAULT, OUTAGE
+ *
+ * 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 { CaseProperties, OutageCaseProperties } from '../entities-v2/Case';
+import { AllowCsatForCaseProperties } from '../actions-v2/AllowCsatForCaseDto';
+import { AssignCaseByUserProperties } from '../actions-v2/AssignCaseByUserDto';
+import { AssignCaseProperties } from '../actions-v2/AssignCaseDto';
+import { CreateNoteForCaseAssignmentProperties } from '../actions-v2/AssignCaseWithNoteFlowDto';
+import { MoveCaseToBlockedActionProperties } from '../actions-v2/CasedefaultstageblockedDto';
+import { EscalateCaseActionProperties } from '../actions-v2/CaseDefaultStageEscalatedDto';
+import { ChangeCaseChannelProperties } from '../actions-v2/ChangeCaseChannelDto';
+import { CreateCaseProperties } from '../actions-v2/CreateCaseDto';
+import { CreateCaseFromCasesProperties } from '../actions-v2/CreateCaseFromCasesDto';
+import { CreateCaseWithDpaProperties } from '../actions-v2/CreateCaseWithDpaDto';
+import { EditCaseFormProperties } from '../actions-v2/EditCaseFormDto';
+import { ExceptionInputProperties } from '../actions-v2/ExceptionInputDto';
+import { MarkCaseClosedProperties } from '../actions-v2/MarkCaseClosedDto';
+import { MarkCaseResolvedProperties } from '../actions-v2/MarkCaseResolvedDto';
+import { MoveCaseOutageToSolvedAction2Properties } from '../actions-v2/MoveCaseOutageToSolvedAction2Dto';
+import { MoveCaseOutageToSolvedActionProperties } from '../actions-v2/MoveCaseOutageToSolvedActionDto';
+import { MoveCaseToPendingReviewActionProperties } from '../actions-v2/MoveCaseToPendingReviewActionDto';
+import { MoveCaseToSolvedActionProperties } from '../actions-v2/MoveCaseToSolvedActionDto';
+import { RemoveAssignmentFromCaseProperties } from '../actions-v2/RemoveAssignmentFromCaseDto';
+import { UpdateFormalComplaintProperties } from '../actions-v2/UpdateFormalComplaintDto';
+import { UpdateSentimentProperties } from '../actions-v2/UpdateSentimentDto';
+import { UpdateTagsProperties } from '../actions-v2/UpdateTagsDto';
+import { ActivityLogRecord } from './ActivityLogRecord';
+import { UserRecord } from './UserRecord';
+import { OutageRecord } from './OutageRecord';
+import { SmsMessageRecord } from './SmsMessageRecord';
+import { EmailRecord } from './EmailRecord';
+import { CallRecord } from './CallRecord';
+import { ContractBuyOutRecord } from './ContractBuyOutRecord';
+import { TeamRecord } from './TeamRecord';
+import { NoteRecord } from './NoteRecord';
+import { AccountRecord } from './AccountRecord';
+import { WorkOrderRecord } from './WorkOrderRecord';
+import { ConversationRecord } from './ConversationRecord';
+import { FileRecord } from './FileRecord';
+import { OrderRecord } from './OrderRecord';
+import { ContactRecord } from './ContactRecord';
+import { AddressRecord } from './AddressRecord';
+import { PushNotificationRecord } from './PushNotificationRecord';
+/** Valid entity types for Case */
+export declare type CaseType = 'DEFAULT' | 'OUTAGE';
+/**
+ * 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 AssignCaseWithNoteFlowFlowBuilderStepOptions {
+    /** Associations to create with this step */
+    associations?: Array<{
+        recordId?: string;
+        entity?: string;
+    }>;
+    /** Groups for this step */
+    groups?: string[];
+}
+/**
+ * FlowBuilder for AssignCaseWithNoteFlow multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ */
+export declare class AssignCaseWithNoteFlowFlowBuilder {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _options?;
+    private _groups;
+    private _steps;
+    constructor(record: CaseRecord<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 AssignCase 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)
+     */
+    assignCase(id: string, properties: AssignCaseProperties, options?: AssignCaseWithNoteFlowFlowBuilderStepOptions): this;
+    /**
+     * Add CreateNoteForCaseAssignment step to the flow
+     * @param properties - Properties for this step
+     * @param options - Optional step settings
+     * @returns this (for method chaining)
+     */
+    createNoteForCaseAssignment(properties: CreateNoteForCaseAssignmentProperties, options?: AssignCaseWithNoteFlowFlowBuilderStepOptions): 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 CasedefaultstageblockedFlowBuilderStepOptions {
+    /** Associations to create with this step */
+    associations?: Array<{
+        recordId?: string;
+        entity?: string;
+    }>;
+    /** Groups for this step */
+    groups?: string[];
+}
+/**
+ * FlowBuilder for Casedefaultstageblocked multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * Transitions to stage: CaseDefaultStageBlocked
+ */
+export declare class CasedefaultstageblockedFlowBuilder {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _options?;
+    private _groups;
+    private _steps;
+    constructor(record: CaseRecord<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 MoveCaseToBlockedAction 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)
+     */
+    moveCaseToBlockedAction(id: string, properties: MoveCaseToBlockedActionProperties, options?: CasedefaultstageblockedFlowBuilderStepOptions): 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 CaseDefaultStageEscalatedFlowBuilderStepOptions {
+    /** Associations to create with this step */
+    associations?: Array<{
+        recordId?: string;
+        entity?: string;
+    }>;
+    /** Groups for this step */
+    groups?: string[];
+}
+/**
+ * FlowBuilder for CaseDefaultStageEscalated multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * Transitions to stage: CaseDefaultStageEscalated
+ */
+export declare class CaseDefaultStageEscalatedFlowBuilder {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _options?;
+    private _groups;
+    private _steps;
+    constructor(record: CaseRecord<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 EscalateCaseAction 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)
+     */
+    escalateCaseAction(id: string, properties: EscalateCaseActionProperties, options?: CaseDefaultStageEscalatedFlowBuilderStepOptions): this;
+    /**
+     * Add CreateNoteForCaseAssignment step to the flow
+     * @param properties - Properties for this step
+     * @param options - Optional step settings
+     * @returns this (for method chaining)
+     */
+    createNoteForCaseAssignment(properties: CreateNoteForCaseAssignmentProperties, options?: CaseDefaultStageEscalatedFlowBuilderStepOptions): 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 CaseDefaultStageSolvedFlowBuilderStepOptions {
+    /** Associations to create with this step */
+    associations?: Array<{
+        recordId?: string;
+        entity?: string;
+    }>;
+    /** Groups for this step */
+    groups?: string[];
+}
+/**
+ * FlowBuilder for CaseDefaultStageSolved multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * Transitions to stage: CaseDefaultStageSolved
+ */
+export declare class CaseDefaultStageSolvedFlowBuilder {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _options?;
+    private _groups;
+    private _steps;
+    constructor(record: CaseRecord<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 AllowCsatForCase 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)
+     */
+    allowCsatForCase(id: string, properties: AllowCsatForCaseProperties, options?: CaseDefaultStageSolvedFlowBuilderStepOptions): 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 EscalateCaseTransitionFlowBuilderStepOptions {
+    /** Associations to create with this step */
+    associations?: Array<{
+        recordId?: string;
+        entity?: string;
+    }>;
+    /** Groups for this step */
+    groups?: string[];
+}
+/**
+ * FlowBuilder for EscalateCaseTransition multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * Transitions to stage: CaseDefaultStageEscalated
+ */
+export declare class EscalateCaseTransitionFlowBuilder {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _options?;
+    private _groups;
+    private _steps;
+    constructor(record: CaseRecord<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 EscalateCaseAction 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)
+     */
+    escalateCaseAction(id: string, properties: EscalateCaseActionProperties, options?: EscalateCaseTransitionFlowBuilderStepOptions): this;
+    /**
+     * Add CreateNoteForCaseAssignment step to the flow
+     * @param properties - Properties for this step
+     * @param options - Optional step settings
+     * @returns this (for method chaining)
+     */
+    createNoteForCaseAssignment(properties: CreateNoteForCaseAssignmentProperties, options?: EscalateCaseTransitionFlowBuilderStepOptions): 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 MoveCaseToBlockedTransitionFlowBuilderStepOptions {
+    /** Associations to create with this step */
+    associations?: Array<{
+        recordId?: string;
+        entity?: string;
+    }>;
+    /** Groups for this step */
+    groups?: string[];
+}
+/**
+ * FlowBuilder for MoveCaseToBlockedTransition multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * Transitions to stage: CaseDefaultStageBlocked
+ */
+export declare class MoveCaseToBlockedTransitionFlowBuilder {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _options?;
+    private _groups;
+    private _steps;
+    constructor(record: CaseRecord<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 MoveCaseToBlockedAction 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)
+     */
+    moveCaseToBlockedAction(id: string, properties: MoveCaseToBlockedActionProperties, options?: MoveCaseToBlockedTransitionFlowBuilderStepOptions): 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 MoveCaseToPendingReviewTransitionFlowBuilderStepOptions {
+    /** Associations to create with this step */
+    associations?: Array<{
+        recordId?: string;
+        entity?: string;
+    }>;
+    /** Groups for this step */
+    groups?: string[];
+}
+/**
+ * FlowBuilder for MoveCaseToPendingReviewTransition multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * Transitions to stage: CaseDefaultStagePendingReview
+ */
+export declare class MoveCaseToPendingReviewTransitionFlowBuilder {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _options?;
+    private _groups;
+    private _steps;
+    constructor(record: CaseRecord<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 MoveCaseToPendingReviewAction 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)
+     */
+    moveCaseToPendingReviewAction(id: string, properties: MoveCaseToPendingReviewActionProperties, options?: MoveCaseToPendingReviewTransitionFlowBuilderStepOptions): 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 MoveDefaultCaseFromOpenToClosedFlowBuilderStepOptions {
+    /** Associations to create with this step */
+    associations?: Array<{
+        recordId?: string;
+        entity?: string;
+    }>;
+    /** Groups for this step */
+    groups?: string[];
+}
+/**
+ * FlowBuilder for MoveDefaultCaseFromOpenToClosed multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * Transitions to stage: CaseDefaultStageClosed
+ */
+export declare class MoveDefaultCaseFromOpenToClosedFlowBuilder {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _options?;
+    private _groups;
+    private _steps;
+    constructor(record: CaseRecord<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 MarkCaseClosed 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)
+     */
+    markCaseClosed(id: string, properties: MarkCaseClosedProperties, options?: MoveDefaultCaseFromOpenToClosedFlowBuilderStepOptions): 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 CaseRecord<TProps = CaseProperties> {
+    private _record;
+    private _provider;
+    private _pendingLinks;
+    private _preGeneratedId;
+    private _activityLogs?;
+    private _users?;
+    private _outages?;
+    private _smsMessages?;
+    private _emails?;
+    private _calls?;
+    private _contractBuyOuts?;
+    private _teams?;
+    private _notes?;
+    private _accounts?;
+    private _workOrders?;
+    private _conversations?;
+    private _cases?;
+    private _files?;
+    private _orders?;
+    private _contacts?;
+    private _addresses?;
+    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(): CaseType | 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;
+    /**
+     * 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 CaseProperties
+     *   console.log(record.properties.SomeTypeSpecificField);
+     * }
+     * ```
+     * @remarks This is the default record type
+     */
+    isDefault(): this is CaseRecord<CaseProperties>;
+    /**
+     * Type guard: check if this record is of type OUTAGE
+     *
+     * When this returns true, TypeScript automatically narrows the type,
+     * giving you access to OUTAGE-specific properties.
+     *
+     * @example
+     * ```typescript
+     * if (record.isOutage()) {
+     *   // TypeScript knows record.properties is OutageCaseProperties
+     *   console.log(record.properties.SomeTypeSpecificField);
+     * }
+     * ```
+     * @remarks Outage
+     */
+    isOutage(): this is CaseRecord<OutageCaseProperties>;
+    /** Valid labels for ActivityLog associations */
+    static readonly activityLogsLabels: readonly ["Case__ActivityLog"];
+    /**
+     * Access linked ActivityLog records
+     * @remarks Available labels: Case__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: 'Case__ActivityLog' });
+     * ```
+     */
+    get activityLogs(): RecordLinkManager<ActivityLogRecord, typeof CaseRecord['activityLogsLabels'][number]>;
+    /** Valid labels for User associations */
+    static readonly usersLabels: readonly ["CaseOwner", "Case__User", "CaseCollaborators", "favourite_cases"];
+    /**
+     * Access linked User records
+     * @remarks Available labels: CaseOwner, Case__User, CaseCollaborators, favourite_cases
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked User records
+     * const items = await record.users.list();
+     * const first = await record.users.first();
+     *
+     * // Filter by label
+     * const specific = await record.users.first({ label: 'CaseOwner' });
+     * ```
+     */
+    get users(): RecordLinkManager<UserRecord, typeof CaseRecord['usersLabels'][number]>;
+    /** Valid labels for Outage associations */
+    static readonly outagesLabels: readonly ["Outage__Case", "Outage"];
+    /**
+     * Access linked Outage records
+     * @remarks Available labels: Outage__Case, Outage
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Outage records
+     * const items = await record.outages.list();
+     * const first = await record.outages.first();
+     *
+     * // Filter by label
+     * const specific = await record.outages.first({ label: 'Outage__Case' });
+     * ```
+     */
+    get outages(): RecordLinkManager<OutageRecord, typeof CaseRecord['outagesLabels'][number]>;
+    /** Valid labels for SmsMessage associations */
+    static readonly smsMessagesLabels: readonly ["Case__SmsMessage"];
+    /**
+     * Access linked SmsMessage records
+     * @remarks Available labels: Case__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: 'Case__SmsMessage' });
+     * ```
+     */
+    get smsMessages(): RecordLinkManager<SmsMessageRecord, typeof CaseRecord['smsMessagesLabels'][number]>;
+    /** Valid labels for Email associations */
+    static readonly emailsLabels: readonly ["Case__Email"];
+    /**
+     * Access linked Email records
+     * @remarks Available labels: Case__Email
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Email records
+     * const items = await record.emails.list();
+     * const first = await record.emails.first();
+     *
+     * // Filter by label
+     * const specific = await record.emails.first({ label: 'Case__Email' });
+     * ```
+     */
+    get emails(): RecordLinkManager<EmailRecord, typeof CaseRecord['emailsLabels'][number]>;
+    /** Valid labels for Call associations */
+    static readonly callsLabels: readonly ["Call__Case"];
+    /**
+     * Access linked Call records
+     * @remarks Available labels: Call__Case
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Call records
+     * const items = await record.calls.list();
+     * const first = await record.calls.first();
+     *
+     * // Filter by label
+     * const specific = await record.calls.first({ label: 'Call__Case' });
+     * ```
+     */
+    get calls(): RecordLinkManager<CallRecord, typeof CaseRecord['callsLabels'][number]>;
+    /** Valid labels for ContractBuyOut associations */
+    static readonly contractBuyOutsLabels: readonly ["Case__ContractBuyOut"];
+    /**
+     * Access linked ContractBuyOut records
+     * @remarks Available labels: Case__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: 'Case__ContractBuyOut' });
+     * ```
+     */
+    get contractBuyOuts(): RecordLinkManager<ContractBuyOutRecord, typeof CaseRecord['contractBuyOutsLabels'][number]>;
+    /** Valid labels for Team associations */
+    static readonly teamsLabels: readonly ["Case_Team"];
+    /**
+     * Access linked Team records
+     * @remarks Available labels: Case_Team
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Team records
+     * const items = await record.teams.list();
+     * const first = await record.teams.first();
+     *
+     * // Filter by label
+     * const specific = await record.teams.first({ label: 'Case_Team' });
+     * ```
+     */
+    get teams(): RecordLinkManager<TeamRecord, typeof CaseRecord['teamsLabels'][number]>;
+    /** Valid labels for Note associations */
+    static readonly notesLabels: readonly ["Case__Note"];
+    /**
+     * Access linked Note records
+     * @remarks Available labels: Case__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: 'Case__Note' });
+     * ```
+     */
+    get notes(): RecordLinkManager<NoteRecord, typeof CaseRecord['notesLabels'][number]>;
+    /** Valid labels for Account associations */
+    static readonly accountsLabels: readonly ["Account__Case"];
+    /**
+     * Access linked Account records
+     * @remarks Available labels: Account__Case
+     * @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__Case' });
+     * ```
+     */
+    get accounts(): RecordLinkManager<AccountRecord, typeof CaseRecord['accountsLabels'][number]>;
+    /** Valid labels for WorkOrder associations */
+    static readonly workOrdersLabels: readonly ["Case__WorkOrder"];
+    /**
+     * Access linked WorkOrder records
+     * @remarks Available labels: Case__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: 'Case__WorkOrder' });
+     * ```
+     */
+    get workOrders(): RecordLinkManager<WorkOrderRecord, typeof CaseRecord['workOrdersLabels'][number]>;
+    /** Valid labels for Conversation associations */
+    static readonly conversationsLabels: readonly ["Case_Conversation"];
+    /**
+     * Access linked Conversation records
+     * @remarks Available labels: Case_Conversation
+     * @throws Error if called on a new (unsaved) record
+     *
+     * @example
+     * ```typescript
+     * // Get all linked Conversation records
+     * const items = await record.conversations.list();
+     * const first = await record.conversations.first();
+     *
+     * // Filter by label
+     * const specific = await record.conversations.first({ label: 'Case_Conversation' });
+     * ```
+     */
+    get conversations(): RecordLinkManager<ConversationRecord, typeof CaseRecord['conversationsLabels'][number]>;
+    /** Valid labels for Case associations */
+    static readonly casesLabels: readonly ["Case__Case"];
+    /**
+     * Access linked Case records
+     * @remarks Available labels: Case__Case
+     * @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__Case' });
+     * ```
+     */
+    get cases(): RecordLinkManager<CaseRecord, typeof CaseRecord['casesLabels'][number]>;
+    /** Valid labels for File associations */
+    static readonly filesLabels: readonly ["Case__File"];
+    /**
+     * Access linked File records
+     * @remarks Available labels: Case__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: 'Case__File' });
+     * ```
+     */
+    get files(): RecordLinkManager<FileRecord, typeof CaseRecord['filesLabels'][number]>;
+    /** Valid labels for Order associations */
+    static readonly ordersLabels: readonly ["Case__Order"];
+    /**
+     * Access linked Order records
+     * @remarks Available labels: Case__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: 'Case__Order' });
+     * ```
+     */
+    get orders(): RecordLinkManager<OrderRecord, typeof CaseRecord['ordersLabels'][number]>;
+    /** Valid labels for Contact associations */
+    static readonly contactsLabels: readonly ["Case__Contact"];
+    /**
+     * Access linked Contact records
+     * @remarks Available labels: Case__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: 'Case__Contact' });
+     * ```
+     */
+    get contacts(): RecordLinkManager<ContactRecord, typeof CaseRecord['contactsLabels'][number]>;
+    /** Valid labels for Address associations */
+    static readonly addressesLabels: readonly ["Case__Address"];
+    /**
+     * Access linked Address records
+     * @remarks Available labels: Case__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: 'Case__Address' });
+     * ```
+     */
+    get addresses(): RecordLinkManager<AddressRecord, typeof CaseRecord['addressesLabels'][number]>;
+    /** Valid labels for PushNotification associations */
+    static readonly pushNotificationsLabels: readonly ["Case__PushNotification"];
+    /**
+     * Access linked PushNotification records
+     * @remarks Available labels: Case__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: 'Case__PushNotification' });
+     * ```
+     */
+    get pushNotifications(): RecordLinkManager<PushNotificationRecord, typeof CaseRecord['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>;
+    /**
+     * CreateCase
+     *
+     * Creates a new Case 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.cases.new();
+     * await record.createCase({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.createCase({ ... }).dryRun();
+     * ```
+     */
+    createCase(properties: CreateCaseProperties, options?: {
+        type?: string;
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * CreateCaseFromCases
+     *
+     * Creates a new Case 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.cases.new();
+     * await record.createCaseFromCases({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.createCaseFromCases({ ... }).dryRun();
+     * ```
+     */
+    createCaseFromCases(properties: CreateCaseFromCasesProperties, options?: {
+        type?: string;
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * CreateCaseWithDpa
+     *
+     * Creates a new Case record with the specified properties.
+     * Returns an ActionBuilder - call .execute() to create or .dryRun() for debugging.
+     *
+     * @remarks Record type: DEFAULT
+     *
+     * @param properties - The properties for the new record
+     * @param options - Optional settings
+     * @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.cases.new();
+     * await record.createCaseWithDpa({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.createCaseWithDpa({ ... }).dryRun();
+     * ```
+     */
+    createCaseWithDpa(properties: CreateCaseWithDpaProperties, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * AllowCsatForCase
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.allowCsatForCase({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.allowCsatForCase({ ... }).dryRun();
+     * ```
+     */
+    allowCsatForCase(propertiesOrOptions?: AllowCsatForCaseProperties | {
+        journeyId?: string;
+        stageKey?: string;
+    }, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * AssignCaseByUser
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.assignCaseByUser({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.assignCaseByUser({ ... }).dryRun();
+     * ```
+     */
+    assignCaseByUser(propertiesOrOptions?: AssignCaseByUserProperties | {
+        journeyId?: string;
+        stageKey?: string;
+    }, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * AssignCase
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.assignCase({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.assignCase({ ... }).dryRun();
+     * ```
+     */
+    assignCase(propertiesOrOptions?: AssignCaseProperties | {
+        journeyId?: string;
+        stageKey?: string;
+    }, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * AssignCaseWithNoteFlow
+     *
+     * Starts a multi-step flow action on this Case 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.cases.new();
+     * await record.assignCaseWithNoteFlow()
+     *   .assignCase(recordId, { ... })
+     *   .createNoteForCaseAssignment({ ... })
+     *   .execute();
+     * ```
+     */
+    assignCaseWithNoteFlow(options?: {
+        journeyId?: string;
+    }): AssignCaseWithNoteFlowFlowBuilder;
+    /**
+     * MoveCaseToBlockedAction
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.moveCaseToBlockedAction({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveCaseToBlockedAction({ ... }).dryRun();
+     * ```
+     */
+    moveCaseToBlockedAction(properties: MoveCaseToBlockedActionProperties, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * Casedefaultstageblocked
+     *
+     * Starts a stage transition flow on this Case record.
+     * Chain step methods and call .execute() to run the flow.
+     *
+     * @remarks Transitions to stage: CaseDefaultStageBlocked
+     *
+     * @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.cases.get(id);
+     * await record.casedefaultstageblocked()
+     *   .moveCaseToBlockedAction(recordId, { ... })
+     *   .execute();
+     * ```
+     */
+    casedefaultstageblocked(options?: {
+        journeyId?: string;
+    }): CasedefaultstageblockedFlowBuilder;
+    /**
+     * EscalateCaseAction
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.escalateCaseAction({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.escalateCaseAction({ ... }).dryRun();
+     * ```
+     */
+    escalateCaseAction(properties: EscalateCaseActionProperties, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * CaseDefaultStageEscalated
+     *
+     * Starts a stage transition flow on this Case record.
+     * Chain step methods and call .execute() to run the flow.
+     *
+     * @remarks Transitions to stage: CaseDefaultStageEscalated
+     *
+     * @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.cases.get(id);
+     * await record.caseDefaultStageEscalated()
+     *   .escalateCaseAction(recordId, { ... })
+     *   .createNoteForCaseAssignment({ ... })
+     *   .execute();
+     * ```
+     */
+    caseDefaultStageEscalated(options?: {
+        journeyId?: string;
+    }): CaseDefaultStageEscalatedFlowBuilder;
+    /**
+     * CaseDefaultStageSolved
+     *
+     * Starts a stage transition flow on this Case record.
+     * Chain step methods and call .execute() to run the flow.
+     *
+     * @remarks Transitions to stage: CaseDefaultStageSolved
+     *
+     * @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.cases.get(id);
+     * await record.caseDefaultStageSolved()
+     *   .allowCsatForCase(recordId, { ... })
+     *   .execute();
+     * ```
+     */
+    caseDefaultStageSolved(options?: {
+        journeyId?: string;
+    }): CaseDefaultStageSolvedFlowBuilder;
+    /**
+     * ChangeCaseChannel
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.changeCaseChannel({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.changeCaseChannel({ ... }).dryRun();
+     * ```
+     */
+    changeCaseChannel(propertiesOrOptions?: ChangeCaseChannelProperties | {
+        journeyId?: string;
+        stageKey?: string;
+    }, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * EditCaseForm
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.editCaseForm({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.editCaseForm({ ... }).dryRun();
+     * ```
+     */
+    editCaseForm(propertiesOrOptions?: EditCaseFormProperties | {
+        journeyId?: string;
+        stageKey?: string;
+    }, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * EscalateCaseTransition
+     *
+     * Starts a stage transition flow on this Case record.
+     * Chain step methods and call .execute() to run the flow.
+     *
+     * @remarks Transitions to stage: CaseDefaultStageEscalated
+     *
+     * @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.cases.get(id);
+     * await record.escalateCaseTransition()
+     *   .escalateCaseAction(recordId, { ... })
+     *   .createNoteForCaseAssignment({ ... })
+     *   .execute();
+     * ```
+     */
+    escalateCaseTransition(options?: {
+        journeyId?: string;
+    }): EscalateCaseTransitionFlowBuilder;
+    /**
+     * ExceptionInput
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.exceptionInput({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.exceptionInput({ ... }).dryRun();
+     * ```
+     */
+    exceptionInput(propertiesOrOptions?: ExceptionInputProperties | {
+        journeyId?: string;
+        stageKey?: string;
+    }, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * MarkCaseClosed
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.markCaseClosed({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.markCaseClosed({ ... }).dryRun();
+     * ```
+     */
+    markCaseClosed(properties: MarkCaseClosedProperties, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * MarkCaseResolved
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.markCaseResolved({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.markCaseResolved({ ... }).dryRun();
+     * ```
+     */
+    markCaseResolved(properties: MarkCaseResolvedProperties, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * MoveCaseOutageToSolvedAction2
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.moveCaseOutageToSolvedAction2({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveCaseOutageToSolvedAction2({ ... }).dryRun();
+     * ```
+     */
+    moveCaseOutageToSolvedAction2(properties: MoveCaseOutageToSolvedAction2Properties, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * MoveCaseOutageToSolvedAction
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.moveCaseOutageToSolvedAction({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveCaseOutageToSolvedAction({ ... }).dryRun();
+     * ```
+     */
+    moveCaseOutageToSolvedAction(properties: MoveCaseOutageToSolvedActionProperties, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * MoveCaseOutageToSolvedTransition
+     *
+     * Transitions this Case record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: OutagePipelineStageSolved
+     *
+     * @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.cases.get(id);
+     * await record.moveCaseOutageToSolvedTransition().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveCaseOutageToSolvedTransition().dryRun();
+     * ```
+     */
+    moveCaseOutageToSolvedTransition(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * MoveCaseToBlockedTransition
+     *
+     * Starts a stage transition flow on this Case record.
+     * Chain step methods and call .execute() to run the flow.
+     *
+     * @remarks Transitions to stage: CaseDefaultStageBlocked
+     *
+     * @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.cases.get(id);
+     * await record.moveCaseToBlockedTransition()
+     *   .moveCaseToBlockedAction(recordId, { ... })
+     *   .execute();
+     * ```
+     */
+    moveCaseToBlockedTransition(options?: {
+        journeyId?: string;
+    }): MoveCaseToBlockedTransitionFlowBuilder;
+    /**
+     * MoveCaseToPendingAgentTransition
+     *
+     * Transitions this Case record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: CaseDefaultStagePendingAgent
+     *
+     * @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.cases.get(id);
+     * await record.moveCaseToPendingAgentTransition().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveCaseToPendingAgentTransition().dryRun();
+     * ```
+     */
+    moveCaseToPendingAgentTransition(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * MoveCaseToPendingReviewAction
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.moveCaseToPendingReviewAction({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveCaseToPendingReviewAction({ ... }).dryRun();
+     * ```
+     */
+    moveCaseToPendingReviewAction(properties: MoveCaseToPendingReviewActionProperties, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * MoveCaseToPendingReviewTransition
+     *
+     * Starts a stage transition flow on this Case record.
+     * Chain step methods and call .execute() to run the flow.
+     *
+     * @remarks Transitions to stage: CaseDefaultStagePendingReview
+     *
+     * @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.cases.get(id);
+     * await record.moveCaseToPendingReviewTransition()
+     *   .moveCaseToPendingReviewAction(recordId, { ... })
+     *   .execute();
+     * ```
+     */
+    moveCaseToPendingReviewTransition(options?: {
+        journeyId?: string;
+    }): MoveCaseToPendingReviewTransitionFlowBuilder;
+    /**
+     * MoveCaseToSolvedAction
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.moveCaseToSolvedAction({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveCaseToSolvedAction({ ... }).dryRun();
+     * ```
+     */
+    moveCaseToSolvedAction(properties: MoveCaseToSolvedActionProperties, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * MoveCaseToSolvedTransition
+     *
+     * Transitions this Case record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: CaseDefaultStageSolved
+     *
+     * @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.cases.get(id);
+     * await record.moveCaseToSolvedTransition().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveCaseToSolvedTransition().dryRun();
+     * ```
+     */
+    moveCaseToSolvedTransition(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * MoveDefaultCaseFromAnyStageToPendingAgent
+     *
+     * Transitions this Case record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: CaseDefaultStagePendingAgent
+     *
+     * @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.cases.get(id);
+     * await record.moveDefaultCaseFromAnyStageToPendingAgent().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveDefaultCaseFromAnyStageToPendingAgent().dryRun();
+     * ```
+     */
+    moveDefaultCaseFromAnyStageToPendingAgent(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * MoveDefaultCaseFromAnyStageToPendingReply
+     *
+     * Transitions this Case record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: CaseDefaultStagePendingReply
+     *
+     * @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.cases.get(id);
+     * await record.moveDefaultCaseFromAnyStageToPendingReply().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.moveDefaultCaseFromAnyStageToPendingReply().dryRun();
+     * ```
+     */
+    moveDefaultCaseFromAnyStageToPendingReply(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * MoveDefaultCaseFromOpenToClosed
+     *
+     * Starts a stage transition flow on this Case record.
+     * Chain step methods and call .execute() to run the flow.
+     *
+     * @remarks Transitions to stage: CaseDefaultStageClosed
+     *
+     * @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.cases.get(id);
+     * await record.moveDefaultCaseFromOpenToClosed()
+     *   .markCaseClosed(recordId, { ... })
+     *   .execute();
+     * ```
+     */
+    moveDefaultCaseFromOpenToClosed(options?: {
+        journeyId?: string;
+    }): MoveDefaultCaseFromOpenToClosedFlowBuilder;
+    /**
+     * MovetoClosed
+     *
+     * Transitions this Case record to a new pipeline stage.
+     * Returns an ActionBuilder - call .execute() to transition or .dryRun() for debugging.
+     *
+     * @remarks Transitions to stage: CaseDefaultStageClosed
+     *
+     * @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.cases.get(id);
+     * await record.movetoClosed().execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.movetoClosed().dryRun();
+     * ```
+     */
+    movetoClosed(options?: {
+        journeyId?: string;
+    }): ActionBuilder;
+    /**
+     * RemoveAssignmentFromCase
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.removeAssignmentFromCase({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.removeAssignmentFromCase({ ... }).dryRun();
+     * ```
+     */
+    removeAssignmentFromCase(propertiesOrOptions?: RemoveAssignmentFromCaseProperties | {
+        journeyId?: string;
+        stageKey?: string;
+    }, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * UpdateFormalComplaint
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.updateFormalComplaint({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.updateFormalComplaint({ ... }).dryRun();
+     * ```
+     */
+    updateFormalComplaint(propertiesOrOptions?: UpdateFormalComplaintProperties | {
+        journeyId?: string;
+        stageKey?: string;
+    }, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * UpdateSentiment
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.updateSentiment({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.updateSentiment({ ... }).dryRun();
+     * ```
+     */
+    updateSentiment(properties: UpdateSentimentProperties, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+    /**
+     * UpdateTags
+     *
+     * Updates this Case 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.cases.get(id);
+     * await record.updateTags({ ... }).execute();
+     *
+     * // Dry run (for debugging)
+     * const payload = record.updateTags({ ... }).dryRun();
+     * ```
+     */
+    updateTags(properties: UpdateTagsProperties, options?: {
+        journeyId?: string;
+        stageKey?: string;
+    }): ActionBuilder;
+}
+/** Type guard to check if an object is a CaseRecord */
+export declare function isCaseRecord(obj: any): obj is CaseRecord;
+export {};