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

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

@@ -80,6 +80,20 @@ export type ActionTypeOption = {
     fields: Array<ActionField>;
     type: Scalars['String']['output'];
 };
+/** AWS: the objects an operator would look up in the console. */
+export type AwsManagedCollectorDetails = ManagedCollectorDetails & {
+    __typename?: 'AwsManagedCollectorDetails';
+    clusterRef?: Maybe<Scalars['String']['output']>;
+    loadBalancerRef?: Maybe<Scalars['String']['output']>;
+    provider: Scalars['String']['output'];
+    /** Task definition ARN, including revision. */
+    revisionRef?: Maybe<Scalars['String']['output']>;
+    securityGroupId?: Maybe<Scalars['String']['output']>;
+    subnetIds?: Maybe<Array<Scalars['String']['output']>>;
+    targetGroupRefs?: Maybe<Array<Scalars['String']['output']>>;
+    /** ECS service ARN. */
+    workloadRef?: Maybe<Scalars['String']['output']>;
+};
 export type CodeAttributesConfig = {
     __typename?: 'CodeAttributesConfig';
     collectColumn?: Maybe<Scalars['Boolean']['output']>;
@@ -199,6 +213,8 @@ export type CreateActionInput = {
 };
 export type CreateDestinationInput = {
     config?: InputMaybe<Scalars['JSON']['input']>;
+    /** When omitted, defaults to false (export active). */
+    disabled?: InputMaybe<Scalars['Boolean']['input']>;
     name: Scalars['String']['input'];
     region?: InputMaybe<Scalars['String']['input']>;
     signals: Array<TelemetrySignal>;
@@ -215,6 +231,57 @@ export type CreateInstrumentationRuleInput = {
     payloadCollection?: InputMaybe<PayloadCollectionConfigInput>;
     ruleType: RuleType;
 };
+export type CreateManagedCollectorDestinationInput = {
+    /** Field values keyed by DestinationField.name for this type (validated server-side). */
+    config?: InputMaybe<Scalars['JSON']['input']>;
+    /** When omitted, defaults to false (export active). */
+    disabled?: InputMaybe<Scalars['Boolean']['input']>;
+    /**
+     * Unique within the region. Letters, digits, '-' and '_' only: it names the destination's exporters
+     * and pipelines in the rendered Collector configuration.
+     */
+    name: Scalars['String']['input'];
+    /** The Collector this destination belongs to. */
+    region: Scalars['String']['input'];
+    /**
+     * TRACES, METRICS and LOGS; each must be supported by the type. PROFILES is not accepted: the managed
+     * Collector does not receive profiles.
+     */
+    signals: Array<TelemetrySignal>;
+    /** An Odigos destination type key, as getManagedCollectorDestinationTypes lists it. */
+    type: Scalars['String']['input'];
+};
+/**
+ * Settings for one region's Collector. Every field except the region is optional: an omitted field
+ * inherits `collector.defaults`, which is what makes a bare `{ region }` a valid, fully-defaulted create.
+ *
+ * An explicitly empty list means "none" and is NOT the same as omitting the field — omitting inherits the
+ * default's list, and clearing it is the only way to say this region wants none of them.
+ */
+export type CreateManagedCollectorInput = {
+    arch?: InputMaybe<Scalars['String']['input']>;
+    assignPublicIp?: InputMaybe<Scalars['Boolean']['input']>;
+    clusterRef?: InputMaybe<Scalars['String']['input']>;
+    cpu?: InputMaybe<Scalars['String']['input']>;
+    endpointOverride?: InputMaybe<Scalars['String']['input']>;
+    /**
+     * Pin the Collector to one network. Omit to let Odigos select the region's only eligible network;
+     * it refuses to guess when several are eligible and reports the candidates.
+     */
+    hostNetworkId?: InputMaybe<Scalars['String']['input']>;
+    imageRepositoryOverride?: InputMaybe<Scalars['String']['input']>;
+    ingress?: InputMaybe<ManagedCollectorIngressInput>;
+    logRetentionDays?: InputMaybe<Scalars['Int']['input']>;
+    memory?: InputMaybe<Scalars['String']['input']>;
+    region: Scalars['String']['input'];
+    /** How many workloads one cutover pass may re-point at this Collector. 0 uses the connector default. */
+    rolloutBatchSize?: InputMaybe<Scalars['Int']['input']>;
+    scaling?: InputMaybe<ManagedCollectorScalingInput>;
+    securityGroupIds?: InputMaybe<Array<Scalars['String']['input']>>;
+    subnetIds?: InputMaybe<Array<Scalars['String']['input']>>;
+    transport?: InputMaybe<ManagedCollectorTransportInput>;
+    useFargateSpot?: InputMaybe<Scalars['Boolean']['input']>;
+};
 export type CreateSourceInput = {
     config?: InputMaybe<SourceConfigInput>;
     enabled: Scalars['Boolean']['input'];
@@ -285,6 +352,7 @@ export type DeleteSourcePayload = {
 export type Destination = {
     __typename?: 'Destination';
     config?: Maybe<Scalars['JSON']['output']>;
+    disabled: Scalars['Boolean']['output'];
     name: Scalars['String']['output'];
     region?: Maybe<Scalars['String']['output']>;
     signals: Array<TelemetrySignal>;
@@ -331,6 +399,20 @@ export type DestinationType = {
     supportedSignals: DestinationSupportedSignals;
     type: Scalars['String']['output'];
 };
+export type DestroyManagedCollectorDestinationInput = {
+    name: Scalars['String']['input'];
+    region: Scalars['String']['input'];
+};
+export type DestroyManagedCollectorDestinationPayload = {
+    __typename?: 'DestroyManagedCollectorDestinationPayload';
+    /**
+     * False when there was nothing by that name in that region. Not an error: deleting something already
+     * gone is the requested end state.
+     */
+    deleted: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+    region: Scalars['String']['output'];
+};
 export type DiagnoseBundle = {
     __typename?: 'DiagnoseBundle';
     contentBase64?: Maybe<Scalars['String']['output']>;
@@ -640,6 +722,423 @@ export type LambdaWorkloadDetails = WorkloadDetails & {
     /** Lambda-managed runtime identifier (e.g. "python3.12", "java21"). */
     runtime?: Maybe<Scalars['String']['output']>;
 };
+/**
+ * Whether Odigos may act on this Collector's cloud objects.
+ *
+ * Two independent bits, never one enum: `mode` says who converges the Collector, `origin` says who
+ * created its objects. Only automatic + odigos may be deleted; automatic + customer is converged and
+ * never deleted; either manual mode is observed and configured but never written to.
+ */
+export type ManagedCollectorAuthority = {
+    __typename?: 'ManagedCollectorAuthority';
+    /** mine | predecessor | foreign | unattributed | none. */
+    attribution: Scalars['String']['output'];
+    /**
+     * Odigos may destroy these objects. Requires mutable AND origin=odigos AND a matching record in the
+     * connector's own state — a tag alone, which a customer could write by hand, is never sufficient.
+     */
+    deletable: Scalars['Boolean']['output'];
+    /** automatic | manual — who deploys and converges. */
+    mode: Scalars['String']['output'];
+    /** Odigos may write to these objects (converge, re-tag, scale). */
+    mutable: Scalars['Boolean']['output'];
+    /** odigos | customer — who created the underlying cloud objects. */
+    origin: Scalars['String']['output'];
+};
+/**
+ * A Collector that connected and then rejected the configuration pushed to it, or never connected at all.
+ * The last known-good configuration stays in force, so this is a "cannot change it" condition rather than
+ * a "it stopped working" one.
+ */
+export type ManagedCollectorConfigIssueDetails = ManagedCollectorIssueDetails & {
+    __typename?: 'ManagedCollectorConfigIssueDetails';
+    code: Scalars['String']['output'];
+    /** Hash still in force on the Collector, if it has ever accepted one. */
+    lastGoodConfigHash?: Maybe<Scalars['String']['output']>;
+    /** Hash of the configuration that was refused. */
+    rejectedConfigHash?: Maybe<Scalars['String']['output']>;
+    /** The Supervisor's own validation error, verbatim. */
+    validationError?: Maybe<Scalars['String']['output']>;
+};
+/**
+ * A condition fixed by setting something under `collector.regions.<region>` — no usable subnets, no
+ * egress route, no security group resolving, a refused TLS or ingress value, several eligible host
+ * networks with none pinned.
+ *
+ * Carries the region and the key so a client can send someone straight to the setting instead of asking
+ * them to find it.
+ */
+export type ManagedCollectorConfigurationIssueDetails = ManagedCollectorIssueDetails & {
+    __typename?: 'ManagedCollectorConfigurationIssueDetails';
+    /**
+     * The candidates a refusal was choosing between, when the refusal was an ambiguity — e.g. the eligible
+     * host networks found in this region when none was pinned. Empty for every other condition.
+     *
+     * Present because "Odigos refused to guess" is only actionable if the reader is told what it was
+     * choosing between.
+     */
+    candidates?: Maybe<Array<Scalars['String']['output']>>;
+    code: Scalars['String']['output'];
+    /** The value that was refused, when there was one. Null when the setting is simply absent. */
+    refusedValue?: Maybe<Scalars['String']['output']>;
+    region: Scalars['String']['output'];
+    /** The setting to change, relative to the region, e.g. "hostNetworkId", "tls.hostname". */
+    settingKey: Scalars['String']['output'];
+};
+/**
+ * What is actually deployed and running, as last observed. Null fields mean not yet built or not yet
+ * observed, which is normal before the first successful convergence.
+ */
+export type ManagedCollectorCurrent = {
+    __typename?: 'ManagedCollectorCurrent';
+    /**
+     * Hash of the configuration last accepted over OpAMP, and when it was pushed. A hash differing from
+     * what the connector would render now is a configuration push still in flight or refused.
+     */
+    configHash?: Maybe<Scalars['String']['output']>;
+    configPushedAt?: Maybe<Scalars['String']['output']>;
+    endpoint: ManagedCollectorEndpoint;
+    /**
+     * RFC3339 timestamp this Collector FIRST reported ready; null when it never has.
+     *
+     * The gate the workload cutover runs on: until it is set, no workload has been re-pointed at this
+     * Collector. Reported because "deployed" and "workloads are actually using it" are different facts and a
+     * customer watching a rollout needs the second one.
+     */
+    firstReadyAt?: Maybe<Scalars['String']['output']>;
+    image?: Maybe<ManagedCollectorImage>;
+    /**
+     * RFC3339 expiry of the enterprise licence the Collector runs under; null when not yet provisioned.
+     *
+     * Its own field rather than only an issue, because an expired licence and a rejected configuration look
+     * identical from outside — the container will not start either way — and send a reader to opposite ends
+     * of the product.
+     */
+    licenseExpiresAt?: Maybe<Scalars['String']['output']>;
+    scaling: ManagedCollectorScalingState;
+};
+/**
+ * Configuration for this region, as resolved from the connector's operational config
+ * (`collector.regions.<region>`, over `collector.defaults`). Compare against ManagedCollectorCurrent to
+ * see drift.
+ */
+export type ManagedCollectorDesired = {
+    __typename?: 'ManagedCollectorDesired';
+    arch: Scalars['String']['output'];
+    assignPublicIp: Scalars['Boolean']['output'];
+    clusterRef?: Maybe<Scalars['String']['output']>;
+    cpu: Scalars['String']['output'];
+    /**
+     * Whether this region gets a Collector at all. Resolved: an unset region inherits the feature
+     * switch, and an explicit false wins over it.
+     */
+    enabled: Scalars['Boolean']['output'];
+    /** When set, Odigos creates no load balancer and publishes this address instead. */
+    endpointOverride?: Maybe<Scalars['String']['output']>;
+    /**
+     * The network the customer pinned the Collector to. Empty means Odigos selects the region's only
+     * eligible network, and refuses to guess when several are eligible.
+     */
+    hostNetworkId?: Maybe<Scalars['String']['output']>;
+    imageRepositoryOverride?: Maybe<Scalars['String']['output']>;
+    ingress: ManagedCollectorIngress;
+    logRetentionDays: Scalars['Int']['output'];
+    /**
+     * Also sizes the Collector's memory_limiter, which is why changing it is a configuration push as
+     * well as a workload change.
+     */
+    memory: Scalars['String']['output'];
+    scaling: ManagedCollectorScalingTarget;
+    securityGroupIds?: Maybe<Array<Scalars['String']['output']>>;
+    /**
+     * Placement the customer pinned. Empty means Odigos chooses.
+     *
+     * A value here means the customer pointed Odigos at their OWN object, which is never mutated or deleted
+     * whatever its tags say — see ManagedCollectorAuthority.
+     */
+    subnetIds?: Maybe<Array<Scalars['String']['output']>>;
+    transport: ManagedCollectorTransport;
+};
+/** Provider-specific infrastructure references, discriminated by `provider`. */
+export type ManagedCollectorDetails = {
+    /** aws | azure | gcp. */
+    provider: Scalars['String']['output'];
+};
+export type ManagedCollectorEndpoint = {
+    __typename?: 'ManagedCollectorEndpoint';
+    /** OTLP/gRPC address workloads export to; null before one exists. */
+    grpc?: Maybe<Scalars['String']['output']>;
+    /** OTLP/HTTP address; null when the provider or configuration exposes only one port. */
+    http?: Maybe<Scalars['String']['output']>;
+    /** Which ingress tier is actually admitting traffic, which may be narrower or wider than requested. */
+    ingressTier?: Maybe<Scalars['String']['output']>;
+    /**
+     * created | endpointOverride — whether Odigos built this address or is echoing back one the
+     * customer supplied.
+     */
+    source: Scalars['String']['output'];
+    /** The transport actually in effect, which may lag ManagedCollectorTransport.mode mid-change. */
+    tlsMode?: Maybe<Scalars['String']['output']>;
+    /** Where TLS terminates: none | platform | loadBalancer | collector. */
+    tlsTermination?: Maybe<Scalars['String']['output']>;
+};
+export type ManagedCollectorImage = {
+    __typename?: 'ManagedCollectorImage';
+    arch: Scalars['String']['output'];
+    /** Manifest-list digest actually deployed, e.g. "sha256:…". This, not the tag, is the pin. */
+    digest: Scalars['String']['output'];
+    tag?: Maybe<Scalars['String']['output']>;
+};
+/** Which senders are admitted to the Collector's OTLP ports. */
+export type ManagedCollectorIngress = {
+    __typename?: 'ManagedCollectorIngress';
+    /**
+     * Explicit ranges for senders with no security group, such as workloads in a peered network.
+     * Validated, never widened.
+     */
+    additionalCidrs?: Maybe<Array<Scalars['String']['output']>>;
+    /** Groups admitted beyond the ones discovery found — senders Odigos does not instrument. */
+    additionalSecurityGroupIds?: Maybe<Array<Scalars['String']['output']>>;
+    /**
+     * Whether the host network's CIDR fallback may be used when no sender security group resolves. False
+     * skips the deploy with a message rather than widening the rule.
+     */
+    allowNetworkCidrFallback: Scalars['Boolean']['output'];
+    /** Floor on how wide that fallback may go; 0 means the default. Larger number = narrower block. */
+    minFallbackPrefixLength?: Maybe<Scalars['Int']['output']>;
+};
+export type ManagedCollectorIngressInput = {
+    additionalCidrs?: InputMaybe<Array<Scalars['String']['input']>>;
+    additionalSecurityGroupIds?: InputMaybe<Array<Scalars['String']['input']>>;
+    allowNetworkCidrFallback?: InputMaybe<Scalars['Boolean']['input']>;
+    minFallbackPrefixLength?: InputMaybe<Scalars['Int']['input']>;
+};
+/**
+ * How to deploy this region's Collector by hand or by IaC.
+ *
+ * Served in BOTH modes on purpose, the same reason InstrumentationInstructions is: in manual mode these
+ * are what the customer applies, and in automatic mode they are the same infrastructure Odigos builds
+ * itself, which is what makes "what exactly did Odigos create here" answerable without a provider console.
+ */
+export type ManagedCollectorInstructions = {
+    __typename?: 'ManagedCollectorInstructions';
+    /**
+     * The deployment rendered per delivery tool, in the connector's preferred order. Never empty.
+     *
+     * Reuses InstructionDocument from the workload instructions: the per-tool shape (variant, steps,
+     * content, unresolved) carries nothing workload-specific and needs no Collector-specific twin.
+     */
+    documents: Array<InstructionDocument>;
+    /** The network the instructions place the Collector in; empty when placement has not resolved one. */
+    hostNetworkId: Scalars['String']['output'];
+    /** automatic | manual — why the customer is being shown this. */
+    mode: Scalars['String']['output'];
+    /**
+     * Caveats that belong with the instructions whichever tool is used — a platform limit, a value the
+     * customer must supply, a step that completes without telemetry actually flowing.
+     */
+    notes: Array<Scalars['String']['output']>;
+    region: Scalars['String']['output'];
+    /** RFC3339 timestamp the instructions were computed. */
+    updatedAt: Scalars['String']['output'];
+};
+/** One structured condition behind a Collector's status. */
+export type ManagedCollectorIssue = {
+    __typename?: 'ManagedCollectorIssue';
+    /**
+     * Stable identifier a client branches on, e.g. NoUsableSubnets, SubnetsNoEgress, TargetsUnhealthy,
+     * OpampNeverConnected, ConfigRejected, DestinationUnreachable, CredentialRevoked, LicenseExpired,
+     * ImagePullFailed, UnsupportedArchitecture, NameConflict, TeardownDeclined, AmbiguousHostNetwork.
+     * Additive: a code is never renamed or repurposed once shipped, and a client ignores one it does not
+     * know.
+     */
+    code: Scalars['String']['output'];
+    /** Machine-readable facts, typed per `code`. Null for conditions whose message is the whole story. */
+    details?: Maybe<ManagedCollectorIssueDetails>;
+    message: Scalars['String']['output'];
+    /** info | warning | error. */
+    severity: Scalars['String']['output'];
+    /** RFC3339 timestamp the condition was first observed. */
+    since?: Maybe<Scalars['String']['output']>;
+    /** True when the next reconcile is expected to clear this without anyone doing anything. */
+    transient: Scalars['Boolean']['output'];
+};
+/**
+ * Facts behind one ManagedCollectorIssue, typed by its `code`. Same discriminator-plus-typed-branch
+ * pattern as WorkloadIssueDetails: add a branch for a code whose remedy needs a value, rather than a new
+ * convention for encoding data into a sentence.
+ */
+export type ManagedCollectorIssueDetails = {
+    /**
+     * The ManagedCollectorIssue.code this block describes, echoed so clients can branch without a
+     * fragment.
+     */
+    code: Scalars['String']['output'];
+};
+/**
+ * Throughput and resource counters for one region's Collector.
+ *
+ * Two possible sources, and `live` says which one answered: the snapshot the Collector last reported over
+ * its OpAMP session (cached by the connector, always available), or a round trip to the running Collector
+ * made for this query. A cached answer is not a degraded one — it is the normal path, and `observedAt`
+ * says how old it is.
+ *
+ * Every counter is nullable because a Collector that has never connected has reported none of them, and a
+ * zero would be a lie about a Collector nobody has heard from.
+ */
+export type ManagedCollectorMetrics = {
+    __typename?: 'ManagedCollectorMetrics';
+    acceptedLogRecords?: Maybe<Scalars['Int']['output']>;
+    acceptedMetricPoints?: Maybe<Scalars['Int']['output']>;
+    /** Spans/points/records the Collector's receivers accepted since it started. */
+    acceptedSpans?: Maybe<Scalars['Int']['output']>;
+    /** Process resource use as the Collector itself reports it. */
+    cpuPercent?: Maybe<Scalars['Float']['output']>;
+    failedLogRecords?: Maybe<Scalars['Int']['output']>;
+    failedMetricPoints?: Maybe<Scalars['Int']['output']>;
+    /** Failed to send and dropped after retries. The number that means telemetry was LOST. */
+    failedSpans?: Maybe<Scalars['Int']['output']>;
+    /**
+     * True when this came from a round trip to the running Collector; false when it is the cached
+     * snapshot from its last periodic report.
+     */
+    live: Scalars['Boolean']['output'];
+    memoryBytes?: Maybe<Scalars['Int']['output']>;
+    /** RFC3339 timestamp the snapshot was TAKEN by the Collector, not when it was read here. */
+    observedAt: Scalars['String']['output'];
+    queueCapacity?: Maybe<Scalars['Int']['output']>;
+    /** Exporter sending queue depth and capacity; a queue at capacity is about to drop. */
+    queueSize?: Maybe<Scalars['Int']['output']>;
+    refusedLogRecords?: Maybe<Scalars['Int']['output']>;
+    refusedMetricPoints?: Maybe<Scalars['Int']['output']>;
+    /** Refused by the receiver — backpressure, or a payload the Collector would not take. */
+    refusedSpans?: Maybe<Scalars['Int']['output']>;
+    region: Scalars['String']['output'];
+    sentLogRecords?: Maybe<Scalars['Int']['output']>;
+    sentMetricPoints?: Maybe<Scalars['Int']['output']>;
+    /** Handed to the downstream destination successfully. */
+    sentSpans?: Maybe<Scalars['Int']['output']>;
+    /** Seconds since the Collector process started. */
+    uptimeSeconds?: Maybe<Scalars['Int']['output']>;
+};
+/**
+ * One managed Collector: identity, computed status, and the desired/current split that makes drift
+ * visible rather than implicit in a stale message.
+ *
+ * Identity is `region`. Never the host network (a Collector can be moved between networks in its region)
+ * and never the OpAMP instance uid (that rotates every time the underlying task is replaced).
+ */
+export type ManagedCollectorReport = {
+    __typename?: 'ManagedCollectorReport';
+    /** Whether Odigos may write to, or destroy, this Collector's cloud objects. */
+    authority: ManagedCollectorAuthority;
+    /** What is actually running. A field differing from its `desired` counterpart IS drift. */
+    current: ManagedCollectorCurrent;
+    /** What the customer configured. Always current intent, even mid-convergence. */
+    desired: ManagedCollectorDesired;
+    /**
+     * Provider-specific infrastructure references. A client not rendering an infrastructure view can
+     * ignore this entirely.
+     */
+    details?: Maybe<ManagedCollectorDetails>;
+    /**
+     * Provider network the Collector RUNS IN: VPC id on AWS, VNet on Azure, VPC network on GCP.
+     *
+     * Placement metadata, not identity — see the schema header. Empty before placement has resolved a host.
+     */
+    hostNetworkId: Scalars['String']['output'];
+    /**
+     * OpAMP instance uid of the current connection; null when never-connected. Useful for correlating
+     * this report with the Collector's own Supervisor logs. Not an identity — see the type doc.
+     */
+    instanceUid?: Maybe<Scalars['String']['output']>;
+    /**
+     * Structured facts behind `status` and `message`, most severe first; empty when there is nothing to
+     * report. Exists for the reason WorkloadIssue does: a client that must ACT on a condition should branch
+     * on `code`, not parse a sentence back apart.
+     */
+    issues: Array<ManagedCollectorIssue>;
+    /** Collector type, e.g. "aws.fargate-collector". Informational; identity is `region`. */
+    kind: Scalars['String']['output'];
+    /**
+     * never-connected | live | stale.
+     *
+     * Three states rather than a boolean on purpose: never-connected and stale have different causes and
+     * different remedies, and collapsing them loses the difference between a Collector nobody deployed and
+     * one that broke. Stale means OpAMP has gone quiet — the Collector is very likely still running and
+     * still exporting, because the data path does not depend on OpAMP, but its configuration can no longer
+     * be changed, which is a real loss and has to be said.
+     */
+    liveness: Scalars['String']['output'];
+    /**
+     * The reader-facing sentence. Kept alongside `issues` because a human wants one line to read first, and
+     * because a status a client's version does not recognize still has to render as something.
+     */
+    message: Scalars['String']['output'];
+    region: Scalars['String']['output'];
+    /** Pending | Deploying | Ready | Degraded | Error | AwaitingCustomer. */
+    status: Scalars['String']['output'];
+    /** RFC3339 timestamp of the last report refresh. */
+    updatedAt: Scalars['String']['output'];
+};
+/** Scaling policy. `mode` is manual (fixed desiredCount) or auto (the platform autoscaler bounds). */
+export type ManagedCollectorScalingInput = {
+    desiredCount?: InputMaybe<Scalars['Int']['input']>;
+    maxCount?: InputMaybe<Scalars['Int']['input']>;
+    minCount?: InputMaybe<Scalars['Int']['input']>;
+    mode: Scalars['String']['input'];
+    targetCpuPercent?: InputMaybe<Scalars['Int']['input']>;
+    targetMemoryPercent?: InputMaybe<Scalars['Int']['input']>;
+};
+/**
+ * Scaling as last converged and observed. runningCount is live; the rest reflect the target in force
+ * at that convergence and may lag ManagedCollectorScalingTarget mid-rollout.
+ */
+export type ManagedCollectorScalingState = {
+    __typename?: 'ManagedCollectorScalingState';
+    desiredCount?: Maybe<Scalars['Int']['output']>;
+    maxCount?: Maybe<Scalars['Int']['output']>;
+    minCount?: Maybe<Scalars['Int']['output']>;
+    mode: Scalars['String']['output'];
+    runningCount?: Maybe<Scalars['Int']['output']>;
+};
+/** Scaling as configured. mode "manual" reads desiredCount; mode "auto" reads the min/max/target trio. */
+export type ManagedCollectorScalingTarget = {
+    __typename?: 'ManagedCollectorScalingTarget';
+    desiredCount?: Maybe<Scalars['Int']['output']>;
+    maxCount?: Maybe<Scalars['Int']['output']>;
+    minCount?: Maybe<Scalars['Int']['output']>;
+    /** manual | auto. */
+    mode: Scalars['String']['output'];
+    targetCpuPercent?: Maybe<Scalars['Int']['output']>;
+    targetMemoryPercent?: Maybe<Scalars['Int']['output']>;
+};
+/**
+ * How workloads reach the Collector. One setting per region, resolved in one place so the deployer, the
+ * published artifacts and the observer cannot hold three different ideas of it.
+ */
+export type ManagedCollectorTransport = {
+    __typename?: 'ManagedCollectorTransport';
+    /** Reference to the certificate: an ACM ARN, or a secret ref. Never a certificate or key value. */
+    certificateRef?: Maybe<Scalars['String']['output']>;
+    /**
+     * A hostname the customer owns, required by every mode that presents a certificate.
+     *
+     * A load balancer's own generated DNS name is not issuable by any CA, so a certificate configured
+     * against it would fail verification on every export — which is why a certificate mode without this is
+     * refused rather than attempted.
+     */
+    hostname?: Maybe<Scalars['String']['output']>;
+    /** off | platform | loadBalancer | collector. Empty means the provider default. */
+    mode?: Maybe<Scalars['String']['output']>;
+};
+export type ManagedCollectorTransportInput = {
+    /** An ACM ARN or a secret ref. Never a certificate or key value. */
+    certificateRef?: InputMaybe<Scalars['String']['input']>;
+    hostname?: InputMaybe<Scalars['String']['input']>;
+    /** off | platform | loadBalancer | collector. */
+    mode?: InputMaybe<Scalars['String']['input']>;
+};
 export type Mutation = {
     __typename?: 'Mutation';
     cancelProfileBundle: Scalars['Boolean']['output'];
@@ -649,11 +1148,29 @@ export type Mutation = {
     createAction: Action;
     createDestination: Destination;
     createInstrumentationRule: InstrumentationRule;
+    /**
+     * Declare that this region should have a managed Collector, with the given settings.
+     *
+     * Writes configuration; the connector's reconcile loop builds the infrastructure on its next pass, so
+     * the returned report is normally still Pending. Fails when this region already has one — use
+     * updateManagedCollector to change it.
+     */
+    createManagedCollector: ManagedCollectorReport;
+    /**
+     * Add a destination to one region's Collector.
+     *
+     * Takes effect as a configuration push over OpAMP on the next Collector reconcile — no redeployment and
+     * no workload change. Fails when that region has no Collector configured, or already has a destination by
+     * this name.
+     */
+    createManagedCollectorDestination: Destination;
     createSource: Source;
     deleteAction: DeleteActionPayload;
     deleteDestination: DeleteDestinationPayload;
     deleteInstrumentationRule: DeleteInstrumentationRulePayload;
     deleteSource: DeleteSourcePayload;
+    /** Remove one destination from a region's Collector. Idempotent. */
+    destroyManagedCollectorDestination: DestroyManagedCollectorDestinationPayload;
     disableSourceProfiling: SlotResult;
     enableSourceProfiling: SlotResult;
     generateDiagnoseBundle: DiagnoseBundle;
@@ -664,6 +1181,13 @@ export type Mutation = {
     requestCleanup: Scalars['Boolean']['output'];
     restartSource: RestartSourcePayload;
     startBackgroundProfileBundle: ProfileBundleStatus;
+    /**
+     * Request teardown of one region's Collector.
+     *
+     * Idempotent — a Collector that is already gone returns deleted: true. Distinct from the generic
+     * requestCleanup, which takes a reconcile id rather than identifying a resource.
+     */
+    teardownManagedCollector: TeardownManagedCollectorPayload;
     testConnectionForDestination: TestConnectionResponse;
     /** Roll back instrumentation changes for the given reconcile id. Not implemented in the discovery-only phase. */
     triggerRollback: Scalars['Boolean']['output'];
@@ -671,6 +1195,15 @@ export type Mutation = {
     updateConfig: UpdateConfigPayload;
     updateDestination: Destination;
     updateInstrumentationRule: InstrumentationRule;
+    /**
+     * Change one region's Collector settings. Omitted fields keep their current value.
+     *
+     * Fails when the region has no Collector configured. Applied live: a size, scaling or ingress change is
+     * converged on the next pass without a connector restart.
+     */
+    updateManagedCollector: ManagedCollectorReport;
+    /** Change one destination. Fails when that region has no destination by this name. */
+    updateManagedCollectorDestination: Destination;
     /**
      * Replace the on-prem license JWT on this agent (writes license.jwt).
      * The token is verified before writing. Returns true on success.
@@ -698,6 +1231,12 @@ export type MutationCreateDestinationArgs = {
 export type MutationCreateInstrumentationRuleArgs = {
     input: CreateInstrumentationRuleInput;
 };
+export type MutationCreateManagedCollectorArgs = {
+    input: CreateManagedCollectorInput;
+};
+export type MutationCreateManagedCollectorDestinationArgs = {
+    input: CreateManagedCollectorDestinationInput;
+};
 export type MutationCreateSourceArgs = {
     input: CreateSourceInput;
 };
@@ -713,6 +1252,9 @@ export type MutationDeleteInstrumentationRuleArgs = {
 export type MutationDeleteSourceArgs = {
     input: DeleteSourceInput;
 };
+export type MutationDestroyManagedCollectorDestinationArgs = {
+    input: DestroyManagedCollectorDestinationInput;
+};
 export type MutationDisableSourceProfilingArgs = {
     service: Scalars['String']['input'];
 };
@@ -736,6 +1278,9 @@ export type MutationStartBackgroundProfileBundleArgs = {
     durationSeconds?: InputMaybe<Scalars['Int']['input']>;
     service?: InputMaybe<Scalars['String']['input']>;
 };
+export type MutationTeardownManagedCollectorArgs = {
+    input: TeardownManagedCollectorInput;
+};
 export type MutationTestConnectionForDestinationArgs = {
     input: TestConnectionDestinationInput;
 };
@@ -754,6 +1299,12 @@ export type MutationUpdateDestinationArgs = {
 export type MutationUpdateInstrumentationRuleArgs = {
     input: UpdateInstrumentationRuleInput;
 };
+export type MutationUpdateManagedCollectorArgs = {
+    input: UpdateManagedCollectorInput;
+};
+export type MutationUpdateManagedCollectorDestinationArgs = {
+    input: UpdateManagedCollectorDestinationInput;
+};
 export type MutationUpdateOnPremLicenseArgs = {
     token: Scalars['String']['input'];
 };
@@ -867,13 +1418,23 @@ export type Query = {
     computePlatformReports: Array<ComputePlatformReport>;
     config: Scalars['JSON']['output'];
     configDefaults: Scalars['JSON']['output'];
-    /** Per-region collector statuses (empty until managed-otelcol integration). */
+    /**
+     * Per-region collector statuses.
+     * @deprecated Use managedCollectorReports, which types what this packs into one prose message. Kept for one release so existing clients keep working.
+     */
     connectorCollectorStatuses: Array<ConnectorCollectorStatus>;
     /** Computed health of this connector runtime. */
     connectorRuntimeHealth: ConnectorRuntimeHealth;
     destination?: Maybe<Destination>;
     destinationTypes: Array<DestinationType>;
     destinations: Array<Destination>;
+    /** One destination of one region's Collector; null when that region has none by that name. */
+    getManagedCollectorDestination?: Maybe<Destination>;
+    /**
+     * The destination types a managed Collector can export to: the whole Odigos destination catalog, in the
+     * same shape destinationTypes serves it.
+     */
+    getManagedCollectorDestinationTypes: Array<DestinationType>;
     /**
      * 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.
@@ -882,6 +1443,25 @@ export type Query = {
     instrumentationRule?: Maybe<InstrumentationRule>;
     instrumentationRuleTypes: Array<InstrumentationRuleTypeOption>;
     instrumentationRules: Array<InstrumentationRule>;
+    /** Every destination one region's Collector exports to, ordered by name. `region` is set on each. */
+    listManagedCollectorDestinations: Array<Destination>;
+    /**
+     * How to deploy one region's Collector. Null when the region is unknown, or when the connector
+     * publishes no deployment instructions for its Collector type.
+     */
+    managedCollectorInstructions?: Maybe<ManagedCollectorInstructions>;
+    /**
+     * Counters for one region's Collector; null when none is recorded there or it has never reported.
+     *
+     * Cached by default. `refresh: true` asks the running Collector for a fresh snapshot and falls back to
+     * the cached one (with `live: false`) when it is not connected or does not answer promptly — a slow
+     * Collector degrades this query's freshness, never its availability.
+     */
+    managedCollectorMetrics?: Maybe<ManagedCollectorMetrics>;
+    /** One Collector by region; null when this connector has none there. */
+    managedCollectorReport?: Maybe<ManagedCollectorReport>;
+    /** Every managed Collector this connector knows about, in both modes. */
+    managedCollectorReports: Array<ManagedCollectorReport>;
     pipelineCounters: PipelineCounters;
     profileBundleStatus: ProfileBundleStatus;
     profileHotFunctions: HotFunctionsResult;
@@ -906,6 +1486,10 @@ export type QueryComputePlatformReportArgs = {
 export type QueryDestinationArgs = {
     name: Scalars['String']['input'];
 };
+export type QueryGetManagedCollectorDestinationArgs = {
+    name: Scalars['String']['input'];
+    region: Scalars['String']['input'];
+};
 export type QueryInstrumentationInstructionsArgs = {
     kind: Scalars['String']['input'];
     region?: InputMaybe<Scalars['String']['input']>;
@@ -914,6 +1498,19 @@ export type QueryInstrumentationInstructionsArgs = {
 export type QueryInstrumentationRuleArgs = {
     name: Scalars['String']['input'];
 };
+export type QueryListManagedCollectorDestinationsArgs = {
+    region: Scalars['String']['input'];
+};
+export type QueryManagedCollectorInstructionsArgs = {
+    region: Scalars['String']['input'];
+};
+export type QueryManagedCollectorMetricsArgs = {
+    refresh?: InputMaybe<Scalars['Boolean']['input']>;
+    region: Scalars['String']['input'];
+};
+export type QueryManagedCollectorReportArgs = {
+    region: Scalars['String']['input'];
+};
 export type QueryProfileBundleStatusArgs = {
     jobId: Scalars['String']['input'];
 };
@@ -1101,6 +1698,28 @@ export type SystemdProcessDetails = ProcessDetails & {
     /** Unit name without the .service suffix. */
     unitName?: Maybe<Scalars['String']['output']>;
 };
+export type TeardownManagedCollectorInput = {
+    region: Scalars['String']['input'];
+};
+/** Outcome of a teardown request. */
+export type TeardownManagedCollectorPayload = {
+    __typename?: 'TeardownManagedCollectorPayload';
+    /**
+     * True when nothing of this Collector remains, including when there was nothing to remove.
+     *
+     * False is a refusal, not an error: `message` names the reason, which is almost always that
+     * ManagedCollectorAuthority did not permit it. A declined teardown is always reported, because silently
+     * leaked infrastructure is the failure mode worth avoiding here.
+     */
+    deleted: Scalars['Boolean']['output'];
+    message?: Maybe<Scalars['String']['output']>;
+    region: Scalars['String']['output'];
+    /**
+     * Objects deliberately left standing, e.g. a customer-created load balancer Odigos adopted but may
+     * not destroy. Empty when nothing was retained.
+     */
+    retained: Array<Scalars['String']['output']>;
+};
 export declare enum TelemetrySignal {
     Logs = "LOGS",
     Metrics = "METRICS",
@@ -1180,6 +1799,8 @@ export type UpdateConfigPayload = {
 };
 export type UpdateDestinationInput = {
     config?: InputMaybe<Scalars['JSON']['input']>;
+    /** When omitted, the existing disabled flag is left unchanged. */
+    disabled?: InputMaybe<Scalars['Boolean']['input']>;
     name: Scalars['String']['input'];
     region?: InputMaybe<Scalars['String']['input']>;
     signals?: InputMaybe<Array<TelemetrySignal>>;
@@ -1195,6 +1816,52 @@ export type UpdateInstrumentationRuleInput = {
     payloadCollection?: InputMaybe<PayloadCollectionConfigInput>;
     ruleType?: InputMaybe<RuleType>;
 };
+/**
+ * A partial update: an omitted field keeps its current value, and `config`, when given, replaces the
+ * whole map. `region` and `name` address the destination and are never themselves changed — create a new
+ * one and delete the old to rename or move it.
+ */
+export type UpdateManagedCollectorDestinationInput = {
+    config?: InputMaybe<Scalars['JSON']['input']>;
+    /** When omitted, the existing disabled flag is left unchanged. */
+    disabled?: InputMaybe<Scalars['Boolean']['input']>;
+    name: Scalars['String']['input'];
+    region: Scalars['String']['input'];
+    signals?: InputMaybe<Array<TelemetrySignal>>;
+    type?: InputMaybe<Scalars['String']['input']>;
+};
+/**
+ * A partial update of one region's settings: an omitted field is LEFT AS IT IS, not reset to the default.
+ * Live — the next reconcile pass picks it up, with no connector restart.
+ */
+export type UpdateManagedCollectorInput = {
+    arch?: InputMaybe<Scalars['String']['input']>;
+    assignPublicIp?: InputMaybe<Scalars['Boolean']['input']>;
+    clusterRef?: InputMaybe<Scalars['String']['input']>;
+    cpu?: InputMaybe<Scalars['String']['input']>;
+    /**
+     * Setting this to false stops convergence and leaves everything running — it does NOT remove the
+     * Collector. Use teardownManagedCollector to destroy it.
+     */
+    enabled?: InputMaybe<Scalars['Boolean']['input']>;
+    endpointOverride?: InputMaybe<Scalars['String']['input']>;
+    /**
+     * Moving the Collector to another network is a REDEPLOYMENT of the same logical Collector: its
+     * credential is replaced and its infrastructure rebuilt in the new network.
+     */
+    hostNetworkId?: InputMaybe<Scalars['String']['input']>;
+    imageRepositoryOverride?: InputMaybe<Scalars['String']['input']>;
+    ingress?: InputMaybe<ManagedCollectorIngressInput>;
+    logRetentionDays?: InputMaybe<Scalars['Int']['input']>;
+    memory?: InputMaybe<Scalars['String']['input']>;
+    region: Scalars['String']['input'];
+    rolloutBatchSize?: InputMaybe<Scalars['Int']['input']>;
+    scaling?: InputMaybe<ManagedCollectorScalingInput>;
+    securityGroupIds?: InputMaybe<Array<Scalars['String']['input']>>;
+    subnetIds?: InputMaybe<Array<Scalars['String']['input']>>;
+    transport?: InputMaybe<ManagedCollectorTransportInput>;
+    useFargateSpot?: InputMaybe<Scalars['Boolean']['input']>;
+};
 export type UpdateSourceInput = {
     config?: InputMaybe<SourceConfigInput>;
     enabled?: InputMaybe<Scalars['Boolean']['input']>;
@@ -1962,6 +2629,7 @@ export type DestinationFieldsFragment = {
     region?: string | null;
     config?: Record<string, any> | null;
     signals: Array<TelemetrySignal>;
+    disabled: boolean;
 };
 export type GetDestinationQueryVariables = Exact<{
     name: Scalars['String']['input'];
@@ -1975,6 +2643,7 @@ export type GetDestinationQuery = {
         region?: string | null;
         config?: Record<string, any> | null;
         signals: Array<TelemetrySignal>;
+        disabled: boolean;
     } | null;
 };
 export type GetDestinationsQueryVariables = Exact<{
@@ -1989,6 +2658,7 @@ export type GetDestinationsQuery = {
         region?: string | null;
         config?: Record<string, any> | null;
         signals: Array<TelemetrySignal>;
+        disabled: boolean;
     }>;
 };
 export type GetDestinationTypesQueryVariables = Exact<{
@@ -2039,6 +2709,7 @@ export type CreateDestinationMutation = {
         region?: string | null;
         config?: Record<string, any> | null;
         signals: Array<TelemetrySignal>;
+        disabled: boolean;
     };
 };
 export type UpdateDestinationMutationVariables = Exact<{
@@ -2053,6 +2724,7 @@ export type UpdateDestinationMutation = {
         region?: string | null;
         config?: Record<string, any> | null;
         signals: Array<TelemetrySignal>;
+        disabled: boolean;
     };
 };
 export type DeleteDestinationMutationVariables = Exact<{
@@ -2575,6 +3247,857 @@ export type UpdateOnPremLicenseMutation = {
     __typename?: 'Mutation';
     updateOnPremLicense: boolean;
 };
+export type GetManagedCollectorReportsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetManagedCollectorReportsQuery = {
+    __typename?: 'Query';
+    managedCollectorReports: Array<{
+        __typename?: 'ManagedCollectorReport';
+        region: string;
+        hostNetworkId: string;
+        kind: string;
+        status: string;
+        message: string;
+        liveness: string;
+        instanceUid?: string | null;
+        updatedAt: string;
+        desired: {
+            __typename?: 'ManagedCollectorDesired';
+            enabled: boolean;
+            hostNetworkId?: string | null;
+            subnetIds?: Array<string> | null;
+            securityGroupIds?: Array<string> | null;
+            clusterRef?: string | null;
+            assignPublicIp: boolean;
+            cpu: string;
+            memory: string;
+            logRetentionDays: number;
+            arch: string;
+            imageRepositoryOverride?: string | null;
+            endpointOverride?: string | null;
+            scaling: {
+                __typename?: 'ManagedCollectorScalingTarget';
+                mode: string;
+                desiredCount?: number | null;
+                minCount?: number | null;
+                maxCount?: number | null;
+                targetCpuPercent?: number | null;
+                targetMemoryPercent?: number | null;
+            };
+            transport: {
+                __typename?: 'ManagedCollectorTransport';
+                mode?: string | null;
+                hostname?: string | null;
+                certificateRef?: string | null;
+            };
+            ingress: {
+                __typename?: 'ManagedCollectorIngress';
+                additionalSecurityGroupIds?: Array<string> | null;
+                additionalCidrs?: Array<string> | null;
+                allowNetworkCidrFallback: boolean;
+                minFallbackPrefixLength?: number | null;
+            };
+        };
+        current: {
+            __typename?: 'ManagedCollectorCurrent';
+            configHash?: string | null;
+            configPushedAt?: string | null;
+            licenseExpiresAt?: string | null;
+            firstReadyAt?: string | null;
+            endpoint: {
+                __typename?: 'ManagedCollectorEndpoint';
+                grpc?: string | null;
+                http?: string | null;
+                source: string;
+                tlsMode?: string | null;
+                tlsTermination?: string | null;
+                ingressTier?: string | null;
+            };
+            scaling: {
+                __typename?: 'ManagedCollectorScalingState';
+                mode: string;
+                desiredCount?: number | null;
+                runningCount?: number | null;
+                minCount?: number | null;
+                maxCount?: number | null;
+            };
+            image?: {
+                __typename?: 'ManagedCollectorImage';
+                digest: string;
+                tag?: string | null;
+                arch: string;
+            } | null;
+        };
+        authority: {
+            __typename?: 'ManagedCollectorAuthority';
+            mode: string;
+            origin: string;
+            attribution: string;
+            mutable: boolean;
+            deletable: boolean;
+        };
+        issues: Array<{
+            __typename?: 'ManagedCollectorIssue';
+            code: string;
+            severity: string;
+            message: string;
+            since?: string | null;
+            transient: boolean;
+            details?: {
+                __typename: 'ManagedCollectorConfigIssueDetails';
+                rejectedConfigHash?: string | null;
+                lastGoodConfigHash?: string | null;
+                validationError?: string | null;
+                code: string;
+            } | {
+                __typename: 'ManagedCollectorConfigurationIssueDetails';
+                region: string;
+                settingKey: string;
+                refusedValue?: string | null;
+                candidates?: Array<string> | null;
+                code: string;
+            } | null;
+        }>;
+        details?: {
+            __typename: 'AwsManagedCollectorDetails';
+            workloadRef?: string | null;
+            revisionRef?: string | null;
+            clusterRef?: string | null;
+            loadBalancerRef?: string | null;
+            targetGroupRefs?: Array<string> | null;
+            securityGroupId?: string | null;
+            subnetIds?: Array<string> | null;
+            provider: string;
+        } | null;
+    }>;
+};
+export type GetManagedCollectorReportQueryVariables = Exact<{
+    region: Scalars['String']['input'];
+}>;
+export type GetManagedCollectorReportQuery = {
+    __typename?: 'Query';
+    managedCollectorReport?: {
+        __typename?: 'ManagedCollectorReport';
+        region: string;
+        hostNetworkId: string;
+        kind: string;
+        status: string;
+        message: string;
+        liveness: string;
+        instanceUid?: string | null;
+        updatedAt: string;
+        desired: {
+            __typename?: 'ManagedCollectorDesired';
+            enabled: boolean;
+            hostNetworkId?: string | null;
+            subnetIds?: Array<string> | null;
+            securityGroupIds?: Array<string> | null;
+            clusterRef?: string | null;
+            assignPublicIp: boolean;
+            cpu: string;
+            memory: string;
+            logRetentionDays: number;
+            arch: string;
+            imageRepositoryOverride?: string | null;
+            endpointOverride?: string | null;
+            scaling: {
+                __typename?: 'ManagedCollectorScalingTarget';
+                mode: string;
+                desiredCount?: number | null;
+                minCount?: number | null;
+                maxCount?: number | null;
+                targetCpuPercent?: number | null;
+                targetMemoryPercent?: number | null;
+            };
+            transport: {
+                __typename?: 'ManagedCollectorTransport';
+                mode?: string | null;
+                hostname?: string | null;
+                certificateRef?: string | null;
+            };
+            ingress: {
+                __typename?: 'ManagedCollectorIngress';
+                additionalSecurityGroupIds?: Array<string> | null;
+                additionalCidrs?: Array<string> | null;
+                allowNetworkCidrFallback: boolean;
+                minFallbackPrefixLength?: number | null;
+            };
+        };
+        current: {
+            __typename?: 'ManagedCollectorCurrent';
+            configHash?: string | null;
+            configPushedAt?: string | null;
+            licenseExpiresAt?: string | null;
+            firstReadyAt?: string | null;
+            endpoint: {
+                __typename?: 'ManagedCollectorEndpoint';
+                grpc?: string | null;
+                http?: string | null;
+                source: string;
+                tlsMode?: string | null;
+                tlsTermination?: string | null;
+                ingressTier?: string | null;
+            };
+            scaling: {
+                __typename?: 'ManagedCollectorScalingState';
+                mode: string;
+                desiredCount?: number | null;
+                runningCount?: number | null;
+                minCount?: number | null;
+                maxCount?: number | null;
+            };
+            image?: {
+                __typename?: 'ManagedCollectorImage';
+                digest: string;
+                tag?: string | null;
+                arch: string;
+            } | null;
+        };
+        authority: {
+            __typename?: 'ManagedCollectorAuthority';
+            mode: string;
+            origin: string;
+            attribution: string;
+            mutable: boolean;
+            deletable: boolean;
+        };
+        issues: Array<{
+            __typename?: 'ManagedCollectorIssue';
+            code: string;
+            severity: string;
+            message: string;
+            since?: string | null;
+            transient: boolean;
+            details?: {
+                __typename: 'ManagedCollectorConfigIssueDetails';
+                rejectedConfigHash?: string | null;
+                lastGoodConfigHash?: string | null;
+                validationError?: string | null;
+                code: string;
+            } | {
+                __typename: 'ManagedCollectorConfigurationIssueDetails';
+                region: string;
+                settingKey: string;
+                refusedValue?: string | null;
+                candidates?: Array<string> | null;
+                code: string;
+            } | null;
+        }>;
+        details?: {
+            __typename: 'AwsManagedCollectorDetails';
+            workloadRef?: string | null;
+            revisionRef?: string | null;
+            clusterRef?: string | null;
+            loadBalancerRef?: string | null;
+            targetGroupRefs?: Array<string> | null;
+            securityGroupId?: string | null;
+            subnetIds?: Array<string> | null;
+            provider: string;
+        } | null;
+    } | null;
+};
+export type GetManagedCollectorInstructionsQueryVariables = Exact<{
+    region: Scalars['String']['input'];
+}>;
+export type GetManagedCollectorInstructionsQuery = {
+    __typename?: 'Query';
+    managedCollectorInstructions?: {
+        __typename?: 'ManagedCollectorInstructions';
+        region: string;
+        hostNetworkId: string;
+        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 GetManagedCollectorMetricsQueryVariables = Exact<{
+    region: Scalars['String']['input'];
+    refresh?: InputMaybe<Scalars['Boolean']['input']>;
+}>;
+export type GetManagedCollectorMetricsQuery = {
+    __typename?: 'Query';
+    managedCollectorMetrics?: {
+        __typename?: 'ManagedCollectorMetrics';
+        region: string;
+        observedAt: string;
+        live: boolean;
+        acceptedSpans?: number | null;
+        acceptedMetricPoints?: number | null;
+        acceptedLogRecords?: number | null;
+        refusedSpans?: number | null;
+        refusedMetricPoints?: number | null;
+        refusedLogRecords?: number | null;
+        sentSpans?: number | null;
+        sentMetricPoints?: number | null;
+        sentLogRecords?: number | null;
+        failedSpans?: number | null;
+        failedMetricPoints?: number | null;
+        failedLogRecords?: number | null;
+        queueSize?: number | null;
+        queueCapacity?: number | null;
+        cpuPercent?: number | null;
+        memoryBytes?: number | null;
+        uptimeSeconds?: number | null;
+    } | null;
+};
+export type CreateManagedCollectorMutationVariables = Exact<{
+    input: CreateManagedCollectorInput;
+}>;
+export type CreateManagedCollectorMutation = {
+    __typename?: 'Mutation';
+    createManagedCollector: {
+        __typename?: 'ManagedCollectorReport';
+        region: string;
+        hostNetworkId: string;
+        kind: string;
+        status: string;
+        message: string;
+        liveness: string;
+        instanceUid?: string | null;
+        updatedAt: string;
+        desired: {
+            __typename?: 'ManagedCollectorDesired';
+            enabled: boolean;
+            hostNetworkId?: string | null;
+            subnetIds?: Array<string> | null;
+            securityGroupIds?: Array<string> | null;
+            clusterRef?: string | null;
+            assignPublicIp: boolean;
+            cpu: string;
+            memory: string;
+            logRetentionDays: number;
+            arch: string;
+            imageRepositoryOverride?: string | null;
+            endpointOverride?: string | null;
+            scaling: {
+                __typename?: 'ManagedCollectorScalingTarget';
+                mode: string;
+                desiredCount?: number | null;
+                minCount?: number | null;
+                maxCount?: number | null;
+                targetCpuPercent?: number | null;
+                targetMemoryPercent?: number | null;
+            };
+            transport: {
+                __typename?: 'ManagedCollectorTransport';
+                mode?: string | null;
+                hostname?: string | null;
+                certificateRef?: string | null;
+            };
+            ingress: {
+                __typename?: 'ManagedCollectorIngress';
+                additionalSecurityGroupIds?: Array<string> | null;
+                additionalCidrs?: Array<string> | null;
+                allowNetworkCidrFallback: boolean;
+                minFallbackPrefixLength?: number | null;
+            };
+        };
+        current: {
+            __typename?: 'ManagedCollectorCurrent';
+            configHash?: string | null;
+            configPushedAt?: string | null;
+            licenseExpiresAt?: string | null;
+            firstReadyAt?: string | null;
+            endpoint: {
+                __typename?: 'ManagedCollectorEndpoint';
+                grpc?: string | null;
+                http?: string | null;
+                source: string;
+                tlsMode?: string | null;
+                tlsTermination?: string | null;
+                ingressTier?: string | null;
+            };
+            scaling: {
+                __typename?: 'ManagedCollectorScalingState';
+                mode: string;
+                desiredCount?: number | null;
+                runningCount?: number | null;
+                minCount?: number | null;
+                maxCount?: number | null;
+            };
+            image?: {
+                __typename?: 'ManagedCollectorImage';
+                digest: string;
+                tag?: string | null;
+                arch: string;
+            } | null;
+        };
+        authority: {
+            __typename?: 'ManagedCollectorAuthority';
+            mode: string;
+            origin: string;
+            attribution: string;
+            mutable: boolean;
+            deletable: boolean;
+        };
+        issues: Array<{
+            __typename?: 'ManagedCollectorIssue';
+            code: string;
+            severity: string;
+            message: string;
+            since?: string | null;
+            transient: boolean;
+            details?: {
+                __typename: 'ManagedCollectorConfigIssueDetails';
+                rejectedConfigHash?: string | null;
+                lastGoodConfigHash?: string | null;
+                validationError?: string | null;
+                code: string;
+            } | {
+                __typename: 'ManagedCollectorConfigurationIssueDetails';
+                region: string;
+                settingKey: string;
+                refusedValue?: string | null;
+                candidates?: Array<string> | null;
+                code: string;
+            } | null;
+        }>;
+        details?: {
+            __typename: 'AwsManagedCollectorDetails';
+            workloadRef?: string | null;
+            revisionRef?: string | null;
+            clusterRef?: string | null;
+            loadBalancerRef?: string | null;
+            targetGroupRefs?: Array<string> | null;
+            securityGroupId?: string | null;
+            subnetIds?: Array<string> | null;
+            provider: string;
+        } | null;
+    };
+};
+export type UpdateManagedCollectorMutationVariables = Exact<{
+    input: UpdateManagedCollectorInput;
+}>;
+export type UpdateManagedCollectorMutation = {
+    __typename?: 'Mutation';
+    updateManagedCollector: {
+        __typename?: 'ManagedCollectorReport';
+        region: string;
+        hostNetworkId: string;
+        kind: string;
+        status: string;
+        message: string;
+        liveness: string;
+        instanceUid?: string | null;
+        updatedAt: string;
+        desired: {
+            __typename?: 'ManagedCollectorDesired';
+            enabled: boolean;
+            hostNetworkId?: string | null;
+            subnetIds?: Array<string> | null;
+            securityGroupIds?: Array<string> | null;
+            clusterRef?: string | null;
+            assignPublicIp: boolean;
+            cpu: string;
+            memory: string;
+            logRetentionDays: number;
+            arch: string;
+            imageRepositoryOverride?: string | null;
+            endpointOverride?: string | null;
+            scaling: {
+                __typename?: 'ManagedCollectorScalingTarget';
+                mode: string;
+                desiredCount?: number | null;
+                minCount?: number | null;
+                maxCount?: number | null;
+                targetCpuPercent?: number | null;
+                targetMemoryPercent?: number | null;
+            };
+            transport: {
+                __typename?: 'ManagedCollectorTransport';
+                mode?: string | null;
+                hostname?: string | null;
+                certificateRef?: string | null;
+            };
+            ingress: {
+                __typename?: 'ManagedCollectorIngress';
+                additionalSecurityGroupIds?: Array<string> | null;
+                additionalCidrs?: Array<string> | null;
+                allowNetworkCidrFallback: boolean;
+                minFallbackPrefixLength?: number | null;
+            };
+        };
+        current: {
+            __typename?: 'ManagedCollectorCurrent';
+            configHash?: string | null;
+            configPushedAt?: string | null;
+            licenseExpiresAt?: string | null;
+            firstReadyAt?: string | null;
+            endpoint: {
+                __typename?: 'ManagedCollectorEndpoint';
+                grpc?: string | null;
+                http?: string | null;
+                source: string;
+                tlsMode?: string | null;
+                tlsTermination?: string | null;
+                ingressTier?: string | null;
+            };
+            scaling: {
+                __typename?: 'ManagedCollectorScalingState';
+                mode: string;
+                desiredCount?: number | null;
+                runningCount?: number | null;
+                minCount?: number | null;
+                maxCount?: number | null;
+            };
+            image?: {
+                __typename?: 'ManagedCollectorImage';
+                digest: string;
+                tag?: string | null;
+                arch: string;
+            } | null;
+        };
+        authority: {
+            __typename?: 'ManagedCollectorAuthority';
+            mode: string;
+            origin: string;
+            attribution: string;
+            mutable: boolean;
+            deletable: boolean;
+        };
+        issues: Array<{
+            __typename?: 'ManagedCollectorIssue';
+            code: string;
+            severity: string;
+            message: string;
+            since?: string | null;
+            transient: boolean;
+            details?: {
+                __typename: 'ManagedCollectorConfigIssueDetails';
+                rejectedConfigHash?: string | null;
+                lastGoodConfigHash?: string | null;
+                validationError?: string | null;
+                code: string;
+            } | {
+                __typename: 'ManagedCollectorConfigurationIssueDetails';
+                region: string;
+                settingKey: string;
+                refusedValue?: string | null;
+                candidates?: Array<string> | null;
+                code: string;
+            } | null;
+        }>;
+        details?: {
+            __typename: 'AwsManagedCollectorDetails';
+            workloadRef?: string | null;
+            revisionRef?: string | null;
+            clusterRef?: string | null;
+            loadBalancerRef?: string | null;
+            targetGroupRefs?: Array<string> | null;
+            securityGroupId?: string | null;
+            subnetIds?: Array<string> | null;
+            provider: string;
+        } | null;
+    };
+};
+export type TeardownManagedCollectorMutationVariables = Exact<{
+    input: TeardownManagedCollectorInput;
+}>;
+export type TeardownManagedCollectorMutation = {
+    __typename?: 'Mutation';
+    teardownManagedCollector: {
+        __typename?: 'TeardownManagedCollectorPayload';
+        region: string;
+        deleted: boolean;
+        message?: string | null;
+        retained: Array<string>;
+    };
+};
+export type ManagedCollectorReportFieldsFragment = {
+    __typename?: 'ManagedCollectorReport';
+    region: string;
+    hostNetworkId: string;
+    kind: string;
+    status: string;
+    message: string;
+    liveness: string;
+    instanceUid?: string | null;
+    updatedAt: string;
+    desired: {
+        __typename?: 'ManagedCollectorDesired';
+        enabled: boolean;
+        hostNetworkId?: string | null;
+        subnetIds?: Array<string> | null;
+        securityGroupIds?: Array<string> | null;
+        clusterRef?: string | null;
+        assignPublicIp: boolean;
+        cpu: string;
+        memory: string;
+        logRetentionDays: number;
+        arch: string;
+        imageRepositoryOverride?: string | null;
+        endpointOverride?: string | null;
+        scaling: {
+            __typename?: 'ManagedCollectorScalingTarget';
+            mode: string;
+            desiredCount?: number | null;
+            minCount?: number | null;
+            maxCount?: number | null;
+            targetCpuPercent?: number | null;
+            targetMemoryPercent?: number | null;
+        };
+        transport: {
+            __typename?: 'ManagedCollectorTransport';
+            mode?: string | null;
+            hostname?: string | null;
+            certificateRef?: string | null;
+        };
+        ingress: {
+            __typename?: 'ManagedCollectorIngress';
+            additionalSecurityGroupIds?: Array<string> | null;
+            additionalCidrs?: Array<string> | null;
+            allowNetworkCidrFallback: boolean;
+            minFallbackPrefixLength?: number | null;
+        };
+    };
+    current: {
+        __typename?: 'ManagedCollectorCurrent';
+        configHash?: string | null;
+        configPushedAt?: string | null;
+        licenseExpiresAt?: string | null;
+        firstReadyAt?: string | null;
+        endpoint: {
+            __typename?: 'ManagedCollectorEndpoint';
+            grpc?: string | null;
+            http?: string | null;
+            source: string;
+            tlsMode?: string | null;
+            tlsTermination?: string | null;
+            ingressTier?: string | null;
+        };
+        scaling: {
+            __typename?: 'ManagedCollectorScalingState';
+            mode: string;
+            desiredCount?: number | null;
+            runningCount?: number | null;
+            minCount?: number | null;
+            maxCount?: number | null;
+        };
+        image?: {
+            __typename?: 'ManagedCollectorImage';
+            digest: string;
+            tag?: string | null;
+            arch: string;
+        } | null;
+    };
+    authority: {
+        __typename?: 'ManagedCollectorAuthority';
+        mode: string;
+        origin: string;
+        attribution: string;
+        mutable: boolean;
+        deletable: boolean;
+    };
+    issues: Array<{
+        __typename?: 'ManagedCollectorIssue';
+        code: string;
+        severity: string;
+        message: string;
+        since?: string | null;
+        transient: boolean;
+        details?: {
+            __typename: 'ManagedCollectorConfigIssueDetails';
+            rejectedConfigHash?: string | null;
+            lastGoodConfigHash?: string | null;
+            validationError?: string | null;
+            code: string;
+        } | {
+            __typename: 'ManagedCollectorConfigurationIssueDetails';
+            region: string;
+            settingKey: string;
+            refusedValue?: string | null;
+            candidates?: Array<string> | null;
+            code: string;
+        } | null;
+    }>;
+    details?: {
+        __typename: 'AwsManagedCollectorDetails';
+        workloadRef?: string | null;
+        revisionRef?: string | null;
+        clusterRef?: string | null;
+        loadBalancerRef?: string | null;
+        targetGroupRefs?: Array<string> | null;
+        securityGroupId?: string | null;
+        subnetIds?: Array<string> | null;
+        provider: string;
+    } | null;
+};
+type ManagedCollectorIssueDetailsFields_ManagedCollectorConfigIssueDetails_Fragment = {
+    __typename: 'ManagedCollectorConfigIssueDetails';
+    rejectedConfigHash?: string | null;
+    lastGoodConfigHash?: string | null;
+    validationError?: string | null;
+    code: string;
+};
+type ManagedCollectorIssueDetailsFields_ManagedCollectorConfigurationIssueDetails_Fragment = {
+    __typename: 'ManagedCollectorConfigurationIssueDetails';
+    region: string;
+    settingKey: string;
+    refusedValue?: string | null;
+    candidates?: Array<string> | null;
+    code: string;
+};
+export type ManagedCollectorIssueDetailsFieldsFragment = ManagedCollectorIssueDetailsFields_ManagedCollectorConfigIssueDetails_Fragment | ManagedCollectorIssueDetailsFields_ManagedCollectorConfigurationIssueDetails_Fragment;
+export type ManagedCollectorDetailsFieldsFragment = {
+    __typename: 'AwsManagedCollectorDetails';
+    workloadRef?: string | null;
+    revisionRef?: string | null;
+    clusterRef?: string | null;
+    loadBalancerRef?: string | null;
+    targetGroupRefs?: Array<string> | null;
+    securityGroupId?: string | null;
+    subnetIds?: Array<string> | null;
+    provider: string;
+};
+export type ManagedCollectorMetricsFieldsFragment = {
+    __typename?: 'ManagedCollectorMetrics';
+    region: string;
+    observedAt: string;
+    live: boolean;
+    acceptedSpans?: number | null;
+    acceptedMetricPoints?: number | null;
+    acceptedLogRecords?: number | null;
+    refusedSpans?: number | null;
+    refusedMetricPoints?: number | null;
+    refusedLogRecords?: number | null;
+    sentSpans?: number | null;
+    sentMetricPoints?: number | null;
+    sentLogRecords?: number | null;
+    failedSpans?: number | null;
+    failedMetricPoints?: number | null;
+    failedLogRecords?: number | null;
+    queueSize?: number | null;
+    queueCapacity?: number | null;
+    cpuPercent?: number | null;
+    memoryBytes?: number | null;
+    uptimeSeconds?: number | null;
+};
+export type GetManagedCollectorDestinationTypesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetManagedCollectorDestinationTypesQuery = {
+    __typename?: 'Query';
+    getManagedCollectorDestinationTypes: 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 ListManagedCollectorDestinationsQueryVariables = Exact<{
+    region: Scalars['String']['input'];
+}>;
+export type ListManagedCollectorDestinationsQuery = {
+    __typename?: 'Query';
+    listManagedCollectorDestinations: Array<{
+        __typename?: 'Destination';
+        name: string;
+        type: string;
+        region?: string | null;
+        config?: Record<string, any> | null;
+        signals: Array<TelemetrySignal>;
+        disabled: boolean;
+    }>;
+};
+export type GetManagedCollectorDestinationQueryVariables = Exact<{
+    region: Scalars['String']['input'];
+    name: Scalars['String']['input'];
+}>;
+export type GetManagedCollectorDestinationQuery = {
+    __typename?: 'Query';
+    getManagedCollectorDestination?: {
+        __typename?: 'Destination';
+        name: string;
+        type: string;
+        region?: string | null;
+        config?: Record<string, any> | null;
+        signals: Array<TelemetrySignal>;
+        disabled: boolean;
+    } | null;
+};
+export type CreateManagedCollectorDestinationMutationVariables = Exact<{
+    input: CreateManagedCollectorDestinationInput;
+}>;
+export type CreateManagedCollectorDestinationMutation = {
+    __typename?: 'Mutation';
+    createManagedCollectorDestination: {
+        __typename?: 'Destination';
+        name: string;
+        type: string;
+        region?: string | null;
+        config?: Record<string, any> | null;
+        signals: Array<TelemetrySignal>;
+        disabled: boolean;
+    };
+};
+export type UpdateManagedCollectorDestinationMutationVariables = Exact<{
+    input: UpdateManagedCollectorDestinationInput;
+}>;
+export type UpdateManagedCollectorDestinationMutation = {
+    __typename?: 'Mutation';
+    updateManagedCollectorDestination: {
+        __typename?: 'Destination';
+        name: string;
+        type: string;
+        region?: string | null;
+        config?: Record<string, any> | null;
+        signals: Array<TelemetrySignal>;
+        disabled: boolean;
+    };
+};
+export type DestroyManagedCollectorDestinationMutationVariables = Exact<{
+    input: DestroyManagedCollectorDestinationInput;
+}>;
+export type DestroyManagedCollectorDestinationMutation = {
+    __typename?: 'Mutation';
+    destroyManagedCollectorDestination: {
+        __typename?: 'DestroyManagedCollectorDestinationPayload';
+        region: string;
+        name: string;
+        deleted: boolean;
+    };
+};
 export type PipelineCountersQueryVariables = Exact<{
     [key: string]: never;
 }>;
@@ -4143,6 +5666,10 @@ export declare const InstructionDocumentFieldsFragmentDoc: DocumentNode<Instruct
 export declare const InstrumentationInstructionsFieldsFragmentDoc: DocumentNode<InstrumentationInstructionsFieldsFragment, unknown>;
 export declare const InstrumentationRuleTypeFieldsFragmentDoc: DocumentNode<InstrumentationRuleTypeFieldsFragment, unknown>;
 export declare const InstrumentationRuleFieldsFragmentDoc: DocumentNode<InstrumentationRuleFieldsFragment, unknown>;
+export declare const ManagedCollectorIssueDetailsFieldsFragmentDoc: DocumentNode<ManagedCollectorIssueDetailsFieldsFragment, unknown>;
+export declare const ManagedCollectorDetailsFieldsFragmentDoc: DocumentNode<ManagedCollectorDetailsFieldsFragment, unknown>;
+export declare const ManagedCollectorReportFieldsFragmentDoc: DocumentNode<ManagedCollectorReportFieldsFragment, unknown>;
+export declare const ManagedCollectorMetricsFieldsFragmentDoc: DocumentNode<ManagedCollectorMetricsFieldsFragment, unknown>;
 export declare const ContainerOverrideFieldsFragmentDoc: DocumentNode<ContainerOverrideFieldsFragment, unknown>;
 export declare const ProcessDetailsFieldsFragmentDoc: DocumentNode<ProcessDetailsFieldsFragment, unknown>;
 export declare const WorkloadContainerFieldsFragmentDoc: DocumentNode<WorkloadContainerFieldsFragment, unknown>;
@@ -4181,6 +5708,19 @@ export declare const CreateInstrumentationRuleDocument: DocumentNode<CreateInstr
 export declare const UpdateInstrumentationRuleDocument: DocumentNode<UpdateInstrumentationRuleMutation, UpdateInstrumentationRuleMutationVariables>;
 export declare const DeleteInstrumentationRuleDocument: DocumentNode<DeleteInstrumentationRuleMutation, DeleteInstrumentationRuleMutationVariables>;
 export declare const UpdateOnPremLicenseDocument: DocumentNode<UpdateOnPremLicenseMutation, UpdateOnPremLicenseMutationVariables>;
+export declare const GetManagedCollectorReportsDocument: DocumentNode<GetManagedCollectorReportsQuery, GetManagedCollectorReportsQueryVariables>;
+export declare const GetManagedCollectorReportDocument: DocumentNode<GetManagedCollectorReportQuery, GetManagedCollectorReportQueryVariables>;
+export declare const GetManagedCollectorInstructionsDocument: DocumentNode<GetManagedCollectorInstructionsQuery, GetManagedCollectorInstructionsQueryVariables>;
+export declare const GetManagedCollectorMetricsDocument: DocumentNode<GetManagedCollectorMetricsQuery, GetManagedCollectorMetricsQueryVariables>;
+export declare const CreateManagedCollectorDocument: DocumentNode<CreateManagedCollectorMutation, CreateManagedCollectorMutationVariables>;
+export declare const UpdateManagedCollectorDocument: DocumentNode<UpdateManagedCollectorMutation, UpdateManagedCollectorMutationVariables>;
+export declare const TeardownManagedCollectorDocument: DocumentNode<TeardownManagedCollectorMutation, TeardownManagedCollectorMutationVariables>;
+export declare const GetManagedCollectorDestinationTypesDocument: DocumentNode<GetManagedCollectorDestinationTypesQuery, GetManagedCollectorDestinationTypesQueryVariables>;
+export declare const ListManagedCollectorDestinationsDocument: DocumentNode<ListManagedCollectorDestinationsQuery, ListManagedCollectorDestinationsQueryVariables>;
+export declare const GetManagedCollectorDestinationDocument: DocumentNode<GetManagedCollectorDestinationQuery, GetManagedCollectorDestinationQueryVariables>;
+export declare const CreateManagedCollectorDestinationDocument: DocumentNode<CreateManagedCollectorDestinationMutation, CreateManagedCollectorDestinationMutationVariables>;
+export declare const UpdateManagedCollectorDestinationDocument: DocumentNode<UpdateManagedCollectorDestinationMutation, UpdateManagedCollectorDestinationMutationVariables>;
+export declare const DestroyManagedCollectorDestinationDocument: DocumentNode<DestroyManagedCollectorDestinationMutation, DestroyManagedCollectorDestinationMutationVariables>;
 export declare const PipelineCountersDocument: DocumentNode<PipelineCountersQuery, PipelineCountersQueryVariables>;
 export declare const ProfileHotFunctionsDocument: DocumentNode<ProfileHotFunctionsQuery, ProfileHotFunctionsQueryVariables>;
 export declare const ProfileBundleStatusDocument: DocumentNode<ProfileBundleStatusQuery, ProfileBundleStatusQueryVariables>;