export interface Parameter {
    Name?: string;
    Type?: 'String' | 'StringList' | 'SecureString';
    Value?: string;
    Version?: number;
    LastModifiedDate?: string;
    ARN?: string;
    DataType?: string;
    Description?: string;
    AllowedPattern?: string;
    KeyId?: string;
    Tier?: 'Standard' | 'Advanced' | 'Intelligent-Tiering';
}
export interface ParameterHistory {
    Name?: string;
    Type?: 'String' | 'StringList' | 'SecureString';
    KeyId?: string;
    LastModifiedDate?: string;
    LastModifiedUser?: string;
    Description?: string;
    Value?: string;
    Version?: number;
    Labels?: string[];
    Tier?: string;
}
export interface PutParameterOptions {
    Name: string;
    Value: string;
    Type?: 'String' | 'StringList' | 'SecureString';
    Description?: string;
    KeyId?: string;
    Overwrite?: boolean;
    AllowedPattern?: string;
    Tags?: {
        Key: string;
        Value: string;
    }[];
    Tier?: 'Standard' | 'Advanced' | 'Intelligent-Tiering';
    DataType?: string;
}
export interface GetParameterOptions {
    Name: string;
    WithDecryption?: boolean;
}
export interface GetParametersOptions {
    Names: string[];
    WithDecryption?: boolean;
}
export interface GetParametersByPathOptions {
    Path: string;
    Recursive?: boolean;
    WithDecryption?: boolean;
    MaxResults?: number;
    NextToken?: string;
    ParameterFilters?: {
        Key: string;
        Option?: string;
        Values?: string[];
    }[];
}
export interface DeleteParameterOptions {
    Name: string;
}
/**
 * SSM Parameter Store client using direct API calls
 */
