@odigos/vmagent-api-apollo-client 0.17.0 → 0.19.0

package/dist/generated/next/graphql.d.ts

@@ -144,6 +144,38 @@ export type ConnectorRuntimeHealth = {
     /** Human-readable status detail. */
     message?: Maybe<Scalars['String']['output']>;
 };
+export type ContainerOverride = {
+    __typename?: 'ContainerOverride';
+    containerName: Scalars['String']['output'];
+    /**
+     * Set true to exclude this container from instrumentation even when its runtime is supported.
+     * Absent or false means the workload-level decision applies.
+     *
+     * Stated as an opt-OUT rather than an `enabled` opt-in on purpose: several GraphQL code generators
+     * (genqlient among them) render a nullable Boolean as a plain bool with no omitempty, so an absent
+     * value arrives as `false`. With `enabled` that would read as "disable this container" and silently
+     * turn instrumentation off; with `disabled` the same zero value reads as "no opinion", which is the
+     * safe default. Any nullable Boolean added here should be phrased so its zero value is the safe one.
+     */
+    disabled?: Maybe<Scalars['Boolean']['output']>;
+    distroOverride?: Maybe<DistroOverride>;
+    runtimeOverride?: Maybe<RuntimeOverride>;
+};
+export type ContainerOverrideInput = {
+    containerName: Scalars['String']['input'];
+    /** Set true to exclude this container from instrumentation. See ContainerOverride.disabled. */
+    disabled?: InputMaybe<Scalars['Boolean']['input']>;
+    distroOverride?: InputMaybe<DistroOverrideInput>;
+    runtimeOverride?: InputMaybe<RuntimeOverrideInput>;
+};
+/** Process running in a containerd container (processKind "containerd"). */
+export type ContainerdProcessDetails = ProcessDetails & {
+    __typename?: 'ContainerdProcessDetails';
+    containerId?: Maybe<Scalars['String']['output']>;
+    imageName?: Maybe<Scalars['String']['output']>;
+    labels?: Maybe<Array<KeyValue>>;
+    processKind: Scalars['String']['output'];
+};
 export type CppProbe = {
     __typename?: 'CppProbe';
     signature: Scalars['String']['output'];
@@ -306,6 +338,71 @@ export type DistroOverride = {
 export type DistroOverrideInput = {
     otelDistroName?: InputMaybe<Scalars['String']['input']>;
 };
+/** Process running in a Docker container (processKind "docker"). */
+export type DockerProcessDetails = ProcessDetails & {
+    __typename?: 'DockerProcessDetails';
+    containerId?: Maybe<Scalars['String']['output']>;
+    containerName?: Maybe<Scalars['String']['output']>;
+    imageName?: Maybe<Scalars['String']['output']>;
+    /** Container labels; customer-defined keys, hence a list rather than named fields. */
+    labels?: Maybe<Array<KeyValue>>;
+    processKind: Scalars['String']['output'];
+};
+export type DockerSourceConfig = {
+    __typename?: 'DockerSourceConfig';
+    containerOverrides?: Maybe<Array<ContainerOverride>>;
+};
+export type DockerSourceConfigInput = {
+    containerOverrides?: InputMaybe<Array<ContainerOverrideInput>>;
+};
+/** Docker containers backing a workload on a host the agent runs on (kind "docker"). */
+export type DockerWorkloadDetails = WorkloadDetails & {
+    __typename?: 'DockerWorkloadDetails';
+    containers?: Maybe<Array<WorkloadContainer>>;
+    kind: Scalars['String']['output'];
+};
+/** Process running in an ECS task container on EC2 (processKind "ecs-docker"). */
+export type EcsProcessDetails = ProcessDetails & {
+    __typename?: 'EcsProcessDetails';
+    containerId?: Maybe<Scalars['String']['output']>;
+    containerName?: Maybe<Scalars['String']['output']>;
+    imageName?: Maybe<Scalars['String']['output']>;
+    labels?: Maybe<Array<KeyValue>>;
+    processKind: Scalars['String']['output'];
+    /** ARN of the running task, when the agent can resolve it. */
+    taskArn?: Maybe<Scalars['String']['output']>;
+    /** ECS task family this container belongs to. */
+    taskFamily?: Maybe<Scalars['String']['output']>;
+};
+export type EcsSourceConfig = {
+    __typename?: 'EcsSourceConfig';
+    containerOverrides?: Maybe<Array<ContainerOverride>>;
+};
+export type EcsSourceConfigInput = {
+    containerOverrides?: InputMaybe<Array<ContainerOverrideInput>>;
+};
+/**
+ * An ECS service or task (kinds "aws.fargate-task", "aws.ecs", "ecs-docker").
+ *
+ * Two very different reporters populate this type and each fills the subset it can see, which is why
+ * every field is nullable: the cloud connector rewrites task definitions and knows the cluster, the
+ * revision, and the launch type but never sees a process; the ECS agent on EC2 sees processes inside
+ * containers but reaches the control plane only through the task metadata endpoint.
+ */
+export type EcsWorkloadDetails = WorkloadDetails & {
+    __typename?: 'EcsWorkloadDetails';
+    /** ARN of the cluster the service runs in. */
+    clusterArn?: Maybe<Scalars['String']['output']>;
+    /** Every container in the task definition, instrumentable or not. */
+    containers?: Maybe<Array<WorkloadContainer>>;
+    /** Deployment controller type (ECS, CODE_DEPLOY, EXTERNAL); instrumentation requires ECS. */
+    deploymentController?: Maybe<Scalars['String']['output']>;
+    kind: Scalars['String']['output'];
+    /** FARGATE, FARGATE_SPOT, or EC2. */
+    launchType?: Maybe<Scalars['String']['output']>;
+    /** Task definition family:revision currently deployed. */
+    taskDefinition?: Maybe<Scalars['String']['output']>;
+};
 export type GolangProbe = {
     __typename?: 'GolangProbe';
     functionName?: Maybe<Scalars['String']['output']>;
@@ -360,6 +457,107 @@ export type HotFunctionsResult = {
     host?: Maybe<HostInfo>;
     services: Array<ServiceHotFunctions>;
 };
+/**
+ * The instrumentation rendered for one delivery tool: a snippet to paste, and the ordered steps that say where
+ * it goes.
+ *
+ * Every field is display-ready. Substitution happens connector-side rather than in a client, so there is only
+ * one place that has to know which of the two OTLP endpoint forms a given variable takes — the SDK accepts a
+ * bare host:port where it needs a scheme-qualified URL and then exports nowhere, which is not a failure any
+ * client would see.
+ */
+export type InstructionDocument = {
+    __typename?: 'InstructionDocument';
+    /** Fully rendered for THIS workload — endpoint, service name, region already substituted. */
+    content: Scalars['String']['output'];
+    description: Scalars['String']['output'];
+    /** Syntax hint for a code block: json | yaml | hcl | shell | text. */
+    format: Scalars['String']['output'];
+    /** Stable id, unique per connector. */
+    id: Scalars['String']['output'];
+    /** Ordered instructions shown above the snippet. The snippet alone never says where it goes. */
+    steps: Array<Scalars['String']['output']>;
+    title: Scalars['String']['output'];
+    /**
+     * Blanks the connector genuinely could not fill, so the customer knows what is still theirs to supply.
+     *
+     * Derived from the RENDERED text rather than from what the instructions declare, so a client cannot be asked
+     * for a value the document does not carry, and cannot miss one it does. Null when nothing is left to fill in.
+     */
+    unresolved?: Maybe<Array<InstructionInput>>;
+    /**
+     * Delivery tool this renders for: terraform, cloudformation, bicep, aws-cli, gcloud, az-cli, manual. A client
+     * uses it to pick a default and to key a chooser; it is not otherwise interpreted.
+     */
+    variant: Scalars['String']['output'];
+    /** Label for that chooser, e.g. "Terraform", "Bicep / ARM", "Reference". */
+    variantLabel: Scalars['String']['output'];
+};
+/** One blank the connector genuinely could not fill. */
+export type InstructionInput = {
+    __typename?: 'InstructionInput';
+    /**
+     * What to put there, and where to find it.
+     *
+     * It travels with the token because the token alone is not self-explanatory in the cases that matter most:
+     * the service name must MATCH the workload's name in Odigos rather than being any sensible label, and the two
+     * OTLP endpoint forms are the same destination spelled two ways that are not interchangeable.
+     */
+    description: Scalars['String']['output'];
+    /** The placeholder exactly as it appears in `content`, e.g. "<YOUR_CONTAINER>". */
+    placeholder: Scalars['String']['output'];
+};
+/**
+ * Instrumentation is attributable to Odigos but does not match what it should be (code
+ * "InstrumentationPartiallyApplied").
+ *
+ * This is a manual-mode condition specifically. In automatic mode a gap is a non-event — the next reconcile
+ * converges it — which is exactly why it needs reporting here: nothing converges a manual-mode workload, so a
+ * half-applied instrumentation stays half-applied and would otherwise report as healthy on the strength of its
+ * ownership marker alone.
+ */
+export type InstrumentationDriftDetails = WorkloadIssueDetails & {
+    __typename?: 'InstrumentationDriftDetails';
+    code: Scalars['String']['output'];
+    /**
+     * Provider-neutral names of the components that are absent or carry a stale value: ownershipMarker,
+     * serviceName, collectorExport, agentLoader, instrumentationLayer, agentSidecar, agentVolume, … A client
+     * renders these; it never re-derives which platform fact led to one.
+     */
+    missingComponents: Array<Scalars['String']['output']>;
+};
+/** Everything needed to instrument one workload by hand or by IaC. */
+export type InstrumentationInstructions = {
+    __typename?: 'InstrumentationInstructions';
+    /**
+     * The change rendered per delivery tool, in the connector's preferred order.
+     *
+     * Never empty. A connector that declares no per-tool rendering for a type still returns one `manual` document
+     * built from the desired state itself, because a customer on an unsupported toolchain needs the change
+     * described more than they need it in their own syntax.
+     */
+    documents: Array<InstructionDocument>;
+    kind: Scalars['String']['output'];
+    /**
+     * automatic | manual — why the customer is being shown this at all.
+     *
+     * Instructions are served in BOTH modes on purpose. In manual mode they are what the customer applies. In
+     * automatic mode they are the same change Odigos is about to make itself, which is what makes
+     * "what exactly did Odigos change here" answerable without reading a provider console.
+     */
+    mode: Scalars['String']['output'];
+    /**
+     * Caveats that belong with the instructions whichever tool the customer uses: a platform limit, a value they
+     * must supply, a step that is easy to complete and still not have telemetry (moving traffic onto a new
+     * revision).
+     */
+    notes: Array<Scalars['String']['output']>;
+    region?: Maybe<Scalars['String']['output']>;
+    /** Composite identity of the workload these are for, matching WorkloadReport. */
+    serviceName: Scalars['String']['output'];
+    /** RFC3339 timestamp the instructions were computed. */
+    updatedAt: Scalars['String']['output'];
+};
 export type InstrumentationRule = {
     enabled: Scalars['Boolean']['output'];
     name: Scalars['String']['output'];
@@ -393,6 +591,24 @@ export type JavaProbeInput = {
     className: Scalars['String']['input'];
     methodName: Scalars['String']['input'];
 };
+/** One key/value pair for data whose keys are defined by the customer rather than by Odigos. */
+export type KeyValue = {
+    __typename?: 'KeyValue';
+    key: Scalars['String']['output'];
+    value: Scalars['String']['output'];
+};
+/** A Lambda function (kind "aws.lambda"). */
+export type LambdaWorkloadDetails = WorkloadDetails & {
+    __typename?: 'LambdaWorkloadDetails';
+    /** Instruction set the function is configured for (x86_64 or arm64). */
+    architecture?: Maybe<Scalars['String']['output']>;
+    functionArn?: Maybe<Scalars['String']['output']>;
+    kind: Scalars['String']['output'];
+    /** ARN of the Odigos instrumentation layer attached to the function, when instrumented. */
+    layerArn?: Maybe<Scalars['String']['output']>;
+    /** Lambda-managed runtime identifier (e.g. "python3.12", "java21"). */
+    runtime?: Maybe<Scalars['String']['output']>;
+};
 export type Mutation = {
     __typename?: 'Mutation';
     cancelProfileBundle: Scalars['Boolean']['output'];
@@ -529,6 +745,14 @@ export type PipelineCounters = {
     scrapeError?: Maybe<Scalars['String']['output']>;
     scrapedAt: Scalars['String']['output'];
 };
+/**
+ * Kind-specific facts about ONE process, selected by WorkloadProcessMetadata.processKind. Null for
+ * plain host processes, whose pid/exe/cmdline are already named fields on WorkloadProcessMetadata.
+ */
+export type ProcessDetails = {
+    /** The WorkloadProcessMetadata.processKind this block describes. */
+    processKind: Scalars['String']['output'];
+};
 export type ProcessorAdditionAction = Action & {
     __typename?: 'ProcessorAdditionAction';
     actionName?: Maybe<Scalars['String']['output']>;
@@ -607,6 +831,11 @@ export type Query = {
     destination?: Maybe<Destination>;
     destinationTypes: Array<DestinationType>;
     destinations: Array<Destination>;
+    /**
+     * How to instrument one workload, keyed the same way as workloadReport. Null when the workload is unknown, or
+     * when its type has no instrumentation defined on this connector.
+     */
+    instrumentationInstructions?: Maybe<InstrumentationInstructions>;
     instrumentationRule?: Maybe<InstrumentationRule>;
     instrumentationRuleTypes: Array<InstrumentationRuleTypeOption>;
     instrumentationRules: Array<InstrumentationRule>;
@@ -634,6 +863,11 @@ export type QueryComputePlatformReportArgs = {
 export type QueryDestinationArgs = {
     name: Scalars['String']['input'];
 };
+export type QueryInstrumentationInstructionsArgs = {
+    kind: Scalars['String']['input'];
+    region?: InputMaybe<Scalars['String']['input']>;
+    serviceName: Scalars['String']['input'];
+};
 export type QueryInstrumentationRuleArgs = {
     name: Scalars['String']['input'];
 };
@@ -665,6 +899,44 @@ export type RestartSourcePayload = {
     name: Scalars['String']['output'];
     restarted: Scalars['Boolean']['output'];
 };
+/**
+ * A managed service whose deployments are immutable REVISIONS behind a traffic split: a Cloud Run service
+ * (kind "gcp.cloud-run") or an Azure Container App (kind "azure.container-apps").
+ *
+ * One type rather than one per platform, because every field here means the same thing on both — the platform
+ * resource identity, the revision the platform last reported ready, and the containers in that revision's
+ * template. `kind` already tells a client which platform it is, so two names for one shape buys nothing. This is
+ * the same reasoning that makes WorkloadContainer shared; per-platform types earn their keep for facts that are
+ * genuinely platform-specific (a Lambda layer ARN, an ECS launch type), not for a renamed field.
+ *
+ * It replaces CloudRunWorkloadDetails and ContainerAppsWorkloadDetails, which had already diverged in the one way
+ * that mattered: both called their revision field `revision` and documented it as OPPOSITE facts — Cloud Run's as
+ * the revision serving traffic, Container Apps' as the latest ready revision, explicitly "not necessarily the one
+ * serving requests". Both reporters in fact populate latest-ready, so a client branching on `__typename` was
+ * being told two different things about the same value. Naming the field for what it actually holds is the
+ * substantive half of this merge.
+ */
+export type RevisionedServiceWorkloadDetails = WorkloadDetails & {
+    __typename?: 'RevisionedServiceWorkloadDetails';
+    /** Every container in the revision's template, instrumentable or not. */
+    containers?: Maybe<Array<WorkloadContainer>>;
+    kind: Scalars['String']['output'];
+    /**
+     * Revision the platform last reported READY — the newest deployment that came up healthy.
+     *
+     * Deliberately NOT "the revision serving traffic", which is a different fact and the one that bites in manual
+     * (IaC) mode: revisions are immutable on both platforms, so instrumentation always produces a new one, and a
+     * traffic split can keep weighting an older, uninstrumented revision indefinitely. A customer can apply
+     * instrumentation correctly and still see no telemetry.
+     *
+     * Reporting which revision is READY is what lets them notice that at all. Reporting which revisions SERVE needs
+     * per-revision traffic weights (Cloud Run trafficStatuses, Container Apps ingress traffic), and that field gets
+     * added by whichever change first observes them — rather than existing now as a slot clients learn to ignore.
+     */
+    latestReadyRevision?: Maybe<Scalars['String']['output']>;
+    /** Fully-qualified platform resource identity: the Cloud Run service name, or the Container App resource id. */
+    service?: Maybe<Scalars['String']['output']>;
+};
 export declare enum RuleType {
     CodeAttributes = "CodeAttributes",
     CustomInstrumentation = "CustomInstrumentation",
@@ -713,11 +985,28 @@ export type Source = {
 export type SourceConfig = {
     __typename?: 'SourceConfig';
     distroOverride?: Maybe<DistroOverride>;
+    docker?: Maybe<DockerSourceConfig>;
+    /**
+     * Kind-specific config. At most one branch is set and it must match the source's kind (validated
+     * server-side), following the same discriminator-plus-typed-branch pattern as
+     * CreateInstrumentationRuleInput. See SourceConfigInput for the full rationale.
+     */
+    ecs?: Maybe<EcsSourceConfig>;
     runtimeOverride?: Maybe<RuntimeOverride>;
     serviceNameOverride?: Maybe<ServiceNameOverride>;
 };
 export type SourceConfigInput = {
     distroOverride?: InputMaybe<DistroOverrideInput>;
+    docker?: InputMaybe<DockerSourceConfigInput>;
+    /**
+     * Kind-specific config. At most one branch may be set and it must match the source's kind
+     * (validated server-side) — a Lambda source rejects `ecs`.
+     *
+     * GraphQL has no input unions, so a discriminator plus typed optional branches is the only way to
+     * express this on the write side; it is the same shape CreateInstrumentationRuleInput uses for
+     * ruleType. Adding a platform means adding a branch here, never widening an untyped map.
+     */
+    ecs?: InputMaybe<EcsSourceConfigInput>;
     runtimeOverride?: InputMaybe<RuntimeOverrideInput>;
     serviceNameOverride?: InputMaybe<ServiceNameOverrideInput>;
 };
@@ -760,6 +1049,15 @@ export type SpanMetricsConfigInput = {
     metricsExpiration?: InputMaybe<Scalars['String']['input']>;
     resourceMetricsKeyAttributes?: InputMaybe<Array<Scalars['String']['input']>>;
 };
+/** Process managed by systemd (processKind "systemd"). */
+export type SystemdProcessDetails = ProcessDetails & {
+    __typename?: 'SystemdProcessDetails';
+    processKind: Scalars['String']['output'];
+    /** Absolute path of the unit file backing this service. */
+    unitFilePath?: Maybe<Scalars['String']['output']>;
+    /** Unit name without the .service suffix. */
+    unitName?: Maybe<Scalars['String']['output']>;
+};
 export declare enum TelemetrySignal {
     Logs = "LOGS",
     Metrics = "METRICS",
@@ -862,6 +1160,51 @@ export type UpdateSourceInput = {
     region?: InputMaybe<Scalars['String']['input']>;
     serviceName?: InputMaybe<Scalars['String']['input']>;
 };
+/**
+ * One container inside a multi-container workload. Shared by every container-shaped platform (ECS
+ * tasks, Cloud Run services, and Kubernetes pods if the k8s API ever moves here) so clients render
+ * containers the same way everywhere.
+ *
+ * This is the dimension the flat report cannot express: a single ECS task definition can pack several
+ * independently instrumentable application containers, and reporting only the workload's aggregate
+ * runtime forces an arbitrary choice between them.
+ */
+export type WorkloadContainer = {
+    __typename?: 'WorkloadContainer';
+    /** Odigos distro applied to this container, when instrumented. */
+    distro?: Maybe<Scalars['String']['output']>;
+    /**
+     * Why this container is not instrumented. This is the ONE place a client learns that, and
+     * deliberately so: every platform-specific fact that leads to an exclusion is resolved by the
+     * reporter and reported here, never as a separate flag the client has to interpret for itself.
+     *
+     * A container Odigos itself injected reports "Odigos agents sidecar"; one the platform does not
+     * treat as part of the application reports "non-essential container"; an unsupported runtime says
+     * so. A client renders the reason — it never re-derives the decision, and it never needs a
+     * platform-specific field (ECS `essential`, an Odigos ownership marker) to do it.
+     */
+    excludedReason?: Maybe<Scalars['String']['output']>;
+    /** Image reference as declared by the customer. */
+    image?: Maybe<Scalars['String']['output']>;
+    /** True when Odigos can instrument this container; false with excludedReason when it cannot. */
+    instrumentationEligible: Scalars['Boolean']['output'];
+    /** True when Odigos instrumentation is currently applied to this container. */
+    instrumented: Scalars['Boolean']['output'];
+    /** Container name, unique within the workload and stable across deployments. */
+    name: Scalars['String']['output'];
+    /**
+     * PIDs observed running in this container, keying into the workload's `instances` and
+     * `processMetadata` — the container layer groups those rows, it does not duplicate them, so the
+     * workload's flat process list stays the single source of truth for per-process facts.
+     *
+     * Empty when the reporter cannot see inside the container: a cloud connector rewriting an ECS task
+     * definition knows the container exists and what runs in it, but never observes its processes. An
+     * empty list therefore means "no process visibility", not "no processes".
+     */
+    pids?: Maybe<Array<Scalars['Int']['output']>>;
+    /** Detected, overridden, and effective runtime for this container specifically. */
+    runtime?: Maybe<WorkloadRuntimeSnapshot>;
+};
 export type WorkloadCurrentReport = {
     __typename?: 'WorkloadCurrentReport';
     instrumented: Scalars['Boolean']['output'];
@@ -882,6 +1225,20 @@ export type WorkloadDesiredReport = {
     sourceEnabled?: Maybe<Scalars['Boolean']['output']>;
     sourceMatched?: Maybe<Scalars['Boolean']['output']>;
 };
+/**
+ * Kind-specific facts about a workload as a whole. The concrete type is selected by
+ * WorkloadReport.kind.
+ *
+ * Container-shaped kinds (docker, ecs, cloud-run, container-apps) resolve to a type carrying
+ * `containers`, which adds the container layer between the workload and its processes. Process-shaped
+ * kinds (systemd, plain host processes) have no container layer at all and leave `details` null: their
+ * processes hang directly off the workload's `instances` / `processMetadata`, with no empty container
+ * wrapper invented to make the shapes match.
+ */
+export type WorkloadDetails = {
+    /** The WorkloadReport.kind this block describes, echoed so clients can branch without a fragment. */
+    kind: Scalars['String']['output'];
+};
 export type WorkloadInstanceStatus = {
     __typename?: 'WorkloadInstanceStatus';
     alive: Scalars['Boolean']['output'];
@@ -899,12 +1256,30 @@ export type WorkloadInstanceStatus = {
 export type WorkloadIssue = {
     __typename?: 'WorkloadIssue';
     code: Scalars['String']['output'];
+    /**
+     * Machine-readable facts behind this issue, typed per `code`. Null for issues whose message is the whole
+     * story.
+     *
+     * It exists because `message` had become the only channel for facts a client needs to ACT on rather than
+     * display: which parts of an instrumentation are missing arrives today as a prose sentence a UI would have
+     * to parse back apart to render as a list, or to offer a targeted fix for. Adding a code here means adding a
+     * branch, never a new convention for encoding data into a sentence.
+     */
+    details?: Maybe<WorkloadIssueDetails>;
     message: Scalars['String']['output'];
     severity: Scalars['String']['output'];
     /** RFC3339 timestamp when the issue was first observed. */
     since?: Maybe<Scalars['String']['output']>;
     transient?: Maybe<Scalars['Boolean']['output']>;
 };
+/**
+ * Facts behind one WorkloadIssue, typed by its `code`. Same discriminator-plus-typed-branch pattern as
+ * WorkloadDetails and the rule/action config branches.
+ */
+export type WorkloadIssueDetails = {
+    /** The WorkloadIssue.code this block describes, echoed so clients can branch without a fragment. */
+    code: Scalars['String']['output'];
+};
 /**
  * One live process under this workload from the instrumentation controller's AnalyzedProcess snapshot
  * (eligible for instrumentation, instrumented, or excluded / uninstrumentable).
@@ -912,6 +1287,12 @@ export type WorkloadIssue = {
 export type WorkloadProcessMetadata = {
     __typename?: 'WorkloadProcessMetadata';
     cmdline?: Maybe<Scalars['String']['output']>;
+    /**
+     * Kind-specific facts about this process, typed per processKind (container id/name/image for
+     * container kinds, unit file for systemd). Null for plain host processes, whose pid/exe/cmdline are
+     * already named fields above.
+     */
+    details?: Maybe<ProcessDetails>;
     /** Set when instrumentationEligible is false (e.g. language mismatch). */
     excludedReason?: Maybe<Scalars['String']['output']>;
     exe?: Maybe<Scalars['String']['output']>;
@@ -919,7 +1300,10 @@ export type WorkloadProcessMetadata = {
     instrumentationEligible: Scalars['Boolean']['output'];
     /** True when the workload is instrumented and this PID is targeted (same notion as instances.instrumented). */
     instrumented: Scalars['Boolean']['output'];
-    /** Arbitrary string attributes (e.g. container.id from ResourceAttributes); JSON object with string values. */
+    /**
+     * Arbitrary string attributes (e.g. container.id from ResourceAttributes); JSON object with string values.
+     * @deprecated Use `details`, which names and types the same facts per processKind. Still populated; will be removed once clients have migrated.
+     */
     metadata?: Maybe<Scalars['JSON']['output']>;
     /** Names of other instrumentation agents detected in this process (e.g. "Datadog Agent"); empty or absent when none. */
     otherAgentNames?: Maybe<Array<Scalars['String']['output']>>;
@@ -944,6 +1328,12 @@ export type WorkloadReport = {
     __typename?: 'WorkloadReport';
     current: WorkloadCurrentReport;
     desired: WorkloadDesiredReport;
+    /**
+     * Kind-specific facts about this workload, typed per kind. Container-shaped kinds resolve to a type
+     * carrying `containers`, which groups the flat `instances` / `processMetadata` above by container;
+     * process-shaped kinds (systemd, plain processes) leave this null and expose processes directly.
+     */
+    details?: Maybe<WorkloadDetails>;
     /** Tracked PIDs, sorted ascending by pid in the backing store. */
     instances?: Maybe<Array<WorkloadInstanceStatus>>;
     issues?: Maybe<Array<WorkloadIssue>>;
@@ -1642,6 +2032,80 @@ export type TestConnectionMutation = {
         reason?: string | null;
     };
 };
+export type InstructionDocumentFieldsFragment = {
+    __typename?: 'InstructionDocument';
+    id: string;
+    variant: string;
+    variantLabel: string;
+    title: string;
+    description: string;
+    steps: Array<string>;
+    format: string;
+    content: string;
+    unresolved?: Array<{
+        __typename?: 'InstructionInput';
+        placeholder: string;
+        description: string;
+    }> | null;
+};
+export type InstrumentationInstructionsFieldsFragment = {
+    __typename?: 'InstrumentationInstructions';
+    serviceName: string;
+    kind: string;
+    region?: string | null;
+    mode: string;
+    notes: Array<string>;
+    updatedAt: string;
+    documents: Array<{
+        __typename?: 'InstructionDocument';
+        id: string;
+        variant: string;
+        variantLabel: string;
+        title: string;
+        description: string;
+        steps: Array<string>;
+        format: string;
+        content: string;
+        unresolved?: Array<{
+            __typename?: 'InstructionInput';
+            placeholder: string;
+            description: string;
+        }> | null;
+    }>;
+};
+export type GetInstrumentationInstructionsQueryVariables = Exact<{
+    serviceName: Scalars['String']['input'];
+    kind: Scalars['String']['input'];
+    region?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type GetInstrumentationInstructionsQuery = {
+    __typename?: 'Query';
+    instrumentationInstructions?: {
+        __typename?: 'InstrumentationInstructions';
+        serviceName: string;
+        kind: string;
+        region?: string | null;
+        mode: string;
+        notes: Array<string>;
+        updatedAt: string;
+        documents: Array<{
+            __typename?: 'InstructionDocument';
+            id: string;
+            variant: string;
+            variantLabel: string;
+            title: string;
+            description: string;
+            steps: Array<string>;
+            format: string;
+            content: string;
+            unresolved?: Array<{
+                __typename?: 'InstructionInput';
+                placeholder: string;
+                description: string;
+            }> | null;
+        }>;
+    } | null;
+};
 export type InstrumentationRuleTypeFieldsFragment = {
     __typename?: 'InstrumentationRuleTypeOption';
     type: string;
@@ -2287,6 +2751,20 @@ export type ConfigureProfilingCacheMutation = {
         };
     };
 };
+export type ContainerOverrideFieldsFragment = {
+    __typename?: 'ContainerOverride';
+    containerName: string;
+    disabled?: boolean | null;
+    runtimeOverride?: {
+        __typename?: 'RuntimeOverride';
+        language?: string | null;
+        version?: string | null;
+    } | null;
+    distroOverride?: {
+        __typename?: 'DistroOverride';
+        otelDistroName?: string | null;
+    } | null;
+};
 export type GetSourceQueryVariables = Exact<{
     name: Scalars['String']['input'];
 }>;
@@ -2314,6 +2792,40 @@ export type GetSourceQuery = {
                 __typename?: 'ServiceNameOverride';
                 serviceName?: string | null;
             } | null;
+            ecs?: {
+                __typename?: 'EcsSourceConfig';
+                containerOverrides?: Array<{
+                    __typename?: 'ContainerOverride';
+                    containerName: string;
+                    disabled?: boolean | null;
+                    runtimeOverride?: {
+                        __typename?: 'RuntimeOverride';
+                        language?: string | null;
+                        version?: string | null;
+                    } | null;
+                    distroOverride?: {
+                        __typename?: 'DistroOverride';
+                        otelDistroName?: string | null;
+                    } | null;
+                }> | null;
+            } | null;
+            docker?: {
+                __typename?: 'DockerSourceConfig';
+                containerOverrides?: Array<{
+                    __typename?: 'ContainerOverride';
+                    containerName: string;
+                    disabled?: boolean | null;
+                    runtimeOverride?: {
+                        __typename?: 'RuntimeOverride';
+                        language?: string | null;
+                        version?: string | null;
+                    } | null;
+                    distroOverride?: {
+                        __typename?: 'DistroOverride';
+                        otelDistroName?: string | null;
+                    } | null;
+                }> | null;
+            } | null;
         } | null;
     } | null;
 };
@@ -2344,6 +2856,40 @@ export type GetSourcesQuery = {
                 __typename?: 'ServiceNameOverride';
                 serviceName?: string | null;
             } | null;
+            ecs?: {
+                __typename?: 'EcsSourceConfig';
+                containerOverrides?: Array<{
+                    __typename?: 'ContainerOverride';
+                    containerName: string;
+                    disabled?: boolean | null;
+                    runtimeOverride?: {
+                        __typename?: 'RuntimeOverride';
+                        language?: string | null;
+                        version?: string | null;
+                    } | null;
+                    distroOverride?: {
+                        __typename?: 'DistroOverride';
+                        otelDistroName?: string | null;
+                    } | null;
+                }> | null;
+            } | null;
+            docker?: {
+                __typename?: 'DockerSourceConfig';
+                containerOverrides?: Array<{
+                    __typename?: 'ContainerOverride';
+                    containerName: string;
+                    disabled?: boolean | null;
+                    runtimeOverride?: {
+                        __typename?: 'RuntimeOverride';
+                        language?: string | null;
+                        version?: string | null;
+                    } | null;
+                    distroOverride?: {
+                        __typename?: 'DistroOverride';
+                        otelDistroName?: string | null;
+                    } | null;
+                }> | null;
+            } | null;
         } | null;
     }>;
 };
@@ -2374,6 +2920,40 @@ export type CreateSourceMutation = {
                 __typename?: 'ServiceNameOverride';
                 serviceName?: string | null;
             } | null;
+            ecs?: {
+                __typename?: 'EcsSourceConfig';
+                containerOverrides?: Array<{
+                    __typename?: 'ContainerOverride';
+                    containerName: string;
+                    disabled?: boolean | null;
+                    runtimeOverride?: {
+                        __typename?: 'RuntimeOverride';
+                        language?: string | null;
+                        version?: string | null;
+                    } | null;
+                    distroOverride?: {
+                        __typename?: 'DistroOverride';
+                        otelDistroName?: string | null;
+                    } | null;
+                }> | null;
+            } | null;
+            docker?: {
+                __typename?: 'DockerSourceConfig';
+                containerOverrides?: Array<{
+                    __typename?: 'ContainerOverride';
+                    containerName: string;
+                    disabled?: boolean | null;
+                    runtimeOverride?: {
+                        __typename?: 'RuntimeOverride';
+                        language?: string | null;
+                        version?: string | null;
+                    } | null;
+                    distroOverride?: {
+                        __typename?: 'DistroOverride';
+                        otelDistroName?: string | null;
+                    } | null;
+                }> | null;
+            } | null;
         } | null;
     };
 };
@@ -2404,6 +2984,40 @@ export type UpdateSourceMutation = {
                 __typename?: 'ServiceNameOverride';
                 serviceName?: string | null;
             } | null;
+            ecs?: {
+                __typename?: 'EcsSourceConfig';
+                containerOverrides?: Array<{
+                    __typename?: 'ContainerOverride';
+                    containerName: string;
+                    disabled?: boolean | null;
+                    runtimeOverride?: {
+                        __typename?: 'RuntimeOverride';
+                        language?: string | null;
+                        version?: string | null;
+                    } | null;
+                    distroOverride?: {
+                        __typename?: 'DistroOverride';
+                        otelDistroName?: string | null;
+                    } | null;
+                }> | null;
+            } | null;
+            docker?: {
+                __typename?: 'DockerSourceConfig';
+                containerOverrides?: Array<{
+                    __typename?: 'ContainerOverride';
+                    containerName: string;
+                    disabled?: boolean | null;
+                    runtimeOverride?: {
+                        __typename?: 'RuntimeOverride';
+                        language?: string | null;
+                        version?: string | null;
+                    } | null;
+                    distroOverride?: {
+                        __typename?: 'DistroOverride';
+                        otelDistroName?: string | null;
+                    } | null;
+                }> | null;
+            } | null;
         } | null;
     };
 };
@@ -2485,6 +3099,11 @@ export type WorkloadReportFieldsFragment = {
         message: string;
         since?: string | null;
         transient?: boolean | null;
+        details?: {
+            __typename: 'InstrumentationDriftDetails';
+            missingComponents: Array<string>;
+            code: string;
+        } | null;
     }> | null;
     instances?: Array<{
         __typename?: 'WorkloadInstanceStatus';
@@ -2532,8 +3151,338 @@ export type WorkloadReportFieldsFragment = {
                 version?: string | null;
             };
         };
+        details?: {
+            __typename: 'ContainerdProcessDetails';
+            containerId?: string | null;
+            imageName?: string | null;
+            processKind: string;
+            labels?: Array<{
+                __typename?: 'KeyValue';
+                key: string;
+                value: string;
+            }> | null;
+        } | {
+            __typename: 'DockerProcessDetails';
+            containerId?: string | null;
+            containerName?: string | null;
+            imageName?: string | null;
+            processKind: string;
+            labels?: Array<{
+                __typename?: 'KeyValue';
+                key: string;
+                value: string;
+            }> | null;
+        } | {
+            __typename: 'EcsProcessDetails';
+            containerId?: string | null;
+            containerName?: string | null;
+            imageName?: string | null;
+            taskFamily?: string | null;
+            taskArn?: string | null;
+            processKind: string;
+            labels?: Array<{
+                __typename?: 'KeyValue';
+                key: string;
+                value: string;
+            }> | null;
+        } | {
+            __typename: 'SystemdProcessDetails';
+            unitName?: string | null;
+            unitFilePath?: string | null;
+            processKind: string;
+        } | null;
+    }> | null;
+    details?: {
+        __typename: 'DockerWorkloadDetails';
+        kind: string;
+        containers?: Array<{
+            __typename?: 'WorkloadContainer';
+            name: string;
+            image?: string | null;
+            pids?: Array<number> | null;
+            instrumented: boolean;
+            instrumentationEligible: boolean;
+            excludedReason?: string | null;
+            distro?: string | null;
+            runtime?: {
+                __typename?: 'WorkloadRuntimeSnapshot';
+                detected: {
+                    __typename?: 'WorkloadRuntime';
+                    language?: string | null;
+                    version?: string | null;
+                };
+                override?: {
+                    __typename?: 'WorkloadRuntime';
+                    language?: string | null;
+                    version?: string | null;
+                } | null;
+                running: {
+                    __typename?: 'WorkloadRuntime';
+                    language?: string | null;
+                    version?: string | null;
+                };
+            } | null;
+        }> | null;
+    } | {
+        __typename: 'EcsWorkloadDetails';
+        clusterArn?: string | null;
+        taskDefinition?: string | null;
+        launchType?: string | null;
+        deploymentController?: string | null;
+        kind: string;
+        containers?: Array<{
+            __typename?: 'WorkloadContainer';
+            name: string;
+            image?: string | null;
+            pids?: Array<number> | null;
+            instrumented: boolean;
+            instrumentationEligible: boolean;
+            excludedReason?: string | null;
+            distro?: string | null;
+            runtime?: {
+                __typename?: 'WorkloadRuntimeSnapshot';
+                detected: {
+                    __typename?: 'WorkloadRuntime';
+                    language?: string | null;
+                    version?: string | null;
+                };
+                override?: {
+                    __typename?: 'WorkloadRuntime';
+                    language?: string | null;
+                    version?: string | null;
+                } | null;
+                running: {
+                    __typename?: 'WorkloadRuntime';
+                    language?: string | null;
+                    version?: string | null;
+                };
+            } | null;
+        }> | null;
+    } | {
+        __typename: 'LambdaWorkloadDetails';
+        functionArn?: string | null;
+        runtime?: string | null;
+        architecture?: string | null;
+        layerArn?: string | null;
+        kind: string;
+    } | {
+        __typename: 'RevisionedServiceWorkloadDetails';
+        service?: string | null;
+        latestReadyRevision?: string | null;
+        kind: string;
+        containers?: Array<{
+            __typename?: 'WorkloadContainer';
+            name: string;
+            image?: string | null;
+            pids?: Array<number> | null;
+            instrumented: boolean;
+            instrumentationEligible: boolean;
+            excludedReason?: string | null;
+            distro?: string | null;
+            runtime?: {
+                __typename?: 'WorkloadRuntimeSnapshot';
+                detected: {
+                    __typename?: 'WorkloadRuntime';
+                    language?: string | null;
+                    version?: string | null;
+                };
+                override?: {
+                    __typename?: 'WorkloadRuntime';
+                    language?: string | null;
+                    version?: string | null;
+                } | null;
+                running: {
+                    __typename?: 'WorkloadRuntime';
+                    language?: string | null;
+                    version?: string | null;
+                };
+            } | null;
+        }> | null;
+    } | null;
+};
+type ProcessDetailsFields_ContainerdProcessDetails_Fragment = {
+    __typename: 'ContainerdProcessDetails';
+    containerId?: string | null;
+    imageName?: string | null;
+    processKind: string;
+    labels?: Array<{
+        __typename?: 'KeyValue';
+        key: string;
+        value: string;
+    }> | null;
+};
+type ProcessDetailsFields_DockerProcessDetails_Fragment = {
+    __typename: 'DockerProcessDetails';
+    containerId?: string | null;
+    containerName?: string | null;
+    imageName?: string | null;
+    processKind: string;
+    labels?: Array<{
+        __typename?: 'KeyValue';
+        key: string;
+        value: string;
+    }> | null;
+};
+type ProcessDetailsFields_EcsProcessDetails_Fragment = {
+    __typename: 'EcsProcessDetails';
+    containerId?: string | null;
+    containerName?: string | null;
+    imageName?: string | null;
+    taskFamily?: string | null;
+    taskArn?: string | null;
+    processKind: string;
+    labels?: Array<{
+        __typename?: 'KeyValue';
+        key: string;
+        value: string;
+    }> | null;
+};
+type ProcessDetailsFields_SystemdProcessDetails_Fragment = {
+    __typename: 'SystemdProcessDetails';
+    unitName?: string | null;
+    unitFilePath?: string | null;
+    processKind: string;
+};
+export type ProcessDetailsFieldsFragment = ProcessDetailsFields_ContainerdProcessDetails_Fragment | ProcessDetailsFields_DockerProcessDetails_Fragment | ProcessDetailsFields_EcsProcessDetails_Fragment | ProcessDetailsFields_SystemdProcessDetails_Fragment;
+export type WorkloadContainerFieldsFragment = {
+    __typename?: 'WorkloadContainer';
+    name: string;
+    image?: string | null;
+    pids?: Array<number> | null;
+    instrumented: boolean;
+    instrumentationEligible: boolean;
+    excludedReason?: string | null;
+    distro?: string | null;
+    runtime?: {
+        __typename?: 'WorkloadRuntimeSnapshot';
+        detected: {
+            __typename?: 'WorkloadRuntime';
+            language?: string | null;
+            version?: string | null;
+        };
+        override?: {
+            __typename?: 'WorkloadRuntime';
+            language?: string | null;
+            version?: string | null;
+        } | null;
+        running: {
+            __typename?: 'WorkloadRuntime';
+            language?: string | null;
+            version?: string | null;
+        };
+    } | null;
+};
+type WorkloadDetailsFields_DockerWorkloadDetails_Fragment = {
+    __typename: 'DockerWorkloadDetails';
+    kind: string;
+    containers?: Array<{
+        __typename?: 'WorkloadContainer';
+        name: string;
+        image?: string | null;
+        pids?: Array<number> | null;
+        instrumented: boolean;
+        instrumentationEligible: boolean;
+        excludedReason?: string | null;
+        distro?: string | null;
+        runtime?: {
+            __typename?: 'WorkloadRuntimeSnapshot';
+            detected: {
+                __typename?: 'WorkloadRuntime';
+                language?: string | null;
+                version?: string | null;
+            };
+            override?: {
+                __typename?: 'WorkloadRuntime';
+                language?: string | null;
+                version?: string | null;
+            } | null;
+            running: {
+                __typename?: 'WorkloadRuntime';
+                language?: string | null;
+                version?: string | null;
+            };
+        } | null;
     }> | null;
 };
+type WorkloadDetailsFields_EcsWorkloadDetails_Fragment = {
+    __typename: 'EcsWorkloadDetails';
+    clusterArn?: string | null;
+    taskDefinition?: string | null;
+    launchType?: string | null;
+    deploymentController?: string | null;
+    kind: string;
+    containers?: Array<{
+        __typename?: 'WorkloadContainer';
+        name: string;
+        image?: string | null;
+        pids?: Array<number> | null;
+        instrumented: boolean;
+        instrumentationEligible: boolean;
+        excludedReason?: string | null;
+        distro?: string | null;
+        runtime?: {
+            __typename?: 'WorkloadRuntimeSnapshot';
+            detected: {
+                __typename?: 'WorkloadRuntime';
+                language?: string | null;
+                version?: string | null;
+            };
+            override?: {
+                __typename?: 'WorkloadRuntime';
+                language?: string | null;
+                version?: string | null;
+            } | null;
+            running: {
+                __typename?: 'WorkloadRuntime';
+                language?: string | null;
+                version?: string | null;
+            };
+        } | null;
+    }> | null;
+};
+type WorkloadDetailsFields_LambdaWorkloadDetails_Fragment = {
+    __typename: 'LambdaWorkloadDetails';
+    functionArn?: string | null;
+    runtime?: string | null;
+    architecture?: string | null;
+    layerArn?: string | null;
+    kind: string;
+};
+type WorkloadDetailsFields_RevisionedServiceWorkloadDetails_Fragment = {
+    __typename: 'RevisionedServiceWorkloadDetails';
+    service?: string | null;
+    latestReadyRevision?: string | null;
+    kind: string;
+    containers?: Array<{
+        __typename?: 'WorkloadContainer';
+        name: string;
+        image?: string | null;
+        pids?: Array<number> | null;
+        instrumented: boolean;
+        instrumentationEligible: boolean;
+        excludedReason?: string | null;
+        distro?: string | null;
+        runtime?: {
+            __typename?: 'WorkloadRuntimeSnapshot';
+            detected: {
+                __typename?: 'WorkloadRuntime';
+                language?: string | null;
+                version?: string | null;
+            };
+            override?: {
+                __typename?: 'WorkloadRuntime';
+                language?: string | null;
+                version?: string | null;
+            } | null;
+            running: {
+                __typename?: 'WorkloadRuntime';
+                language?: string | null;
+                version?: string | null;
+            };
+        } | null;
+    }> | null;
+};
+export type WorkloadDetailsFieldsFragment = WorkloadDetailsFields_DockerWorkloadDetails_Fragment | WorkloadDetailsFields_EcsWorkloadDetails_Fragment | WorkloadDetailsFields_LambdaWorkloadDetails_Fragment | WorkloadDetailsFields_RevisionedServiceWorkloadDetails_Fragment;
 export type GetWorkloadReportQueryVariables = Exact<{
     serviceName: Scalars['String']['input'];
     kind: Scalars['String']['input'];
@@ -2595,6 +3544,11 @@ export type GetWorkloadReportQuery = {
             message: string;
             since?: string | null;
             transient?: boolean | null;
+            details?: {
+                __typename: 'InstrumentationDriftDetails';
+                missingComponents: Array<string>;
+                code: string;
+            } | null;
         }> | null;
         instances?: Array<{
             __typename?: 'WorkloadInstanceStatus';
@@ -2642,7 +3596,154 @@ export type GetWorkloadReportQuery = {
                     version?: string | null;
                 };
             };
+            details?: {
+                __typename: 'ContainerdProcessDetails';
+                containerId?: string | null;
+                imageName?: string | null;
+                processKind: string;
+                labels?: Array<{
+                    __typename?: 'KeyValue';
+                    key: string;
+                    value: string;
+                }> | null;
+            } | {
+                __typename: 'DockerProcessDetails';
+                containerId?: string | null;
+                containerName?: string | null;
+                imageName?: string | null;
+                processKind: string;
+                labels?: Array<{
+                    __typename?: 'KeyValue';
+                    key: string;
+                    value: string;
+                }> | null;
+            } | {
+                __typename: 'EcsProcessDetails';
+                containerId?: string | null;
+                containerName?: string | null;
+                imageName?: string | null;
+                taskFamily?: string | null;
+                taskArn?: string | null;
+                processKind: string;
+                labels?: Array<{
+                    __typename?: 'KeyValue';
+                    key: string;
+                    value: string;
+                }> | null;
+            } | {
+                __typename: 'SystemdProcessDetails';
+                unitName?: string | null;
+                unitFilePath?: string | null;
+                processKind: string;
+            } | null;
         }> | null;
+        details?: {
+            __typename: 'DockerWorkloadDetails';
+            kind: string;
+            containers?: Array<{
+                __typename?: 'WorkloadContainer';
+                name: string;
+                image?: string | null;
+                pids?: Array<number> | null;
+                instrumented: boolean;
+                instrumentationEligible: boolean;
+                excludedReason?: string | null;
+                distro?: string | null;
+                runtime?: {
+                    __typename?: 'WorkloadRuntimeSnapshot';
+                    detected: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    };
+                    override?: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    } | null;
+                    running: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    };
+                } | null;
+            }> | null;
+        } | {
+            __typename: 'EcsWorkloadDetails';
+            clusterArn?: string | null;
+            taskDefinition?: string | null;
+            launchType?: string | null;
+            deploymentController?: string | null;
+            kind: string;
+            containers?: Array<{
+                __typename?: 'WorkloadContainer';
+                name: string;
+                image?: string | null;
+                pids?: Array<number> | null;
+                instrumented: boolean;
+                instrumentationEligible: boolean;
+                excludedReason?: string | null;
+                distro?: string | null;
+                runtime?: {
+                    __typename?: 'WorkloadRuntimeSnapshot';
+                    detected: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    };
+                    override?: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    } | null;
+                    running: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    };
+                } | null;
+            }> | null;
+        } | {
+            __typename: 'LambdaWorkloadDetails';
+            functionArn?: string | null;
+            runtime?: string | null;
+            architecture?: string | null;
+            layerArn?: string | null;
+            kind: string;
+        } | {
+            __typename: 'RevisionedServiceWorkloadDetails';
+            service?: string | null;
+            latestReadyRevision?: string | null;
+            kind: string;
+            containers?: Array<{
+                __typename?: 'WorkloadContainer';
+                name: string;
+                image?: string | null;
+                pids?: Array<number> | null;
+                instrumented: boolean;
+                instrumentationEligible: boolean;
+                excludedReason?: string | null;
+                distro?: string | null;
+                runtime?: {
+                    __typename?: 'WorkloadRuntimeSnapshot';
+                    detected: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    };
+                    override?: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    } | null;
+                    running: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    };
+                } | null;
+            }> | null;
+        } | null;
     } | null;
 };
 export type GetWorkloadReportsQueryVariables = Exact<{
@@ -2704,6 +3805,11 @@ export type GetWorkloadReportsQuery = {
             message: string;
             since?: string | null;
             transient?: boolean | null;
+            details?: {
+                __typename: 'InstrumentationDriftDetails';
+                missingComponents: Array<string>;
+                code: string;
+            } | null;
         }> | null;
         instances?: Array<{
             __typename?: 'WorkloadInstanceStatus';
@@ -2751,7 +3857,154 @@ export type GetWorkloadReportsQuery = {
                     version?: string | null;
                 };
             };
+            details?: {
+                __typename: 'ContainerdProcessDetails';
+                containerId?: string | null;
+                imageName?: string | null;
+                processKind: string;
+                labels?: Array<{
+                    __typename?: 'KeyValue';
+                    key: string;
+                    value: string;
+                }> | null;
+            } | {
+                __typename: 'DockerProcessDetails';
+                containerId?: string | null;
+                containerName?: string | null;
+                imageName?: string | null;
+                processKind: string;
+                labels?: Array<{
+                    __typename?: 'KeyValue';
+                    key: string;
+                    value: string;
+                }> | null;
+            } | {
+                __typename: 'EcsProcessDetails';
+                containerId?: string | null;
+                containerName?: string | null;
+                imageName?: string | null;
+                taskFamily?: string | null;
+                taskArn?: string | null;
+                processKind: string;
+                labels?: Array<{
+                    __typename?: 'KeyValue';
+                    key: string;
+                    value: string;
+                }> | null;
+            } | {
+                __typename: 'SystemdProcessDetails';
+                unitName?: string | null;
+                unitFilePath?: string | null;
+                processKind: string;
+            } | null;
         }> | null;
