@d19n/youfibre-odin-sdk 2.0.14 → 2.0.16

package/dist/records-v2/CaseRecord.js

@@ -0,0 +1,2877 @@
+"use strict";
+/**
+ * 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
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCaseRecord = exports.CaseRecord = exports.MoveDefaultCaseFromOpenToClosedFlowBuilder = exports.MoveCaseToPendingReviewTransitionFlowBuilder = exports.MoveCaseToBlockedTransitionFlowBuilder = exports.EscalateCaseTransitionFlowBuilder = exports.CaseDefaultStageSolvedFlowBuilder = exports.CaseDefaultStageEscalatedFlowBuilder = exports.CasedefaultstageblockedFlowBuilder = exports.AssignCaseWithNoteFlowFlowBuilder = void 0;
+const uuid_1 = require("uuid");
+const core_1 = require("@d19n/odin-types/dist/core");
+const record_link_manager_1 = require("@d19n/odin-sdk-generator/dist/record-link-manager");
+const ActivityLogRecord_1 = require("./ActivityLogRecord");
+const UserRecord_1 = require("./UserRecord");
+const OutageRecord_1 = require("./OutageRecord");
+const SmsMessageRecord_1 = require("./SmsMessageRecord");
+const EmailRecord_1 = require("./EmailRecord");
+const CallRecord_1 = require("./CallRecord");
+const ContractBuyOutRecord_1 = require("./ContractBuyOutRecord");
+const TeamRecord_1 = require("./TeamRecord");
+const NoteRecord_1 = require("./NoteRecord");
+const AccountRecord_1 = require("./AccountRecord");
+const WorkOrderRecord_1 = require("./WorkOrderRecord");
+const ConversationRecord_1 = require("./ConversationRecord");
+const FileRecord_1 = require("./FileRecord");
+const OrderRecord_1 = require("./OrderRecord");
+const ContactRecord_1 = require("./ContactRecord");
+const AddressRecord_1 = require("./AddressRecord");
+const PushNotificationRecord_1 = require("./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)
+ */
+class ActionBuilder {
+    constructor(provider, moduleName, entityName, payload, clearPendingLinks) {
+        this._provider = provider;
+        this._moduleName = moduleName;
+        this._entityName = entityName;
+        this._payload = payload;
+        this._clearPendingLinks = clearPendingLinks;
+    }
+    /**
+     * 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, externalAppId) {
+        this._payload.externalId = externalId;
+        this._payload.externalAppId = externalAppId;
+        return 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) {
+        this._payload.groups = groups;
+        return this;
+    }
+    /**
+     * Execute the action
+     * @returns The result from the API
+     */
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._provider._applyAction(this._moduleName, this._entityName, this._payload);
+            this._clearPendingLinks();
+            return result;
+        });
+    }
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun() {
+        return this._payload;
+    }
+    /**
+     * Prevents accidental `await actionBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then() {
+        throw new Error('ActionBuilder cannot be awaited directly. Call .execute() to run the action or .dryRun() to get the payload.');
+    }
+}
+/**
+ * FlowBuilder for AssignCaseWithNoteFlow multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ */
+class AssignCaseWithNoteFlowFlowBuilder {
+    constructor(record, provider, pendingLinks, options) {
+        this._groups = [];
+        this._steps = [];
+        this._record = record;
+        this._provider = provider;
+        this._pendingLinks = pendingLinks;
+        this._options = options;
+    }
+    /**
+     * Add a group to the main action
+     * @param group - Group name to add
+     * @returns this (for method chaining)
+     */
+    addGroup(group) {
+        this._groups.push(group);
+        return 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, properties, options) {
+        var _a;
+        this._steps.push({
+            actionName: 'AssignCase',
+            properties,
+            id,
+            entity: 'SupportModule:Case',
+            schemaId: 'be8173eb-269b-4a67-be0c-11ce6af5d561',
+            schemaActionId: '1b9ad25e-fe28-42fd-8198-b89d9df26bb1',
+            schemaTypeId: '2d18d4c3-b4f8-4633-bfb0-ff0d62fbaecf',
+            type: 'DEFAULT',
+            autoLinkParent: false,
+            associations: (_a = options === null || options === void 0 ? void 0 : options.associations) === null || _a === void 0 ? void 0 : _a.map(a => (Object.assign(Object.assign({}, a), { linkType: null, relationType: undefined }))),
+            groups: options === null || options === void 0 ? void 0 : options.groups,
+        });
+        return 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, options) {
+        var _a;
+        this._steps.push({
+            actionName: 'CreateNoteForCaseAssignment',
+            properties,
+            entity: 'SupportModule:Note',
+            schemaId: '39e849e9-bd95-4499-bca2-e88162062e09',
+            schemaActionId: '9ac8c98c-4e2d-4b45-851a-bfe818365d32',
+            schemaTypeId: '0d68c73f-4489-4d73-8482-f6146f87f460',
+            type: 'DEFAULT',
+            autoLinkParent: true,
+            associations: (_a = options === null || options === void 0 ? void 0 : options.associations) === null || _a === void 0 ? void 0 : _a.map(a => (Object.assign(Object.assign({}, a), { linkType: null, relationType: undefined }))),
+            groups: options === null || options === void 0 ? void 0 : options.groups,
+        });
+        return this;
+    }
+    /**
+     * Execute the flow
+     * @returns The result from the API
+     */
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = this._buildRequestPayload();
+            const result = yield this._provider._applyAction('SupportModule', 'Case', payload);
+            // Clear pending links on the record after execution
+            this._record.clearPendingLinks();
+            return result;
+        });
+    }
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun() {
+        return this._buildRequestPayload();
+    }
+    /**
+     * Prevents accidental `await flowBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then() {
+        throw new Error('FlowBuilder cannot be awaited directly. Call .execute() to run the flow or .dryRun() to get the payload.');
+    }
+    /**
+     * Build the request payload for the action
+     * @private
+     */
+    _buildRequestPayload() {
+        const record = this._record.record;
+        if (!(record === null || record === void 0 ? void 0 : record.id))
+            throw new Error('Cannot execute flow on unsaved record');
+        // Build steps with parent associations
+        const stepsWithAssociations = this._steps.map(step => {
+            const stepAssociations = [...(step.associations || [])];
+            // Auto-add parent association if step requires it
+            if (step.autoLinkParent) {
+                stepAssociations.push({
+                    entity: record.entity,
+                    recordId: record.id,
+                    linkType: null,
+                    relationType: 'PARENT',
+                });
+            }
+            return {
+                entity: step.entity,
+                type: step.type,
+                schemaId: step.schemaId,
+                schemaActionId: step.schemaActionId,
+                schemaTypeId: step.schemaTypeId,
+                actionName: step.actionName,
+                properties: step.properties,
+                title: step.title,
+                id: step.id,
+                associations: stepAssociations.length > 0 ? stepAssociations : undefined,
+                groups: step.groups,
+            };
+        });
+        return Object.assign({ id: record.id, entity: record.entity, type: record.type, actionName: 'AssignCaseWithNoteFlow', schemaActionId: '65580715-5ec8-4593-a953-2ab975eadd64', steps: stepsWithAssociations, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined, groups: this._groups.length > 0 ? this._groups : undefined }, this._options);
+    }
+}
+exports.AssignCaseWithNoteFlowFlowBuilder = AssignCaseWithNoteFlowFlowBuilder;
+/**
+ * FlowBuilder for Casedefaultstageblocked multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * Transitions to stage: CaseDefaultStageBlocked
+ */
+class CasedefaultstageblockedFlowBuilder {
+    constructor(record, provider, pendingLinks, options) {
+        this._groups = [];
+        this._steps = [];
+        this._record = record;
+        this._provider = provider;
+        this._pendingLinks = pendingLinks;
+        this._options = options;
+    }
+    /**
+     * Add a group to the main action
+     * @param group - Group name to add
+     * @returns this (for method chaining)
+     */
+    addGroup(group) {
+        this._groups.push(group);
+        return 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, properties, options) {
+        var _a;
+        this._steps.push({
+            actionName: 'MoveCaseToBlockedAction',
+            properties,
+            id,
+            entity: 'SupportModule:Case',
+            schemaId: 'be8173eb-269b-4a67-be0c-11ce6af5d561',
+            schemaActionId: 'e9420724-d4ea-4e08-8a63-1664f8202d34',
+            schemaTypeId: '2d18d4c3-b4f8-4633-bfb0-ff0d62fbaecf',
+            type: 'DEFAULT',
+            autoLinkParent: false,
+            associations: (_a = options === null || options === void 0 ? void 0 : options.associations) === null || _a === void 0 ? void 0 : _a.map(a => (Object.assign(Object.assign({}, a), { linkType: null, relationType: undefined }))),
+            groups: options === null || options === void 0 ? void 0 : options.groups,
+        });
+        return this;
+    }
+    /**
+     * Execute the flow
+     * @returns The result from the API
+     */
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = this._buildRequestPayload();
+            const result = yield this._provider._applyAction('SupportModule', 'Case', payload);
+            // Clear pending links on the record after execution
+            this._record.clearPendingLinks();
+            return result;
+        });
+    }
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun() {
+        return this._buildRequestPayload();
+    }
+    /**
+     * Prevents accidental `await flowBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then() {
+        throw new Error('FlowBuilder cannot be awaited directly. Call .execute() to run the flow or .dryRun() to get the payload.');
+    }
+    /**
+     * Build the request payload for the action
+     * @private
+     */
+    _buildRequestPayload() {
+        const record = this._record.record;
+        if (!(record === null || record === void 0 ? void 0 : record.id))
+            throw new Error('Cannot execute flow on unsaved record');
+        // Build steps with parent associations
+        const stepsWithAssociations = this._steps.map(step => {
+            const stepAssociations = [...(step.associations || [])];
+            // Auto-add parent association if step requires it
+            if (step.autoLinkParent) {
+                stepAssociations.push({
+                    entity: record.entity,
+                    recordId: record.id,
+                    linkType: null,
+                    relationType: 'PARENT',
+                });
+            }
+            return {
+                entity: step.entity,
+                type: step.type,
+                schemaId: step.schemaId,
+                schemaActionId: step.schemaActionId,
+                schemaTypeId: step.schemaTypeId,
+                actionName: step.actionName,
+                properties: step.properties,
+                title: step.title,
+                id: step.id,
+                associations: stepAssociations.length > 0 ? stepAssociations : undefined,
+                groups: step.groups,
+            };
+        });
+        return Object.assign({ id: record.id, entity: record.entity, type: record.type, actionName: 'Casedefaultstageblocked', schemaActionId: '1823e74e-d4af-4ab6-9e6d-f20a94f153d9', steps: stepsWithAssociations, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined, groups: this._groups.length > 0 ? this._groups : undefined, stageKey: 'CaseDefaultStageBlocked' }, this._options);
+    }
+}
+exports.CasedefaultstageblockedFlowBuilder = CasedefaultstageblockedFlowBuilder;
+/**
+ * FlowBuilder for CaseDefaultStageEscalated multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * Transitions to stage: CaseDefaultStageEscalated
+ */
+class CaseDefaultStageEscalatedFlowBuilder {
+    constructor(record, provider, pendingLinks, options) {
+        this._groups = [];
+        this._steps = [];
+        this._record = record;
+        this._provider = provider;
+        this._pendingLinks = pendingLinks;
+        this._options = options;
+    }
+    /**
+     * Add a group to the main action
+     * @param group - Group name to add
+     * @returns this (for method chaining)
+     */
+    addGroup(group) {
+        this._groups.push(group);
+        return 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, properties, options) {
+        var _a;
+        this._steps.push({
+            actionName: 'EscalateCaseAction',
+            properties,
+            id,
+            entity: 'SupportModule:Case',
+            schemaId: 'be8173eb-269b-4a67-be0c-11ce6af5d561',
+            schemaActionId: 'fdc282dd-cdc3-49bd-8818-df217a3e226d',
+            autoLinkParent: false,
+            associations: (_a = options === null || options === void 0 ? void 0 : options.associations) === null || _a === void 0 ? void 0 : _a.map(a => (Object.assign(Object.assign({}, a), { linkType: null, relationType: undefined }))),
+            groups: options === null || options === void 0 ? void 0 : options.groups,
+        });
+        return 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, options) {
+        var _a;
+        this._steps.push({
+            actionName: 'CreateNoteForCaseAssignment',
+            properties,
+            entity: 'SupportModule:Note',
+            schemaId: '39e849e9-bd95-4499-bca2-e88162062e09',
+            schemaActionId: '9ac8c98c-4e2d-4b45-851a-bfe818365d32',
+            schemaTypeId: '0d68c73f-4489-4d73-8482-f6146f87f460',
+            type: 'DEFAULT',
+            autoLinkParent: true,
+            associations: (_a = options === null || options === void 0 ? void 0 : options.associations) === null || _a === void 0 ? void 0 : _a.map(a => (Object.assign(Object.assign({}, a), { linkType: null, relationType: undefined }))),
+            groups: options === null || options === void 0 ? void 0 : options.groups,
+        });
+        return this;
+    }
+    /**
+     * Execute the flow
+     * @returns The result from the API
+     */
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = this._buildRequestPayload();
+            const result = yield this._provider._applyAction('SupportModule', 'Case', payload);
+            // Clear pending links on the record after execution
+            this._record.clearPendingLinks();
+            return result;
+        });
+    }
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun() {
+        return this._buildRequestPayload();
+    }
+    /**
+     * Prevents accidental `await flowBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then() {
+        throw new Error('FlowBuilder cannot be awaited directly. Call .execute() to run the flow or .dryRun() to get the payload.');
+    }
+    /**
+     * Build the request payload for the action
+     * @private
+     */
+    _buildRequestPayload() {
+        const record = this._record.record;
+        if (!(record === null || record === void 0 ? void 0 : record.id))
+            throw new Error('Cannot execute flow on unsaved record');
+        // Build steps with parent associations
+        const stepsWithAssociations = this._steps.map(step => {
+            const stepAssociations = [...(step.associations || [])];
+            // Auto-add parent association if step requires it
+            if (step.autoLinkParent) {
+                stepAssociations.push({
+                    entity: record.entity,
+                    recordId: record.id,
+                    linkType: null,
+                    relationType: 'PARENT',
+                });
+            }
+            return {
+                entity: step.entity,
+                type: step.type,
+                schemaId: step.schemaId,
+                schemaActionId: step.schemaActionId,
+                schemaTypeId: step.schemaTypeId,
+                actionName: step.actionName,
+                properties: step.properties,
+                title: step.title,
+                id: step.id,
+                associations: stepAssociations.length > 0 ? stepAssociations : undefined,
+                groups: step.groups,
+            };
+        });
+        return Object.assign({ id: record.id, entity: record.entity, type: record.type, actionName: 'CaseDefaultStageEscalated', schemaActionId: 'bfc4661a-11ae-427f-96fd-54563e38c447', steps: stepsWithAssociations, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined, groups: this._groups.length > 0 ? this._groups : undefined, stageKey: 'CaseDefaultStageEscalated' }, this._options);
+    }
+}
+exports.CaseDefaultStageEscalatedFlowBuilder = CaseDefaultStageEscalatedFlowBuilder;
+/**
+ * FlowBuilder for CaseDefaultStageSolved multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * Transitions to stage: CaseDefaultStageSolved
+ */
+class CaseDefaultStageSolvedFlowBuilder {
+    constructor(record, provider, pendingLinks, options) {
+        this._groups = [];
+        this._steps = [];
+        this._record = record;
+        this._provider = provider;
+        this._pendingLinks = pendingLinks;
+        this._options = options;
+    }
+    /**
+     * Add a group to the main action
+     * @param group - Group name to add
+     * @returns this (for method chaining)
+     */
+    addGroup(group) {
+        this._groups.push(group);
+        return 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, properties, options) {
+        var _a;
+        this._steps.push({
+            actionName: 'AllowCsatForCase',
+            properties,
+            id,
+            entity: 'SupportModule:Case',
+            schemaId: 'be8173eb-269b-4a67-be0c-11ce6af5d561',
+            schemaActionId: '5e215610-d78f-4654-a7c8-4504948936db',
+            schemaTypeId: '2d18d4c3-b4f8-4633-bfb0-ff0d62fbaecf',
+            type: 'DEFAULT',
+            autoLinkParent: false,
+            associations: (_a = options === null || options === void 0 ? void 0 : options.associations) === null || _a === void 0 ? void 0 : _a.map(a => (Object.assign(Object.assign({}, a), { linkType: null, relationType: undefined }))),
+            groups: options === null || options === void 0 ? void 0 : options.groups,
+        });
+        return this;
+    }
+    /**
+     * Execute the flow
+     * @returns The result from the API
+     */
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = this._buildRequestPayload();
+            const result = yield this._provider._applyAction('SupportModule', 'Case', payload);
+            // Clear pending links on the record after execution
+            this._record.clearPendingLinks();
+            return result;
+        });
+    }
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun() {
+        return this._buildRequestPayload();
+    }
+    /**
+     * Prevents accidental `await flowBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then() {
+        throw new Error('FlowBuilder cannot be awaited directly. Call .execute() to run the flow or .dryRun() to get the payload.');
+    }
+    /**
+     * Build the request payload for the action
+     * @private
+     */
+    _buildRequestPayload() {
+        const record = this._record.record;
+        if (!(record === null || record === void 0 ? void 0 : record.id))
+            throw new Error('Cannot execute flow on unsaved record');
+        // Build steps with parent associations
+        const stepsWithAssociations = this._steps.map(step => {
+            const stepAssociations = [...(step.associations || [])];
+            // Auto-add parent association if step requires it
+            if (step.autoLinkParent) {
+                stepAssociations.push({
+                    entity: record.entity,
+                    recordId: record.id,
+                    linkType: null,
+                    relationType: 'PARENT',
+                });
+            }
+            return {
+                entity: step.entity,
+                type: step.type,
+                schemaId: step.schemaId,
+                schemaActionId: step.schemaActionId,
+                schemaTypeId: step.schemaTypeId,
+                actionName: step.actionName,
+                properties: step.properties,
+                title: step.title,
+                id: step.id,
+                associations: stepAssociations.length > 0 ? stepAssociations : undefined,
+                groups: step.groups,
+            };
+        });
+        return Object.assign({ id: record.id, entity: record.entity, type: record.type, actionName: 'CaseDefaultStageSolved', schemaActionId: '88571d94-6096-47ea-a2b8-81838e46492c', steps: stepsWithAssociations, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined, groups: this._groups.length > 0 ? this._groups : undefined, stageKey: 'CaseDefaultStageSolved' }, this._options);
+    }
+}
+exports.CaseDefaultStageSolvedFlowBuilder = CaseDefaultStageSolvedFlowBuilder;
+/**
+ * FlowBuilder for EscalateCaseTransition multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * Transitions to stage: CaseDefaultStageEscalated
+ */
+class EscalateCaseTransitionFlowBuilder {
+    constructor(record, provider, pendingLinks, options) {
+        this._groups = [];
+        this._steps = [];
+        this._record = record;
+        this._provider = provider;
+        this._pendingLinks = pendingLinks;
+        this._options = options;
+    }
+    /**
+     * Add a group to the main action
+     * @param group - Group name to add
+     * @returns this (for method chaining)
+     */
+    addGroup(group) {
+        this._groups.push(group);
+        return 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, properties, options) {
+        var _a;
+        this._steps.push({
+            actionName: 'EscalateCaseAction',
+            properties,
+            id,
+            entity: 'SupportModule:Case',
+            schemaId: 'be8173eb-269b-4a67-be0c-11ce6af5d561',
+            schemaActionId: 'fdc282dd-cdc3-49bd-8818-df217a3e226d',
+            autoLinkParent: false,
+            associations: (_a = options === null || options === void 0 ? void 0 : options.associations) === null || _a === void 0 ? void 0 : _a.map(a => (Object.assign(Object.assign({}, a), { linkType: null, relationType: undefined }))),
+            groups: options === null || options === void 0 ? void 0 : options.groups,
+        });
+        return 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, options) {
+        var _a;
+        this._steps.push({
+            actionName: 'CreateNoteForCaseAssignment',
+            properties,
+            entity: 'SupportModule:Note',
+            schemaId: '39e849e9-bd95-4499-bca2-e88162062e09',
+            schemaActionId: '9ac8c98c-4e2d-4b45-851a-bfe818365d32',
+            schemaTypeId: '0d68c73f-4489-4d73-8482-f6146f87f460',
+            type: 'DEFAULT',
+            autoLinkParent: true,
+            associations: (_a = options === null || options === void 0 ? void 0 : options.associations) === null || _a === void 0 ? void 0 : _a.map(a => (Object.assign(Object.assign({}, a), { linkType: null, relationType: undefined }))),
+            groups: options === null || options === void 0 ? void 0 : options.groups,
+        });
+        return this;
+    }
+    /**
+     * Execute the flow
+     * @returns The result from the API
+     */
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = this._buildRequestPayload();
+            const result = yield this._provider._applyAction('SupportModule', 'Case', payload);
+            // Clear pending links on the record after execution
+            this._record.clearPendingLinks();
+            return result;
+        });
+    }
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun() {
+        return this._buildRequestPayload();
+    }
+    /**
+     * Prevents accidental `await flowBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then() {
+        throw new Error('FlowBuilder cannot be awaited directly. Call .execute() to run the flow or .dryRun() to get the payload.');
+    }
+    /**
+     * Build the request payload for the action
+     * @private
+     */
+    _buildRequestPayload() {
+        const record = this._record.record;
+        if (!(record === null || record === void 0 ? void 0 : record.id))
+            throw new Error('Cannot execute flow on unsaved record');
+        // Build steps with parent associations
+        const stepsWithAssociations = this._steps.map(step => {
+            const stepAssociations = [...(step.associations || [])];
+            // Auto-add parent association if step requires it
+            if (step.autoLinkParent) {
+                stepAssociations.push({
+                    entity: record.entity,
+                    recordId: record.id,
+                    linkType: null,
+                    relationType: 'PARENT',
+                });
+            }
+            return {
+                entity: step.entity,
+                type: step.type,
+                schemaId: step.schemaId,
+                schemaActionId: step.schemaActionId,
+                schemaTypeId: step.schemaTypeId,
+                actionName: step.actionName,
+                properties: step.properties,
+                title: step.title,
+                id: step.id,
+                associations: stepAssociations.length > 0 ? stepAssociations : undefined,
+                groups: step.groups,
+            };
+        });
+        return Object.assign({ id: record.id, entity: record.entity, type: record.type, actionName: 'EscalateCaseTransition', schemaActionId: 'f0455f2d-b00e-4a30-883b-b93ef636ab64', steps: stepsWithAssociations, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined, groups: this._groups.length > 0 ? this._groups : undefined, stageKey: 'CaseDefaultStageEscalated' }, this._options);
+    }
+}
+exports.EscalateCaseTransitionFlowBuilder = EscalateCaseTransitionFlowBuilder;
+/**
+ * FlowBuilder for MoveCaseToBlockedTransition multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * Transitions to stage: CaseDefaultStageBlocked
+ */
+class MoveCaseToBlockedTransitionFlowBuilder {
+    constructor(record, provider, pendingLinks, options) {
+        this._groups = [];
+        this._steps = [];
+        this._record = record;
+        this._provider = provider;
+        this._pendingLinks = pendingLinks;
+        this._options = options;
+    }
+    /**
+     * Add a group to the main action
+     * @param group - Group name to add
+     * @returns this (for method chaining)
+     */
+    addGroup(group) {
+        this._groups.push(group);
+        return 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, properties, options) {
+        var _a;
+        this._steps.push({
+            actionName: 'MoveCaseToBlockedAction',
+            properties,
+            id,
+            entity: 'SupportModule:Case',
+            schemaId: 'be8173eb-269b-4a67-be0c-11ce6af5d561',
+            schemaActionId: 'e9420724-d4ea-4e08-8a63-1664f8202d34',
+            schemaTypeId: '2d18d4c3-b4f8-4633-bfb0-ff0d62fbaecf',
+            type: 'DEFAULT',
+            autoLinkParent: false,
+            associations: (_a = options === null || options === void 0 ? void 0 : options.associations) === null || _a === void 0 ? void 0 : _a.map(a => (Object.assign(Object.assign({}, a), { linkType: null, relationType: undefined }))),
+            groups: options === null || options === void 0 ? void 0 : options.groups,
+        });
+        return this;
+    }
+    /**
+     * Execute the flow
+     * @returns The result from the API
+     */
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = this._buildRequestPayload();
+            const result = yield this._provider._applyAction('SupportModule', 'Case', payload);
+            // Clear pending links on the record after execution
+            this._record.clearPendingLinks();
+            return result;
+        });
+    }
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun() {
+        return this._buildRequestPayload();
+    }
+    /**
+     * Prevents accidental `await flowBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then() {
+        throw new Error('FlowBuilder cannot be awaited directly. Call .execute() to run the flow or .dryRun() to get the payload.');
+    }
+    /**
+     * Build the request payload for the action
+     * @private
+     */
+    _buildRequestPayload() {
+        const record = this._record.record;
+        if (!(record === null || record === void 0 ? void 0 : record.id))
+            throw new Error('Cannot execute flow on unsaved record');
+        // Build steps with parent associations
+        const stepsWithAssociations = this._steps.map(step => {
+            const stepAssociations = [...(step.associations || [])];
+            // Auto-add parent association if step requires it
+            if (step.autoLinkParent) {
+                stepAssociations.push({
+                    entity: record.entity,
+                    recordId: record.id,
+                    linkType: null,
+                    relationType: 'PARENT',
+                });
+            }
+            return {
+                entity: step.entity,
+                type: step.type,
+                schemaId: step.schemaId,
+                schemaActionId: step.schemaActionId,
+                schemaTypeId: step.schemaTypeId,
+                actionName: step.actionName,
+                properties: step.properties,
+                title: step.title,
+                id: step.id,
+                associations: stepAssociations.length > 0 ? stepAssociations : undefined,
+                groups: step.groups,
+            };
+        });
+        return Object.assign({ id: record.id, entity: record.entity, type: record.type, actionName: 'MoveCaseToBlockedTransition', schemaActionId: 'cbab8e97-2ad7-4861-af39-ca58eaf6bea3', steps: stepsWithAssociations, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined, groups: this._groups.length > 0 ? this._groups : undefined, stageKey: 'CaseDefaultStageBlocked' }, this._options);
+    }
+}
+exports.MoveCaseToBlockedTransitionFlowBuilder = MoveCaseToBlockedTransitionFlowBuilder;
+/**
+ * FlowBuilder for MoveCaseToPendingReviewTransition multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * Transitions to stage: CaseDefaultStagePendingReview
+ */
+class MoveCaseToPendingReviewTransitionFlowBuilder {
+    constructor(record, provider, pendingLinks, options) {
+        this._groups = [];
+        this._steps = [];
+        this._record = record;
+        this._provider = provider;
+        this._pendingLinks = pendingLinks;
+        this._options = options;
+    }
+    /**
+     * Add a group to the main action
+     * @param group - Group name to add
+     * @returns this (for method chaining)
+     */
+    addGroup(group) {
+        this._groups.push(group);
+        return 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, properties, options) {
+        var _a;
+        this._steps.push({
+            actionName: 'MoveCaseToPendingReviewAction',
+            properties,
+            id,
+            entity: 'SupportModule:Case',
+            schemaId: 'be8173eb-269b-4a67-be0c-11ce6af5d561',
+            schemaActionId: 'ebbbc806-bd60-49e6-af50-6e5e859a8f04',
+            schemaTypeId: '2d18d4c3-b4f8-4633-bfb0-ff0d62fbaecf',
+            type: 'DEFAULT',
+            autoLinkParent: false,
+            associations: (_a = options === null || options === void 0 ? void 0 : options.associations) === null || _a === void 0 ? void 0 : _a.map(a => (Object.assign(Object.assign({}, a), { linkType: null, relationType: undefined }))),
+            groups: options === null || options === void 0 ? void 0 : options.groups,
+        });
+        return this;
+    }
+    /**
+     * Execute the flow
+     * @returns The result from the API
+     */
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = this._buildRequestPayload();
+            const result = yield this._provider._applyAction('SupportModule', 'Case', payload);
+            // Clear pending links on the record after execution
+            this._record.clearPendingLinks();
+            return result;
+        });
+    }
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun() {
+        return this._buildRequestPayload();
+    }
+    /**
+     * Prevents accidental `await flowBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then() {
+        throw new Error('FlowBuilder cannot be awaited directly. Call .execute() to run the flow or .dryRun() to get the payload.');
+    }
+    /**
+     * Build the request payload for the action
+     * @private
+     */
+    _buildRequestPayload() {
+        const record = this._record.record;
+        if (!(record === null || record === void 0 ? void 0 : record.id))
+            throw new Error('Cannot execute flow on unsaved record');
+        // Build steps with parent associations
+        const stepsWithAssociations = this._steps.map(step => {
+            const stepAssociations = [...(step.associations || [])];
+            // Auto-add parent association if step requires it
+            if (step.autoLinkParent) {
+                stepAssociations.push({
+                    entity: record.entity,
+                    recordId: record.id,
+                    linkType: null,
+                    relationType: 'PARENT',
+                });
+            }
+            return {
+                entity: step.entity,
+                type: step.type,
+                schemaId: step.schemaId,
+                schemaActionId: step.schemaActionId,
+                schemaTypeId: step.schemaTypeId,
+                actionName: step.actionName,
+                properties: step.properties,
+                title: step.title,
+                id: step.id,
+                associations: stepAssociations.length > 0 ? stepAssociations : undefined,
+                groups: step.groups,
+            };
+        });
+        return Object.assign({ id: record.id, entity: record.entity, type: record.type, actionName: 'MoveCaseToPendingReviewTransition', schemaActionId: '1bceda63-e8f7-4576-a7da-279d89730812', steps: stepsWithAssociations, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined, groups: this._groups.length > 0 ? this._groups : undefined, stageKey: 'CaseDefaultStagePendingReview' }, this._options);
+    }
+}
+exports.MoveCaseToPendingReviewTransitionFlowBuilder = MoveCaseToPendingReviewTransitionFlowBuilder;
+/**
+ * FlowBuilder for MoveDefaultCaseFromOpenToClosed multi-step action
+ *
+ * Use method chaining to add steps, then call execute() to run the flow.
+ * Transitions to stage: CaseDefaultStageClosed
+ */
+class MoveDefaultCaseFromOpenToClosedFlowBuilder {
+    constructor(record, provider, pendingLinks, options) {
+        this._groups = [];
+        this._steps = [];
+        this._record = record;
+        this._provider = provider;
+        this._pendingLinks = pendingLinks;
+        this._options = options;
+    }
+    /**
+     * Add a group to the main action
+     * @param group - Group name to add
+     * @returns this (for method chaining)
+     */
+    addGroup(group) {
+        this._groups.push(group);
+        return 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, properties, options) {
+        var _a;
+        this._steps.push({
+            actionName: 'MarkCaseClosed',
+            properties,
+            id,
+            entity: 'SupportModule:Case',
+            schemaId: 'be8173eb-269b-4a67-be0c-11ce6af5d561',
+            schemaActionId: 'c6d9e241-8cd8-44f4-a215-40be5979b996',
+            autoLinkParent: false,
+            associations: (_a = options === null || options === void 0 ? void 0 : options.associations) === null || _a === void 0 ? void 0 : _a.map(a => (Object.assign(Object.assign({}, a), { linkType: null, relationType: undefined }))),
+            groups: options === null || options === void 0 ? void 0 : options.groups,
+        });
+        return this;
+    }
+    /**
+     * Execute the flow
+     * @returns The result from the API
+     */
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = this._buildRequestPayload();
+            const result = yield this._provider._applyAction('SupportModule', 'Case', payload);
+            // Clear pending links on the record after execution
+            this._record.clearPendingLinks();
+            return result;
+        });
+    }
+    /**
+     * Returns the request payload without executing (for debugging)
+     * @returns The request payload that would be sent to the API
+     */
+    dryRun() {
+        return this._buildRequestPayload();
+    }
+    /**
+     * Prevents accidental `await flowBuilder` without .execute()
+     * Forces developers to explicitly call .execute()
+     * @throws Error always - use .execute() or .dryRun() instead
+     */
+    then() {
+        throw new Error('FlowBuilder cannot be awaited directly. Call .execute() to run the flow or .dryRun() to get the payload.');
+    }
+    /**
+     * Build the request payload for the action
+     * @private
+     */
+    _buildRequestPayload() {
+        const record = this._record.record;
+        if (!(record === null || record === void 0 ? void 0 : record.id))
+            throw new Error('Cannot execute flow on unsaved record');
+        // Build steps with parent associations
+        const stepsWithAssociations = this._steps.map(step => {
+            const stepAssociations = [...(step.associations || [])];
+            // Auto-add parent association if step requires it
+            if (step.autoLinkParent) {
+                stepAssociations.push({
+                    entity: record.entity,
+                    recordId: record.id,
+                    linkType: null,
+                    relationType: 'PARENT',
+                });
+            }
+            return {
+                entity: step.entity,
+                type: step.type,
+                schemaId: step.schemaId,
+                schemaActionId: step.schemaActionId,
+                schemaTypeId: step.schemaTypeId,
+                actionName: step.actionName,
+                properties: step.properties,
+                title: step.title,
+                id: step.id,
+                associations: stepAssociations.length > 0 ? stepAssociations : undefined,
+                groups: step.groups,
+            };
+        });
+        return Object.assign({ id: record.id, entity: record.entity, type: record.type, actionName: 'MoveDefaultCaseFromOpenToClosed', schemaActionId: 'ec219350-d59b-4663-afeb-16a286c4ff0c', steps: stepsWithAssociations, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined, groups: this._groups.length > 0 ? this._groups : undefined, stageKey: 'CaseDefaultStageClosed' }, this._options);
+    }
+}
+exports.MoveDefaultCaseFromOpenToClosedFlowBuilder = MoveDefaultCaseFromOpenToClosedFlowBuilder;
+class CaseRecord {
+    /**
+     * 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, provider, preGeneratedId) {
+        this._pendingLinks = [];
+        this._record = record;
+        this._provider = provider;
+        this._preGeneratedId = preGeneratedId !== null && preGeneratedId !== void 0 ? preGeneratedId : (0, uuid_1.v4)();
+    }
+    // ============================================
+    // CORE PROPERTIES
+    // ============================================
+    /** Returns true if this is a new (unsaved) record */
+    get isNew() { var _a; return !((_a = this._record) === null || _a === void 0 ? void 0 : _a.id); }
+    /** Record ID - always available (pre-generated for new records) */
+    get id() { var _a, _b; return (_b = (_a = this._record) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : this._preGeneratedId; }
+    get entity() { var _a, _b; return (_b = (_a = this._record) === null || _a === void 0 ? void 0 : _a.entity) !== null && _b !== void 0 ? _b : 'SupportModule:Case'; }
+    get type() { var _a; return (_a = this._record) === null || _a === void 0 ? void 0 : _a.type; }
+    /** Record properties - empty object for new (unsaved) records */
+    get properties() { var _a; return ((_a = this._record) === null || _a === void 0 ? void 0 : _a.properties) || {}; }
+    get title() { var _a; return (_a = this._record) === null || _a === void 0 ? void 0 : _a.title; }
+    get recordNumber() { var _a; return (_a = this._record) === null || _a === void 0 ? void 0 : _a.recordNumber; }
+    get stage() { var _a; return (_a = this._record) === null || _a === void 0 ? void 0 : _a.stage; }
+    get createdAt() { var _a; return (_a = this._record) === null || _a === void 0 ? void 0 : _a.createdAt; }
+    get updatedAt() { var _a; return (_a = this._record) === null || _a === void 0 ? void 0 : _a.updatedAt; }
+    get externalId() { var _a; return (_a = this._record) === null || _a === void 0 ? void 0 : _a.externalId; }
+    get externalAppId() { var _a; return (_a = this._record) === null || _a === void 0 ? void 0 : _a.externalAppId; }
+    get groups() { var _a; return ((_a = this._record) === null || _a === void 0 ? void 0 : _a.groups) || []; }
+    /** Access the underlying OdinRecord (null for new records) */
+    get record() { return this._record; }
+    // ============================================
+    // TYPE GUARDS (with TypeScript type predicates)
+    // ============================================
+    /**
+     * 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() { var _a; return ((_a = this._record) === null || _a === void 0 ? void 0 : _a.type) === 'DEFAULT'; }
+    /**
+     * 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() { var _a; return ((_a = this._record) === null || _a === void 0 ? void 0 : _a.type) === 'OUTAGE'; }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._activityLogs) {
+            this._activityLogs = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'AuditModule:ActivityLog',
+                targetModuleName: 'AuditModule',
+                targetEntityName: 'ActivityLog',
+                labels: ['Case__ActivityLog'],
+            }, ActivityLogRecord_1.ActivityLogRecord);
+        }
+        return this._activityLogs;
+    }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._users) {
+            this._users = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'IdentityModule:User',
+                targetModuleName: 'IdentityModule',
+                targetEntityName: 'User',
+                labels: ['CaseOwner', 'Case__User', 'CaseCollaborators', 'favourite_cases'],
+            }, UserRecord_1.UserRecord);
+        }
+        return this._users;
+    }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._outages) {
+            this._outages = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'ServiceModule:Outage',
+                targetModuleName: 'ServiceModule',
+                targetEntityName: 'Outage',
+                labels: ['Outage__Case', 'Outage'],
+            }, OutageRecord_1.OutageRecord);
+        }
+        return this._outages;
+    }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._smsMessages) {
+            this._smsMessages = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'NotificationModule:SmsMessage',
+                targetModuleName: 'NotificationModule',
+                targetEntityName: 'SmsMessage',
+                labels: ['Case__SmsMessage'],
+            }, SmsMessageRecord_1.SmsMessageRecord);
+        }
+        return this._smsMessages;
+    }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._emails) {
+            this._emails = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'NotificationModule:Email',
+                targetModuleName: 'NotificationModule',
+                targetEntityName: 'Email',
+                labels: ['Case__Email'],
+            }, EmailRecord_1.EmailRecord);
+        }
+        return this._emails;
+    }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._calls) {
+            this._calls = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'NotificationModule:Call',
+                targetModuleName: 'NotificationModule',
+                targetEntityName: 'Call',
+                labels: ['Call__Case'],
+            }, CallRecord_1.CallRecord);
+        }
+        return this._calls;
+    }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._contractBuyOuts) {
+            this._contractBuyOuts = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'OrderModule:ContractBuyOut',
+                targetModuleName: 'OrderModule',
+                targetEntityName: 'ContractBuyOut',
+                labels: ['Case__ContractBuyOut'],
+            }, ContractBuyOutRecord_1.ContractBuyOutRecord);
+        }
+        return this._contractBuyOuts;
+    }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._teams) {
+            this._teams = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'IdentityModule:Team',
+                targetModuleName: 'IdentityModule',
+                targetEntityName: 'Team',
+                labels: ['Case_Team'],
+            }, TeamRecord_1.TeamRecord);
+        }
+        return this._teams;
+    }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._notes) {
+            this._notes = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'SupportModule:Note',
+                targetModuleName: 'SupportModule',
+                targetEntityName: 'Note',
+                labels: ['Case__Note'],
+            }, NoteRecord_1.NoteRecord);
+        }
+        return this._notes;
+    }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._accounts) {
+            this._accounts = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'CrmModule:Account',
+                targetModuleName: 'CrmModule',
+                targetEntityName: 'Account',
+                labels: ['Account__Case'],
+            }, AccountRecord_1.AccountRecord);
+        }
+        return this._accounts;
+    }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._workOrders) {
+            this._workOrders = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'FieldServiceModule:WorkOrder',
+                targetModuleName: 'FieldServiceModule',
+                targetEntityName: 'WorkOrder',
+                labels: ['Case__WorkOrder'],
+            }, WorkOrderRecord_1.WorkOrderRecord);
+        }
+        return this._workOrders;
+    }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._conversations) {
+            this._conversations = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'NotificationModule:Conversation',
+                targetModuleName: 'NotificationModule',
+                targetEntityName: 'Conversation',
+                labels: ['Case_Conversation'],
+            }, ConversationRecord_1.ConversationRecord);
+        }
+        return this._conversations;
+    }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._cases) {
+            this._cases = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'SupportModule:Case',
+                targetModuleName: 'SupportModule',
+                targetEntityName: 'Case',
+                labels: ['Case__Case'],
+            }, CaseRecord);
+        }
+        return this._cases;
+    }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._files) {
+            this._files = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'SchemaModule:File',
+                targetModuleName: 'SchemaModule',
+                targetEntityName: 'File',
+                labels: ['Case__File'],
+            }, FileRecord_1.FileRecord);
+        }
+        return this._files;
+    }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._orders) {
+            this._orders = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'OrderModule:Order',
+                targetModuleName: 'OrderModule',
+                targetEntityName: 'Order',
+                labels: ['Case__Order'],
+            }, OrderRecord_1.OrderRecord);
+        }
+        return this._orders;
+    }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._contacts) {
+            this._contacts = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'CrmModule:Contact',
+                targetModuleName: 'CrmModule',
+                targetEntityName: 'Contact',
+                labels: ['Case__Contact'],
+            }, ContactRecord_1.ContactRecord);
+        }
+        return this._contacts;
+    }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._addresses) {
+            this._addresses = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'CrmModule:Address',
+                targetModuleName: 'CrmModule',
+                targetEntityName: 'Address',
+                labels: ['Case__Address'],
+            }, AddressRecord_1.AddressRecord);
+        }
+        return this._addresses;
+    }
+    /**
+     * 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() {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('Cannot access links on a new (unsaved) record');
+        if (!this._pushNotifications) {
+            this._pushNotifications = new record_link_manager_1.RecordLinkManager(this._provider, this._record, {
+                sourceEntity: 'SupportModule:Case',
+                targetEntity: 'NotificationModule:PushNotification',
+                targetModuleName: 'NotificationModule',
+                targetEntityName: 'PushNotification',
+                labels: ['Case__PushNotification'],
+            }, PushNotificationRecord_1.PushNotificationRecord);
+        }
+        return this._pushNotifications;
+    }
+    // ============================================
+    // LINK MANAGEMENT
+    // ============================================
+    /**
+     * Queue a link to be created with the next action.
+     * Works for both create and update actions.
+     * @returns this (for chaining)
+     */
+    link(target) {
+        this._pendingLinks.push(new core_1.OdinRecordLinkDto({ id: target.id, entity: target.entity }));
+        return this;
+    }
+    /** Get the currently queued links */
+    get pendingLinks() {
+        return [...this._pendingLinks];
+    }
+    /** Clear pending links without executing an action */
+    clearPendingLinks() {
+        this._pendingLinks = [];
+        return this;
+    }
+    /**
+     * Immediately unlink a record (API call).
+     * Unlike link(), this executes immediately.
+     * @throws Error if called on a new (unsaved) record
+     */
+    unlink(target) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+                throw new Error('Cannot unlink from a new (unsaved) record');
+            const targetId = typeof target === 'string' ? target : target.id;
+            yield this._provider._deleteLinks('SupportModule', 'Case', this._record.id, targetId);
+        });
+    }
+    // ============================================
+    // CREATE ACTIONS (no existing record required)
+    // ============================================
+    /**
+     * 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, options) {
+        var _a, _b;
+        const payload = {
+            entity: 'SupportModule:Case',
+            type: (_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : (_b = this._record) === null || _b === void 0 ? void 0 : _b.type,
+            actionName: 'CreateCase',
+            properties: properties || {},
+            associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined,
+            journeyId: options === null || options === void 0 ? void 0 : options.journeyId,
+            stageKey: options === null || options === void 0 ? void 0 : options.stageKey,
+        };
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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, options) {
+        var _a, _b;
+        const payload = {
+            entity: 'SupportModule:Case',
+            type: (_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : (_b = this._record) === null || _b === void 0 ? void 0 : _b.type,
+            actionName: 'CreateCaseFromCases',
+            properties: properties || {},
+            associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined,
+            journeyId: options === null || options === void 0 ? void 0 : options.journeyId,
+            stageKey: options === null || options === void 0 ? void 0 : options.stageKey,
+        };
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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, options) {
+        const payload = {
+            entity: 'SupportModule:Case',
+            type: 'DEFAULT',
+            actionName: 'CreateCaseWithDpa',
+            properties: properties || {},
+            associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined,
+            journeyId: options === null || options === void 0 ? void 0 : options.journeyId,
+            stageKey: options === null || options === void 0 ? void 0 : options.stageKey,
+        };
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    // ============================================
+    // UPDATE ACTIONS (require existing record)
+    // ============================================
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('allowCsatForCase requires an existing record. Use accessor.get() first.');
+        let properties = {};
+        let opts = options;
+        if (propertiesOrOptions) {
+            if ('journeyId' in propertiesOrOptions || 'stageKey' in propertiesOrOptions) {
+                opts = propertiesOrOptions;
+            }
+            else {
+                properties = propertiesOrOptions;
+            }
+        }
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'AllowCsatForCase', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, opts);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('assignCaseByUser requires an existing record. Use accessor.get() first.');
+        let properties = {};
+        let opts = options;
+        if (propertiesOrOptions) {
+            if ('journeyId' in propertiesOrOptions || 'stageKey' in propertiesOrOptions) {
+                opts = propertiesOrOptions;
+            }
+            else {
+                properties = propertiesOrOptions;
+            }
+        }
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'AssignCaseByUser', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, opts);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('assignCase requires an existing record. Use accessor.get() first.');
+        let properties = {};
+        let opts = options;
+        if (propertiesOrOptions) {
+            if ('journeyId' in propertiesOrOptions || 'stageKey' in propertiesOrOptions) {
+                opts = propertiesOrOptions;
+            }
+            else {
+                properties = propertiesOrOptions;
+            }
+        }
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'AssignCase', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, opts);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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) {
+        return new AssignCaseWithNoteFlowFlowBuilder(this, this._provider, this._pendingLinks, options);
+    }
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('moveCaseToBlockedAction requires an existing record. Use accessor.get() first.');
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'MoveCaseToBlockedAction', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, options);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('casedefaultstageblocked requires an existing record. Use accessor.get() first.');
+        return new CasedefaultstageblockedFlowBuilder(this, this._provider, this._pendingLinks, options);
+    }
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('escalateCaseAction requires an existing record. Use accessor.get() first.');
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'EscalateCaseAction', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, options);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('caseDefaultStageEscalated requires an existing record. Use accessor.get() first.');
+        return new CaseDefaultStageEscalatedFlowBuilder(this, this._provider, this._pendingLinks, options);
+    }
+    /**
+     * 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) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('caseDefaultStageSolved requires an existing record. Use accessor.get() first.');
+        return new CaseDefaultStageSolvedFlowBuilder(this, this._provider, this._pendingLinks, options);
+    }
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('changeCaseChannel requires an existing record. Use accessor.get() first.');
+        let properties = {};
+        let opts = options;
+        if (propertiesOrOptions) {
+            if ('journeyId' in propertiesOrOptions || 'stageKey' in propertiesOrOptions) {
+                opts = propertiesOrOptions;
+            }
+            else {
+                properties = propertiesOrOptions;
+            }
+        }
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'ChangeCaseChannel', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, opts);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('editCaseForm requires an existing record. Use accessor.get() first.');
+        let properties = {};
+        let opts = options;
+        if (propertiesOrOptions) {
+            if ('journeyId' in propertiesOrOptions || 'stageKey' in propertiesOrOptions) {
+                opts = propertiesOrOptions;
+            }
+            else {
+                properties = propertiesOrOptions;
+            }
+        }
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'EditCaseForm', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, opts);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('escalateCaseTransition requires an existing record. Use accessor.get() first.');
+        return new EscalateCaseTransitionFlowBuilder(this, this._provider, this._pendingLinks, options);
+    }
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('exceptionInput requires an existing record. Use accessor.get() first.');
+        let properties = {};
+        let opts = options;
+        if (propertiesOrOptions) {
+            if ('journeyId' in propertiesOrOptions || 'stageKey' in propertiesOrOptions) {
+                opts = propertiesOrOptions;
+            }
+            else {
+                properties = propertiesOrOptions;
+            }
+        }
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'ExceptionInput', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, opts);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('markCaseClosed requires an existing record. Use accessor.get() first.');
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'MarkCaseClosed', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, options);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('markCaseResolved requires an existing record. Use accessor.get() first.');
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'MarkCaseResolved', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, options);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('moveCaseOutageToSolvedAction2 requires an existing record. Use accessor.get() first.');
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'MoveCaseOutageToSolvedAction2', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, options);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('moveCaseOutageToSolvedAction requires an existing record. Use accessor.get() first.');
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'MoveCaseOutageToSolvedAction', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, options);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('moveCaseOutageToSolvedTransition requires an existing record. Use accessor.get() first.');
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'MoveCaseOutageToSolvedTransition', associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined, stageKey: 'OutagePipelineStageSolved' }, options);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('moveCaseToBlockedTransition requires an existing record. Use accessor.get() first.');
+        return new MoveCaseToBlockedTransitionFlowBuilder(this, this._provider, this._pendingLinks, options);
+    }
+    /**
+     * 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) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('moveCaseToPendingAgentTransition requires an existing record. Use accessor.get() first.');
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'MoveCaseToPendingAgentTransition', associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined, stageKey: 'CaseDefaultStagePendingAgent' }, options);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('moveCaseToPendingReviewAction requires an existing record. Use accessor.get() first.');
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'MoveCaseToPendingReviewAction', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, options);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('moveCaseToPendingReviewTransition requires an existing record. Use accessor.get() first.');
+        return new MoveCaseToPendingReviewTransitionFlowBuilder(this, this._provider, this._pendingLinks, options);
+    }
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('moveCaseToSolvedAction requires an existing record. Use accessor.get() first.');
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'MoveCaseToSolvedAction', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, options);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('moveCaseToSolvedTransition requires an existing record. Use accessor.get() first.');
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'MoveCaseToSolvedTransition', associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined, stageKey: 'CaseDefaultStageSolved' }, options);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('moveDefaultCaseFromAnyStageToPendingAgent requires an existing record. Use accessor.get() first.');
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'MoveDefaultCaseFromAnyStageToPendingAgent', associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined, stageKey: 'CaseDefaultStagePendingAgent' }, options);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('moveDefaultCaseFromAnyStageToPendingReply requires an existing record. Use accessor.get() first.');
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'MoveDefaultCaseFromAnyStageToPendingReply', associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined, stageKey: 'CaseDefaultStagePendingReply' }, options);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('moveDefaultCaseFromOpenToClosed requires an existing record. Use accessor.get() first.');
+        return new MoveDefaultCaseFromOpenToClosedFlowBuilder(this, this._provider, this._pendingLinks, options);
+    }
+    /**
+     * 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) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('movetoClosed requires an existing record. Use accessor.get() first.');
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'MovetoClosed', associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined, stageKey: 'CaseDefaultStageClosed' }, options);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('removeAssignmentFromCase requires an existing record. Use accessor.get() first.');
+        let properties = {};
+        let opts = options;
+        if (propertiesOrOptions) {
+            if ('journeyId' in propertiesOrOptions || 'stageKey' in propertiesOrOptions) {
+                opts = propertiesOrOptions;
+            }
+            else {
+                properties = propertiesOrOptions;
+            }
+        }
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'RemoveAssignmentFromCase', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, opts);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('updateFormalComplaint requires an existing record. Use accessor.get() first.');
+        let properties = {};
+        let opts = options;
+        if (propertiesOrOptions) {
+            if ('journeyId' in propertiesOrOptions || 'stageKey' in propertiesOrOptions) {
+                opts = propertiesOrOptions;
+            }
+            else {
+                properties = propertiesOrOptions;
+            }
+        }
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'UpdateFormalComplaint', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, opts);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('updateSentiment requires an existing record. Use accessor.get() first.');
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'UpdateSentiment', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, options);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+    /**
+     * 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, options) {
+        var _a;
+        if (!((_a = this._record) === null || _a === void 0 ? void 0 : _a.id))
+            throw new Error('updateTags requires an existing record. Use accessor.get() first.');
+        const payload = Object.assign({ id: this._record.id, entity: this._record.entity, type: this._record.type, actionName: 'UpdateTags', properties, associations: this._pendingLinks.length > 0 ? this._pendingLinks : undefined }, options);
+        return new ActionBuilder(this._provider, 'SupportModule', 'Case', payload, () => { this._pendingLinks = []; });
+    }
+}
+exports.CaseRecord = CaseRecord;
+// ============================================
+// TYPED LINK ACCESSORS
+// ============================================
+/** Valid labels for ActivityLog associations */
+CaseRecord.activityLogsLabels = ['Case__ActivityLog'];
+/** Valid labels for User associations */
+CaseRecord.usersLabels = ['CaseOwner', 'Case__User', 'CaseCollaborators', 'favourite_cases'];
+/** Valid labels for Outage associations */
+CaseRecord.outagesLabels = ['Outage__Case', 'Outage'];
+/** Valid labels for SmsMessage associations */
+CaseRecord.smsMessagesLabels = ['Case__SmsMessage'];
+/** Valid labels for Email associations */
+CaseRecord.emailsLabels = ['Case__Email'];
+/** Valid labels for Call associations */
+CaseRecord.callsLabels = ['Call__Case'];
+/** Valid labels for ContractBuyOut associations */
+CaseRecord.contractBuyOutsLabels = ['Case__ContractBuyOut'];
+/** Valid labels for Team associations */
+CaseRecord.teamsLabels = ['Case_Team'];
+/** Valid labels for Note associations */
+CaseRecord.notesLabels = ['Case__Note'];
+/** Valid labels for Account associations */
+CaseRecord.accountsLabels = ['Account__Case'];
+/** Valid labels for WorkOrder associations */
+CaseRecord.workOrdersLabels = ['Case__WorkOrder'];
+/** Valid labels for Conversation associations */
+CaseRecord.conversationsLabels = ['Case_Conversation'];
+/** Valid labels for Case associations */
+CaseRecord.casesLabels = ['Case__Case'];
+/** Valid labels for File associations */
+CaseRecord.filesLabels = ['Case__File'];
+/** Valid labels for Order associations */
+CaseRecord.ordersLabels = ['Case__Order'];
+/** Valid labels for Contact associations */
+CaseRecord.contactsLabels = ['Case__Contact'];
+/** Valid labels for Address associations */
+CaseRecord.addressesLabels = ['Case__Address'];
+/** Valid labels for PushNotification associations */
+CaseRecord.pushNotificationsLabels = ['Case__PushNotification'];
+/** Type guard to check if an object is a CaseRecord */
+function isCaseRecord(obj) {
+    return obj instanceof CaseRecord;
+}
+exports.isCaseRecord = isCaseRecord;