/**
 * log10x_env_register — persist a full EnvironmentConfig document to an
 * on-prem env-config store (k8s ConfigMap, AWS SSM, GCP Secret Manager,
 * Azure App Configuration, or local file).
 *
 * Companion to `log10x_create_env`. Where create_env mints a new env on
 * the Log10x account (account-level identity + apiKey), env_register
 * writes the **cluster-side** descriptor that other tools resolve: where
 * the streamer is, where the retriever is, which SIEM the logs land in,
 * which offload destinations the Receiver may write to. The two tools
 * are independent — register can run against an env_id that originated
 * outside the Log10x account API, e.g. an on-prem-only customer who
 * never calls the SaaS backend.
 *
 * Behaviour:
 *
 *   1. Build the EnvironmentConfig from args (caller may pass
 *      `offload_destinations`; absent → defaults to a single
 *      `nickname: "primary"` placeholder so the document satisfies the
 *      `min(1)` schema rule).
 *   2. Validate against `environmentConfigSchema` (zod). Validation
 *      failures return BEFORE any store side effect — partial writes
 *      are not allowed.
 *   3. Pick a store:
 *        - if `target_store` is supplied, instantiate exactly that
 *          backend and refuse if it's unavailable (no silent fallback —
 *          if the caller asked for SSM, write to SSM or fail).
 *        - otherwise probe the chain (k8s → aws_ssm → gcp_sm → azure_ac
 *          → local) and use the first that reports `isAvailable: true`.
 *          Local file is the dev fallback so the chain always terminates
 *          on a writeable store.
 *   4. Call `store.write(config)`. Stamp `updated_at` to now if the
 *      caller didn't supply one.
 *   5. Return the canonical persisted document + which store_kind we
 *      wrote to + the availability probe trace so the agent can show
 *      "wrote to k8s ConfigMap in namespace log10x".
 *
 * Idempotent: re-running with the same `env_id` overwrites in place
 * (k8s server-side-apply, SSM PutParameter, local file rewrite). The
 * tool DOES NOT diff against an existing document — callers who want
 * partial updates should read + merge + register again.
 */
import { z } from 'zod';
import { clusterIdentitySchema, siemDestinationSchema, streamerConfigSchema, retrieverConfigSchema, type OffloadDestination } from '../lib/env-config/types.js';
import type { StoreKind } from '../lib/env-config/store-interface.js';
import { type StructuredOutput } from '../lib/output-types.js';
export declare const envRegisterSchema: {
    env_id: z.ZodString;
    nickname: z.ZodString;
    cluster: z.ZodObject<{
        type: z.ZodEnum<{
            kind: "kind";
            eks: "eks";
            gke: "gke";
            aks: "aks";
            minikube: "minikube";
            bare_metal: "bare_metal";
            other: "other";
        }>;
        region: z.ZodOptional<z.ZodString>;
        account: z.ZodOptional<z.ZodString>;
        project_id: z.ZodOptional<z.ZodString>;
        subscription: z.ZodOptional<z.ZodString>;
        context_name: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>;
    destination: z.ZodObject<{
        siem_vendor: z.ZodEnum<{
            datadog: "datadog";
            other: "other";
            splunk: "splunk";
            elasticsearch: "elasticsearch";
            clickhouse: "clickhouse";
            cloudwatch: "cloudwatch";
            "azure-monitor": "azure-monitor";
            "gcp-logging": "gcp-logging";
            sumo: "sumo";
            coralogix: "coralogix";
            "elastic-serverless": "elastic-serverless";
        }>;
        region: z.ZodOptional<z.ZodString>;
        log_group_prefix: z.ZodOptional<z.ZodString>;
        ingest_url: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>;
    streamer: z.ZodObject<{
        url: z.ZodString;
        target_path: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>;
    retriever: z.ZodObject<{
        url: z.ZodString;
        input_bucket: z.ZodString;
        input_prefix: z.ZodOptional<z.ZodString>;
        query_queues: z.ZodObject<{
            index: z.ZodString;
            subquery: z.ZodString;
            stream: z.ZodString;
            query: z.ZodString;
        }, z.core.$strip>;
        query_log_group: z.ZodOptional<z.ZodString>;
        helm_release: z.ZodOptional<z.ZodObject<{
            name: z.ZodString;
            namespace: z.ZodString;
            chart_version: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
    }, z.core.$strip>;
    offload_destinations: z.ZodOptional<z.ZodArray<z.ZodObject<{
        nickname: z.ZodString;
        type: z.ZodEnum<{
            s3: "s3";
            gcs: "gcs";
            azure_blob: "azure_blob";
            file: "file";
        }>;
        status: z.ZodDefault<z.ZodEnum<{
            failed: "failed";
            active: "active";
            draining: "draining";
            archived: "archived";
        }>>;
        bucket: z.ZodOptional<z.ZodString>;
        prefix: z.ZodOptional<z.ZodString>;
        region: z.ZodOptional<z.ZodString>;
        project_id: z.ZodOptional<z.ZodString>;
        storage_account: z.ZodOptional<z.ZodString>;
        path: z.ZodOptional<z.ZodString>;
        auth: z.ZodOptional<z.ZodObject<{
            method: z.ZodEnum<{
                none: "none";
                irsa: "irsa";
                iam_role: "iam_role";
                workload_identity: "workload_identity";
                service_principal: "service_principal";
                access_key: "access_key";
                connection_string: "connection_string";
            }>;
            role: z.ZodOptional<z.ZodString>;
            sa: z.ZodOptional<z.ZodString>;
            note: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
        archived_at: z.ZodOptional<z.ZodString>;
        first_used_at: z.ZodOptional<z.ZodString>;
        note: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    target_store: z.ZodOptional<z.ZodEnum<{
        k8s: "k8s";
        aws_ssm: "aws_ssm";
        gcp_sm: "gcp_sm";
        azure_ac: "azure_ac";
        local: "local";
    }>>;
};
export type EnvRegisterArgs = {
    env_id: string;
    nickname: string;
    cluster: z.infer<typeof clusterIdentitySchema>;
    destination: z.infer<typeof siemDestinationSchema>;
    streamer: z.infer<typeof streamerConfigSchema>;
    retriever: z.infer<typeof retrieverConfigSchema>;
    offload_destinations?: OffloadDestination[];
    target_store?: StoreKind;
};
export declare function executeEnvRegister(args: EnvRegisterArgs): Promise<string | StructuredOutput>;