import { APIResource } from "../../resource.js";
import * as Core from "../../core.js";
import * as ConcurrencyLimitsAPI from "./concurrency-limits.js";
import * as Shared from "../shared.js";
import * as TagAPI from "./tag.js";
import * as TagsAPI from "./tags.js";
export declare class ConcurrencyLimits extends APIResource {
    tag: TagAPI.Tag;
    tags: TagsAPI.Tags;
    /**
     * Create Concurrency Limit
     */
    create(params: ConcurrencyLimitCreateParams, options?: Core.RequestOptions): Core.APIPromise<Shared.ConcurrencyLimit>;
    /**
     * Get a concurrency limit by id.
     *
     * The `active slots` field contains a list of TaskRun IDs currently using a
     * concurrency slot for the specified tag.
     */
    retrieve(id: string, params?: ConcurrencyLimitRetrieveParams, options?: Core.RequestOptions): Core.APIPromise<Shared.ConcurrencyLimit>;
    retrieve(id: string, options?: Core.RequestOptions): Core.APIPromise<Shared.ConcurrencyLimit>;
    /**
     * Delete Concurrency Limit
     */
    delete(id: string, params?: ConcurrencyLimitDeleteParams, options?: Core.RequestOptions): Core.APIPromise<unknown>;
    delete(id: string, options?: Core.RequestOptions): Core.APIPromise<unknown>;
    /**
     * Decrement Concurrency Limits V1
     */
    decrement(params: ConcurrencyLimitDecrementParams, options?: Core.RequestOptions): Core.APIPromise<unknown>;
    /**
     * Query for concurrency limits.
     *
     * For each concurrency limit the `active slots` field contains a list of TaskRun
     * IDs currently using a concurrency slot for the specified tag.
     */
    filter(params?: ConcurrencyLimitFilterParams, options?: Core.RequestOptions): Core.APIPromise<ConcurrencyLimitFilterResponse>;
    filter(options?: Core.RequestOptions): Core.APIPromise<ConcurrencyLimitFilterResponse>;
    /**
     * Increment Concurrency Limits V1
     */
    increment(params: ConcurrencyLimitIncrementParams, options?: Core.RequestOptions): Core.APIPromise<ConcurrencyLimitIncrementResponse>;
}
export type ConcurrencyLimitDeleteResponse = unknown;
export type ConcurrencyLimitDecrementResponse = unknown;
export type ConcurrencyLimitFilterResponse = Array<Shared.ConcurrencyLimit>;
export type ConcurrencyLimitIncrementResponse = Array<Shared.MinimalConcurrencyLimitResponse>;
export interface ConcurrencyLimitCreateParams {
    /**
     * Body param: The concurrency limit.
     */
    concurrency_limit: number;
    /**
     * Body param: A tag the concurrency limit is applied to.
     */
    tag: string;
    /**
     * Header param:
     */
    'x-prefect-api-version'?: string;
}
export interface ConcurrencyLimitRetrieveParams {
    'x-prefect-api-version'?: string;
}
export interface ConcurrencyLimitDeleteParams {
    'x-prefect-api-version'?: string;
}
export interface ConcurrencyLimitDecrementParams {
    /**
     * Body param: The tags to release a slot for
     */
    names: Array<string>;
    /**
     * Body param: The ID of the task run releasing the slot
     */
    task_run_id: string;
    /**
     * Header param:
     */
    'x-prefect-api-version'?: string;
}
export interface ConcurrencyLimitFilterParams {
    /**
     * 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 interface ConcurrencyLimitIncrementParams {
    /**
     * Body param: The tags to acquire a slot for
     */
    names: Array<string>;
    /**
     * Body param: The ID of the task run acquiring the slot
     */
    task_run_id: string;
    /**
     * Header param:
     */
    'x-prefect-api-version'?: string;
}
export declare namespace ConcurrencyLimits {
    export import ConcurrencyLimitDeleteResponse = ConcurrencyLimitsAPI.ConcurrencyLimitDeleteResponse;
    export import ConcurrencyLimitDecrementResponse = ConcurrencyLimitsAPI.ConcurrencyLimitDecrementResponse;
    export import ConcurrencyLimitFilterResponse = ConcurrencyLimitsAPI.ConcurrencyLimitFilterResponse;
    export import ConcurrencyLimitIncrementResponse = ConcurrencyLimitsAPI.ConcurrencyLimitIncrementResponse;
    export import ConcurrencyLimitCreateParams = ConcurrencyLimitsAPI.ConcurrencyLimitCreateParams;
    export import ConcurrencyLimitRetrieveParams = ConcurrencyLimitsAPI.ConcurrencyLimitRetrieveParams;
    export import ConcurrencyLimitDeleteParams = ConcurrencyLimitsAPI.ConcurrencyLimitDeleteParams;
    export import ConcurrencyLimitDecrementParams = ConcurrencyLimitsAPI.ConcurrencyLimitDecrementParams;
    export import ConcurrencyLimitFilterParams = ConcurrencyLimitsAPI.ConcurrencyLimitFilterParams;
    export import ConcurrencyLimitIncrementParams = ConcurrencyLimitsAPI.ConcurrencyLimitIncrementParams;
    export import Tag = TagAPI.Tag;
    export import TagDeleteResponse = TagAPI.TagDeleteResponse;
    export import TagDeleteParams = TagAPI.TagDeleteParams;
    export import Tags = TagsAPI.Tags;
    export import TagResetResponse = TagsAPI.TagResetResponse;
    export import TagRetrieveParams = TagsAPI.TagRetrieveParams;
    export import TagResetParams = TagsAPI.TagResetParams;
}
//# sourceMappingURL=concurrency-limits.d.ts.map