@odigos/vmagent-api-apollo-client 0.22.0 → 0.23.0

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

@@ -0,0 +1,4205 @@
+import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    JSON: {
+        input: Record<string, any>;
+        output: Record<string, any>;
+    };
+};
+export type Action = {
+    actionName?: Maybe<Scalars['String']['output']>;
+    actionType: ActionType;
+    disabled: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+    notes?: Maybe<Scalars['String']['output']>;
+    orderHint?: Maybe<Scalars['Int']['output']>;
+    pipelines?: Maybe<Array<Scalars['String']['output']>>;
+    signals: Array<TelemetrySignal>;
+};
+export type ActionField = {
+    __typename?: 'ActionField';
+    componentProperties: Scalars['String']['output'];
+    componentType: Scalars['String']['output'];
+    displayName: Scalars['String']['output'];
+    initialValue?: Maybe<Scalars['String']['output']>;
+    name: Scalars['String']['output'];
+    renderCondition?: Maybe<Scalars['String']['output']>;
+};
+export declare enum ActionType {
+    ProcessorAddition = "processorAddition",
+    SpanMetrics = "spanMetrics",
+    UrlTemplatization = "urlTemplatization"
+}
+export type ActionTypeOption = {
+    __typename?: 'ActionTypeOption';
+    allowedSignals: Array<TelemetrySignal>;
+    description: Scalars['String']['output'];
+    displayName: Scalars['String']['output'];
+    docsUrl: Scalars['String']['output'];
+    fields: Array<ActionField>;
+    type: Scalars['String']['output'];
+};
+export type CodeAttributesConfig = {
+    __typename?: 'CodeAttributesConfig';
+    collectColumn?: Maybe<Scalars['Boolean']['output']>;
+    collectFilePath?: Maybe<Scalars['Boolean']['output']>;
+    collectFunction?: Maybe<Scalars['Boolean']['output']>;
+    collectLineNumber?: Maybe<Scalars['Boolean']['output']>;
+    collectNamespace?: Maybe<Scalars['Boolean']['output']>;
+    collectStacktrace?: Maybe<Scalars['Boolean']['output']>;
+};
+export type CodeAttributesConfigInput = {
+    collectColumn?: InputMaybe<Scalars['Boolean']['input']>;
+    collectFilePath?: InputMaybe<Scalars['Boolean']['input']>;
+    collectFunction?: InputMaybe<Scalars['Boolean']['input']>;
+    collectLineNumber?: InputMaybe<Scalars['Boolean']['input']>;
+    collectNamespace?: InputMaybe<Scalars['Boolean']['input']>;
+    collectStacktrace?: InputMaybe<Scalars['Boolean']['input']>;
+};
+export type CodeAttributesRule = InstrumentationRule & {
+    __typename?: 'CodeAttributesRule';
+    config?: Maybe<CodeAttributesConfig>;
+    enabled: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+    notes?: Maybe<Scalars['String']['output']>;
+    ruleType: RuleType;
+};
+export type ComputePlatformReport = {
+    __typename?: 'ComputePlatformReport';
+    /** Provider resource id (e.g. cluster ARN, instance id). */
+    externalId?: Maybe<Scalars['String']['output']>;
+    kind: Scalars['String']['output'];
+    /** Kind-specific attributes (e.g. EC2 instance count, Fargate task coverage). JSON object with string/number values. */
+    metadata?: Maybe<Scalars['JSON']['output']>;
+    name: Scalars['String']['output'];
+    /** Installed Odigos version, when known. */
+    odigosVersion?: Maybe<Scalars['String']['output']>;
+    /** Provider region the compute platform was discovered in; part of the composite identity. Null for region-less platforms. */
+    region?: Maybe<Scalars['String']['output']>;
+    /** Lifecycle of Odigos on this compute platform (e.g. Discovered, Installed). Install status is populated once the central↔odigos flow lands. */
+    status?: Maybe<Scalars['String']['output']>;
+    /** RFC3339 timestamp of the last report refresh. */
+    updatedAt: Scalars['String']['output'];
+};
+export type ConnectorCollectorStatus = {
+    __typename?: 'ConnectorCollectorStatus';
+    isHealthy: Scalars['Boolean']['output'];
+    message?: Maybe<Scalars['String']['output']>;
+    /** Collector identity (e.g. region name). */
+    name: Scalars['String']['output'];
+};
+export type ConnectorRuntimeHealth = {
+    __typename?: 'ConnectorRuntimeHealth';
+    /** The live Postgres schema version matches the version this runtime expects. */
+    hasSchemaVersionMatch: Scalars['Boolean']['output'];
+    /** Provider credentials authenticated successfully on the last check. */
+    isAuthenticated: Scalars['Boolean']['output'];
+    /** Initial discovery has completed at least once. */
+    isDiscoveryReady: Scalars['Boolean']['output'];
+    /** The runtime has registered with Central and is heartbeating. */
+    isRegistered: Scalars['Boolean']['output'];
+    /** RFC3339 timestamp of the last heartbeat written by the runtime. */
+    lastHeartbeatAt?: Maybe<Scalars['String']['output']>;
+    /** 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'];
+};
+export type CppProbeInput = {
+    signature: Scalars['String']['input'];
+};
+export type CreateActionInput = {
+    actionName?: InputMaybe<Scalars['String']['input']>;
+    actionType: ActionType;
+    disabled: Scalars['Boolean']['input'];
+    name: Scalars['String']['input'];
+    notes?: InputMaybe<Scalars['String']['input']>;
+    orderHint?: InputMaybe<Scalars['Int']['input']>;
+    pipelines?: InputMaybe<Array<Scalars['String']['input']>>;
+    processorAddition?: InputMaybe<ProcessorAdditionConfigInput>;
+    signals: Array<TelemetrySignal>;
+    spanMetrics?: InputMaybe<SpanMetricsConfigInput>;
+    /** Config must match actionType (validated server-side). */
+    urlTemplatization?: InputMaybe<UrlTemplatizationConfigInput>;
+};
+export type CreateDestinationInput = {
+    config?: InputMaybe<Scalars['JSON']['input']>;
+    name: Scalars['String']['input'];
+    region?: InputMaybe<Scalars['String']['input']>;
+    signals: Array<TelemetrySignal>;
+    type: Scalars['String']['input'];
+};
+export type CreateInstrumentationRuleInput = {
+    HeadersCollection?: InputMaybe<HeadersCollectionConfigInput>;
+    codeAttributes?: InputMaybe<CodeAttributesConfigInput>;
+    /** Exactly one config branch must match ruleType (validated server-side). */
+    customInstrumentation?: InputMaybe<CustomInstrumentationConfigInput>;
+    enabled: Scalars['Boolean']['input'];
+    name: Scalars['String']['input'];
+    notes?: InputMaybe<Scalars['String']['input']>;
+    payloadCollection?: InputMaybe<PayloadCollectionConfigInput>;
+    ruleType: RuleType;
+};
+export type CreateSourceInput = {
+    config?: InputMaybe<SourceConfigInput>;
+    enabled: Scalars['Boolean']['input'];
+    kind: Scalars['String']['input'];
+    name: Scalars['String']['input'];
+    region?: InputMaybe<Scalars['String']['input']>;
+    serviceName?: InputMaybe<Scalars['String']['input']>;
+};
+export type CustomInstrumentationConfig = {
+    __typename?: 'CustomInstrumentationConfig';
+    cpp?: Maybe<Array<CppProbe>>;
+    golang?: Maybe<Array<GolangProbe>>;
+    java?: Maybe<Array<JavaProbe>>;
+};
+export type CustomInstrumentationConfigInput = {
+    cpp?: InputMaybe<Array<CppProbeInput>>;
+    golang?: InputMaybe<Array<GolangProbeInput>>;
+    java?: InputMaybe<Array<JavaProbeInput>>;
+};
+export type CustomInstrumentationRule = InstrumentationRule & {
+    __typename?: 'CustomInstrumentationRule';
+    config?: Maybe<CustomInstrumentationConfig>;
+    enabled: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+    notes?: Maybe<Scalars['String']['output']>;
+    ruleType: RuleType;
+};
+export type CustomReadDataLabel = {
+    __typename?: 'CustomReadDataLabel';
+    condition: Scalars['String']['output'];
+    title: Scalars['String']['output'];
+    value: Scalars['String']['output'];
+};
+export type DeleteActionInput = {
+    name: Scalars['String']['input'];
+};
+export type DeleteActionPayload = {
+    __typename?: 'DeleteActionPayload';
+    deleted: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+};
+export type DeleteDestinationInput = {
+    name: Scalars['String']['input'];
+};
+export type DeleteDestinationPayload = {
+    __typename?: 'DeleteDestinationPayload';
+    deleted: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+};
+export type DeleteInstrumentationRuleInput = {
+    name: Scalars['String']['input'];
+};
+export type DeleteInstrumentationRulePayload = {
+    __typename?: 'DeleteInstrumentationRulePayload';
+    deleted: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+};
+export type DeleteSourceInput = {
+    kind?: InputMaybe<Scalars['String']['input']>;
+    name: Scalars['String']['input'];
+    region?: InputMaybe<Scalars['String']['input']>;
+};
+export type DeleteSourcePayload = {
+    __typename?: 'DeleteSourcePayload';
+    deleted: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+};
+export type Destination = {
+    __typename?: 'Destination';
+    config?: Maybe<Scalars['JSON']['output']>;
+    name: Scalars['String']['output'];
+    region?: Maybe<Scalars['String']['output']>;
+    signals: Array<TelemetrySignal>;
+    type: Scalars['String']['output'];
+};
+export type DestinationCounters = {
+    __typename?: 'DestinationCounters';
+    exporter: Scalars['String']['output'];
+    logs: DestinationSignal;
+    metrics: DestinationSignal;
+    profiles: DestinationSignal;
+    traces: DestinationSignal;
+};
+export type DestinationField = {
+    __typename?: 'DestinationField';
+    componentProperties: Scalars['String']['output'];
+    componentType: Scalars['String']['output'];
+    customReadDataLabels: Array<CustomReadDataLabel>;
+    displayName: Scalars['String']['output'];
+    hideFromReadData: Scalars['Boolean']['output'];
+    initialValue?: Maybe<Scalars['String']['output']>;
+    name: Scalars['String']['output'];
+    renderCondition?: Maybe<Scalars['String']['output']>;
+    secret: Scalars['Boolean']['output'];
+};
+export type DestinationSignal = {
+    __typename?: 'DestinationSignal';
+    failed: Scalars['Float']['output'];
+    queue: Scalars['Float']['output'];
+    sent: Scalars['Float']['output'];
+};
+export type DestinationSupportedSignals = {
+    __typename?: 'DestinationSupportedSignals';
+    logs: Scalars['Boolean']['output'];
+    metrics: Scalars['Boolean']['output'];
+    profiles: Scalars['Boolean']['output'];
+    traces: Scalars['Boolean']['output'];
+};
+export type DestinationType = {
+    __typename?: 'DestinationType';
+    displayName: Scalars['String']['output'];
+    fields: Array<DestinationField>;
+    imageUrl: Scalars['String']['output'];
+    supportedSignals: DestinationSupportedSignals;
+    type: Scalars['String']['output'];
+};
+export type DiagnoseBundle = {
+    __typename?: 'DiagnoseBundle';
+    contentBase64?: Maybe<Scalars['String']['output']>;
+    createdAt: Scalars['String']['output'];
+    error?: Maybe<Scalars['String']['output']>;
+    filePath: Scalars['String']['output'];
+    id: Scalars['String']['output'];
+    sizeBytes?: Maybe<Scalars['Float']['output']>;
+};
+export type DistroOverride = {
+    __typename?: 'DistroOverride';
+    otelDistroName?: Maybe<Scalars['String']['output']>;
+};
+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']>;
+    packageName: Scalars['String']['output'];
+    receiverMethodName?: Maybe<Scalars['String']['output']>;
+    receiverName?: Maybe<Scalars['String']['output']>;
+};
+export type GolangProbeInput = {
+    functionName?: InputMaybe<Scalars['String']['input']>;
+    packageName: Scalars['String']['input'];
+    receiverMethodName?: InputMaybe<Scalars['String']['input']>;
+    receiverName?: InputMaybe<Scalars['String']['input']>;
+};
+export type HeadersCollectionConfig = {
+    __typename?: 'HeadersCollectionConfig';
+    headerKeys: Array<Scalars['String']['output']>;
+};
+export type HeadersCollectionConfigInput = {
+    headerKeys: Array<Scalars['String']['input']>;
+};
+export type HeadersCollectionRule = InstrumentationRule & {
+    __typename?: 'HeadersCollectionRule';
+    config?: Maybe<HeadersCollectionConfig>;
+    enabled: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+    notes?: Maybe<Scalars['String']['output']>;
+    ruleType: RuleType;
+};
+export type HostInfo = {
+    __typename?: 'HostInfo';
+    arch: Scalars['String']['output'];
+    hostname: Scalars['String']['output'];
+    kernel: Scalars['String']['output'];
+    os: Scalars['String']['output'];
+};
+export type HotFunction = {
+    __typename?: 'HotFunction';
+    buildId?: Maybe<Scalars['String']['output']>;
+    instrumentable?: Maybe<Scalars['String']['output']>;
+    module: Scalars['String']['output'];
+    name: Scalars['String']['output'];
+    offset?: Maybe<Scalars['Float']['output']>;
+    self: Scalars['Float']['output'];
+    size?: Maybe<Scalars['Float']['output']>;
+    total: Scalars['Float']['output'];
+};
+export type HotFunctionsResult = {
+    __typename?: 'HotFunctionsResult';
+    cache?: Maybe<ProfileCacheStats>;
+    dynamicInstrumentation: Scalars['Boolean']['output'];
+    enabled: Scalars['Boolean']['output'];
+    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'];
+};
+/**
+ * Observed state of one instrumentation library after eBPF load (Go/Java today).
+ * Inactive or disabled libraries are omitted. Mirrors OSS InstrumentationLibraryStatus
+ * without Kubernetes types.
+ */
+export type InstrumentationLibraryStatus = {
+    __typename?: 'InstrumentationLibraryStatus';
+    healthy?: Maybe<Scalars['Boolean']['output']>;
+    identifyingAttributes?: Maybe<Array<KeyValue>>;
+    /** RFC3339 timestamp of the last status update. */
+    lastStatusTime?: Maybe<Scalars['String']['output']>;
+    message?: Maybe<Scalars['String']['output']>;
+    name: Scalars['String']['output'];
+    nonIdentifyingAttributes?: Maybe<Array<KeyValue>>;
+    reason?: Maybe<Scalars['String']['output']>;
+    type: InstrumentationLibraryType;
+};
+export declare enum InstrumentationLibraryType {
+    Exporter = "exporter",
+    Instrumentation = "instrumentation",
+    Sampler = "sampler"
+}
+export type InstrumentationRule = {
+    enabled: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+    notes?: Maybe<Scalars['String']['output']>;
+    ruleType: RuleType;
+};
+export type InstrumentationRuleField = {
+    __typename?: 'InstrumentationRuleField';
+    componentProperties: Scalars['String']['output'];
+    componentType: Scalars['String']['output'];
+    displayName: Scalars['String']['output'];
+    initialValue?: Maybe<Scalars['String']['output']>;
+    name: Scalars['String']['output'];
+    renderCondition?: Maybe<Scalars['String']['output']>;
+};
+export type InstrumentationRuleTypeOption = {
+    __typename?: 'InstrumentationRuleTypeOption';
+    description: Scalars['String']['output'];
+    displayName: Scalars['String']['output'];
+    docsUrl: Scalars['String']['output'];
+    fields: Array<InstrumentationRuleField>;
+    supportedLanguages: Array<Scalars['String']['output']>;
+    type: Scalars['String']['output'];
+};
+export type JavaProbe = {
+    __typename?: 'JavaProbe';
+    className: Scalars['String']['output'];
+    methodName: Scalars['String']['output'];
+};
+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'];
+    clearProfileCache: Scalars['Boolean']['output'];
+    clearSourceProfilingBuffer: SlotResult;
+    configureProfilingCache: ProfilingSlots;
+    createAction: Action;
+    createDestination: Destination;
+    createInstrumentationRule: InstrumentationRule;
+    createSource: Source;
+    deleteAction: DeleteActionPayload;
+    deleteDestination: DeleteDestinationPayload;
+    deleteInstrumentationRule: DeleteInstrumentationRulePayload;
+    deleteSource: DeleteSourcePayload;
+    disableSourceProfiling: SlotResult;
+    enableSourceProfiling: SlotResult;
+    generateDiagnoseBundle: DiagnoseBundle;
+    generateProfileBundle: ProfileBundle;
+    /** Trigger an out-of-band provider discovery refresh; returns true if a refresh was enqueued. */
+    refreshDiscovery: Scalars['Boolean']['output'];
+    /** Request bounded cleanup of connector-created resources. Not implemented in the discovery-only phase. */
+    requestCleanup: Scalars['Boolean']['output'];
+    restartSource: RestartSourcePayload;
+    startBackgroundProfileBundle: ProfileBundleStatus;
+    testConnectionForDestination: TestConnectionResponse;
+    /** Roll back instrumentation changes for the given reconcile id. Not implemented in the discovery-only phase. */
+    triggerRollback: Scalars['Boolean']['output'];
+    updateAction: Action;
+    updateConfig: UpdateConfigPayload;
+    updateDestination: Destination;
+    updateInstrumentationRule: InstrumentationRule;
+    /**
+     * Replace the on-prem license JWT on this agent (writes license.jwt).
+     * The token is verified before writing. Returns true on success.
+     */
+    updateOnPremLicense: Scalars['Boolean']['output'];
+    updateSource: Source;
+};
+export type MutationCancelProfileBundleArgs = {
+    jobId: Scalars['String']['input'];
+};
+export type MutationClearSourceProfilingBufferArgs = {
+    service: Scalars['String']['input'];
+};
+export type MutationConfigureProfilingCacheArgs = {
+    maxSlots?: InputMaybe<Scalars['Int']['input']>;
+    slotMaxBytes?: InputMaybe<Scalars['Int']['input']>;
+    slotTTLSeconds?: InputMaybe<Scalars['Int']['input']>;
+};
+export type MutationCreateActionArgs = {
+    input: CreateActionInput;
+};
+export type MutationCreateDestinationArgs = {
+    input: CreateDestinationInput;
+};
+export type MutationCreateInstrumentationRuleArgs = {
+    input: CreateInstrumentationRuleInput;
+};
+export type MutationCreateSourceArgs = {
+    input: CreateSourceInput;
+};
+export type MutationDeleteActionArgs = {
+    input: DeleteActionInput;
+};
+export type MutationDeleteDestinationArgs = {
+    input: DeleteDestinationInput;
+};
+export type MutationDeleteInstrumentationRuleArgs = {
+    input: DeleteInstrumentationRuleInput;
+};
+export type MutationDeleteSourceArgs = {
+    input: DeleteSourceInput;
+};
+export type MutationDisableSourceProfilingArgs = {
+    service: Scalars['String']['input'];
+};
+export type MutationEnableSourceProfilingArgs = {
+    service: Scalars['String']['input'];
+};
+export type MutationGenerateDiagnoseBundleArgs = {
+    includeContent?: InputMaybe<Scalars['Boolean']['input']>;
+};
+export type MutationGenerateProfileBundleArgs = {
+    durationSeconds?: InputMaybe<Scalars['Int']['input']>;
+    service?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationRequestCleanupArgs = {
+    id: Scalars['String']['input'];
+};
+export type MutationRestartSourceArgs = {
+    input: RestartSourceInput;
+};
+export type MutationStartBackgroundProfileBundleArgs = {
+    durationSeconds?: InputMaybe<Scalars['Int']['input']>;
+    service?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationTestConnectionForDestinationArgs = {
+    input: TestConnectionDestinationInput;
+};
+export type MutationTriggerRollbackArgs = {
+    id: Scalars['String']['input'];
+};
+export type MutationUpdateActionArgs = {
+    input: UpdateActionInput;
+};
+export type MutationUpdateConfigArgs = {
+    input: UpdateConfigInput;
+};
+export type MutationUpdateDestinationArgs = {
+    input: UpdateDestinationInput;
+};
+export type MutationUpdateInstrumentationRuleArgs = {
+    input: UpdateInstrumentationRuleInput;
+};
+export type MutationUpdateOnPremLicenseArgs = {
+    token: Scalars['String']['input'];
+};
+export type MutationUpdateSourceArgs = {
+    input: UpdateSourceInput;
+};
+export type PayloadCollectionConfig = {
+    __typename?: 'PayloadCollectionConfig';
+    collectDbQuery?: Maybe<Scalars['Boolean']['output']>;
+    collectHttpRequest?: Maybe<Scalars['Boolean']['output']>;
+    collectHttpResponse?: Maybe<Scalars['Boolean']['output']>;
+    collectMessaging?: Maybe<Scalars['Boolean']['output']>;
+};
+export type PayloadCollectionConfigInput = {
+    collectDbQuery?: InputMaybe<Scalars['Boolean']['input']>;
+    collectHttpRequest?: InputMaybe<Scalars['Boolean']['input']>;
+    collectHttpResponse?: InputMaybe<Scalars['Boolean']['input']>;
+    collectMessaging?: InputMaybe<Scalars['Boolean']['input']>;
+};
+export type PayloadCollectionRule = InstrumentationRule & {
+    __typename?: 'PayloadCollectionRule';
+    config?: Maybe<PayloadCollectionConfig>;
+    enabled: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+    notes?: Maybe<Scalars['String']['output']>;
+    ruleType: RuleType;
+};
+export type PipelineCounters = {
+    __typename?: 'PipelineCounters';
+    destinations: Array<DestinationCounters>;
+    otelcolHealthy: Scalars['Boolean']['output'];
+    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']>;
+    actionType: ActionType;
+    config?: Maybe<ProcessorAdditionConfig>;
+    disabled: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+    notes?: Maybe<Scalars['String']['output']>;
+    orderHint?: Maybe<Scalars['Int']['output']>;
+    pipelines?: Maybe<Array<Scalars['String']['output']>>;
+    signals: Array<TelemetrySignal>;
+};
+export type ProcessorAdditionConfig = {
+    __typename?: 'ProcessorAdditionConfig';
+    processorConfig: Scalars['JSON']['output'];
+    processorName?: Maybe<Scalars['String']['output']>;
+    type: Scalars['String']['output'];
+};
+export type ProcessorAdditionConfigInput = {
+    processorConfig: Scalars['JSON']['input'];
+    processorName?: InputMaybe<Scalars['String']['input']>;
+    type: Scalars['String']['input'];
+};
+export type ProfileBundle = {
+    __typename?: 'ProfileBundle';
+    createdAt: Scalars['String']['output'];
+    durationSec: Scalars['Int']['output'];
+    error?: Maybe<Scalars['String']['output']>;
+    errorKind?: Maybe<Scalars['String']['output']>;
+    filePath: Scalars['String']['output'];
+    id: Scalars['String']['output'];
+    sampleBytes: Scalars['Float']['output'];
+};
+export type ProfileBundleStatus = {
+    __typename?: 'ProfileBundleStatus';
+    durationSec: Scalars['Int']['output'];
+    elapsedSec: Scalars['Int']['output'];
+    error?: Maybe<Scalars['String']['output']>;
+    errorKind?: Maybe<Scalars['String']['output']>;
+    filePath?: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    sampleBytes?: Maybe<Scalars['Float']['output']>;
+    startedAt: Scalars['String']['output'];
+    state: Scalars['String']['output'];
+};
+export type ProfileCacheStats = {
+    __typename?: 'ProfileCacheStats';
+    evictedSlotsTotal: Scalars['Float']['output'];
+    maxSlots: Scalars['Int']['output'];
+    maxTotalBytesBudget: Scalars['Float']['output'];
+    services: Scalars['Int']['output'];
+    slotMaxBytes: Scalars['Float']['output'];
+    slotTtlSeconds: Scalars['Int']['output'];
+    totalBytes: Scalars['Float']['output'];
+};
+export type ProfilingSlots = {
+    __typename?: 'ProfilingSlots';
+    activeKeys: Array<Scalars['String']['output']>;
+    cache: ProfileCacheStats;
+    keysWithData: Array<Scalars['String']['output']>;
+};
+export type Query = {
+    __typename?: 'Query';
+    action?: Maybe<Action>;
+    actionTypes: Array<ActionTypeOption>;
+    actions: Array<Action>;
+    /** Lookup a compute platform by composite key name + kind + region; null if absent. region may be omitted for region-less platforms. */
+    computePlatformReport?: Maybe<ComputePlatformReport>;
+    computePlatformReports: Array<ComputePlatformReport>;
+    config: Scalars['JSON']['output'];
+    configDefaults: Scalars['JSON']['output'];
+    /** Per-region collector statuses (empty until managed-otelcol integration). */
+    connectorCollectorStatuses: Array<ConnectorCollectorStatus>;
+    /** Computed health of this connector runtime. */
+    connectorRuntimeHealth: ConnectorRuntimeHealth;
+    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>;
+    pipelineCounters: PipelineCounters;
+    profileBundleStatus: ProfileBundleStatus;
+    profileHotFunctions: HotFunctionsResult;
+    profilingSlots: ProfilingSlots;
+    source?: Maybe<Source>;
+    sourceProfile: SourceProfilingResult;
+    sources: Array<Source>;
+    /** Provider source kinds this connector can discover/instrument (e.g. ["aws.lambda", "aws.ecs_service"]). */
+    supportedSourceKinds: Array<Scalars['String']['output']>;
+    /** Lookup by composite key serviceName + kind + region; null if absent. region may be omitted for region-less platforms. */
+    workloadReport?: Maybe<WorkloadReport>;
+    workloadReports: Array<WorkloadReport>;
+};
+export type QueryActionArgs = {
+    name: Scalars['String']['input'];
+};
+export type QueryComputePlatformReportArgs = {
+    kind: Scalars['String']['input'];
+    name: Scalars['String']['input'];
+    region?: InputMaybe<Scalars['String']['input']>;
+};
+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'];
+};
+export type QueryProfileBundleStatusArgs = {
+    jobId: Scalars['String']['input'];
+};
+export type QueryProfileHotFunctionsArgs = {
+    topN?: InputMaybe<Scalars['Int']['input']>;
+};
+export type QuerySourceArgs = {
+    name: Scalars['String']['input'];
+};
+export type QuerySourceProfileArgs = {
+    service: Scalars['String']['input'];
+};
+export type QueryWorkloadReportArgs = {
+    kind: Scalars['String']['input'];
+    region?: InputMaybe<Scalars['String']['input']>;
+    serviceName: Scalars['String']['input'];
+};
+export type RestartSourceInput = {
+    kind: Scalars['String']['input'];
+    name: Scalars['String']['input'];
+};
+export type RestartSourcePayload = {
+    __typename?: 'RestartSourcePayload';
+    kind: Scalars['String']['output'];
+    message?: Maybe<Scalars['String']['output']>;
+    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",
+    HeadersCollection = "HeadersCollection",
+    PayloadCollection = "PayloadCollection"
+}
+export type RuntimeOverride = {
+    __typename?: 'RuntimeOverride';
+    language?: Maybe<Scalars['String']['output']>;
+    version?: Maybe<Scalars['String']['output']>;
+};
+export type RuntimeOverrideInput = {
+    language?: InputMaybe<Scalars['String']['input']>;
+    version?: InputMaybe<Scalars['String']['input']>;
+};
+export type ServiceHotFunctions = {
+    __typename?: 'ServiceHotFunctions';
+    functions: Array<HotFunction>;
+    language?: Maybe<Scalars['String']['output']>;
+    service: Scalars['String']['output'];
+    totalNanos: Scalars['Float']['output'];
+};
+export type ServiceNameOverride = {
+    __typename?: 'ServiceNameOverride';
+    serviceName?: Maybe<Scalars['String']['output']>;
+};
+export type ServiceNameOverrideInput = {
+    serviceName?: InputMaybe<Scalars['String']['input']>;
+};
+export type SlotResult = {
+    __typename?: 'SlotResult';
+    activeSlots: Scalars['Int']['output'];
+    maxSlots: Scalars['Int']['output'];
+    sourceKey: Scalars['String']['output'];
+    status: Scalars['String']['output'];
+};
+export type Source = {
+    __typename?: 'Source';
+    config?: Maybe<SourceConfig>;
+    enabled: Scalars['Boolean']['output'];
+    kind: Scalars['String']['output'];
+    name: Scalars['String']['output'];
+    region?: Maybe<Scalars['String']['output']>;
+    serviceName?: Maybe<Scalars['String']['output']>;
+};
+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>;
+};
+export type SourceProfilingResult = {
+    __typename?: 'SourceProfilingResult';
+    profileJson: Scalars['String']['output'];
+};
+export type SpanMetricsAction = Action & {
+    __typename?: 'SpanMetricsAction';
+    actionName?: Maybe<Scalars['String']['output']>;
+    actionType: ActionType;
+    config?: Maybe<SpanMetricsConfig>;
+    disabled: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+    notes?: Maybe<Scalars['String']['output']>;
+    orderHint?: Maybe<Scalars['Int']['output']>;
+    pipelines?: Maybe<Array<Scalars['String']['output']>>;
+    signals: Array<TelemetrySignal>;
+};
+export type SpanMetricsConfig = {
+    __typename?: 'SpanMetricsConfig';
+    additionalDimensions?: Maybe<Array<Scalars['String']['output']>>;
+    disabled?: Maybe<Scalars['Boolean']['output']>;
+    excludedResourceAttributes?: Maybe<Array<Scalars['String']['output']>>;
+    explicitHistogramBuckets?: Maybe<Array<Scalars['String']['output']>>;
+    histogramDisabled?: Maybe<Scalars['Boolean']['output']>;
+    includedProcessInDimensions?: Maybe<Scalars['Boolean']['output']>;
+    interval?: Maybe<Scalars['String']['output']>;
+    metricsExpiration?: Maybe<Scalars['String']['output']>;
+    resourceMetricsKeyAttributes?: Maybe<Array<Scalars['String']['output']>>;
+};
+export type SpanMetricsConfigInput = {
+    additionalDimensions?: InputMaybe<Array<Scalars['String']['input']>>;
+    disabled?: InputMaybe<Scalars['Boolean']['input']>;
+    excludedResourceAttributes?: InputMaybe<Array<Scalars['String']['input']>>;
+    explicitHistogramBuckets?: InputMaybe<Array<Scalars['String']['input']>>;
+    histogramDisabled?: InputMaybe<Scalars['Boolean']['input']>;
+    includedProcessInDimensions?: InputMaybe<Scalars['Boolean']['input']>;
+    interval?: InputMaybe<Scalars['String']['input']>;
+    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",
+    Profiles = "PROFILES",
+    Traces = "TRACES"
+}
+export type TestConnectionDestinationInput = {
+    config?: InputMaybe<Scalars['JSON']['input']>;
+    type: Scalars['String']['input'];
+};
+export type TestConnectionResponse = {
+    __typename?: 'TestConnectionResponse';
+    destinationType?: Maybe<Scalars['String']['output']>;
+    message?: Maybe<Scalars['String']['output']>;
+    reason?: Maybe<Scalars['String']['output']>;
+    statusCode: Scalars['Int']['output'];
+    succeeded: Scalars['Boolean']['output'];
+};
+export type UrlTemplatizationAction = Action & {
+    __typename?: 'URLTemplatizationAction';
+    actionName?: Maybe<Scalars['String']['output']>;
+    actionType: ActionType;
+    config?: Maybe<UrlTemplatizationConfig>;
+    disabled: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+    notes?: Maybe<Scalars['String']['output']>;
+    orderHint?: Maybe<Scalars['Int']['output']>;
+    pipelines?: Maybe<Array<Scalars['String']['output']>>;
+    signals: Array<TelemetrySignal>;
+};
+export type UrlTemplatizationConfig = {
+    __typename?: 'URLTemplatizationConfig';
+    templatizationRulesGroups: Array<UrlTemplatizationRulesGroup>;
+};
+export type UrlTemplatizationConfigInput = {
+    templatizationRulesGroups: Array<UrlTemplatizationRulesGroupInput>;
+};
+export type UrlTemplatizationRule = {
+    __typename?: 'URLTemplatizationRule';
+    examples?: Maybe<Array<Scalars['String']['output']>>;
+    notes?: Maybe<Scalars['String']['output']>;
+    template: Scalars['String']['output'];
+};
+export type UrlTemplatizationRuleInput = {
+    examples?: InputMaybe<Array<Scalars['String']['input']>>;
+    notes?: InputMaybe<Scalars['String']['input']>;
+    template: Scalars['String']['input'];
+};
+export type UrlTemplatizationRulesGroup = {
+    __typename?: 'URLTemplatizationRulesGroup';
+    notes?: Maybe<Scalars['String']['output']>;
+    templatizationRules: Array<UrlTemplatizationRule>;
+};
+export type UrlTemplatizationRulesGroupInput = {
+    notes?: InputMaybe<Scalars['String']['input']>;
+    templatizationRules: Array<UrlTemplatizationRuleInput>;
+};
+export type UpdateActionInput = {
+    actionName?: InputMaybe<Scalars['String']['input']>;
+    actionType?: InputMaybe<ActionType>;
+    disabled?: InputMaybe<Scalars['Boolean']['input']>;
+    name: Scalars['String']['input'];
+    notes?: InputMaybe<Scalars['String']['input']>;
+    orderHint?: InputMaybe<Scalars['Int']['input']>;
+    pipelines?: InputMaybe<Array<Scalars['String']['input']>>;
+    processorAddition?: InputMaybe<ProcessorAdditionConfigInput>;
+    signals?: InputMaybe<Array<TelemetrySignal>>;
+    spanMetrics?: InputMaybe<SpanMetricsConfigInput>;
+    urlTemplatization?: InputMaybe<UrlTemplatizationConfigInput>;
+};
+export type UpdateConfigInput = {
+    config: Scalars['JSON']['input'];
+};
+export type UpdateConfigPayload = {
+    __typename?: 'UpdateConfigPayload';
+    config: Scalars['JSON']['output'];
+};
+export type UpdateDestinationInput = {
+    config?: InputMaybe<Scalars['JSON']['input']>;
+    name: Scalars['String']['input'];
+    region?: InputMaybe<Scalars['String']['input']>;
+    signals?: InputMaybe<Array<TelemetrySignal>>;
+    type?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateInstrumentationRuleInput = {
+    HeadersCollection?: InputMaybe<HeadersCollectionConfigInput>;
+    codeAttributes?: InputMaybe<CodeAttributesConfigInput>;
+    customInstrumentation?: InputMaybe<CustomInstrumentationConfigInput>;
+    enabled: Scalars['Boolean']['input'];
+    name: Scalars['String']['input'];
+    notes?: InputMaybe<Scalars['String']['input']>;
+    payloadCollection?: InputMaybe<PayloadCollectionConfigInput>;
+    ruleType?: InputMaybe<RuleType>;
+};
+export type UpdateSourceInput = {
+    config?: InputMaybe<SourceConfigInput>;
+    enabled?: InputMaybe<Scalars['Boolean']['input']>;
+    kind?: InputMaybe<Scalars['String']['input']>;
+    name: Scalars['String']['input'];
+    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'];
+    processCount: Scalars['Int']['output'];
+    runtime: WorkloadRuntimeSnapshot;
+    /** Deprecated: use runtime.running.language. Kept for backward compatibility. */
+    runtimeName?: Maybe<Scalars['String']['output']>;
+    /** Deprecated: use runtime.running.version. Kept for backward compatibility. */
+    runtimeVersion?: Maybe<Scalars['String']['output']>;
+    state: Scalars['String']['output'];
+};
+export type WorkloadDesiredReport = {
+    __typename?: 'WorkloadDesiredReport';
+    enabled: Scalars['Boolean']['output'];
+    mode?: Maybe<Scalars['String']['output']>;
+    reason?: Maybe<Scalars['String']['output']>;
+    sdkType?: Maybe<Scalars['String']['output']>;
+    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'];
+    distro?: Maybe<Scalars['String']['output']>;
+    /** Stable id (e.g. serviceName-pid). */
+    id: Scalars['String']['output'];
+    instrumented: Scalars['Boolean']['output'];
+    message?: Maybe<Scalars['String']['output']>;
+    pid: Scalars['Int']['output'];
+    probesAttached: Scalars['Boolean']['output'];
+    restarted?: Maybe<Scalars['Boolean']['output']>;
+    runtimeName?: Maybe<Scalars['String']['output']>;
+    runtimeVersion?: Maybe<Scalars['String']['output']>;
+};
+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).
+ */
+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']>;
+    /** True when language/runtime matches the workload instrumentation target. */
+    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.
+     * @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']>>;
+    pid: Scalars['Int']['output'];
+    ppid?: Maybe<Scalars['Int']['output']>;
+    /** eBPF probes loaded for this PID; may be absent on the wire when false (omitempty). */
+    probesAttached?: Maybe<Scalars['Boolean']['output']>;
+    processKind?: Maybe<Scalars['String']['output']>;
+    /** Per-PID detected runtime, workload source override, and effective running runtime. */
+    runtime: WorkloadRuntimeSnapshot;
+    /** Service name from process discovery when set (may differ from workload identity). */
+    serviceNameObserved?: Maybe<Scalars['String']['output']>;
+    startTimeEpoch?: Maybe<Scalars['Float']['output']>;
+};
+export type WorkloadProgressReport = {
+    __typename?: 'WorkloadProgressReport';
+    message?: Maybe<Scalars['String']['output']>;
+    stage: Scalars['String']['output'];
+    waitingFor?: Maybe<Scalars['String']['output']>;
+};
+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>>;
+    kind: Scalars['String']['output'];
+    /**
+     * Go/Java instrumentation libraries aggregated across this source's PIDs.
+     * Empty when the SDK does not report per-library status.
+     */
+    libraries?: Maybe<Array<InstrumentationLibraryStatus>>;
+    /** Controller process rows for this workload; same PIDs as the controller; sorted ascending by pid. */
+    processMetadata?: Maybe<Array<WorkloadProcessMetadata>>;
+    progress: WorkloadProgressReport;
+    /** Provider region the workload was discovered in (e.g. AWS region); part of the composite identity. Null for region-less platforms. */
+    region?: Maybe<Scalars['String']['output']>;
+    serviceName: Scalars['String']['output'];
+    /** RFC3339 timestamp of the last report refresh. */
+    updatedAt: Scalars['String']['output'];
+};
+/** Single runtime language and version pair. */
+export type WorkloadRuntime = {
+    __typename?: 'WorkloadRuntime';
+    language?: Maybe<Scalars['String']['output']>;
+    version?: Maybe<Scalars['String']['output']>;
+};
+/** Runtime breakdown for a workload: detector output, optional source override, and effective running values. */
+export type WorkloadRuntimeSnapshot = {
+    __typename?: 'WorkloadRuntimeSnapshot';
+    /** Values from process/runtime detection. */
+    detected: WorkloadRuntime;
+    /** Source config override when applied; null when no override is set. */
+    override?: Maybe<WorkloadRuntime>;
+    /** Effective language/version used for instrumentation (override wins over detection). */
+    running: WorkloadRuntime;
+};
+export type ActionTypeFieldsFragment = {
+    __typename?: 'ActionTypeOption';
+    type: string;
+    displayName: string;
+    description: string;
+    allowedSignals: Array<TelemetrySignal>;
+    docsUrl: string;
+    fields: Array<{
+        __typename?: 'ActionField';
+        name: string;
+        displayName: string;
+        componentType: string;
+        componentProperties: string;
+        initialValue?: string | null;
+        renderCondition?: string | null;
+    }>;
+};
+export type GetActionTypesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetActionTypesQuery = {
+    __typename?: 'Query';
+    actionTypes: Array<{
+        __typename?: 'ActionTypeOption';
+        type: string;
+        displayName: string;
+        description: string;
+        allowedSignals: Array<TelemetrySignal>;
+        docsUrl: string;
+        fields: Array<{
+            __typename?: 'ActionField';
+            name: string;
+            displayName: string;
+            componentType: string;
+            componentProperties: string;
+            initialValue?: string | null;
+            renderCondition?: string | null;
+        }>;
+    }>;
+};
+type ActionFields_ProcessorAdditionAction_Fragment = {
+    __typename: 'ProcessorAdditionAction';
+    name: string;
+    actionName?: string | null;
+    notes?: string | null;
+    disabled: boolean;
+    signals: Array<TelemetrySignal>;
+    pipelines?: Array<string> | null;
+    orderHint?: number | null;
+    actionType: ActionType;
+    config?: {
+        __typename?: 'ProcessorAdditionConfig';
+        type: string;
+        processorName?: string | null;
+        processorConfig: Record<string, any>;
+    } | null;
+};
+type ActionFields_SpanMetricsAction_Fragment = {
+    __typename: 'SpanMetricsAction';
+    name: string;
+    actionName?: string | null;
+    notes?: string | null;
+    disabled: boolean;
+    signals: Array<TelemetrySignal>;
+    pipelines?: Array<string> | null;
+    orderHint?: number | null;
+    actionType: ActionType;
+    config?: {
+        __typename?: 'SpanMetricsConfig';
+        disabled?: boolean | null;
+        interval?: string | null;
+        metricsExpiration?: string | null;
+        additionalDimensions?: Array<string> | null;
+        histogramDisabled?: boolean | null;
+        explicitHistogramBuckets?: Array<string> | null;
+        resourceMetricsKeyAttributes?: Array<string> | null;
+        includedProcessInDimensions?: boolean | null;
+        excludedResourceAttributes?: Array<string> | null;
+    } | null;
+};
+type ActionFields_UrlTemplatizationAction_Fragment = {
+    __typename: 'URLTemplatizationAction';
+    name: string;
+    actionName?: string | null;
+    notes?: string | null;
+    disabled: boolean;
+    signals: Array<TelemetrySignal>;
+    pipelines?: Array<string> | null;
+    orderHint?: number | null;
+    actionType: ActionType;
+    config?: {
+        __typename?: 'URLTemplatizationConfig';
+        templatizationRulesGroups: Array<{
+            __typename?: 'URLTemplatizationRulesGroup';
+            notes?: string | null;
+            templatizationRules: Array<{
+                __typename?: 'URLTemplatizationRule';
+                template: string;
+                examples?: Array<string> | null;
+                notes?: string | null;
+            }>;
+        }>;
+    } | null;
+};
+export type ActionFieldsFragment = ActionFields_ProcessorAdditionAction_Fragment | ActionFields_SpanMetricsAction_Fragment | ActionFields_UrlTemplatizationAction_Fragment;
+export type GetActionQueryVariables = Exact<{
+    name: Scalars['String']['input'];
+}>;
+export type GetActionQuery = {
+    __typename?: 'Query';
+    action?: {
+        __typename: 'ProcessorAdditionAction';
+        name: string;
+        actionName?: string | null;
+        notes?: string | null;
+        disabled: boolean;
+        signals: Array<TelemetrySignal>;
+        pipelines?: Array<string> | null;
+        orderHint?: number | null;
+        actionType: ActionType;
+        config?: {
+            __typename?: 'ProcessorAdditionConfig';
+            type: string;
+            processorName?: string | null;
+            processorConfig: Record<string, any>;
+        } | null;
+    } | {
+        __typename: 'SpanMetricsAction';
+        name: string;
+        actionName?: string | null;
+        notes?: string | null;
+        disabled: boolean;
+        signals: Array<TelemetrySignal>;
+        pipelines?: Array<string> | null;
+        orderHint?: number | null;
+        actionType: ActionType;
+        config?: {
+            __typename?: 'SpanMetricsConfig';
+            disabled?: boolean | null;
+            interval?: string | null;
+            metricsExpiration?: string | null;
+            additionalDimensions?: Array<string> | null;
+            histogramDisabled?: boolean | null;
+            explicitHistogramBuckets?: Array<string> | null;
+            resourceMetricsKeyAttributes?: Array<string> | null;
+            includedProcessInDimensions?: boolean | null;
+            excludedResourceAttributes?: Array<string> | null;
+        } | null;
+    } | {
+        __typename: 'URLTemplatizationAction';
+        name: string;
+        actionName?: string | null;
+        notes?: string | null;
+        disabled: boolean;
+        signals: Array<TelemetrySignal>;
+        pipelines?: Array<string> | null;
+        orderHint?: number | null;
+        actionType: ActionType;
+        config?: {
+            __typename?: 'URLTemplatizationConfig';
+            templatizationRulesGroups: Array<{
+                __typename?: 'URLTemplatizationRulesGroup';
+                notes?: string | null;
+                templatizationRules: Array<{
+                    __typename?: 'URLTemplatizationRule';
+                    template: string;
+                    examples?: Array<string> | null;
+                    notes?: string | null;
+                }>;
+            }>;
+        } | null;
+    } | null;
+};
+export type GetActionsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetActionsQuery = {
+    __typename?: 'Query';
+    actions: Array<{
+        __typename: 'ProcessorAdditionAction';
+        name: string;
+        actionName?: string | null;
+        notes?: string | null;
+        disabled: boolean;
+        signals: Array<TelemetrySignal>;
+        pipelines?: Array<string> | null;
+        orderHint?: number | null;
+        actionType: ActionType;
+        config?: {
+            __typename?: 'ProcessorAdditionConfig';
+            type: string;
+            processorName?: string | null;
+            processorConfig: Record<string, any>;
+        } | null;
+    } | {
+        __typename: 'SpanMetricsAction';
+        name: string;
+        actionName?: string | null;
+        notes?: string | null;
+        disabled: boolean;
+        signals: Array<TelemetrySignal>;
+        pipelines?: Array<string> | null;
+        orderHint?: number | null;
+        actionType: ActionType;
+        config?: {
+            __typename?: 'SpanMetricsConfig';
+            disabled?: boolean | null;
+            interval?: string | null;
+            metricsExpiration?: string | null;
+            additionalDimensions?: Array<string> | null;
+            histogramDisabled?: boolean | null;
+            explicitHistogramBuckets?: Array<string> | null;
+            resourceMetricsKeyAttributes?: Array<string> | null;
+            includedProcessInDimensions?: boolean | null;
+            excludedResourceAttributes?: Array<string> | null;
+        } | null;
+    } | {
+        __typename: 'URLTemplatizationAction';
+        name: string;
+        actionName?: string | null;
+        notes?: string | null;
+        disabled: boolean;
+        signals: Array<TelemetrySignal>;
+        pipelines?: Array<string> | null;
+        orderHint?: number | null;
+        actionType: ActionType;
+        config?: {
+            __typename?: 'URLTemplatizationConfig';
+            templatizationRulesGroups: Array<{
+                __typename?: 'URLTemplatizationRulesGroup';
+                notes?: string | null;
+                templatizationRules: Array<{
+                    __typename?: 'URLTemplatizationRule';
+                    template: string;
+                    examples?: Array<string> | null;
+                    notes?: string | null;
+                }>;
+            }>;
+        } | null;
+    }>;
+};
+export type CreateActionMutationVariables = Exact<{
+    input: CreateActionInput;
+}>;
+export type CreateActionMutation = {
+    __typename?: 'Mutation';
+    createAction: {
+        __typename: 'ProcessorAdditionAction';
+        name: string;
+        actionName?: string | null;
+        notes?: string | null;
+        disabled: boolean;
+        signals: Array<TelemetrySignal>;
+        pipelines?: Array<string> | null;
+        orderHint?: number | null;
+        actionType: ActionType;
+        config?: {
+            __typename?: 'ProcessorAdditionConfig';
+            type: string;
+            processorName?: string | null;
+            processorConfig: Record<string, any>;
+        } | null;
+    } | {
+        __typename: 'SpanMetricsAction';
+        name: string;
+        actionName?: string | null;
+        notes?: string | null;
+        disabled: boolean;
+        signals: Array<TelemetrySignal>;
+        pipelines?: Array<string> | null;
+        orderHint?: number | null;
+        actionType: ActionType;
+        config?: {
+            __typename?: 'SpanMetricsConfig';
+            disabled?: boolean | null;
+            interval?: string | null;
+            metricsExpiration?: string | null;
+            additionalDimensions?: Array<string> | null;
+            histogramDisabled?: boolean | null;
+            explicitHistogramBuckets?: Array<string> | null;
+            resourceMetricsKeyAttributes?: Array<string> | null;
+            includedProcessInDimensions?: boolean | null;
+            excludedResourceAttributes?: Array<string> | null;
+        } | null;
+    } | {
+        __typename: 'URLTemplatizationAction';
+        name: string;
+        actionName?: string | null;
+        notes?: string | null;
+        disabled: boolean;
+        signals: Array<TelemetrySignal>;
+        pipelines?: Array<string> | null;
+        orderHint?: number | null;
+        actionType: ActionType;
+        config?: {
+            __typename?: 'URLTemplatizationConfig';
+            templatizationRulesGroups: Array<{
+                __typename?: 'URLTemplatizationRulesGroup';
+                notes?: string | null;
+                templatizationRules: Array<{
+                    __typename?: 'URLTemplatizationRule';
+                    template: string;
+                    examples?: Array<string> | null;
+                    notes?: string | null;
+                }>;
+            }>;
+        } | null;
+    };
+};
+export type UpdateActionMutationVariables = Exact<{
+    input: UpdateActionInput;
+}>;
+export type UpdateActionMutation = {
+    __typename?: 'Mutation';
+    updateAction: {
+        __typename: 'ProcessorAdditionAction';
+        name: string;
+        actionName?: string | null;
+        notes?: string | null;
+        disabled: boolean;
+        signals: Array<TelemetrySignal>;
+        pipelines?: Array<string> | null;
+        orderHint?: number | null;
+        actionType: ActionType;
+        config?: {
+            __typename?: 'ProcessorAdditionConfig';
+            type: string;
+            processorName?: string | null;
+            processorConfig: Record<string, any>;
+        } | null;
+    } | {
+        __typename: 'SpanMetricsAction';
+        name: string;
+        actionName?: string | null;
+        notes?: string | null;
+        disabled: boolean;
+        signals: Array<TelemetrySignal>;
+        pipelines?: Array<string> | null;
+        orderHint?: number | null;
+        actionType: ActionType;
+        config?: {
+            __typename?: 'SpanMetricsConfig';
+            disabled?: boolean | null;
+            interval?: string | null;
+            metricsExpiration?: string | null;
+            additionalDimensions?: Array<string> | null;
+            histogramDisabled?: boolean | null;
+            explicitHistogramBuckets?: Array<string> | null;
+            resourceMetricsKeyAttributes?: Array<string> | null;
+            includedProcessInDimensions?: boolean | null;
+            excludedResourceAttributes?: Array<string> | null;
+        } | null;
+    } | {
+        __typename: 'URLTemplatizationAction';
+        name: string;
+        actionName?: string | null;
+        notes?: string | null;
+        disabled: boolean;
+        signals: Array<TelemetrySignal>;
+        pipelines?: Array<string> | null;
+        orderHint?: number | null;
+        actionType: ActionType;
+        config?: {
+            __typename?: 'URLTemplatizationConfig';
+            templatizationRulesGroups: Array<{
+                __typename?: 'URLTemplatizationRulesGroup';
+                notes?: string | null;
+                templatizationRules: Array<{
+                    __typename?: 'URLTemplatizationRule';
+                    template: string;
+                    examples?: Array<string> | null;
+                    notes?: string | null;
+                }>;
+            }>;
+        } | null;
+    };
+};
+export type DeleteActionMutationVariables = Exact<{
+    input: DeleteActionInput;
+}>;
+export type DeleteActionMutation = {
+    __typename?: 'Mutation';
+    deleteAction: {
+        __typename?: 'DeleteActionPayload';
+        name: string;
+        deleted: boolean;
+    };
+};
+export type ComputePlatformReportFieldsFragment = {
+    __typename?: 'ComputePlatformReport';
+    name: string;
+    kind: string;
+    region?: string | null;
+    externalId?: string | null;
+    status?: string | null;
+    odigosVersion?: string | null;
+    metadata?: Record<string, any> | null;
+    updatedAt: string;
+};
+export type GetComputePlatformReportQueryVariables = Exact<{
+    name: Scalars['String']['input'];
+    kind: Scalars['String']['input'];
+    region?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type GetComputePlatformReportQuery = {
+    __typename?: 'Query';
+    computePlatformReport?: {
+        __typename?: 'ComputePlatformReport';
+        name: string;
+        kind: string;
+        region?: string | null;
+        externalId?: string | null;
+        status?: string | null;
+        odigosVersion?: string | null;
+        metadata?: Record<string, any> | null;
+        updatedAt: string;
+    } | null;
+};
+export type GetComputePlatformReportsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetComputePlatformReportsQuery = {
+    __typename?: 'Query';
+    computePlatformReports: Array<{
+        __typename?: 'ComputePlatformReport';
+        name: string;
+        kind: string;
+        region?: string | null;
+        externalId?: string | null;
+        status?: string | null;
+        odigosVersion?: string | null;
+        metadata?: Record<string, any> | null;
+        updatedAt: string;
+    }>;
+};
+export type GetConfigQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetConfigQuery = {
+    __typename?: 'Query';
+    config: Record<string, any>;
+};
+export type GetConfigDefaultsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetConfigDefaultsQuery = {
+    __typename?: 'Query';
+    configDefaults: Record<string, any>;
+};
+export type UpdateConfigMutationVariables = Exact<{
+    input: UpdateConfigInput;
+}>;
+export type UpdateConfigMutation = {
+    __typename?: 'Mutation';
+    updateConfig: {
+        __typename?: 'UpdateConfigPayload';
+        config: Record<string, any>;
+    };
+};
+export type GetSupportedSourceKindsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetSupportedSourceKindsQuery = {
+    __typename?: 'Query';
+    supportedSourceKinds: Array<string>;
+};
+export type GetConnectorRuntimeHealthQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetConnectorRuntimeHealthQuery = {
+    __typename?: 'Query';
+    connectorRuntimeHealth: {
+        __typename?: 'ConnectorRuntimeHealth';
+        isRegistered: boolean;
+        lastHeartbeatAt?: string | null;
+        hasSchemaVersionMatch: boolean;
+        isAuthenticated: boolean;
+        isDiscoveryReady: boolean;
+        message?: string | null;
+    };
+};
+export type GetConnectorCollectorStatusesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetConnectorCollectorStatusesQuery = {
+    __typename?: 'Query';
+    connectorCollectorStatuses: Array<{
+        __typename?: 'ConnectorCollectorStatus';
+        name: string;
+        isHealthy: boolean;
+        message?: string | null;
+    }>;
+};
+export type RefreshDiscoveryMutationVariables = Exact<{
+    [key: string]: never;
+}>;
+export type RefreshDiscoveryMutation = {
+    __typename?: 'Mutation';
+    refreshDiscovery: boolean;
+};
+export type TriggerRollbackMutationVariables = Exact<{
+    id: Scalars['String']['input'];
+}>;
+export type TriggerRollbackMutation = {
+    __typename?: 'Mutation';
+    triggerRollback: boolean;
+};
+export type RequestCleanupMutationVariables = Exact<{
+    id: Scalars['String']['input'];
+}>;
+export type RequestCleanupMutation = {
+    __typename?: 'Mutation';
+    requestCleanup: boolean;
+};
+export type DestinationTypeFieldsFragment = {
+    __typename?: 'DestinationType';
+    type: string;
+    displayName: string;
+    imageUrl: string;
+    supportedSignals: {
+        __typename?: 'DestinationSupportedSignals';
+        traces: boolean;
+        metrics: boolean;
+        logs: boolean;
+        profiles: boolean;
+    };
+    fields: Array<{
+        __typename?: 'DestinationField';
+        name: string;
+        displayName: string;
+        componentType: string;
+        componentProperties: string;
+        secret: boolean;
+        initialValue?: string | null;
+        renderCondition?: string | null;
+        hideFromReadData: boolean;
+        customReadDataLabels: Array<{
+            __typename?: 'CustomReadDataLabel';
+            condition: string;
+            title: string;
+            value: string;
+        }>;
+    }>;
+};
+export type DestinationFieldsFragment = {
+    __typename?: 'Destination';
+    name: string;
+    type: string;
+    region?: string | null;
+    config?: Record<string, any> | null;
+    signals: Array<TelemetrySignal>;
+};
+export type GetDestinationQueryVariables = Exact<{
+    name: Scalars['String']['input'];
+}>;
+export type GetDestinationQuery = {
+    __typename?: 'Query';
+    destination?: {
+        __typename?: 'Destination';
+        name: string;
+        type: string;
+        region?: string | null;
+        config?: Record<string, any> | null;
+        signals: Array<TelemetrySignal>;
+    } | null;
+};
+export type GetDestinationsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetDestinationsQuery = {
+    __typename?: 'Query';
+    destinations: Array<{
+        __typename?: 'Destination';
+        name: string;
+        type: string;
+        region?: string | null;
+        config?: Record<string, any> | null;
+        signals: Array<TelemetrySignal>;
+    }>;
+};
+export type GetDestinationTypesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetDestinationTypesQuery = {
+    __typename?: 'Query';
+    destinationTypes: Array<{
+        __typename?: 'DestinationType';
+        type: string;
+        displayName: string;
+        imageUrl: string;
+        supportedSignals: {
+            __typename?: 'DestinationSupportedSignals';
+            traces: boolean;
+            metrics: boolean;
+            logs: boolean;
+            profiles: boolean;
+        };
+        fields: Array<{
+            __typename?: 'DestinationField';
+            name: string;
+            displayName: string;
+            componentType: string;
+            componentProperties: string;
+            secret: boolean;
+            initialValue?: string | null;
+            renderCondition?: string | null;
+            hideFromReadData: boolean;
+            customReadDataLabels: Array<{
+                __typename?: 'CustomReadDataLabel';
+                condition: string;
+                title: string;
+                value: string;
+            }>;
+        }>;
+    }>;
+};
+export type CreateDestinationMutationVariables = Exact<{
+    input: CreateDestinationInput;
+}>;
+export type CreateDestinationMutation = {
+    __typename?: 'Mutation';
+    createDestination: {
+        __typename?: 'Destination';
+        name: string;
+        type: string;
+        region?: string | null;
+        config?: Record<string, any> | null;
+        signals: Array<TelemetrySignal>;
+    };
+};
+export type UpdateDestinationMutationVariables = Exact<{
+    input: UpdateDestinationInput;
+}>;
+export type UpdateDestinationMutation = {
+    __typename?: 'Mutation';
+    updateDestination: {
+        __typename?: 'Destination';
+        name: string;
+        type: string;
+        region?: string | null;
+        config?: Record<string, any> | null;
+        signals: Array<TelemetrySignal>;
+    };
+};
+export type DeleteDestinationMutationVariables = Exact<{
+    input: DeleteDestinationInput;
+}>;
+export type DeleteDestinationMutation = {
+    __typename?: 'Mutation';
+    deleteDestination: {
+        __typename?: 'DeleteDestinationPayload';
+        name: string;
+        deleted: boolean;
+    };
+};
+export type TestConnectionMutationVariables = Exact<{
+    input: TestConnectionDestinationInput;
+}>;
+export type TestConnectionMutation = {
+    __typename?: 'Mutation';
+    testConnectionForDestination: {
+        __typename?: 'TestConnectionResponse';
+        succeeded: boolean;
+        statusCode: number;
+        destinationType?: string | null;
+        message?: string | null;
+        reason?: string | null;
+    };
+};
+export type GenerateDiagnoseBundleMutationVariables = Exact<{
+    includeContent?: InputMaybe<Scalars['Boolean']['input']>;
+}>;
+export type GenerateDiagnoseBundleMutation = {
+    __typename?: 'Mutation';
+    generateDiagnoseBundle: {
+        __typename?: 'DiagnoseBundle';
+        id: string;
+        filePath: string;
+        createdAt: string;
+        sizeBytes?: number | null;
+        contentBase64?: string | null;
+        error?: 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;
+    displayName: string;
+    description: string;
+    supportedLanguages: Array<string>;
+    docsUrl: string;
+    fields: Array<{
+        __typename?: 'InstrumentationRuleField';
+        name: string;
+        displayName: string;
+        componentType: string;
+        componentProperties: string;
+        initialValue?: string | null;
+        renderCondition?: string | null;
+    }>;
+};
+export type GetInstrumentationRuleTypesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetInstrumentationRuleTypesQuery = {
+    __typename?: 'Query';
+    instrumentationRuleTypes: Array<{
+        __typename?: 'InstrumentationRuleTypeOption';
+        type: string;
+        displayName: string;
+        description: string;
+        supportedLanguages: Array<string>;
+        docsUrl: string;
+        fields: Array<{
+            __typename?: 'InstrumentationRuleField';
+            name: string;
+            displayName: string;
+            componentType: string;
+            componentProperties: string;
+            initialValue?: string | null;
+            renderCondition?: string | null;
+        }>;
+    }>;
+};
+type InstrumentationRuleFields_CodeAttributesRule_Fragment = {
+    __typename: 'CodeAttributesRule';
+    name: string;
+    ruleType: RuleType;
+    enabled: boolean;
+    notes?: string | null;
+    config?: {
+        __typename?: 'CodeAttributesConfig';
+        collectFilePath?: boolean | null;
+        collectFunction?: boolean | null;
+        collectLineNumber?: boolean | null;
+        collectColumn?: boolean | null;
+        collectNamespace?: boolean | null;
+        collectStacktrace?: boolean | null;
+    } | null;
+};
+type InstrumentationRuleFields_CustomInstrumentationRule_Fragment = {
+    __typename: 'CustomInstrumentationRule';
+    name: string;
+    ruleType: RuleType;
+    enabled: boolean;
+    notes?: string | null;
+    config?: {
+        __typename?: 'CustomInstrumentationConfig';
+        java?: Array<{
+            __typename?: 'JavaProbe';
+            className: string;
+            methodName: string;
+        }> | null;
+        golang?: Array<{
+            __typename?: 'GolangProbe';
+            packageName: string;
+            functionName?: string | null;
+            receiverName?: string | null;
+            receiverMethodName?: string | null;
+        }> | null;
+        cpp?: Array<{
+            __typename?: 'CppProbe';
+            signature: string;
+        }> | null;
+    } | null;
+};
+type InstrumentationRuleFields_HeadersCollectionRule_Fragment = {
+    __typename: 'HeadersCollectionRule';
+    name: string;
+    ruleType: RuleType;
+    enabled: boolean;
+    notes?: string | null;
+    config?: {
+        __typename?: 'HeadersCollectionConfig';
+        headerKeys: Array<string>;
+    } | null;
+};
+type InstrumentationRuleFields_PayloadCollectionRule_Fragment = {
+    __typename: 'PayloadCollectionRule';
+    name: string;
+    ruleType: RuleType;
+    enabled: boolean;
+    notes?: string | null;
+    config?: {
+        __typename?: 'PayloadCollectionConfig';
+        collectHttpRequest?: boolean | null;
+        collectHttpResponse?: boolean | null;
+        collectDbQuery?: boolean | null;
+        collectMessaging?: boolean | null;
+    } | null;
+};
+export type InstrumentationRuleFieldsFragment = InstrumentationRuleFields_CodeAttributesRule_Fragment | InstrumentationRuleFields_CustomInstrumentationRule_Fragment | InstrumentationRuleFields_HeadersCollectionRule_Fragment | InstrumentationRuleFields_PayloadCollectionRule_Fragment;
+export type GetInstrumentationRuleQueryVariables = Exact<{
+    name: Scalars['String']['input'];
+}>;
+export type GetInstrumentationRuleQuery = {
+    __typename?: 'Query';
+    instrumentationRule?: {
+        __typename: 'CodeAttributesRule';
+        name: string;
+        ruleType: RuleType;
+        enabled: boolean;
+        notes?: string | null;
+        config?: {
+            __typename?: 'CodeAttributesConfig';
+            collectFilePath?: boolean | null;
+            collectFunction?: boolean | null;
+            collectLineNumber?: boolean | null;
+            collectColumn?: boolean | null;
+            collectNamespace?: boolean | null;
+            collectStacktrace?: boolean | null;
+        } | null;
+    } | {
+        __typename: 'CustomInstrumentationRule';
+        name: string;
+        ruleType: RuleType;
+        enabled: boolean;
+        notes?: string | null;
+        config?: {
+            __typename?: 'CustomInstrumentationConfig';
+            java?: Array<{
+                __typename?: 'JavaProbe';
+                className: string;
+                methodName: string;
+            }> | null;
+            golang?: Array<{
+                __typename?: 'GolangProbe';
+                packageName: string;
+                functionName?: string | null;
+                receiverName?: string | null;
+                receiverMethodName?: string | null;
+            }> | null;
+            cpp?: Array<{
+                __typename?: 'CppProbe';
+                signature: string;
+            }> | null;
+        } | null;
+    } | {
+        __typename: 'HeadersCollectionRule';
+        name: string;
+        ruleType: RuleType;
+        enabled: boolean;
+        notes?: string | null;
+        config?: {
+            __typename?: 'HeadersCollectionConfig';
+            headerKeys: Array<string>;
+        } | null;
+    } | {
+        __typename: 'PayloadCollectionRule';
+        name: string;
+        ruleType: RuleType;
+        enabled: boolean;
+        notes?: string | null;
+        config?: {
+            __typename?: 'PayloadCollectionConfig';
+            collectHttpRequest?: boolean | null;
+            collectHttpResponse?: boolean | null;
+            collectDbQuery?: boolean | null;
+            collectMessaging?: boolean | null;
+        } | null;
+    } | null;
+};
+export type GetInstrumentationRulesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetInstrumentationRulesQuery = {
+    __typename?: 'Query';
+    instrumentationRules: Array<{
+        __typename: 'CodeAttributesRule';
+        name: string;
+        ruleType: RuleType;
+        enabled: boolean;
+        notes?: string | null;
+        config?: {
+            __typename?: 'CodeAttributesConfig';
+            collectFilePath?: boolean | null;
+            collectFunction?: boolean | null;
+            collectLineNumber?: boolean | null;
+            collectColumn?: boolean | null;
+            collectNamespace?: boolean | null;
+            collectStacktrace?: boolean | null;
+        } | null;
+    } | {
+        __typename: 'CustomInstrumentationRule';
+        name: string;
+        ruleType: RuleType;
+        enabled: boolean;
+        notes?: string | null;
+        config?: {
+            __typename?: 'CustomInstrumentationConfig';
+            java?: Array<{
+                __typename?: 'JavaProbe';
+                className: string;
+                methodName: string;
+            }> | null;
+            golang?: Array<{
+                __typename?: 'GolangProbe';
+                packageName: string;
+                functionName?: string | null;
+                receiverName?: string | null;
+                receiverMethodName?: string | null;
+            }> | null;
+            cpp?: Array<{
+                __typename?: 'CppProbe';
+                signature: string;
+            }> | null;
+        } | null;
+    } | {
+        __typename: 'HeadersCollectionRule';
+        name: string;
+        ruleType: RuleType;
+        enabled: boolean;
+        notes?: string | null;
+        config?: {
+            __typename?: 'HeadersCollectionConfig';
+            headerKeys: Array<string>;
+        } | null;
+    } | {
+        __typename: 'PayloadCollectionRule';
+        name: string;
+        ruleType: RuleType;
+        enabled: boolean;
+        notes?: string | null;
+        config?: {
+            __typename?: 'PayloadCollectionConfig';
+            collectHttpRequest?: boolean | null;
+            collectHttpResponse?: boolean | null;
+            collectDbQuery?: boolean | null;
+            collectMessaging?: boolean | null;
+        } | null;
+    }>;
+};
+export type CreateInstrumentationRuleMutationVariables = Exact<{
+    input: CreateInstrumentationRuleInput;
+}>;
+export type CreateInstrumentationRuleMutation = {
+    __typename?: 'Mutation';
+    createInstrumentationRule: {
+        __typename: 'CodeAttributesRule';
+        name: string;
+        ruleType: RuleType;
+        enabled: boolean;
+        notes?: string | null;
+        config?: {
+            __typename?: 'CodeAttributesConfig';
+            collectFilePath?: boolean | null;
+            collectFunction?: boolean | null;
+            collectLineNumber?: boolean | null;
+            collectColumn?: boolean | null;
+            collectNamespace?: boolean | null;
+            collectStacktrace?: boolean | null;
+        } | null;
+    } | {
+        __typename: 'CustomInstrumentationRule';
+        name: string;
+        ruleType: RuleType;
+        enabled: boolean;
+        notes?: string | null;
+        config?: {
+            __typename?: 'CustomInstrumentationConfig';
+            java?: Array<{
+                __typename?: 'JavaProbe';
+                className: string;
+                methodName: string;
+            }> | null;
+            golang?: Array<{
+                __typename?: 'GolangProbe';
+                packageName: string;
+                functionName?: string | null;
+                receiverName?: string | null;
+                receiverMethodName?: string | null;
+            }> | null;
+            cpp?: Array<{
+                __typename?: 'CppProbe';
+                signature: string;
+            }> | null;
+        } | null;
+    } | {
+        __typename: 'HeadersCollectionRule';
+        name: string;
+        ruleType: RuleType;
+        enabled: boolean;
+        notes?: string | null;
+        config?: {
+            __typename?: 'HeadersCollectionConfig';
+            headerKeys: Array<string>;
+        } | null;
+    } | {
+        __typename: 'PayloadCollectionRule';
+        name: string;
+        ruleType: RuleType;
+        enabled: boolean;
+        notes?: string | null;
+        config?: {
+            __typename?: 'PayloadCollectionConfig';
+            collectHttpRequest?: boolean | null;
+            collectHttpResponse?: boolean | null;
+            collectDbQuery?: boolean | null;
+            collectMessaging?: boolean | null;
+        } | null;
+    };
+};
+export type UpdateInstrumentationRuleMutationVariables = Exact<{
+    input: UpdateInstrumentationRuleInput;
+}>;
+export type UpdateInstrumentationRuleMutation = {
+    __typename?: 'Mutation';
+    updateInstrumentationRule: {
+        __typename: 'CodeAttributesRule';
+        name: string;
+        ruleType: RuleType;
+        enabled: boolean;
+        notes?: string | null;
+        config?: {
+            __typename?: 'CodeAttributesConfig';
+            collectFilePath?: boolean | null;
+            collectFunction?: boolean | null;
+            collectLineNumber?: boolean | null;
+            collectColumn?: boolean | null;
+            collectNamespace?: boolean | null;
+            collectStacktrace?: boolean | null;
+        } | null;
+    } | {
+        __typename: 'CustomInstrumentationRule';
+        name: string;
+        ruleType: RuleType;
+        enabled: boolean;
+        notes?: string | null;
+        config?: {
+            __typename?: 'CustomInstrumentationConfig';
+            java?: Array<{
+                __typename?: 'JavaProbe';
+                className: string;
+                methodName: string;
+            }> | null;
+            golang?: Array<{
+                __typename?: 'GolangProbe';
+                packageName: string;
+                functionName?: string | null;
+                receiverName?: string | null;
+                receiverMethodName?: string | null;
+            }> | null;
+            cpp?: Array<{
+                __typename?: 'CppProbe';
+                signature: string;
+            }> | null;
+        } | null;
+    } | {
+        __typename: 'HeadersCollectionRule';
+        name: string;
+        ruleType: RuleType;
+        enabled: boolean;
+        notes?: string | null;
+        config?: {
+            __typename?: 'HeadersCollectionConfig';
+            headerKeys: Array<string>;
+        } | null;
+    } | {
+        __typename: 'PayloadCollectionRule';
+        name: string;
+        ruleType: RuleType;
+        enabled: boolean;
+        notes?: string | null;
+        config?: {
+            __typename?: 'PayloadCollectionConfig';
+            collectHttpRequest?: boolean | null;
+            collectHttpResponse?: boolean | null;
+            collectDbQuery?: boolean | null;
+            collectMessaging?: boolean | null;
+        } | null;
+    };
+};
+export type DeleteInstrumentationRuleMutationVariables = Exact<{
+    input: DeleteInstrumentationRuleInput;
+}>;
+export type DeleteInstrumentationRuleMutation = {
+    __typename?: 'Mutation';
+    deleteInstrumentationRule: {
+        __typename?: 'DeleteInstrumentationRulePayload';
+        name: string;
+        deleted: boolean;
+    };
+};
+export type UpdateOnPremLicenseMutationVariables = Exact<{
+    token: Scalars['String']['input'];
+}>;
+export type UpdateOnPremLicenseMutation = {
+    __typename?: 'Mutation';
+    updateOnPremLicense: boolean;
+};
+export type PipelineCountersQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type PipelineCountersQuery = {
+    __typename?: 'Query';
+    pipelineCounters: {
+        __typename?: 'PipelineCounters';
+        otelcolHealthy: boolean;
+        scrapedAt: string;
+        scrapeError?: string | null;
+        destinations: Array<{
+            __typename?: 'DestinationCounters';
+            exporter: string;
+            traces: {
+                __typename?: 'DestinationSignal';
+                sent: number;
+                failed: number;
+                queue: number;
+            };
+            metrics: {
+                __typename?: 'DestinationSignal';
+                sent: number;
+                failed: number;
+                queue: number;
+            };
+            logs: {
+                __typename?: 'DestinationSignal';
+                sent: number;
+                failed: number;
+                queue: number;
+            };
+            profiles: {
+                __typename?: 'DestinationSignal';
+                sent: number;
+                failed: number;
+                queue: number;
+            };
+        }>;
+    };
+};
+export type ProfileHotFunctionsQueryVariables = Exact<{
+    topN?: InputMaybe<Scalars['Int']['input']>;
+}>;
+export type ProfileHotFunctionsQuery = {
+    __typename?: 'Query';
+    profileHotFunctions: {
+        __typename?: 'HotFunctionsResult';
+        enabled: boolean;
+        dynamicInstrumentation: boolean;
+        services: Array<{
+            __typename?: 'ServiceHotFunctions';
+            service: string;
+            totalNanos: number;
+            language?: string | null;
+            functions: Array<{
+                __typename?: 'HotFunction';
+                name: string;
+                self: number;
+                total: number;
+                module: string;
+                buildId?: string | null;
+                offset?: number | null;
+                size?: number | null;
+                instrumentable?: string | null;
+            }>;
+        }>;
+        cache?: {
+            __typename?: 'ProfileCacheStats';
+            services: number;
+            totalBytes: number;
+            maxSlots: number;
+            slotMaxBytes: number;
+            maxTotalBytesBudget: number;
+            evictedSlotsTotal: number;
+            slotTtlSeconds: number;
+        } | null;
+        host?: {
+            __typename?: 'HostInfo';
+            os: string;
+            kernel: string;
+            arch: string;
+            hostname: string;
+        } | null;
+    };
+};
+export type ProfileBundleStatusQueryVariables = Exact<{
+    jobId: Scalars['String']['input'];
+}>;
+export type ProfileBundleStatusQuery = {
+    __typename?: 'Query';
+    profileBundleStatus: {
+        __typename?: 'ProfileBundleStatus';
+        id: string;
+        state: string;
+        startedAt: string;
+        durationSec: number;
+        elapsedSec: number;
+        filePath?: string | null;
+        sampleBytes?: number | null;
+        error?: string | null;
+        errorKind?: string | null;
+    };
+};
+export type GenerateProfileBundleMutationVariables = Exact<{
+    durationSeconds?: InputMaybe<Scalars['Int']['input']>;
+    service?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type GenerateProfileBundleMutation = {
+    __typename?: 'Mutation';
+    generateProfileBundle: {
+        __typename?: 'ProfileBundle';
+        id: string;
+        filePath: string;
+        createdAt: string;
+        durationSec: number;
+        sampleBytes: number;
+        error?: string | null;
+        errorKind?: string | null;
+    };
+};
+export type StartBackgroundProfileBundleMutationVariables = Exact<{
+    durationSeconds?: InputMaybe<Scalars['Int']['input']>;
+    service?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type StartBackgroundProfileBundleMutation = {
+    __typename?: 'Mutation';
+    startBackgroundProfileBundle: {
+        __typename?: 'ProfileBundleStatus';
+        id: string;
+        state: string;
+        startedAt: string;
+        durationSec: number;
+        elapsedSec: number;
+        filePath?: string | null;
+        sampleBytes?: number | null;
+        error?: string | null;
+        errorKind?: string | null;
+    };
+};
+export type CancelProfileBundleMutationVariables = Exact<{
+    jobId: Scalars['String']['input'];
+}>;
+export type CancelProfileBundleMutation = {
+    __typename?: 'Mutation';
+    cancelProfileBundle: boolean;
+};
+export type ClearProfileCacheMutationVariables = Exact<{
+    [key: string]: never;
+}>;
+export type ClearProfileCacheMutation = {
+    __typename?: 'Mutation';
+    clearProfileCache: boolean;
+};
+export type ProfilingSlotsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type ProfilingSlotsQuery = {
+    __typename?: 'Query';
+    profilingSlots: {
+        __typename?: 'ProfilingSlots';
+        activeKeys: Array<string>;
+        keysWithData: Array<string>;
+        cache: {
+            __typename?: 'ProfileCacheStats';
+            services: number;
+            totalBytes: number;
+            maxSlots: number;
+            slotMaxBytes: number;
+            maxTotalBytesBudget: number;
+            evictedSlotsTotal: number;
+            slotTtlSeconds: number;
+        };
+    };
+};
+export type SourceProfileQueryVariables = Exact<{
+    service: Scalars['String']['input'];
+}>;
+export type SourceProfileQuery = {
+    __typename?: 'Query';
+    sourceProfile: {
+        __typename?: 'SourceProfilingResult';
+        profileJson: string;
+    };
+};
+export type EnableSourceProfilingMutationVariables = Exact<{
+    service: Scalars['String']['input'];
+}>;
+export type EnableSourceProfilingMutation = {
+    __typename?: 'Mutation';
+    enableSourceProfiling: {
+        __typename?: 'SlotResult';
+        status: string;
+        sourceKey: string;
+        activeSlots: number;
+        maxSlots: number;
+    };
+};
+export type DisableSourceProfilingMutationVariables = Exact<{
+    service: Scalars['String']['input'];
+}>;
+export type DisableSourceProfilingMutation = {
+    __typename?: 'Mutation';
+    disableSourceProfiling: {
+        __typename?: 'SlotResult';
+        status: string;
+        sourceKey: string;
+        activeSlots: number;
+        maxSlots: number;
+    };
+};
+export type ClearSourceProfilingBufferMutationVariables = Exact<{
+    service: Scalars['String']['input'];
+}>;
+export type ClearSourceProfilingBufferMutation = {
+    __typename?: 'Mutation';
+    clearSourceProfilingBuffer: {
+        __typename?: 'SlotResult';
+        status: string;
+        sourceKey: string;
+        activeSlots: number;
+        maxSlots: number;
+    };
+};
+export type ConfigureProfilingCacheMutationVariables = Exact<{
+    maxSlots?: InputMaybe<Scalars['Int']['input']>;
+    slotMaxBytes?: InputMaybe<Scalars['Int']['input']>;
+    slotTTLSeconds?: InputMaybe<Scalars['Int']['input']>;
+}>;
+export type ConfigureProfilingCacheMutation = {
+    __typename?: 'Mutation';
+    configureProfilingCache: {
+        __typename?: 'ProfilingSlots';
+        activeKeys: Array<string>;
+        keysWithData: Array<string>;
+        cache: {
+            __typename?: 'ProfileCacheStats';
+            services: number;
+            totalBytes: number;
+            maxSlots: number;
+            slotMaxBytes: number;
+            maxTotalBytesBudget: number;
+            evictedSlotsTotal: number;
+            slotTtlSeconds: number;
+        };
+    };
+};
+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'];
+}>;
+export type GetSourceQuery = {
+    __typename?: 'Query';
+    source?: {
+        __typename?: 'Source';
+        name: string;
+        kind: string;
+        serviceName?: string | null;
+        region?: string | null;
+        enabled: boolean;
+        config?: {
+            __typename?: 'SourceConfig';
+            runtimeOverride?: {
+                __typename?: 'RuntimeOverride';
+                language?: string | null;
+                version?: string | null;
+            } | null;
+            distroOverride?: {
+                __typename?: 'DistroOverride';
+                otelDistroName?: string | null;
+            } | null;
+            serviceNameOverride?: {
+                __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;
+};
+export type GetSourcesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetSourcesQuery = {
+    __typename?: 'Query';
+    sources: Array<{
+        __typename?: 'Source';
+        name: string;
+        kind: string;
+        serviceName?: string | null;
+        region?: string | null;
+        enabled: boolean;
+        config?: {
+            __typename?: 'SourceConfig';
+            runtimeOverride?: {
+                __typename?: 'RuntimeOverride';
+                language?: string | null;
+                version?: string | null;
+            } | null;
+            distroOverride?: {
+                __typename?: 'DistroOverride';
+                otelDistroName?: string | null;
+            } | null;
+            serviceNameOverride?: {
+                __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;
+    }>;
+};
+export type CreateSourceMutationVariables = Exact<{
+    input: CreateSourceInput;
+}>;
+export type CreateSourceMutation = {
+    __typename?: 'Mutation';
+    createSource: {
+        __typename?: 'Source';
+        name: string;
+        kind: string;
+        serviceName?: string | null;
+        region?: string | null;
+        enabled: boolean;
+        config?: {
+            __typename?: 'SourceConfig';
+            runtimeOverride?: {
+                __typename?: 'RuntimeOverride';
+                language?: string | null;
+                version?: string | null;
+            } | null;
+            distroOverride?: {
+                __typename?: 'DistroOverride';
+                otelDistroName?: string | null;
+            } | null;
+            serviceNameOverride?: {
+                __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;
+    };
+};
+export type UpdateSourceMutationVariables = Exact<{
+    input: UpdateSourceInput;
+}>;
+export type UpdateSourceMutation = {
+    __typename?: 'Mutation';
+    updateSource: {
+        __typename?: 'Source';
+        name: string;
+        kind: string;
+        serviceName?: string | null;
+        region?: string | null;
+        enabled: boolean;
+        config?: {
+            __typename?: 'SourceConfig';
+            runtimeOverride?: {
+                __typename?: 'RuntimeOverride';
+                language?: string | null;
+                version?: string | null;
+            } | null;
+            distroOverride?: {
+                __typename?: 'DistroOverride';
+                otelDistroName?: string | null;
+            } | null;
+            serviceNameOverride?: {
+                __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;
+    };
+};
+export type DeleteSourceMutationVariables = Exact<{
+    input: DeleteSourceInput;
+}>;
+export type DeleteSourceMutation = {
+    __typename?: 'Mutation';
+    deleteSource: {
+        __typename?: 'DeleteSourcePayload';
+        name: string;
+        deleted: boolean;
+    };
+};
+export type RestartSourceMutationVariables = Exact<{
+    input: RestartSourceInput;
+}>;
+export type RestartSourceMutation = {
+    __typename?: 'Mutation';
+    restartSource: {
+        __typename?: 'RestartSourcePayload';
+        name: string;
+        kind: string;
+        restarted: boolean;
+        message?: string | null;
+    };
+};
+export type WorkloadReportFieldsFragment = {
+    __typename?: 'WorkloadReport';
+    serviceName: string;
+    kind: string;
+    region?: string | null;
+    updatedAt: string;
+    desired: {
+        __typename?: 'WorkloadDesiredReport';
+        enabled: boolean;
+        reason?: string | null;
+        mode?: string | null;
+        sdkType?: string | null;
+        sourceMatched?: boolean | null;
+        sourceEnabled?: boolean | null;
+    };
+    current: {
+        __typename?: 'WorkloadCurrentReport';
+        state: string;
+        instrumented: boolean;
+        runtimeName?: string | null;
+        runtimeVersion?: string | null;
+        processCount: number;
+        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;
+            };
+        };
+    };
+    progress: {
+        __typename?: 'WorkloadProgressReport';
+        stage: string;
+        message?: string | null;
+        waitingFor?: string | null;
+    };
+    issues?: Array<{
+        __typename?: 'WorkloadIssue';
+        code: string;
+        severity: string;
+        message: string;
+        since?: string | null;
+        transient?: boolean | null;
+        details?: {
+            __typename: 'InstrumentationDriftDetails';
+            missingComponents: Array<string>;
+            code: string;
+        } | null;
+    }> | null;
+    instances?: Array<{
+        __typename?: 'WorkloadInstanceStatus';
+        id: string;
+        pid: number;
+        alive: boolean;
+        runtimeName?: string | null;
+        runtimeVersion?: string | null;
+        instrumented: boolean;
+        probesAttached: boolean;
+        restarted?: boolean | null;
+        message?: string | null;
+        distro?: string | null;
+    }> | null;
+    processMetadata?: Array<{
+        __typename?: 'WorkloadProcessMetadata';
+        pid: number;
+        ppid?: number | null;
+        exe?: string | null;
+        cmdline?: string | null;
+        processKind?: string | null;
+        serviceNameObserved?: string | null;
+        startTimeEpoch?: number | null;
+        instrumentationEligible: boolean;
+        instrumented: boolean;
+        probesAttached?: boolean | null;
+        excludedReason?: string | null;
+        otherAgentNames?: Array<string> | null;
+        metadata?: Record<string, any> | 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;
+            };
+        };
+        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;
+    libraries?: Array<{
+        __typename?: 'InstrumentationLibraryStatus';
+        name: string;
+        type: InstrumentationLibraryType;
+        healthy?: boolean | null;
+        message?: string | null;
+        reason?: string | null;
+        lastStatusTime?: string | null;
+        identifyingAttributes?: Array<{
+            __typename?: 'KeyValue';
+            key: string;
+            value: string;
+        }> | null;
+        nonIdentifyingAttributes?: Array<{
+            __typename?: 'KeyValue';
+            key: string;
+            value: string;
+        }> | 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'];
+    region?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type GetWorkloadReportQuery = {
+    __typename?: 'Query';
+    workloadReport?: {
+        __typename?: 'WorkloadReport';
+        serviceName: string;
+        kind: string;
+        region?: string | null;
+        updatedAt: string;
+        desired: {
+            __typename?: 'WorkloadDesiredReport';
+            enabled: boolean;
+            reason?: string | null;
+            mode?: string | null;
+            sdkType?: string | null;
+            sourceMatched?: boolean | null;
+            sourceEnabled?: boolean | null;
+        };
+        current: {
+            __typename?: 'WorkloadCurrentReport';
+            state: string;
+            instrumented: boolean;
+            runtimeName?: string | null;
+            runtimeVersion?: string | null;
+            processCount: number;
+            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;
+                };
+            };
+        };
+        progress: {
+            __typename?: 'WorkloadProgressReport';
+            stage: string;
+            message?: string | null;
+            waitingFor?: string | null;
+        };
+        issues?: Array<{
+            __typename?: 'WorkloadIssue';
+            code: string;
+            severity: string;
+            message: string;
+            since?: string | null;
+            transient?: boolean | null;
+            details?: {
+                __typename: 'InstrumentationDriftDetails';
+                missingComponents: Array<string>;
+                code: string;
+            } | null;
+        }> | null;
+        instances?: Array<{
+            __typename?: 'WorkloadInstanceStatus';
+            id: string;
+            pid: number;
+            alive: boolean;
+            runtimeName?: string | null;
+            runtimeVersion?: string | null;
+            instrumented: boolean;
+            probesAttached: boolean;
+            restarted?: boolean | null;
+            message?: string | null;
+            distro?: string | null;
+        }> | null;
+        processMetadata?: Array<{
+            __typename?: 'WorkloadProcessMetadata';
+            pid: number;
+            ppid?: number | null;
+            exe?: string | null;
+            cmdline?: string | null;
+            processKind?: string | null;
+            serviceNameObserved?: string | null;
+            startTimeEpoch?: number | null;
+            instrumentationEligible: boolean;
+            instrumented: boolean;
+            probesAttached?: boolean | null;
+            excludedReason?: string | null;
+            otherAgentNames?: Array<string> | null;
+            metadata?: Record<string, any> | 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;
+                };
+            };
+            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;
+        libraries?: Array<{
+            __typename?: 'InstrumentationLibraryStatus';
+            name: string;
+            type: InstrumentationLibraryType;
+            healthy?: boolean | null;
+            message?: string | null;
+            reason?: string | null;
+            lastStatusTime?: string | null;
+            identifyingAttributes?: Array<{
+                __typename?: 'KeyValue';
+                key: string;
+                value: string;
+            }> | null;
+            nonIdentifyingAttributes?: Array<{
+                __typename?: 'KeyValue';
+                key: string;
+                value: string;
+            }> | null;
+        }> | null;
+    } | null;
+};
+export type GetWorkloadReportsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetWorkloadReportsQuery = {
+    __typename?: 'Query';
+    workloadReports: Array<{
+        __typename?: 'WorkloadReport';
+        serviceName: string;
+        kind: string;
+        region?: string | null;
+        updatedAt: string;
+        desired: {
+            __typename?: 'WorkloadDesiredReport';
+            enabled: boolean;
+            reason?: string | null;
+            mode?: string | null;
+            sdkType?: string | null;
+            sourceMatched?: boolean | null;
+            sourceEnabled?: boolean | null;
+        };
+        current: {
+            __typename?: 'WorkloadCurrentReport';
+            state: string;
+            instrumented: boolean;
+            runtimeName?: string | null;
+            runtimeVersion?: string | null;
+            processCount: number;
+            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;
+                };
+            };
+        };
+        progress: {
+            __typename?: 'WorkloadProgressReport';
+            stage: string;
+            message?: string | null;
+            waitingFor?: string | null;
+        };
+        issues?: Array<{
+            __typename?: 'WorkloadIssue';
+            code: string;
+            severity: string;
+            message: string;
+            since?: string | null;
+            transient?: boolean | null;
+            details?: {
+                __typename: 'InstrumentationDriftDetails';
+                missingComponents: Array<string>;
+                code: string;
+            } | null;
+        }> | null;
+        instances?: Array<{
+            __typename?: 'WorkloadInstanceStatus';
+            id: string;
+            pid: number;
+            alive: boolean;
+            runtimeName?: string | null;
+            runtimeVersion?: string | null;
+            instrumented: boolean;
+            probesAttached: boolean;
+            restarted?: boolean | null;
+            message?: string | null;
+            distro?: string | null;
+        }> | null;
+        processMetadata?: Array<{
+            __typename?: 'WorkloadProcessMetadata';
+            pid: number;
+            ppid?: number | null;
+            exe?: string | null;
+            cmdline?: string | null;
+            processKind?: string | null;
+            serviceNameObserved?: string | null;
+            startTimeEpoch?: number | null;
+            instrumentationEligible: boolean;
+            instrumented: boolean;
+            probesAttached?: boolean | null;
+            excludedReason?: string | null;
+            otherAgentNames?: Array<string> | null;
+            metadata?: Record<string, any> | 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;
+                };
+            };
+            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;
+        libraries?: Array<{
+            __typename?: 'InstrumentationLibraryStatus';
+            name: string;
+            type: InstrumentationLibraryType;
+            healthy?: boolean | null;
+            message?: string | null;
+            reason?: string | null;
+            lastStatusTime?: string | null;
+            identifyingAttributes?: Array<{
+                __typename?: 'KeyValue';
+                key: string;
+                value: string;
+            }> | null;
+            nonIdentifyingAttributes?: Array<{
+                __typename?: 'KeyValue';
+                key: string;
+                value: string;
+            }> | null;
+        }> | null;
+    }>;
+};
+export declare const ActionTypeFieldsFragmentDoc: DocumentNode<ActionTypeFieldsFragment, unknown>;
+export declare const ActionFieldsFragmentDoc: DocumentNode<ActionFieldsFragment, unknown>;
+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>;
+export declare const GetActionsDocument: DocumentNode<GetActionsQuery, GetActionsQueryVariables>;
+export declare const CreateActionDocument: DocumentNode<CreateActionMutation, CreateActionMutationVariables>;
+export declare const UpdateActionDocument: DocumentNode<UpdateActionMutation, UpdateActionMutationVariables>;
+export declare const DeleteActionDocument: DocumentNode<DeleteActionMutation, DeleteActionMutationVariables>;
+export declare const GetComputePlatformReportDocument: DocumentNode<GetComputePlatformReportQuery, GetComputePlatformReportQueryVariables>;
+export declare const GetComputePlatformReportsDocument: DocumentNode<GetComputePlatformReportsQuery, GetComputePlatformReportsQueryVariables>;
+export declare const GetConfigDocument: DocumentNode<GetConfigQuery, GetConfigQueryVariables>;
+export declare const GetConfigDefaultsDocument: DocumentNode<GetConfigDefaultsQuery, GetConfigDefaultsQueryVariables>;
+export declare const UpdateConfigDocument: DocumentNode<UpdateConfigMutation, UpdateConfigMutationVariables>;
+export declare const GetSupportedSourceKindsDocument: DocumentNode<GetSupportedSourceKindsQuery, GetSupportedSourceKindsQueryVariables>;
+export declare const GetConnectorRuntimeHealthDocument: DocumentNode<GetConnectorRuntimeHealthQuery, GetConnectorRuntimeHealthQueryVariables>;
+export declare const GetConnectorCollectorStatusesDocument: DocumentNode<GetConnectorCollectorStatusesQuery, GetConnectorCollectorStatusesQueryVariables>;
+export declare const RefreshDiscoveryDocument: DocumentNode<RefreshDiscoveryMutation, RefreshDiscoveryMutationVariables>;
+export declare const TriggerRollbackDocument: DocumentNode<TriggerRollbackMutation, TriggerRollbackMutationVariables>;
+export declare const RequestCleanupDocument: DocumentNode<RequestCleanupMutation, RequestCleanupMutationVariables>;
+export declare const GetDestinationDocument: DocumentNode<GetDestinationQuery, GetDestinationQueryVariables>;
+export declare const GetDestinationsDocument: DocumentNode<GetDestinationsQuery, GetDestinationsQueryVariables>;
+export declare const GetDestinationTypesDocument: DocumentNode<GetDestinationTypesQuery, GetDestinationTypesQueryVariables>;
+export declare const CreateDestinationDocument: DocumentNode<CreateDestinationMutation, CreateDestinationMutationVariables>;
+export declare const UpdateDestinationDocument: DocumentNode<UpdateDestinationMutation, UpdateDestinationMutationVariables>;
+export declare const DeleteDestinationDocument: DocumentNode<DeleteDestinationMutation, DeleteDestinationMutationVariables>;
+export declare const TestConnectionDocument: DocumentNode<TestConnectionMutation, TestConnectionMutationVariables>;
+export declare const GenerateDiagnoseBundleDocument: DocumentNode<GenerateDiagnoseBundleMutation, GenerateDiagnoseBundleMutationVariables>;
+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>;
+export declare const CreateInstrumentationRuleDocument: DocumentNode<CreateInstrumentationRuleMutation, CreateInstrumentationRuleMutationVariables>;
+export declare const UpdateInstrumentationRuleDocument: DocumentNode<UpdateInstrumentationRuleMutation, UpdateInstrumentationRuleMutationVariables>;
+export declare const DeleteInstrumentationRuleDocument: DocumentNode<DeleteInstrumentationRuleMutation, DeleteInstrumentationRuleMutationVariables>;
+export declare const UpdateOnPremLicenseDocument: DocumentNode<UpdateOnPremLicenseMutation, UpdateOnPremLicenseMutationVariables>;
+export declare const PipelineCountersDocument: DocumentNode<PipelineCountersQuery, PipelineCountersQueryVariables>;
+export declare const ProfileHotFunctionsDocument: DocumentNode<ProfileHotFunctionsQuery, ProfileHotFunctionsQueryVariables>;
+export declare const ProfileBundleStatusDocument: DocumentNode<ProfileBundleStatusQuery, ProfileBundleStatusQueryVariables>;
+export declare const GenerateProfileBundleDocument: DocumentNode<GenerateProfileBundleMutation, GenerateProfileBundleMutationVariables>;
+export declare const StartBackgroundProfileBundleDocument: DocumentNode<StartBackgroundProfileBundleMutation, StartBackgroundProfileBundleMutationVariables>;
+export declare const CancelProfileBundleDocument: DocumentNode<CancelProfileBundleMutation, CancelProfileBundleMutationVariables>;
+export declare const ClearProfileCacheDocument: DocumentNode<ClearProfileCacheMutation, ClearProfileCacheMutationVariables>;
+export declare const ProfilingSlotsDocument: DocumentNode<ProfilingSlotsQuery, ProfilingSlotsQueryVariables>;
+export declare const SourceProfileDocument: DocumentNode<SourceProfileQuery, SourceProfileQueryVariables>;
+export declare const EnableSourceProfilingDocument: DocumentNode<EnableSourceProfilingMutation, EnableSourceProfilingMutationVariables>;
+export declare const DisableSourceProfilingDocument: DocumentNode<DisableSourceProfilingMutation, DisableSourceProfilingMutationVariables>;
+export declare const ClearSourceProfilingBufferDocument: DocumentNode<ClearSourceProfilingBufferMutation, ClearSourceProfilingBufferMutationVariables>;
+export declare const ConfigureProfilingCacheDocument: DocumentNode<ConfigureProfilingCacheMutation, ConfigureProfilingCacheMutationVariables>;
+export declare const GetSourceDocument: DocumentNode<GetSourceQuery, GetSourceQueryVariables>;
+export declare const GetSourcesDocument: DocumentNode<GetSourcesQuery, GetSourcesQueryVariables>;
+export declare const CreateSourceDocument: DocumentNode<CreateSourceMutation, CreateSourceMutationVariables>;
+export declare const UpdateSourceDocument: DocumentNode<UpdateSourceMutation, UpdateSourceMutationVariables>;
+export declare const DeleteSourceDocument: DocumentNode<DeleteSourceMutation, DeleteSourceMutationVariables>;
+export declare const RestartSourceDocument: DocumentNode<RestartSourceMutation, RestartSourceMutationVariables>;
+export declare const GetWorkloadReportDocument: DocumentNode<GetWorkloadReportQuery, GetWorkloadReportQueryVariables>;
+export declare const GetWorkloadReportsDocument: DocumentNode<GetWorkloadReportsQuery, GetWorkloadReportsQueryVariables>;
+export {};