export interface LambdaFunctionConfiguration {
    FunctionName?: string;
    FunctionArn?: string;
    Runtime?: string;
    Role?: string;
    Handler?: string;
    CodeSize?: number;
    Description?: string;
    Timeout?: number;
    MemorySize?: number;
    LastModified?: string;
    CodeSha256?: string;
    Version?: string;
    State?: 'Pending' | 'Active' | 'Inactive' | 'Failed';
    StateReason?: string;
    StateReasonCode?: string;
    Environment?: {
        Variables?: Record<string, string>;
    };
    Architectures?: ('x86_64' | 'arm64')[];
}
export interface InvokeResult {
    StatusCode?: number;
    FunctionError?: string;
    LogResult?: string;
    Payload?: string;
    ExecutedVersion?: string;
}
export interface CreateFunctionParams {
    FunctionName: string;
    /** Omit for container-image functions (PackageType: 'Image'). */
    Runtime?: 'nodejs18.x' | 'nodejs20.x' | 'python3.11' | 'python3.12' | string;
    Role: string;
    /** Omit for container-image functions (the image CMD is the entrypoint). */
    Handler?: string;
    Code: {
        ZipFile?: string;
        S3Bucket?: string;
        S3Key?: string;
        S3ObjectVersion?: string;
        /** ECR image URI for container-image functions. */
        ImageUri?: string;
    };
    /** 'Zip' (default) or 'Image' for container-image deployments. */
    PackageType?: 'Zip' | 'Image';
    Description?: string;
    Timeout?: number;
    MemorySize?: number;
    Environment?: {
        Variables: Record<string, string>;
    };
    Tags?: Record<string, string>;
    Architectures?: ('x86_64' | 'arm64')[];
    EphemeralStorage?: {
        Size: number;
    };
    /**
     * Lambda layer version ARNs to attach (max 5). Required for custom runtimes
     * such as the Bun layer used with `Runtime: 'provided.al2023'`.
     */
    Layers?: string[];
}
export interface UpdateFunctionCodeParams {
    FunctionName: string;
    ZipFile?: string;
    S3Bucket?: string;
    S3Key?: string;
    S3ObjectVersion?: string;
    /** ECR image URI for container-image functions. */
    ImageUri?: string;
    Publish?: boolean;
    Architectures?: ('x86_64' | 'arm64')[];
}
export interface AddPermissionParams {
    FunctionName: string;
    StatementId: string;
    Action: string;
    Principal: string;
    SourceArn?: string;
    SourceAccount?: string;
    FunctionUrlAuthType?: 'NONE' | 'AWS_IAM';
    InvokedViaFunctionUrl?: boolean;
}
/**
 * Lambda service management using direct API calls
 */
