@roarkanalytics/sdk 2.31.0 → 2.33.1

package/resources/metric.d.ts

@@ -3,13 +3,17 @@ import { APIPromise } from "../core/api-promise.js";
 import { RequestOptions } from "../internal/request-options.js";
 export declare class Metric extends APIResource {
     /**
-     * Create a new custom metric definition. The metric will be added to the specified
-     * analysis package and can be used for evaluating calls.
+     * Create a new metric definition. The `calculationType` field selects the variant:
+     * LLM_JUDGE (LLM-evaluated), FORMULA (computed from a math expression over other
+     * metrics), or PATTERN (detects a trigger→outcome pattern within a window). To
+     * create a threshold on top of an existing metric, use
+     * `POST /metric/definitions/{idOrSlug}/thresholds` instead.
      *
      * @example
      * ```ts
      * const response = await client.metric.createDefinition({
      *   analysisPackageId: '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+     *   calculationType: 'LLM_JUDGE',
      *   name: 'Customer Satisfaction',
      *   outputType: 'BOOLEAN',
      * });
@@ -19,35 +23,31 @@ export declare class Metric extends APIResource {
     /**
      * Fetch all metric definitions available in the project, including both
      * system-generated and custom metrics.
-     *
-     * @example
-     * ```ts
-     * const response = await client.metric.listDefinitions();
-     * ```
      */
     listDefinitions(options?: RequestOptions): APIPromise<MetricListDefinitionsResponse>;
 }
 export interface MetricCreateDefinitionResponse {
     /**
-     * Metric definition data
+     * The created metric definition. The variant is selected by `calculationType`.
      */
-    data: MetricCreateDefinitionResponse.Data;
+    data: MetricCreateDefinitionResponse.LlmJudgeMetricResponse | MetricCreateDefinitionResponse.FormulaMetricResponse | MetricCreateDefinitionResponse.PatternMetricResponse;
 }
 export declare namespace MetricCreateDefinitionResponse {
-    /**
-     * Metric definition data
-     */
-    interface Data {
+    interface LlmJudgeMetricResponse {
         /**
          * Unique identifier for the metric definition
          */
         id: string;
+        /**
+         * Metric evaluated by an LLM against a prompt.
+         */
+        calculationType: 'LLM_JUDGE';
         /**
          * Description of what the metric measures
          */
         description: string;
         /**
-         * Stable metric identifier (e.g. "call_reason", "customer_satisfaction")
+         * Alias of `slug` retained for backwards compatibility. Same value as `slug`.
          */
         metricId: string;
         /**
@@ -58,6 +58,10 @@ export declare namespace MetricCreateDefinitionResponse {
          * Whether metric is global or per-participant
          */
         scope: 'GLOBAL' | 'PER_PARTICIPANT';
+        /**
+         * Stable metric slug (e.g. "call_reason", "customer_satisfaction")
+         */
+        slug: string;
         /**
          * Which levels this metric can produce values at
          */
@@ -66,12 +70,208 @@ export declare namespace MetricCreateDefinitionResponse {
          * Type of value this metric produces
          */
         type: 'COUNT' | 'NUMERIC' | 'BOOLEAN' | 'SCALE' | 'TEXT' | 'CLASSIFICATION' | 'OFFSET';
+        /**
+         * The resolved variant this response reflects (org-scoped Default if the org has
+         * customized it, otherwise the system Default). Pass this as sourceVariantId when
+         * building a derived metric off this one to pin the exact config.
+         */
+        variantId: string;
+        /**
+         * The variant's current version. Immutable snapshot of the config — editing the
+         * metric produces a new versionId. Use it to detect config changes.
+         */
+        versionId: string;
+        /**
+         * Unit information if applicable
+         */
+        unit?: LlmJudgeMetricResponse.Unit;
+    }
+    namespace LlmJudgeMetricResponse {
+        /**
+         * Unit information if applicable
+         */
+        interface Unit {
+            /**
+             * Name of the unit
+             */
+            name: string;
+            /**
+             * Symbol for the unit
+             */
+            symbol: string | null;
+        }
+    }
+    interface FormulaMetricResponse {
+        /**
+         * Unique identifier for the metric definition
+         */
+        id: string;
+        /**
+         * Metric computed by evaluating an expression over other metrics.
+         */
+        calculationType: 'FORMULA';
+        /**
+         * Description of what the metric measures
+         */
+        description: string;
+        /**
+         * Formula configuration.
+         */
+        formula: FormulaMetricResponse.Formula;
+        /**
+         * Alias of `slug` retained for backwards compatibility. Same value as `slug`.
+         */
+        metricId: string;
+        /**
+         * Name of the metric
+         */
+        name: string;
+        /**
+         * Whether metric is global or per-participant
+         */
+        scope: 'GLOBAL' | 'PER_PARTICIPANT';
+        /**
+         * Stable metric slug (e.g. "call_reason", "customer_satisfaction")
+         */
+        slug: string;
+        /**
+         * Which levels this metric can produce values at
+         */
+        supportedContexts: Array<'CALL' | 'SEGMENT' | 'TURN'>;
+        /**
+         * Type of value this metric produces
+         */
+        type: 'COUNT' | 'NUMERIC' | 'BOOLEAN' | 'SCALE' | 'TEXT' | 'CLASSIFICATION' | 'OFFSET';
+        /**
+         * The resolved variant this response reflects (org-scoped Default if the org has
+         * customized it, otherwise the system Default). Pass this as sourceVariantId when
+         * building a derived metric off this one to pin the exact config.
+         */
+        variantId: string;
+        /**
+         * The variant's current version. Immutable snapshot of the config — editing the
+         * metric produces a new versionId. Use it to detect config changes.
+         */
+        versionId: string;
+        /**
+         * Unit information if applicable
+         */
+        unit?: FormulaMetricResponse.Unit;
+    }
+    namespace FormulaMetricResponse {
+        /**
+         * Formula configuration.
+         */
+        interface Formula {
+            expression: string;
+            sources: Array<Formula.Source>;
+        }
+        namespace Formula {
+            interface Source {
+                sourceMetricDefinitionId: string;
+                sourceVariantId: string | null;
+            }
+        }
+        /**
+         * Unit information if applicable
+         */
+        interface Unit {
+            /**
+             * Name of the unit
+             */
+            name: string;
+            /**
+             * Symbol for the unit
+             */
+            symbol: string | null;
+        }
+    }
+    interface PatternMetricResponse {
+        /**
+         * Unique identifier for the metric definition
+         */
+        id: string;
+        /**
+         * Metric detecting a trigger condition followed by an outcome within a window.
+         */
+        calculationType: 'PATTERN';
+        /**
+         * Description of what the metric measures
+         */
+        description: string;
+        /**
+         * Alias of `slug` retained for backwards compatibility. Same value as `slug`.
+         */
+        metricId: string;
+        /**
+         * Name of the metric
+         */
+        name: string;
+        /**
+         * Pattern configuration.
+         */
+        pattern: PatternMetricResponse.Pattern;
+        /**
+         * Whether metric is global or per-participant
+         */
+        scope: 'GLOBAL' | 'PER_PARTICIPANT';
+        /**
+         * Stable metric slug (e.g. "call_reason", "customer_satisfaction")
+         */
+        slug: string;
+        /**
+         * Which levels this metric can produce values at
+         */
+        supportedContexts: Array<'CALL' | 'SEGMENT' | 'TURN'>;
+        /**
+         * Type of value this metric produces
+         */
+        type: 'COUNT' | 'NUMERIC' | 'BOOLEAN' | 'SCALE' | 'TEXT' | 'CLASSIFICATION' | 'OFFSET';
+        /**
+         * The resolved variant this response reflects (org-scoped Default if the org has
+         * customized it, otherwise the system Default). Pass this as sourceVariantId when
+         * building a derived metric off this one to pin the exact config.
+         */
+        variantId: string;
+        /**
+         * The variant's current version. Immutable snapshot of the config — editing the
+         * metric produces a new versionId. Use it to detect config changes.
+         */
+        versionId: string;
         /**
          * Unit information if applicable
          */
-        unit?: Data.Unit;
+        unit?: PatternMetricResponse.Unit;
     }
-    namespace Data {
+    namespace PatternMetricResponse {
+        /**
+         * Pattern configuration.
+         */
+        interface Pattern {
+            operation: 'PATTERN_EXISTS' | 'PATTERN_COUNT' | 'OUTCOME_AGGREGATE';
+            outcome: Pattern.Outcome | null;
+            triggerCombinator: 'AND' | 'OR' | null;
+            triggers: Array<Pattern.Trigger>;
+            windowMode: string | null;
+        }
+        namespace Pattern {
+            interface Outcome {
+                operator: 'GREATER_THAN' | 'GREATER_THAN_OR_EQUALS' | 'LESS_THAN' | 'LESS_THAN_OR_EQUALS' | 'EQUALS' | 'NOT_EQUALS';
+                sourceMetricDefinitionId: string;
+                sourceParticipantRole: 'AGENT' | 'CUSTOMER' | 'SIMULATED_CUSTOMER' | 'BACKGROUND_SPEAKER' | null;
+                sourceVariantId: string | null;
+                thresholdValue: string;
+                windowAfter: number | null;
+                windowBefore: number | null;
+            }
+            interface Trigger {
+                operator: 'GREATER_THAN' | 'GREATER_THAN_OR_EQUALS' | 'LESS_THAN' | 'LESS_THAN_OR_EQUALS' | 'EQUALS' | 'NOT_EQUALS';
+                sourceMetricDefinitionId: string;
+                sourceParticipantRole: 'AGENT' | 'CUSTOMER' | 'SIMULATED_CUSTOMER' | 'BACKGROUND_SPEAKER' | null;
+                sourceVariantId: string | null;
+                thresholdValue: string;
+            }
+        }
         /**
          * Unit information if applicable
          */
@@ -91,23 +291,24 @@ export interface MetricListDefinitionsResponse {
     /**
      * Metrics response payload
      */
-    data: Array<MetricListDefinitionsResponse.Data>;
+    data: Array<MetricListDefinitionsResponse.LlmJudgeMetricResponse | MetricListDefinitionsResponse.ProviderMetricResponse | MetricListDefinitionsResponse.ThresholdMetricResponse | MetricListDefinitionsResponse.FormulaMetricResponse | MetricListDefinitionsResponse.PatternMetricResponse>;
 }
 export declare namespace MetricListDefinitionsResponse {
-    /**
-     * Metric definition data
-     */
-    interface Data {
+    interface LlmJudgeMetricResponse {
         /**
          * Unique identifier for the metric definition
          */
         id: string;
+        /**
+         * Metric evaluated by an LLM against a prompt.
+         */
+        calculationType: 'LLM_JUDGE';
         /**
          * Description of what the metric measures
          */
         description: string;
         /**
-         * Stable metric identifier (e.g. "call_reason", "customer_satisfaction")
+         * Alias of `slug` retained for backwards compatibility. Same value as `slug`.
          */
         metricId: string;
         /**
@@ -118,6 +319,10 @@ export declare namespace MetricListDefinitionsResponse {
          * Whether metric is global or per-participant
          */
         scope: 'GLOBAL' | 'PER_PARTICIPANT';
+        /**
+         * Stable metric slug (e.g. "call_reason", "customer_satisfaction")
+         */
+        slug: string;
         /**
          * Which levels this metric can produce values at
          */
@@ -126,12 +331,360 @@ export declare namespace MetricListDefinitionsResponse {
          * Type of value this metric produces
          */
         type: 'COUNT' | 'NUMERIC' | 'BOOLEAN' | 'SCALE' | 'TEXT' | 'CLASSIFICATION' | 'OFFSET';
+        /**
+         * The resolved variant this response reflects (org-scoped Default if the org has
+         * customized it, otherwise the system Default). Pass this as sourceVariantId when
+         * building a derived metric off this one to pin the exact config.
+         */
+        variantId: string;
+        /**
+         * The variant's current version. Immutable snapshot of the config — editing the
+         * metric produces a new versionId. Use it to detect config changes.
+         */
+        versionId: string;
         /**
          * Unit information if applicable
          */
-        unit?: Data.Unit;
+        unit?: LlmJudgeMetricResponse.Unit;
     }
-    namespace Data {
+    namespace LlmJudgeMetricResponse {
+        /**
+         * Unit information if applicable
+         */
+        interface Unit {
+            /**
+             * Name of the unit
+             */
+            name: string;
+            /**
+             * Symbol for the unit
+             */
+            symbol: string | null;
+        }
+    }
+    interface ProviderMetricResponse {
+        /**
+         * Unique identifier for the metric definition
+         */
+        id: string;
+        /**
+         * System-managed metric produced by an analysis provider.
+         */
+        calculationType: 'PROVIDER';
+        /**
+         * Description of what the metric measures
+         */
+        description: string;
+        /**
+         * Alias of `slug` retained for backwards compatibility. Same value as `slug`.
+         */
+        metricId: string;
+        /**
+         * Name of the metric
+         */
+        name: string;
+        /**
+         * Whether metric is global or per-participant
+         */
+        scope: 'GLOBAL' | 'PER_PARTICIPANT';
+        /**
+         * Stable metric slug (e.g. "call_reason", "customer_satisfaction")
+         */
+        slug: string;
+        /**
+         * Which levels this metric can produce values at
+         */
+        supportedContexts: Array<'CALL' | 'SEGMENT' | 'TURN'>;
+        /**
+         * Type of value this metric produces
+         */
+        type: 'COUNT' | 'NUMERIC' | 'BOOLEAN' | 'SCALE' | 'TEXT' | 'CLASSIFICATION' | 'OFFSET';
+        /**
+         * The resolved variant this response reflects (org-scoped Default if the org has
+         * customized it, otherwise the system Default). Pass this as sourceVariantId when
+         * building a derived metric off this one to pin the exact config.
+         */
+        variantId: string;
+        /**
+         * The variant's current version. Immutable snapshot of the config — editing the
+         * metric produces a new versionId. Use it to detect config changes.
+         */
+        versionId: string;
+        /**
+         * Unit information if applicable
+         */
+        unit?: ProviderMetricResponse.Unit;
+    }
+    namespace ProviderMetricResponse {
+        /**
+         * Unit information if applicable
+         */
+        interface Unit {
+            /**
+             * Name of the unit
+             */
+            name: string;
+            /**
+             * Symbol for the unit
+             */
+            symbol: string | null;
+        }
+    }
+    interface ThresholdMetricResponse {
+        /**
+         * Unique identifier for the metric definition
+         */
+        id: string;
+        /**
+         * Boolean metric derived by comparing a source metric against a threshold.
+         */
+        calculationType: 'THRESHOLD';
+        /**
+         * Description of what the metric measures
+         */
+        description: string;
+        /**
+         * Alias of `slug` retained for backwards compatibility. Same value as `slug`.
+         */
+        metricId: string;
+        /**
+         * Name of the metric
+         */
+        name: string;
+        /**
+         * Whether metric is global or per-participant
+         */
+        scope: 'GLOBAL' | 'PER_PARTICIPANT';
+        /**
+         * Stable metric slug (e.g. "call_reason", "customer_satisfaction")
+         */
+        slug: string;
+        /**
+         * Which levels this metric can produce values at
+         */
+        supportedContexts: Array<'CALL' | 'SEGMENT' | 'TURN'>;
+        /**
+         * Type of value this metric produces
+         */
+        type: 'COUNT' | 'NUMERIC' | 'BOOLEAN' | 'SCALE' | 'TEXT' | 'CLASSIFICATION' | 'OFFSET';
+        /**
+         * The resolved variant this response reflects (org-scoped Default if the org has
+         * customized it, otherwise the system Default). Pass this as sourceVariantId when
+         * building a derived metric off this one to pin the exact config.
+         */
+        variantId: string;
+        /**
+         * The variant's current version. Immutable snapshot of the config — editing the
+         * metric produces a new versionId. Use it to detect config changes.
+         */
+        versionId: string;
+        /**
+         * Threshold configuration.
+         */
+        threshold?: ThresholdMetricResponse.Threshold;
+        /**
+         * Unit information if applicable
+         */
+        unit?: ThresholdMetricResponse.Unit;
+    }
+    namespace ThresholdMetricResponse {
+        /**
+         * Threshold configuration.
+         */
+        interface Threshold {
+            aggregationMode: 'EACH' | 'COUNT' | 'AVERAGE' | 'MIN' | 'MAX' | 'MEDIAN' | 'P95' | 'P99' | 'SUM';
+            countThreshold: number | null;
+            operator: 'GREATER_THAN' | 'GREATER_THAN_OR_EQUALS' | 'LESS_THAN' | 'LESS_THAN_OR_EQUALS' | 'EQUALS' | 'NOT_EQUALS';
+            sourceMetricDefinitionId: string;
+            sourceParticipantRole: 'AGENT' | 'CUSTOMER' | 'SIMULATED_CUSTOMER' | 'BACKGROUND_SPEAKER' | null;
+            sourceVariantId: string | null;
+            thresholdValue: string;
+        }
+        /**
+         * Unit information if applicable
+         */
+        interface Unit {
+            /**
+             * Name of the unit
+             */
+            name: string;
+            /**
+             * Symbol for the unit
+             */
+            symbol: string | null;
+        }
+    }
+    interface FormulaMetricResponse {
+        /**
+         * Unique identifier for the metric definition
+         */
+        id: string;
+        /**
+         * Metric computed by evaluating an expression over other metrics.
+         */
+        calculationType: 'FORMULA';
+        /**
+         * Description of what the metric measures
+         */
+        description: string;
+        /**
+         * Formula configuration.
+         */
+        formula: FormulaMetricResponse.Formula;
+        /**
+         * Alias of `slug` retained for backwards compatibility. Same value as `slug`.
+         */
+        metricId: string;
+        /**
+         * Name of the metric
+         */
+        name: string;
+        /**
+         * Whether metric is global or per-participant
+         */
+        scope: 'GLOBAL' | 'PER_PARTICIPANT';
+        /**
+         * Stable metric slug (e.g. "call_reason", "customer_satisfaction")
+         */
+        slug: string;
+        /**
+         * Which levels this metric can produce values at
+         */
+        supportedContexts: Array<'CALL' | 'SEGMENT' | 'TURN'>;
+        /**
+         * Type of value this metric produces
+         */
+        type: 'COUNT' | 'NUMERIC' | 'BOOLEAN' | 'SCALE' | 'TEXT' | 'CLASSIFICATION' | 'OFFSET';
+        /**
+         * The resolved variant this response reflects (org-scoped Default if the org has
+         * customized it, otherwise the system Default). Pass this as sourceVariantId when
+         * building a derived metric off this one to pin the exact config.
+         */
+        variantId: string;
+        /**
+         * The variant's current version. Immutable snapshot of the config — editing the
+         * metric produces a new versionId. Use it to detect config changes.
+         */
+        versionId: string;
+        /**
+         * Unit information if applicable
+         */
+        unit?: FormulaMetricResponse.Unit;
+    }
+    namespace FormulaMetricResponse {
+        /**
+         * Formula configuration.
+         */
+        interface Formula {
+            expression: string;
+            sources: Array<Formula.Source>;
+        }
+        namespace Formula {
+            interface Source {
+                sourceMetricDefinitionId: string;
+                sourceVariantId: string | null;
+            }
+        }
+        /**
+         * Unit information if applicable
+         */
+        interface Unit {
+            /**
+             * Name of the unit
+             */
+            name: string;
+            /**
+             * Symbol for the unit
+             */
+            symbol: string | null;
+        }
+    }
+    interface PatternMetricResponse {
+        /**
+         * Unique identifier for the metric definition
+         */
+        id: string;
+        /**
+         * Metric detecting a trigger condition followed by an outcome within a window.
+         */
+        calculationType: 'PATTERN';
+        /**
+         * Description of what the metric measures
+         */
+        description: string;
+        /**
+         * Alias of `slug` retained for backwards compatibility. Same value as `slug`.
+         */
+        metricId: string;
+        /**
+         * Name of the metric
+         */
+        name: string;
+        /**
+         * Pattern configuration.
+         */
+        pattern: PatternMetricResponse.Pattern;
+        /**
+         * Whether metric is global or per-participant
+         */
+        scope: 'GLOBAL' | 'PER_PARTICIPANT';
+        /**
+         * Stable metric slug (e.g. "call_reason", "customer_satisfaction")
+         */
+        slug: string;
+        /**
+         * Which levels this metric can produce values at
+         */
+        supportedContexts: Array<'CALL' | 'SEGMENT' | 'TURN'>;
+        /**
+         * Type of value this metric produces
+         */
+        type: 'COUNT' | 'NUMERIC' | 'BOOLEAN' | 'SCALE' | 'TEXT' | 'CLASSIFICATION' | 'OFFSET';
+        /**
+         * The resolved variant this response reflects (org-scoped Default if the org has
+         * customized it, otherwise the system Default). Pass this as sourceVariantId when
+         * building a derived metric off this one to pin the exact config.
+         */
+        variantId: string;
+        /**
+         * The variant's current version. Immutable snapshot of the config — editing the
+         * metric produces a new versionId. Use it to detect config changes.
+         */
+        versionId: string;
+        /**
+         * Unit information if applicable
+         */
+        unit?: PatternMetricResponse.Unit;
+    }
+    namespace PatternMetricResponse {
+        /**
+         * Pattern configuration.
+         */
+        interface Pattern {
+            operation: 'PATTERN_EXISTS' | 'PATTERN_COUNT' | 'OUTCOME_AGGREGATE';
+            outcome: Pattern.Outcome | null;
+            triggerCombinator: 'AND' | 'OR' | null;
+            triggers: Array<Pattern.Trigger>;
+            windowMode: string | null;
+        }
+        namespace Pattern {
+            interface Outcome {
+                operator: 'GREATER_THAN' | 'GREATER_THAN_OR_EQUALS' | 'LESS_THAN' | 'LESS_THAN_OR_EQUALS' | 'EQUALS' | 'NOT_EQUALS';
+                sourceMetricDefinitionId: string;
+                sourceParticipantRole: 'AGENT' | 'CUSTOMER' | 'SIMULATED_CUSTOMER' | 'BACKGROUND_SPEAKER' | null;
+                sourceVariantId: string | null;
+                thresholdValue: string;
+                windowAfter: number | null;
+                windowBefore: number | null;
+            }
+            interface Trigger {
+                operator: 'GREATER_THAN' | 'GREATER_THAN_OR_EQUALS' | 'LESS_THAN' | 'LESS_THAN_OR_EQUALS' | 'EQUALS' | 'NOT_EQUALS';
+                sourceMetricDefinitionId: string;
+                sourceParticipantRole: 'AGENT' | 'CUSTOMER' | 'SIMULATED_CUSTOMER' | 'BACKGROUND_SPEAKER' | null;
+                sourceVariantId: string | null;
+                thresholdValue: string;
+            }
+        }
         /**
          * Unit information if applicable
          */
@@ -147,111 +700,253 @@ export declare namespace MetricListDefinitionsResponse {
         }
     }
 }
-export interface MetricCreateDefinitionParams {
-    /**
-     * ID of the analysis package to add this metric to
-     */
-    analysisPackageId: string;
-    /**
-     * Name of the metric
-     */
-    name: string;
-    /**
-     * Type of value this metric produces
-     */
-    outputType: 'COUNT' | 'NUMERIC' | 'BOOLEAN' | 'SCALE' | 'TEXT' | 'CLASSIFICATION' | 'OFFSET';
-    /**
-     * Label for the false/negative case (only for BOOLEAN type)
-     */
-    booleanFalseLabel?: string;
-    /**
-     * Label for the true/positive case (only for BOOLEAN type)
-     */
-    booleanTrueLabel?: string;
-    /**
-     * Options for classification. Required for CLASSIFICATION type.
-     */
-    classificationOptions?: Array<MetricCreateDefinitionParams.ClassificationOption>;
-    /**
-     * LLM prompt/criteria for evaluating this metric. Used to instruct the model on
-     * how to score. Required for BOOLEAN, NUMERIC, TEXT, and SCALE types.
-     */
-    llmPrompt?: string;
-    /**
-     * Maximum number of classifications that can be selected (only for CLASSIFICATION
-     * type)
-     */
-    maxClassifications?: number;
-    /**
-     * Unique identifier for the metric (e.g. "customer_satisfaction"). Auto-generated
-     * from name if not provided.
-     */
-    metricId?: string;
-    /**
-     * Participant role to evaluate. Required when scope is PER_PARTICIPANT.
-     */
-    participantRole?: 'AGENT' | 'CUSTOMER' | 'SIMULATED_CUSTOMER' | 'BACKGROUND_SPEAKER';
-    /**
-     * Labels for scale ranges (only for SCALE type)
-     */
-    scaleLabels?: Array<MetricCreateDefinitionParams.ScaleLabel>;
-    /**
-     * Maximum value for scale. Required for SCALE type.
-     */
-    scaleMax?: number;
-    /**
-     * Minimum value for scale. Required for SCALE type.
-     */
-    scaleMin?: number;
-    /**
-     * Whether metric is global or per-participant (default: GLOBAL)
-     */
-    scope?: 'GLOBAL' | 'PER_PARTICIPANT';
-    /**
-     * Which levels this metric can produce values at (default: ["CALL"])
-     */
-    supportedContexts?: Array<'CALL' | 'SEGMENT' | 'TURN'>;
-}
+export type MetricCreateDefinitionParams = MetricCreateDefinitionParams.PromptMetricInput | MetricCreateDefinitionParams.FormulaMetricInput | MetricCreateDefinitionParams.PatternMetricInput;
 export declare namespace MetricCreateDefinitionParams {
-    interface ClassificationOption {
+    interface PromptMetricInput {
         /**
-         * Description of what this option means
+         * ID of the analysis package to add this metric to
          */
-        description: string;
+        analysisPackageId: string;
         /**
-         * Display order of this option
+         * LLM-evaluated metric.
          */
-        displayOrder: number;
+        calculationType: 'LLM_JUDGE';
         /**
-         * Label for this classification option
+         * Name of the metric
          */
-        label: string;
+        name: string;
+        /**
+         * Type of value this metric produces
+         */
+        outputType: 'COUNT' | 'NUMERIC' | 'BOOLEAN' | 'SCALE' | 'TEXT' | 'CLASSIFICATION' | 'OFFSET';
+        /**
+         * Label for the false case (only for BOOLEAN type)
+         */
+        booleanFalseLabel?: string;
+        /**
+         * Label for the true case (only for BOOLEAN type)
+         */
+        booleanTrueLabel?: string;
+        /**
+         * Options for classification. Required for CLASSIFICATION type.
+         */
+        classificationOptions?: Array<PromptMetricInput.ClassificationOption>;
+        /**
+         * LLM prompt/criteria for evaluating this metric. Required for BOOLEAN, NUMERIC,
+         * TEXT, and SCALE types.
+         */
+        llmPrompt?: string;
+        /**
+         * Maximum number of classifications that can be selected (only for CLASSIFICATION
+         * type)
+         */
+        maxClassifications?: number;
+        /**
+         * Alias of `slug` accepted for backwards compatibility. Use `slug` for new
+         * integrations.
+         */
+        metricId?: string;
+        /**
+         * Participant role to evaluate. Required when scope is PER_PARTICIPANT.
+         */
+        participantRole?: 'AGENT' | 'CUSTOMER' | 'SIMULATED_CUSTOMER' | 'BACKGROUND_SPEAKER';
+        /**
+         * Labels for scale ranges (only for SCALE type)
+         */
+        scaleLabels?: Array<PromptMetricInput.ScaleLabel>;
+        /**
+         * Maximum value for scale. Required for SCALE type.
+         */
+        scaleMax?: number;
+        /**
+         * Minimum value for scale. Required for SCALE type.
+         */
+        scaleMin?: number;
+        /**
+         * Whether metric is global or per-participant (default: GLOBAL)
+         */
+        scope?: 'GLOBAL' | 'PER_PARTICIPANT';
+        /**
+         * Stable slug for the metric. Auto-generated from name if omitted.
+         */
+        slug?: string;
+        /**
+         * Which levels this metric can produce values at (default: ["CALL"])
+         */
+        supportedContexts?: Array<'CALL' | 'SEGMENT' | 'TURN'>;
     }
-    interface ScaleLabel {
+    namespace PromptMetricInput {
         /**
-         * Display order of this label
+         * Option for classification metrics.
          */
-        displayOrder: number;
+        interface ClassificationOption {
+            description: string;
+            displayOrder: number;
+            label: string;
+        }
+        interface ScaleLabel {
+            /**
+             * Display order of this label
+             */
+            displayOrder: number;
+            /**
+             * Label for this range
+             */
+            label: string;
+            /**
+             * Maximum value for this label range
+             */
+            rangeMax: number;
+            /**
+             * Minimum value for this label range
+             */
+            rangeMin: number;
+            /**
+             * Hex color code for this label (e.g. "#FF0000")
+             */
+            colorHex?: string;
+            /**
+             * Description of what this range means
+             */
+            description?: string;
+        }
+    }
+    interface FormulaMetricInput {
+        /**
+         * ID of the analysis package to add this metric to
+         */
+        analysisPackageId: string;
+        /**
+         * Metric computed by evaluating a mathematical expression over other metrics.
+         */
+        calculationType: 'FORMULA';
+        /**
+         * Formula expression using `{{id:<uuid>}}` references to source metrics. Operators
+         * depend on output type: +, -, \*, / for NUMERIC; ==, !=, >=, <=, >, < for
+         * BOOLEAN.
+         */
+        formula: string;
+        /**
+         * Name of the metric
+         */
+        name: string;
+        /**
+         * Output type of the formula. NUMERIC for arithmetic expressions, BOOLEAN for
+         * comparison expressions.
+         */
+        outputType: 'NUMERIC' | 'BOOLEAN';
+        /**
+         * Source metrics referenced by the formula. Minimum 2.
+         */
+        sources: Array<FormulaMetricInput.Source>;
+        /**
+         * Alias of `slug` accepted for backwards compatibility. Use `slug` for new
+         * integrations.
+         */
+        metricId?: string;
+        /**
+         * Stable slug for the metric. Auto-generated from name if omitted.
+         */
+        slug?: string;
+    }
+    namespace FormulaMetricInput {
+        interface Source {
+            /**
+             * ID of a metric referenced in the formula
+             */
+            sourceMetricDefinitionId: string;
+            /**
+             * Variant of the source metric to use
+             */
+            sourceVariantId?: string;
+        }
+    }
+    interface PatternMetricInput {
+        /**
+         * ID of the analysis package to add this metric to
+         */
+        analysisPackageId: string;
+        /**
+         * Metric detecting temporal patterns: a trigger condition followed by an outcome
+         * within a window.
+         */
+        calculationType: 'PATTERN';
+        /**
+         * Name of the metric
+         */
+        name: string;
+        /**
+         * Pattern operation. PATTERN_EXISTS produces a BOOLEAN; PATTERN_COUNT produces a
+         * NUMERIC count; OUTCOME_AGGREGATE aggregates a numeric outcome.
+         */
+        operation: 'PATTERN_EXISTS' | 'PATTERN_COUNT' | 'OUTCOME_AGGREGATE';
         /**
-         * Label for this range
+         * Outcome condition evaluated within the window relative to the trigger.
          */
-        label: string;
+        outcome: PatternMetricInput.Outcome;
         /**
-         * Maximum value for this label range
+         * Alias of `slug` accepted for backwards compatibility. Use `slug` for new
+         * integrations.
          */
-        rangeMax: number;
+        metricId?: string;
         /**
-         * Minimum value for this label range
+         * Stable slug for the metric. Auto-generated from name if omitted.
          */
-        rangeMin: number;
+        slug?: string;
         /**
-         * Hex color code for this label (e.g. "#FF0000")
+         * Single trigger condition. Use either trigger or triggers + triggerCombinator.
          */
-        colorHex?: string;
+        trigger?: PatternMetricInput.Trigger;
         /**
-         * Description of what this range means
+         * How to combine multiple triggers. Required when triggers has more than 1 entry.
          */
-        description?: string;
+        triggerCombinator?: 'AND' | 'OR';
+        /**
+         * Multiple trigger conditions. Use with triggerCombinator.
+         */
+        triggers?: Array<PatternMetricInput.Trigger>;
+        /**
+         * Unit for trigger/outcome window values (default: seconds)
+         */
+        windowMode?: 'seconds' | 'segments';
+    }
+    namespace PatternMetricInput {
+        /**
+         * Outcome condition evaluated within the window relative to the trigger.
+         */
+        interface Outcome {
+            operator: 'GREATER_THAN' | 'GREATER_THAN_OR_EQUALS' | 'LESS_THAN' | 'LESS_THAN_OR_EQUALS' | 'EQUALS' | 'NOT_EQUALS';
+            sourceMetricDefinitionId: string;
+            thresholdValue: string;
+            /**
+             * How far after the trigger to look for the outcome (in seconds or segments, see
+             * windowMode)
+             */
+            windowAfter: number;
+            sourceParticipantRole?: 'AGENT' | 'CUSTOMER' | 'SIMULATED_CUSTOMER' | 'BACKGROUND_SPEAKER';
+            sourceVariantId?: string;
+            /**
+             * How far before the trigger to look for the outcome (default: 0)
+             */
+            windowBefore?: number;
+        }
+        /**
+         * Single trigger condition. Use either trigger or triggers + triggerCombinator.
+         */
+        interface Trigger {
+            operator: 'GREATER_THAN' | 'GREATER_THAN_OR_EQUALS' | 'LESS_THAN' | 'LESS_THAN_OR_EQUALS' | 'EQUALS' | 'NOT_EQUALS';
+            sourceMetricDefinitionId: string;
+            thresholdValue: string;
+            sourceParticipantRole?: 'AGENT' | 'CUSTOMER' | 'SIMULATED_CUSTOMER' | 'BACKGROUND_SPEAKER';
+            sourceVariantId?: string;
+        }
+        interface Trigger {
+            operator: 'GREATER_THAN' | 'GREATER_THAN_OR_EQUALS' | 'LESS_THAN' | 'LESS_THAN_OR_EQUALS' | 'EQUALS' | 'NOT_EQUALS';
+            sourceMetricDefinitionId: string;
+            thresholdValue: string;
+            sourceParticipantRole?: 'AGENT' | 'CUSTOMER' | 'SIMULATED_CUSTOMER' | 'BACKGROUND_SPEAKER';
+            sourceVariantId?: string;
+        }
     }
 }
 export declare namespace Metric {