+        details?: {
+            __typename: 'DockerWorkloadDetails';
+            kind: string;
+            containers?: Array<{
+                __typename?: 'WorkloadContainer';
+                name: string;
+                image?: string | null;
+                pids?: Array<number> | null;
+                instrumented: boolean;
+                instrumentationEligible: boolean;
+                excludedReason?: string | null;
+                distro?: string | null;
+                runtime?: {
+                    __typename?: 'WorkloadRuntimeSnapshot';
+                    detected: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    };
+                    override?: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    } | null;
+                    running: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    };
+                } | null;
+            }> | null;
+        } | {
+            __typename: 'EcsWorkloadDetails';
+            clusterArn?: string | null;
+            taskDefinition?: string | null;
+            launchType?: string | null;
+            deploymentController?: string | null;
+            kind: string;
+            containers?: Array<{
+                __typename?: 'WorkloadContainer';
+                name: string;
+                image?: string | null;
+                pids?: Array<number> | null;
+                instrumented: boolean;
+                instrumentationEligible: boolean;
+                excludedReason?: string | null;
+                distro?: string | null;
+                runtime?: {
+                    __typename?: 'WorkloadRuntimeSnapshot';
+                    detected: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    };
+                    override?: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    } | null;
+                    running: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    };
+                } | null;
+            }> | null;
+        } | {
+            __typename: 'LambdaWorkloadDetails';
+            functionArn?: string | null;
+            runtime?: string | null;
+            architecture?: string | null;
+            layerArn?: string | null;
+            kind: string;
+        } | {
+            __typename: 'RevisionedServiceWorkloadDetails';
+            service?: string | null;
+            latestReadyRevision?: string | null;
+            kind: string;
+            containers?: Array<{
+                __typename?: 'WorkloadContainer';
+                name: string;
+                image?: string | null;
+                pids?: Array<number> | null;
+                instrumented: boolean;
+                instrumentationEligible: boolean;
+                excludedReason?: string | null;
+                distro?: string | null;
+                runtime?: {
+                    __typename?: 'WorkloadRuntimeSnapshot';
+                    detected: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    };
+                    override?: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    } | null;
+                    running: {
+                        __typename?: 'WorkloadRuntime';
+                        language?: string | null;
+                        version?: string | null;
+                    };
+                } | null;
+            }> | null;
+        } | null;
     }>;
 };
 export declare const ActionTypeFieldsFragmentDoc: DocumentNode<ActionTypeFieldsFragment, unknown>;
