/**
 * Default Integration Strategy Implementations
 *
 * This module provides the default strategy implementations:
 * - FullAccessStrategy: Full read/write permissions
 * - ReadOnlyStrategy: Read-only permissions
 * - WriteOnlyStrategy: Write-only permissions
 * - CompositeStrategy: Combination of multiple strategies
 *
 * @module declarative-api/strategy/default-strategies
 */
import type { IIntegrationStrategy, IntegrationStrategyType, GrantOptions, InjectOptions, GrantResult, InjectResult, IResourceEntity } from '../../../lib/runtime-web/types/declarative-api';
import { BaseIntegrationStrategy } from './integration-strategy';
/**
 * Full Access Strategy.
 *
 * Grants full read/write permissions to resources.
 * This is the default strategy when none is specified.
 *
 * Validates: Requirements 4.2, 4.4
 */
export declare class FullAccessStrategy extends BaseIntegrationStrategy {
    readonly strategyType: IntegrationStrategyType;
    protected getPermissionLevel(): 'read' | 'write' | 'full';
}
/**
 * Read-Only Strategy.
 *
 * Grants only read permissions to resources.
 * Use when Lambda only needs to query/read data.
 *
 * Validates: Requirements 4.2
 */
export declare class ReadOnlyStrategy extends BaseIntegrationStrategy {
    readonly strategyType: IntegrationStrategyType;
    protected getPermissionLevel(): 'read' | 'write' | 'full';
}
/**
 * Write-Only Strategy.
 *
 * Grants only write permissions to resources.
 * Use when Lambda only needs to write/publish data.
 *
 * Validates: Requirements 4.2
 */
export declare class WriteOnlyStrategy extends BaseIntegrationStrategy {
    readonly strategyType: IntegrationStrategyType;
    protected getPermissionLevel(): 'read' | 'write' | 'full';
}
/**
 * Composite Strategy.
 *
 * Combines multiple strategies into one. When granting permissions
 * or injecting environment variables, all composed strategies are
 * applied in order.
 *
 * Strategies are stateless - the composite simply delegates to
 * its component strategies.
 *
 * @example
 * ```typescript
 * const composite = new CompositeStrategy([
 *   new ReadOnlyStrategy(),
 *   new WriteOnlyStrategy(),
 * ]);
 * // Results in both read and write permissions
 * ```
 *
 * Validates: Requirements 4.3, 4.6
 */
export declare class CompositeStrategy implements IIntegrationStrategy {
    readonly strategyType: IntegrationStrategyType;
    /**
     * The composed strategies.
     */
    private readonly strategies;
    /**
     * Create a composite strategy.
     *
     * @param strategies - The strategies to compose
     * @throws Error if no strategies provided
     */
    constructor(strategies: readonly IIntegrationStrategy[]);
    /**
     * Get the composed strategies.
     *
     * @returns Readonly array of composed strategies
     */
    getStrategies(): readonly IIntegrationStrategy[];
    /**
     * Grant permissions using all composed strategies.
     *
     * Merges actions from all strategies, removing duplicates.
     * If any strategy fails, the composite fails.
     *
     * @param resource - The resource to grant access to
     * @param role - The IAM role
     * @param options - Optional grant configuration
     * @returns Combined result of all grant operations
     */
    grantPermissions(resource: IResourceEntity, role: unknown, options?: GrantOptions): GrantResult;
    /**
     * Inject environment variables using all composed strategies.
     *
     * Merges injected variables from all strategies.
     * Later strategies override earlier ones for same variable names.
     *
     * @param resource - The resource to inject identifiers for
     * @param lambda - The Lambda function
     * @param options - Optional injection configuration
     * @returns Combined result of all inject operations
     */
    injectEnvironment(resource: IResourceEntity, lambda: unknown, options?: InjectOptions): InjectResult;
}
/**
 * Custom Strategy.
 *
 * Allows defining custom actions for permissions.
 * Use when the default strategies don't fit your needs.
 *
 * @example
 * ```typescript
 * const custom = new CustomStrategy(['dynamodb:GetItem', 'dynamodb:Query']);
 * ```
 */
export declare class CustomStrategy extends BaseIntegrationStrategy {
    readonly strategyType: IntegrationStrategyType;
    /**
     * Custom actions to grant.
     */
    private readonly customActions;
    /**
     * Create a custom strategy.
     *
     * @param actions - The custom actions to grant
     */
    constructor(actions: readonly string[]);
    /**
     * Get the custom actions.
     *
     * @returns Readonly array of custom actions
     */
    getCustomActions(): readonly string[];
    protected getPermissionLevel(): 'read' | 'write' | 'full';
    /**
     * Grant custom permissions.
     *
     * @param resource - The resource to grant access to
     * @param _role - The IAM role
     * @param options - Optional grant configuration
     * @returns Result with custom actions
     */
    grantPermissions(resource: IResourceEntity, _role: unknown, options?: GrantOptions): GrantResult;
}
/**
 * Strategy Factory.
 *
 * Creates integration strategies by type.
 * Provides a centralized way to create and configure strategies.
 */
export declare class IntegrationStrategyFactory {
    /**
     * Singleton instances for stateless strategies.
     */
    private static readonly fullAccess;
    private static readonly readOnly;
    private static readonly writeOnly;
    /**
     * Create a strategy by type.
     *
     * @param type - The strategy type to create
     * @returns The created strategy
     * @throws Error if type is 'composite' or 'custom' (use specific methods)
     */
    static create(type: IntegrationStrategyType): IIntegrationStrategy;
    /**
     * Create a composite strategy from multiple strategies.
     *
     * @param strategies - The strategies to compose
     * @returns A composite strategy
     */
    static createComposite(strategies: readonly IIntegrationStrategy[]): CompositeStrategy;
    /**
     * Create a custom strategy with specific actions.
     *
     * @param actions - The custom actions to grant
     * @returns A custom strategy
     */
    static createCustom(actions: readonly string[]): CustomStrategy;
    /**
     * Get the default strategy (full-access).
     *
     * @returns The default full-access strategy
     */
    static getDefault(): IIntegrationStrategy;
}
