import { APIResource } from "../../resource.js";
import * as Core from "../../core.js";
import * as BlockSchemasAPI from "./block-schemas.js";
import * as ChecksumAPI from "./checksum.js";
import * as BlockTypesAPI from "../block-types/block-types.js";
export declare class BlockSchemas extends APIResource {
    checksum: ChecksumAPI.Checksum;
    /**
     * Create Block Schema
     */
    create(params: BlockSchemaCreateParams, options?: Core.RequestOptions): Core.APIPromise<BlockSchema>;
    /**
     * Get a block schema by id.
     */
    retrieve(id: string, params?: BlockSchemaRetrieveParams, options?: Core.RequestOptions): Core.APIPromise<BlockSchema>;
    retrieve(id: string, options?: Core.RequestOptions): Core.APIPromise<BlockSchema>;
    /**
     * Delete a block schema by id.
     */
    delete(id: string, params?: BlockSchemaDeleteParams, options?: Core.RequestOptions): Core.APIPromise<void>;
    delete(id: string, options?: Core.RequestOptions): Core.APIPromise<void>;
    /**
     * Read all block schemas, optionally filtered by type
     */
    filter(params?: BlockSchemaFilterParams, options?: Core.RequestOptions): Core.APIPromise<BlockSchemaFilterResponse>;
    filter(options?: Core.RequestOptions): Core.APIPromise<BlockSchemaFilterResponse>;
}
/**
 * An ORM representation of a block schema.
 */
export interface BlockSchema {
    /**
     * A block type ID
     */
    block_type_id: string | null;
    /**
     * The block schema's unique checksum
     */
    checksum: string;
    id?: string;
    /**
     * An ORM representation of a block type
     */
    block_type?: BlockTypesAPI.BlockType | null;
    /**
     * A list of Block capabilities
     */
    capabilities?: Array<string>;
    created?: string | null;
    /**
     * The block schema's field schema
     */
    fields?: unknown;
    updated?: string | null;
    /**
     * Human readable identifier for the block schema
     */
    version?: string;
}
export type BlockSchemaFilterResponse = Array<BlockSchema>;
export interface BlockSchemaCreateParams {
    /**
     * Body param: A block type ID
     */
    block_type_id: string;
    /**
     * Body param: A list of Block capabilities
     */
    capabilities?: Array<string>;
    /**
     * Body param: The block schema's field schema
     */
    fields?: unknown;
    /**
     * Body param: Human readable identifier for the block schema
     */
    version?: string;
    /**
     * Header param:
     */
    'x-prefect-api-version'?: string;
}
export interface BlockSchemaRetrieveParams {
    'x-prefect-api-version'?: string;
}
export interface BlockSchemaDeleteParams {
    'x-prefect-api-version'?: string;
}
export interface BlockSchemaFilterParams {
    /**
     * Body param: Filter BlockSchemas
     */
    block_schemas?: BlockSchemaFilterParams.BlockSchemas | null;
    /**
     * Body param: Defaults to PREFECT_API_DEFAULT_LIMIT if not provided.
     */
    limit?: number;
    /**
     * Body param:
     */
    offset?: number;
    /**
     * Header param:
     */
    'x-prefect-api-version'?: string;
}
export declare namespace BlockSchemaFilterParams {
    /**
     * Filter BlockSchemas
     */
    interface BlockSchemas {
        /**
         * Filter by BlockSchema.id
         */
        id?: BlockSchemas.ID | null;
        /**
         * Filter by `BlockSchema.capabilities`
         */
        block_capabilities?: BlockSchemas.BlockCapabilities | null;
        /**
         * Filter by `BlockSchema.block_type_id`.
         */
        block_type_id?: BlockSchemas.BlockTypeID | null;
        /**
         * Operator for combining filter criteria. Defaults to 'and\_'.
         */
        operator?: 'and_' | 'or_';
        /**
         * Filter by `BlockSchema.capabilities`
         */
        version?: BlockSchemas.Version | null;
    }
    namespace BlockSchemas {
        /**
         * Filter by BlockSchema.id
         */
        interface ID {
            /**
             * A list of IDs to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by `BlockSchema.capabilities`
         */
        interface BlockCapabilities {
            /**
             * A list of block capabilities. Block entities will be returned only if an
             * associated block schema has a superset of the defined capabilities.
             */
            all_?: Array<string> | null;
        }
        /**
         * Filter by `BlockSchema.block_type_id`.
         */
        interface BlockTypeID {
            /**
             * A list of block type ids to include
             */
            any_?: Array<string> | null;
        }
        /**
         * Filter by `BlockSchema.capabilities`
         */
        interface Version {
            /**
             * A list of block schema versions.
             */
            any_?: Array<string> | null;
        }
    }
}
export declare namespace BlockSchemas {
    export import BlockSchema = BlockSchemasAPI.BlockSchema;
    export import BlockSchemaFilterResponse = BlockSchemasAPI.BlockSchemaFilterResponse;
    export import BlockSchemaCreateParams = BlockSchemasAPI.BlockSchemaCreateParams;
    export import BlockSchemaRetrieveParams = BlockSchemasAPI.BlockSchemaRetrieveParams;
    export import BlockSchemaDeleteParams = BlockSchemasAPI.BlockSchemaDeleteParams;
    export import BlockSchemaFilterParams = BlockSchemasAPI.BlockSchemaFilterParams;
    export import Checksum = ChecksumAPI.Checksum;
    export import ChecksumRetrieveParams = ChecksumAPI.ChecksumRetrieveParams;
}
//# sourceMappingURL=block-schemas.d.ts.map