@@ -2759,8 +4012,14 @@ export declare const ActionFieldsFragmentDoc: DocumentNode<ActionFieldsFragment,
 export declare const ComputePlatformReportFieldsFragmentDoc: DocumentNode<ComputePlatformReportFieldsFragment, unknown>;
 export declare const DestinationTypeFieldsFragmentDoc: DocumentNode<DestinationTypeFieldsFragment, unknown>;
 export declare const DestinationFieldsFragmentDoc: DocumentNode<DestinationFieldsFragment, unknown>;
+export declare const InstructionDocumentFieldsFragmentDoc: DocumentNode<InstructionDocumentFieldsFragment, unknown>;
+export declare const InstrumentationInstructionsFieldsFragmentDoc: DocumentNode<InstrumentationInstructionsFieldsFragment, unknown>;
 export declare const InstrumentationRuleTypeFieldsFragmentDoc: DocumentNode<InstrumentationRuleTypeFieldsFragment, unknown>;
 export declare const InstrumentationRuleFieldsFragmentDoc: DocumentNode<InstrumentationRuleFieldsFragment, unknown>;
+export declare const ContainerOverrideFieldsFragmentDoc: DocumentNode<ContainerOverrideFieldsFragment, unknown>;
+export declare const ProcessDetailsFieldsFragmentDoc: DocumentNode<ProcessDetailsFieldsFragment, unknown>;
+export declare const WorkloadContainerFieldsFragmentDoc: DocumentNode<WorkloadContainerFieldsFragment, unknown>;
+export declare const WorkloadDetailsFieldsFragmentDoc: DocumentNode<WorkloadDetailsFieldsFragment, unknown>;
 export declare const WorkloadReportFieldsFragmentDoc: DocumentNode<WorkloadReportFieldsFragment, unknown>;
 export declare const GetActionTypesDocument: DocumentNode<GetActionTypesQuery, GetActionTypesQueryVariables>;
 export declare const GetActionDocument: DocumentNode<GetActionQuery, GetActionQueryVariables>;
@@ -2786,6 +4045,7 @@ export declare const CreateDestinationDocument: DocumentNode<CreateDestinationMu
 export declare const UpdateDestinationDocument: DocumentNode<UpdateDestinationMutation, UpdateDestinationMutationVariables>;
 export declare const DeleteDestinationDocument: DocumentNode<DeleteDestinationMutation, DeleteDestinationMutationVariables>;
 export declare const TestConnectionDocument: DocumentNode<TestConnectionMutation, TestConnectionMutationVariables>;
+export declare const GetInstrumentationInstructionsDocument: DocumentNode<GetInstrumentationInstructionsQuery, GetInstrumentationInstructionsQueryVariables>;
 export declare const GetInstrumentationRuleTypesDocument: DocumentNode<GetInstrumentationRuleTypesQuery, GetInstrumentationRuleTypesQueryVariables>;
 export declare const GetInstrumentationRuleDocument: DocumentNode<GetInstrumentationRuleQuery, GetInstrumentationRuleQueryVariables>;
 export declare const GetInstrumentationRulesDocument: DocumentNode<GetInstrumentationRulesQuery, GetInstrumentationRulesQueryVariables>;