import { IcebergRestCatalog } from 'iceberg-js';
import { StorageError } from '../lib/errors';
import { Fetch } from '../lib/fetch';
import { AnalyticBucket } from '../lib/types';
/**
 * Client class for managing Analytics Buckets using Iceberg tables
 * Provides methods for creating, listing, and deleting analytics buckets
 */
export default class StorageAnalyticsClient {
    protected url: string;
    protected headers: {
        [key: string]: string;
    };
    protected fetch: Fetch;
    protected shouldThrowOnError: boolean;
    /**
     * @alpha
     *
     * Creates a new StorageAnalyticsClient instance
     *
     * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
     *
     * @category Analytics Buckets
     * @param url - The base URL for the storage API
     * @param headers - HTTP headers to include in requests
     * @param fetch - Optional custom fetch implementation
     *
     * @example
     * ```typescript
     * const client = new StorageAnalyticsClient(url, headers)
     * ```
     */
    constructor(url: string, headers?: {
        [key: string]: string;
    }, fetch?: Fetch);
    /**
     * @alpha
     *
     * Enable throwing errors instead of returning them in the response
     * When enabled, failed operations will throw instead of returning { data: null, error }
     *
     * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
     *
     * @category Analytics Buckets
     * @returns This instance for method chaining
     */
    throwOnError(): this;
    /**
     * @alpha
     *
     * Creates a new analytics bucket using Iceberg tables
     * Analytics buckets are optimized for analytical queries and data processing
     *
     * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
     *
     * @category Analytics Buckets
     * @param name A unique name for the bucket you are creating
     * @returns Promise with response containing newly created analytics bucket or error
     *
     * @example Create analytics bucket
     * ```js
     * const { data, error } = await supabase
     *   .storage
     *   .analytics
     *   .createBucket('analytics-data')
     * ```
     *
     * Response:
     * ```json
     * {
     *   "data": {
     *     "name": "analytics-data",
     *     "type": "ANALYTICS",
     *     "format": "iceberg",
     *     "created_at": "2024-05-22T22:26:05.100Z",
     *     "updated_at": "2024-05-22T22:26:05.100Z"
     *   },
     *   "error": null
     * }
     * ```
     */
    createBucket(name: string): Promise<{
        data: AnalyticBucket;
        error: null;
    } | {
        data: null;
        error: StorageError;
    }>;
    /**
     * @alpha
     *
     * Retrieves the details of all Analytics Storage buckets within an existing project
     * Only returns buckets of type 'ANALYTICS'
     *
     * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
     *
     * @category Analytics Buckets
     * @param options Query parameters for listing buckets
     * @param options.limit Maximum number of buckets to return
     * @param options.offset Number of buckets to skip
     * @param options.sortColumn Column to sort by ('name', 'created_at', 'updated_at')
     * @param options.sortOrder Sort order ('asc' or 'desc')
     * @param options.search Search term to filter bucket names
     * @returns Promise with response containing array of analytics buckets or error
     *
     * @example List analytics buckets
     * ```js
     * const { data, error } = await supabase
     *   .storage
     *   .analytics
     *   .listBuckets({
     *     limit: 10,
     *     offset: 0,
     *     sortColumn: 'created_at',
     *     sortOrder: 'desc'
     *   })
     * ```
     *
     * Response:
     * ```json
     * {
     *   "data": [
     *     {
     *       "name": "analytics-data",
     *       "type": "ANALYTICS",
     *       "format": "iceberg",
     *       "created_at": "2024-05-22T22:26:05.100Z",
     *       "updated_at": "2024-05-22T22:26:05.100Z"
     *     }
     *   ],
     *   "error": null
     * }
     * ```
     */
    listBuckets(options?: {
        limit?: number;
        offset?: number;
        sortColumn?: 'name' | 'created_at' | 'updated_at';
        sortOrder?: 'asc' | 'desc';
        search?: string;
    }): Promise<{
        data: AnalyticBucket[];
        error: null;
    } | {
        data: null;
        error: StorageError;
    }>;
    /**
     * @alpha
     *
     * Deletes an existing analytics bucket
     * A bucket can't be deleted with existing objects inside it
     * You must first empty the bucket before deletion
     *
     * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
     *
     * @category Analytics Buckets
     * @param bucketName The unique identifier of the bucket you would like to delete
     * @returns Promise with response containing success message or error
     *
     * @example Delete analytics bucket
     * ```js
     * const { data, error } = await supabase
     *   .storage
     *   .analytics
     *   .deleteBucket('analytics-data')
     * ```
     *
     * Response:
     * ```json
     * {
     *   "data": {
     *     "message": "Successfully deleted"
     *   },
     *   "error": null
     * }
     * ```
     */
    deleteBucket(bucketName: string): Promise<{
        data: {
            message: string;
        };
        error: null;
    } | {
        data: null;
        error: StorageError;
    }>;
    /**
     * @alpha
     *
     * Get an Iceberg REST Catalog client configured for a specific analytics bucket
     * Use this to perform advanced table and namespace operations within the bucket
     * The returned client provides full access to the Apache Iceberg REST Catalog API
     *
     * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
     *
     * @category Analytics Buckets
     * @param bucketName - The name of the analytics bucket (warehouse) to connect to
     * @returns Configured IcebergRestCatalog instance for advanced Iceberg operations
     *
     * @example Get catalog and create table
     * ```js
     * // First, create an analytics bucket
     * const { data: bucket, error: bucketError } = await supabase
     *   .storage
     *   .analytics
     *   .createBucket('analytics-data')
     *
     * // Get the Iceberg catalog for that bucket
     * const catalog = supabase.storage.analytics.from('analytics-data')
     *
     * // Create a namespace
     * await catalog.createNamespace({ namespace: ['default'] })
     *
     * // Create a table with schema
     * await catalog.createTable(
     *   { namespace: ['default'] },
     *   {
     *     name: 'events',
     *     schema: {
     *       type: 'struct',
     *       fields: [
     *         { id: 1, name: 'id', type: 'long', required: true },
     *         { id: 2, name: 'timestamp', type: 'timestamp', required: true },
     *         { id: 3, name: 'user_id', type: 'string', required: false }
     *       ],
     *       'schema-id': 0,
     *       'identifier-field-ids': [1]
     *     },
     *     'partition-spec': {
     *       'spec-id': 0,
     *       fields: []
     *     },
     *     'write-order': {
     *       'order-id': 0,
     *       fields: []
     *     },
     *     properties: {
     *       'write.format.default': 'parquet'
     *     }
     *   }
     * )
     * ```
     *
     * @example List tables in namespace
     * ```js
     * const catalog = supabase.storage.analytics.from('analytics-data')
     *
     * // List all tables in the default namespace
     * const tables = await catalog.listTables({ namespace: ['default'] })
     * console.log(tables) // [{ namespace: ['default'], name: 'events' }]
     * ```
     *
     * @example Working with namespaces
     * ```js
     * const catalog = supabase.storage.analytics.from('analytics-data')
     *
     * // List all namespaces
     * const namespaces = await catalog.listNamespaces()
     *
     * // Create namespace with properties
     * await catalog.createNamespace(
     *   { namespace: ['production'] },
     *   { properties: { owner: 'data-team', env: 'prod' } }
     * )
     * ```
     *
     * @example Cleanup operations
     * ```js
     * const catalog = supabase.storage.analytics.from('analytics-data')
     *
     * // Drop table with purge option (removes all data)
     * await catalog.dropTable(
     *   { namespace: ['default'], name: 'events' },
     *   { purge: true }
     * )
     *
     * // Drop namespace (must be empty)
     * await catalog.dropNamespace({ namespace: ['default'] })
     * ```
     *
     * @example Error handling with catalog operations
     * ```js
     * import { IcebergError } from 'iceberg-js'
     *
     * const catalog = supabase.storage.analytics.from('analytics-data')
     *
     * try {
     *   await catalog.dropTable({ namespace: ['default'], name: 'events' }, { purge: true })
     * } catch (error) {
     *   // Handle 404 errors (resource not found)
     *   const is404 =
     *     (error instanceof IcebergError && error.status === 404) ||
     *     error?.status === 404 ||
     *     error?.details?.error?.code === 404
     *
     *   if (is404) {
     *     console.log('Table does not exist')
     *   } else {
     *     throw error // Re-throw other errors
     *   }
     * }
     * ```
     *
     * @remarks
     * This method provides a bridge between Supabase's bucket management and the standard
     * Apache Iceberg REST Catalog API. The bucket name maps to the Iceberg warehouse parameter.
     * All authentication and configuration is handled automatically using your Supabase credentials.
     *
     * **Error Handling**: Operations may throw `IcebergError` from the iceberg-js library.
     * Always handle 404 errors gracefully when checking for resource existence.
     *
     * **Cleanup Operations**: When using `dropTable`, the `purge: true` option permanently
     * deletes all table data. Without it, the table is marked as deleted but data remains.
     *
     * **Library Dependency**: The returned catalog is an instance of `IcebergRestCatalog`
     * from iceberg-js. For complete API documentation and advanced usage, refer to the
     * [iceberg-js documentation](https://supabase.github.io/iceberg-js/).
     *
     * For advanced Iceberg operations beyond bucket management, you can also install and use
     * the `iceberg-js` package directly with manual configuration.
     */
    from(bucketName: string): IcebergRestCatalog;
}
//# sourceMappingURL=StorageAnalyticsClient.d.ts.map