export declare class LambdaClient {
    private client;
    private region;
    constructor(region?: string, profile?: string);
    /**
     * Create a new Lambda function
     */
    createFunction(params: CreateFunctionParams): Promise<LambdaFunctionConfiguration>;
    /**
     * Get function configuration
     */
    getFunction(functionName: string): Promise<{
        Configuration?: LambdaFunctionConfiguration;
        Code?: {
            RepositoryType?: string;
            Location?: string;
        };
        Tags?: Record<string, string>;
    }>;
    /**
     * Update function code
     */
    updateFunctionCode(params: UpdateFunctionCodeParams): Promise<LambdaFunctionConfiguration>;
    /**
     * Update function code with inline JavaScript/TypeScript code
     * Automatically creates a zip file with the code as index.js
     */
    updateFunctionCodeInline(functionName: string, code: string, filename?: string): Promise<LambdaFunctionConfiguration>;
    /**
     * Update function configuration
     */
    updateFunctionConfiguration(params: {
        FunctionName: string;
        Runtime?: string;
        Role?: string;
        Handler?: string;
        Description?: string;
        Timeout?: number;
        MemorySize?: number;
        Environment?: {
            Variables: Record<string, string>;
        };
        /** Layer version ARNs (max 5). Pass to re-point a function at a new layer version. */
        Layers?: string[];
    }): Promise<LambdaFunctionConfiguration>;
    /**
     * Delete a Lambda function
     */
    deleteFunction(functionName: string): Promise<void>;
    /**
     * Invoke a Lambda function
     */
    invoke(params: {
        FunctionName: string;
        InvocationType?: 'RequestResponse' | 'Event' | 'DryRun';
        Payload?: string | object;
        LogType?: 'None' | 'Tail';
    }): Promise<InvokeResult>;
    /**
     * List Lambda functions
     */
    listFunctions(params?: {
        MaxItems?: number;
        Marker?: string;
        FunctionVersion?: 'ALL';
    }): Promise<{
        Functions?: LambdaFunctionConfiguration[];
        NextMarker?: string;
    }>;
    /**
     * Add permission to Lambda function (resource-based policy)
     */
    addPermission(params: AddPermissionParams): Promise<{
        Statement?: string;
    }>;
    /**
     * Remove permission from Lambda function
     */
    removePermission(functionName: string, statementId: string): Promise<void>;
    /**
     * Publish a version of the function
     */
    publishVersion(params: {
        FunctionName: string;
        Description?: string;
        CodeSha256?: string;
    }): Promise<LambdaFunctionConfiguration>;
    /**
     * Create an alias for a function version
     */
    createAlias(params: {
        FunctionName: string;
        Name: string;
        FunctionVersion: string;
        Description?: string;
    }): Promise<{
        AliasArn?: string;
        Name?: string;
        FunctionVersion?: string;
        Description?: string;
    }>;
    /** Point an existing alias at a (new) function version. */
    updateAlias(params: {
        FunctionName: string;
        Name: string;
        FunctionVersion: string;
        Description?: string;
    }): Promise<{
        AliasArn?: string;
        Name?: string;
        FunctionVersion?: string;
    }>;
    /** Read an alias (e.g. the version `live` points at). Returns null if absent. */
    getAlias(functionName: string, name: string): Promise<{
        Name?: string;
        FunctionVersion?: string;
        AliasArn?: string;
    } | null>;
    /** Read a provisioned-concurrency config for a qualifier. Returns null if none. */
    getProvisionedConcurrencyConfig(functionName: string, qualifier: string): Promise<{
        Status?: string;
        RequestedProvisionedConcurrentExecutions?: number;
        AllocatedProvisionedConcurrentExecutions?: number;
    } | null>;
    /** Pre-provision N warm execution environments on a function version/alias. */
    putProvisionedConcurrencyConfig(params: {
        FunctionName: string;
        Qualifier: string;
        ProvisionedConcurrentExecutions: number;
    }): Promise<{
        Status?: string;
        RequestedProvisionedConcurrentExecutions?: number;
    }>;
    /** Remove a provisioned-concurrency config from a function version/alias. */
    deleteProvisionedConcurrencyConfig(functionName: string, qualifier: string): Promise<void>;
    /**
     * Wait for function to become active
     */
    waitForFunctionActive(functionName: string, maxWaitSeconds?: number): Promise<LambdaFunctionConfiguration>;
    /**
     * Check if function exists
     */
    functionExists(functionName: string): Promise<boolean>;
    /**
     * Create a function URL for the Lambda function
     */
    createFunctionUrl(params: {
        FunctionName: string;
        AuthType: 'NONE' | 'AWS_IAM';
        Cors?: {
            AllowOrigins?: string[];
            AllowMethods?: string[];
            AllowHeaders?: string[];
            ExposeHeaders?: string[];
            MaxAge?: number;
            AllowCredentials?: boolean;
        };
        InvokeMode?: 'BUFFERED' | 'RESPONSE_STREAM';
    }): Promise<{
        FunctionUrl?: string;
        FunctionArn?: string;
        AuthType?: string;
        CreationTime?: string;
    }>;
    /**
     * Get function URL configuration
     */
    getFunctionUrl(functionName: string): Promise<{
        FunctionUrl?: string;
        FunctionArn?: string;
        AuthType?: string;
        Cors?: {
            AllowOrigins?: string[];
            AllowMethods?: string[];
            AllowHeaders?: string[];
        };
        CreationTime?: string;
    } | null>;
    /**
     * Delete function URL configuration
     */
    deleteFunctionUrl(functionName: string): Promise<void>;
    /**
     * Create function with inline code (convenience method)
     */
    createFunctionWithCode(params: {
        FunctionName: string;
        Runtime: 'nodejs18.x' | 'nodejs20.x' | 'python3.11' | 'python3.12' | string;
        Role: string;
        Handler: string;
        Code: string;
        Filename?: string;
        Description?: string;
        Timeout?: number;
        MemorySize?: number;
        Environment?: {
            Variables: Record<string, string>;
        };
    }): Promise<LambdaFunctionConfiguration>;
    /**
     * Add permission for Function URL public access
     */
    addFunctionUrlPermission(functionName: string): Promise<{
        Statement?: string;
    }>;
    /**
     * Publish a new Lambda layer version
     */
    publishLayerVersion(params: {
        LayerName: string;
        Description?: string;
        Content: {
            S3Bucket?: string;
            S3Key?: string;
            ZipFile?: string;
        };
        CompatibleRuntimes?: string[];
        CompatibleArchitectures?: ('x86_64' | 'arm64')[];
        LicenseInfo?: string;
    }): Promise<{
        LayerArn?: string;
        LayerVersionArn?: string;
        Description?: string;
        Version?: number;
        CompatibleRuntimes?: string[];
        CompatibleArchitectures?: string[];
    }>;
    /**
     * List layer versions
     */
    listLayerVersions(layerName: string, params?: {
        CompatibleRuntime?: string;
        CompatibleArchitecture?: 'x86_64' | 'arm64';
        MaxItems?: number;
        Marker?: string;
    }): Promise<{
        LayerVersions?: Array<{
            LayerVersionArn?: string;
            Version?: number;
            Description?: string;
            CompatibleRuntimes?: string[];
            CompatibleArchitectures?: string[];
        }>;
        NextMarker?: string;
    }>;
    /**
     * Get layer version details
     */
    getLayerVersion(layerName: string, versionNumber: number): Promise<{
        LayerArn?: string;
        LayerVersionArn?: string;
        Description?: string;
        Version?: number;
        CompatibleRuntimes?: string[];
        CompatibleArchitectures?: string[];
        Content?: {
            Location?: string;
            CodeSha256?: string;
            CodeSize?: number;
        };
    }>;
    /**
     * Add permission to a layer version (e.g., make it public)
     */
    addLayerVersionPermission(params: {
        LayerName: string;
        VersionNumber: number;
        StatementId: string;
        Action: string;
        Principal: string;
        OrganizationId?: string;
    }): Promise<{
        Statement?: string;
        RevisionId?: string;
    }>;
    /**
     * Delete a layer version
     */
    deleteLayerVersion(layerName: string, versionNumber: number): Promise<void>;
}