export declare class SSMClient {
    private client;
    private region;
    constructor(region?: string, profile?: string);
    /**
     * Put a parameter to Parameter Store
     */
    putParameter(options: PutParameterOptions): Promise<{
        Version?: number;
        Tier?: string;
    }>;
    /**
     * Get a parameter from Parameter Store
     */
    getParameter(options: GetParameterOptions): Promise<{
        Parameter?: Parameter;
    }>;
    /**
     * Get multiple parameters from Parameter Store
     */
    getParameters(options: GetParametersOptions): Promise<{
        Parameters?: Parameter[];
        InvalidParameters?: string[];
    }>;
    /**
     * Get parameters by path (hierarchical)
     */
    getParametersByPath(options: GetParametersByPathOptions): Promise<{
        Parameters?: Parameter[];
        NextToken?: string;
    }>;
    /**
     * Delete a parameter from Parameter Store
     */
    deleteParameter(options: DeleteParameterOptions): Promise<void>;
    /**
     * Delete multiple parameters from Parameter Store
     */
    deleteParameters(names: string[]): Promise<{
        DeletedParameters?: string[];
        InvalidParameters?: string[];
    }>;
    /**
     * Describe parameters (metadata only, no values)
     */
    describeParameters(options?: {
        Filters?: {
            Key: string;
            Values: string[];
        }[];
        ParameterFilters?: {
            Key: string;
            Option?: string;
            Values?: string[];
        }[];
        MaxResults?: number;
        NextToken?: string;
    }): Promise<{
        Parameters?: Parameter[];
        NextToken?: string;
    }>;
    /**
     * Get parameter history
     */
    getParameterHistory(options: {
        Name: string;
        WithDecryption?: boolean;
        MaxResults?: number;
        NextToken?: string;
    }): Promise<{
        Parameters?: ParameterHistory[];
        NextToken?: string;
    }>;
    /**
     * Label a parameter version
     */
    labelParameterVersion(options: {
        Name: string;
        ParameterVersion?: number;
        Labels: string[];
    }): Promise<{
        InvalidLabels?: string[];
        ParameterVersion?: number;
    }>;
    /**
     * Add tags to a parameter
     */
    addTagsToResource(options: {
        ResourceType: 'Parameter';
        ResourceId: string;
        Tags: {
            Key: string;
            Value: string;
        }[];
    }): Promise<void>;
    /**
     * Remove tags from a parameter
     */
    removeTagsFromResource(options: {
        ResourceType: 'Parameter';
        ResourceId: string;
        TagKeys: string[];
    }): Promise<void>;
    /**
     * List tags for a parameter
     */
    listTagsForResource(options: {
        ResourceType: 'Parameter';
        ResourceId: string;
    }): Promise<{
        TagList?: {
            Key: string;
            Value: string;
        }[];
    }>;
    /**
     * Helper: Set a string parameter
     */
    setString(name: string, value: string, options?: {
        description?: string;
        overwrite?: boolean;
        tags?: {
            Key: string;
            Value: string;
        }[];
    }): Promise<{
        Version?: number;
    }>;
    /**
     * Helper: Set a secure string parameter (encrypted)
     */
    setSecureString(name: string, value: string, options?: {
        description?: string;
        overwrite?: boolean;
        kmsKeyId?: string;
        tags?: {
            Key: string;
            Value: string;
        }[];
    }): Promise<{
        Version?: number;
    }>;
    /**
     * Helper: Get a parameter value (decrypted)
     */
    getValue(name: string): Promise<string | undefined>;
    /**
     * Helper: Get all parameters under a path
     */
    getAllByPath(path: string, recursive?: boolean): Promise<Parameter[]>;
    /**
     * Parse parameter response
     */
    private parseParameter;
    /**
     * Send a command to EC2 instances via SSM. Accepts either explicit
     * `InstanceIds` or tag-based `Targets` (one is required).
     */
    sendCommand(options: {
        InstanceIds?: string[];
        Targets?: Array<{
            Key: string;
            Values: string[];
        }>;
        DocumentName: string;
        Parameters?: Record<string, string[]>;
        TimeoutSeconds?: number;
        Comment?: string;
        OutputS3BucketName?: string;
        OutputS3KeyPrefix?: string;
    }): Promise<{
        CommandId?: string;
        Status?: string;
        StatusDetails?: string;
    }>;
    /**
     * Get command invocation result
     */
    getCommandInvocation(options: {
        CommandId: string;
        InstanceId: string;
    }): Promise<{
        Status?: string;
        StatusDetails?: string;
        StandardOutputContent?: string;
        StandardErrorContent?: string;
        ResponseCode?: number;
    }>;
    /**
     * Run a shell command on an EC2 instance and wait for result
     */
    runShellCommand(instanceId: string, commands: string[], options?: {
        timeoutSeconds?: number;
        waitForCompletion?: boolean;
        pollIntervalMs?: number;
        maxWaitMs?: number;
    }): Promise<{
        success: boolean;
        output?: string;
        error?: string;
        status?: string;
    }>;
    /**
     * List per-instance invocations for a previously-sent command.
     * Used by tag-based deploys to discover which instances received the
     * command and poll each one for completion.
     */
    listCommandInvocations(options: {
        CommandId: string;
        Details?: boolean;
    }): Promise<Array<{
        InstanceId: string;
        Status?: string;
        StatusDetails?: string;
        StandardOutputContent?: string;
        StandardErrorContent?: string;
    }>>;
    /**
     * Fan out a shell command to every EC2 instance matching the given tags
     * and wait for all of them to finish. The Forge-style "deploy to my app
     * servers" primitive — no instance IDs to track, just tag filters.
     */
    sendCommandByTags(options: {
        tags: Record<string, string>;
        commands: string[];
        timeoutSeconds?: number;
        pollIntervalMs?: number;
        maxWaitMs?: number;
        comment?: string;
    }): Promise<{
        success: boolean;
        instanceCount: number;
        perInstance: Array<{
            instanceId: string;
            status: string;
            output?: string;
            error?: string;
        }>;
        error?: string;
    }>;
}
