import { H as HttpClientConfig } from './types-C8x5GGVP.js';
import { ContentstackRegion } from './regions/index.js';
import { C as ContentstackHttpClient } from './client-C0hESzBg.js';
import { C as ContentstackCredentials, e as OAuthConfig, f as OAuthTokens } from './types-BmuNBa52.js';

interface PublishDetails {
    environment: string;
    locale: string;
    time: string;
    user: string;
}
interface WorkflowStage {
    uid: string;
    name: string;
    color: string;
    order: number;
    next_available_stages?: string[];
}
interface FieldSchema {
    uid: string;
    data_type: string;
    display_name: string;
    mandatory?: boolean;
    unique?: boolean;
    multiple?: boolean;
    field_metadata?: Record<string, unknown>;
    schema?: FieldSchema[];
    [key: string]: unknown;
}
interface Entry {
    uid: string;
    title: string;
    url?: string;
    locale: string;
    created_at: string;
    updated_at: string;
    created_by: string;
    updated_by: string;
    _version: number;
    tags?: string[];
    publish_details?: PublishDetails[];
    _workflow?: WorkflowStage;
    [field: string]: unknown;
}
interface ContentType {
    uid: string;
    title: string;
    description?: string;
    schema: FieldSchema[];
    options: Record<string, unknown>;
    created_at: string;
    updated_at: string;
}
interface Asset {
    uid: string;
    title: string;
    filename: string;
    url: string;
    content_type: string;
    file_size: string;
    dimension?: {
        width: number;
        height: number;
    };
    created_at: string;
    updated_at: string;
}
interface AssetFolder {
    uid: string;
    name: string;
    parent_uid?: string;
    is_dir: boolean;
    created_at: string;
    updated_at: string;
}
interface Environment {
    uid: string;
    name: string;
    urls: Array<{
        url: string;
        locale: string;
    }>;
    created_at: string;
    updated_at: string;
}
interface Locale {
    uid: string;
    code: string;
    name: string;
    fallback_locale?: string;
    created_at: string;
    updated_at: string;
}
interface Branch {
    uid: string;
    source: string;
    alias?: Array<{
        uid: string;
    }>;
    created_at: string;
    updated_at: string;
}
interface Release {
    uid: string;
    name: string;
    description?: string;
    locked: boolean;
    archived: boolean;
    created_at: string;
    updated_at: string;
}
interface ReleaseItem {
    uid: string;
    version: number;
    content_type_uid: string;
    action: "publish" | "unpublish";
    locale: string;
}
interface Taxonomy {
    uid: string;
    name: string;
    description?: string;
    created_at: string;
    updated_at: string;
}
interface TaxonomyTerm {
    uid: string;
    name: string;
    parent_uid?: string;
    depth: number;
    created_at: string;
    updated_at: string;
}
interface Webhook {
    uid: string;
    name: string;
    destinations: Array<{
        target_url: string;
        http_basic_auth?: string;
        http_basic_password?: string;
        custom_header?: Array<{
            header_name: string;
            value: string;
        }>;
    }>;
    channels: string[];
    retry_policy: string;
    disabled: boolean;
    created_at: string;
    updated_at: string;
}
interface Workflow {
    uid: string;
    name: string;
    description?: string;
    content_types: string[];
    workflow_stages: WorkflowStage[];
    enabled: boolean;
    created_at: string;
    updated_at: string;
}
interface BasePublishAction {
    environments: string[];
    locales: string[];
    scheduled_at?: string;
}
interface BaseToken {
    uid: string;
    name: string;
    description?: string;
    token: string;
    created_at: string;
    updated_at: string;
}
interface ManagementToken extends BaseToken {
    scope: Array<{
        module: string;
        acl: Record<string, unknown>;
    }>;
    expires_on?: string;
}
interface DeliveryToken extends BaseToken {
    scope: Array<{
        environments: Array<{
            uid: string;
            name: string;
        }>;
        module: string;
    }>;
}
interface GlobalField {
    uid: string;
    title: string;
    description?: string;
    schema: FieldSchema[];
    created_at: string;
    updated_at: string;
}
interface Label {
    uid: string;
    name: string;
    content_types: string[];
    parent?: string[];
    created_at: string;
    updated_at: string;
}
interface Role {
    uid: string;
    name: string;
    description?: string;
    rules: Array<{
        module: string;
        users: string[];
        acl: Record<string, unknown>;
    }>;
    stack: {
        api_key: string;
    };
    created_at: string;
    updated_at: string;
}
interface AuditLogEntry {
    uid: string;
    module: string;
    event_type: string;
    request_id: string;
    metadata: Record<string, unknown>;
    remote_addr: string;
    created_at: string;
    created_by: string;
}
interface Extension {
    uid: string;
    title: string;
    type: string;
    tag?: string;
    scope?: {
        content_types: string[];
    };
    src?: string;
    config?: Record<string, unknown>;
    created_at: string;
    updated_at: string;
}
interface BranchAlias {
    uid: string;
    source: string;
    created_at: string;
    updated_at: string;
}
interface PublishRule {
    uid: string;
    workflow: string;
    actions: string[];
    branches: string[];
    content_types: string[];
    locales: string[];
    environment: string;
    approvers: Array<{
        uid: string;
        name?: string;
        email?: string;
    }>;
    created_at: string;
    updated_at: string;
}
interface PreviewToken extends BaseToken {
    scope: Array<{
        environments: Array<{
            uid: string;
            name: string;
        }>;
        module: string;
    }>;
}
interface MergeJob {
    uid: string;
    base_branch: string;
    compare_branch: string;
    status: string;
    merge_comment?: string;
    errors?: unknown[];
    created_at: string;
    updated_at: string;
}

type AssetPublishAction = BasePublishAction;
declare class AssetsClient {
    private readonly http;
    constructor(http: ContentstackHttpClient);
    list(opts?: {
        limit?: number;
        folder?: string;
    }): AsyncIterable<Asset>;
    listAll(opts?: {
        limit?: number;
        folder?: string;
    }): Promise<Asset[]>;
    get(uid: string): Promise<Asset>;
    upload(form: FormData): Promise<Asset>;
    update(uid: string, data: Partial<Asset>): Promise<Asset>;
    delete(uid: string): Promise<void>;
    publish(uid: string, data: AssetPublishAction): Promise<void>;
    unpublish(uid: string, data: AssetPublishAction): Promise<void>;
    listFolders(opts?: {
        limit?: number;
    }): Promise<AssetFolder[]>;
    getFolder(uid: string): Promise<AssetFolder>;
    createFolder(data: {
        name: string;
        parent_uid?: string;
    }): Promise<AssetFolder>;
    updateFolder(uid: string, data: {
        name: string;
    }): Promise<AssetFolder>;
    deleteFolder(uid: string): Promise<void>;
    replace(uid: string, form: FormData): Promise<Asset>;
    getReferences(uid: string): Promise<unknown[]>;
}

interface CrudConfig {
    basePath: string;
    singularKey: string;
    pluralKey: string;
}
declare class CrudClient<T> {
    protected readonly http: ContentstackHttpClient;
    protected readonly config: CrudConfig;
    constructor(http: ContentstackHttpClient, config: CrudConfig);
    list(opts?: {
        limit?: number;
    }): AsyncIterable<T>;
    listAll(opts?: {
        limit?: number;
    }): Promise<T[]>;
    get(uid: string): Promise<T>;
    create(data: Partial<T>): Promise<T>;
    update(uid: string, data: Partial<T>): Promise<T>;
    delete(uid: string): Promise<void>;
}

declare class AuditLogClient extends CrudClient<AuditLogEntry> {
    constructor(http: ContentstackHttpClient);
}

interface CMAClientManagementTokenAuth {
    type: "management-token";
    token: string;
}
interface CMAClientOAuthAuth {
    type: "oauth";
    accessToken?: string;
    getAccessToken?: () => string | Promise<string>;
}
interface CMAClientAuthtokenAuth {
    type: "authtoken";
    token: string;
}
interface CMAClientCredentialsAuth extends ContentstackCredentials {
    type: "credentials";
}
interface CMAClientOAuthFlowAuth {
    type: "oauth-flow";
    config: OAuthConfig;
    tokens?: OAuthTokens;
    code?: string;
    codeVerifier?: string;
    obtainedAt?: number;
    refreshThresholdMs?: number;
    onTokens?: (tokens: OAuthTokens & {
        obtainedAt: number;
    }) => void | Promise<void>;
}
type CMAClientAuth = CMAClientManagementTokenAuth | CMAClientOAuthAuth | CMAClientAuthtokenAuth | CMAClientCredentialsAuth | CMAClientOAuthFlowAuth;

declare class BranchAliasesClient {
    private readonly http;
    constructor(http: ContentstackHttpClient);
    list(): Promise<BranchAlias[]>;
    get(uid: string): Promise<BranchAlias>;
    createOrUpdate(uid: string, targetBranch: string): Promise<BranchAlias>;
    delete(uid: string): Promise<void>;
}

interface MergeRequest {
    base_branch: string;
    compare_branch: string;
    default_merge_strategy: "merge_prefer_base" | "merge_prefer_compare" | "overwrite_with_compare" | "merge_new_only" | "ignore";
    merge_comment?: string;
    item_merge_strategies?: Record<string, string>;
}
declare class BranchesClient {
    private readonly http;
    constructor(http: ContentstackHttpClient);
    list(opts?: {
        limit?: number;
    }): AsyncIterable<Branch>;
    listAll(opts?: {
        limit?: number;
    }): Promise<Branch[]>;
    get(uid: string): Promise<Branch>;
    create(data: {
        uid: string;
        source: string;
    }): Promise<Branch>;
    delete(uid: string): Promise<void>;
    compare(baseBranch: string, compareBranch: string): Promise<unknown>;
    merge(data: MergeRequest): Promise<MergeJob>;
    listMergeJobs(): Promise<MergeJob[]>;
    getMergeJob(uid: string): Promise<MergeJob>;
}

interface BulkEntry {
    uid: string;
    content_type: string;
    locale: string;
    version?: number;
}
interface BulkPublishAction extends BasePublishAction {
    entries?: BulkEntry[];
    assets?: Array<{
        uid: string;
    }>;
}
interface BulkWorkflowAction {
    entries: Array<{
        uid: string;
        content_type: string;
        locale: string;
    }>;
    workflow_stage: {
        uid: string;
        comment?: string;
    };
}
declare class BulkOperationsClient {
    private readonly http;
    constructor(http: ContentstackHttpClient);
    publish(data: BulkPublishAction): Promise<void>;
    unpublish(data: BulkPublishAction): Promise<void>;
    delete(data: {
        entries?: Array<{
            uid: string;
            content_type: string;
            locale: string;
        }>;
        assets?: Array<{
            uid: string;
        }>;
    }): Promise<void>;
    updateWorkflow(data: BulkWorkflowAction): Promise<void>;
    addItems(data: Record<string, unknown>): Promise<void>;
    updateItems(data: Record<string, unknown>): Promise<void>;
    jobStatus(jobId: string): Promise<unknown>;
    getJobItems(jobId: string, opts?: {
        limit?: number;
        skip?: number;
    }): Promise<unknown[]>;
}

declare class ContentTypesClient extends CrudClient<ContentType> {
    constructor(http: ContentstackHttpClient);
    list(opts?: {
        limit?: number;
        include_count?: boolean;
    }): AsyncIterable<ContentType>;
    listAll(opts?: {
        limit?: number;
        include_count?: boolean;
    }): Promise<ContentType[]>;
    export(uid: string): Promise<ContentType>;
    import(data: Record<string, unknown>): Promise<ContentType>;
}

interface EntryListOptions {
    locale?: string;
    include_publish_details?: boolean;
    include_workflow?: boolean;
    include_count?: boolean;
    query?: Record<string, unknown>;
    asc?: string;
    desc?: string;
    limit?: number;
}
interface EntryGetOptions {
    locale?: string;
    include_publish_details?: boolean;
    include_workflow?: boolean;
    version?: number;
}
type PublishAction = BasePublishAction;
interface WorkflowStageAction {
    workflow_stage: {
        uid: string;
        comment?: string;
        due_date?: string;
        assigned_to?: Array<{
            uid: string;
            name: string;
            email: string;
        }>;
        notify?: boolean;
    };
}
declare class EntriesClient {
    private readonly http;
    constructor(http: ContentstackHttpClient);
    private basePath;
    list(ctUid: string, opts?: EntryListOptions): AsyncIterable<Entry>;
    listAll(ctUid: string, opts?: EntryListOptions): Promise<Entry[]>;
    get(ctUid: string, entryUid: string, opts?: EntryGetOptions): Promise<Entry>;
    create(ctUid: string, data: Partial<Entry>): Promise<Entry>;
    update(ctUid: string, entryUid: string, data: Partial<Entry>): Promise<Entry>;
    delete(ctUid: string, entryUid: string, opts?: {
        locale?: string;
    }): Promise<void>;
    publish(ctUid: string, entryUid: string, data: PublishAction): Promise<void>;
    unpublish(ctUid: string, entryUid: string, data: PublishAction): Promise<void>;
    localize(ctUid: string, entryUid: string, data: Record<string, unknown>): Promise<Entry>;
    setWorkflowStage(ctUid: string, entryUid: string, data: WorkflowStageAction): Promise<void>;
    references(ctUid: string, entryUid: string): Promise<unknown[]>;
    languages(ctUid: string, entryUid: string): Promise<unknown[]>;
    versions(ctUid: string, entryUid: string): Promise<unknown[]>;
    import(ctUid: string, data: Record<string, unknown>, opts?: {
        locale?: string;
        overwrite?: boolean;
    }): Promise<Entry>;
}

declare class EnvironmentsClient extends CrudClient<Environment> {
    constructor(http: ContentstackHttpClient);
}

declare class ExtensionsClient extends CrudClient<Extension> {
    constructor(http: ContentstackHttpClient);
    upload(form: FormData): Promise<Extension>;
}

declare class GlobalFieldsClient extends CrudClient<GlobalField> {
    constructor(http: ContentstackHttpClient);
    export(uid: string): Promise<GlobalField>;
    import(data: Record<string, unknown>): Promise<GlobalField>;
}

declare class LabelsClient extends CrudClient<Label> {
    constructor(http: ContentstackHttpClient);
}

declare class LocalesClient extends CrudClient<Locale> {
    constructor(http: ContentstackHttpClient);
}

declare class PublishRulesClient extends CrudClient<PublishRule> {
    constructor(http: ContentstackHttpClient);
}

interface DeployAction extends BasePublishAction {
    action?: "publish" | "unpublish";
}
declare class ReleasesClient {
    private readonly http;
    constructor(http: ContentstackHttpClient);
    list(opts?: {
        limit?: number;
        include_count?: boolean;
    }): AsyncIterable<Release>;
    listAll(opts?: {
        limit?: number;
    }): Promise<Release[]>;
    get(uid: string): Promise<Release>;
    create(data: Partial<Release>): Promise<Release>;
    update(uid: string, data: Partial<Release>): Promise<Release>;
    delete(uid: string): Promise<void>;
    deploy(uid: string, data: DeployAction): Promise<void>;
    listItems(uid: string): Promise<ReleaseItem[]>;
    addItem(uid: string, item: Partial<ReleaseItem>): Promise<void>;
    removeItem(uid: string, item: {
        uid: string;
        content_type_uid: string;
        locale: string;
        version: number;
        action: string;
    }): Promise<void>;
    clone(uid: string, data: {
        name: string;
        description?: string;
    }): Promise<Release>;
}

declare class RolesClient extends CrudClient<Role> {
    constructor(http: ContentstackHttpClient);
}

declare class TaxonomiesClient {
    private readonly http;
    constructor(http: ContentstackHttpClient);
    list(opts?: {
        limit?: number;
    }): AsyncIterable<Taxonomy>;
    listAll(opts?: {
        limit?: number;
    }): Promise<Taxonomy[]>;
    get(uid: string): Promise<Taxonomy>;
    create(data: Partial<Taxonomy>): Promise<Taxonomy>;
    update(uid: string, data: Partial<Taxonomy>): Promise<Taxonomy>;
    delete(uid: string): Promise<void>;
    listTerms(taxonomyUid: string, opts?: {
        limit?: number;
    }): AsyncIterable<TaxonomyTerm>;
    listAllTerms(taxonomyUid: string, opts?: {
        limit?: number;
    }): Promise<TaxonomyTerm[]>;
    getTerm(taxonomyUid: string, termUid: string): Promise<TaxonomyTerm>;
    createTerm(taxonomyUid: string, data: Partial<TaxonomyTerm>): Promise<TaxonomyTerm>;
    updateTerm(taxonomyUid: string, termUid: string, data: Partial<TaxonomyTerm>): Promise<TaxonomyTerm>;
    deleteTerm(taxonomyUid: string, termUid: string): Promise<void>;
    ancestors(taxonomyUid: string, termUid: string): Promise<TaxonomyTerm[]>;
    descendants(taxonomyUid: string, termUid: string): Promise<TaxonomyTerm[]>;
    moveTerm(taxonomyUid: string, termUid: string, data: {
        parent_uid?: string;
        order: number;
    }): Promise<TaxonomyTerm>;
    export(uid: string): Promise<Taxonomy>;
    import(data: Record<string, unknown>): Promise<Taxonomy>;
}

declare class TokensClient {
    private management;
    private delivery;
    private preview;
    constructor(http: ContentstackHttpClient);
    listManagementTokens(): Promise<ManagementToken[]>;
    getManagementToken(uid: string): Promise<ManagementToken>;
    createManagementToken(data: Partial<ManagementToken>): Promise<ManagementToken>;
    updateManagementToken(uid: string, data: Partial<ManagementToken>): Promise<ManagementToken>;
    deleteManagementToken(uid: string): Promise<void>;
    listDeliveryTokens(): Promise<DeliveryToken[]>;
    getDeliveryToken(uid: string): Promise<DeliveryToken>;
    createDeliveryToken(data: Partial<DeliveryToken>): Promise<DeliveryToken>;
    updateDeliveryToken(uid: string, data: Partial<DeliveryToken>): Promise<DeliveryToken>;
    deleteDeliveryToken(uid: string): Promise<void>;
    listPreviewTokens(): Promise<PreviewToken[]>;
    getPreviewToken(uid: string): Promise<PreviewToken>;
    createPreviewToken(data: Partial<PreviewToken>): Promise<PreviewToken>;
    updatePreviewToken(uid: string, data: Partial<PreviewToken>): Promise<PreviewToken>;
    deletePreviewToken(uid: string): Promise<void>;
}

declare class WebhooksClient extends CrudClient<Webhook> {
    constructor(http: ContentstackHttpClient);
    logs(uid: string): Promise<unknown[]>;
    retry(uid: string, executionUid: string): Promise<void>;
}

declare class WorkflowsClient extends CrudClient<Workflow> {
    constructor(http: ContentstackHttpClient);
}

interface CMAClientConfig {
    region: ContentstackRegion;
    apiKey: string;
    auth: CMAClientAuth;
    branch?: string;
    httpOptions?: Partial<HttpClientConfig>;
}
interface CMAClient {
    entries: EntriesClient;
    contentTypes: ContentTypesClient;
    assets: AssetsClient;
    environments: EnvironmentsClient;
    locales: LocalesClient;
    globalFields: GlobalFieldsClient;
    webhooks: WebhooksClient;
    workflows: WorkflowsClient;
    releases: ReleasesClient;
    branches: BranchesClient;
    branchAliases: BranchAliasesClient;
    taxonomies: TaxonomiesClient;
    bulk: BulkOperationsClient;
    tokens: TokensClient;
    labels: LabelsClient;
    roles: RolesClient;
    auditLog: AuditLogClient;
    extensions: ExtensionsClient;
    publishRules: PublishRulesClient;
    onBranch(branchUid: string): CMAClient;
}
declare function createCMAClient(config: CMAClientConfig): CMAClient;

/**
 * Framework-agnostic request builders for CMA operations.
 *
 * These pure functions build paths, query parameters, and request bodies
 * for Contentstack CMA endpoints. Both React hooks and Vue composables
 * use them to avoid duplicating request construction logic.
 */
interface EntryQueryParams {
    locale?: string;
    version?: number;
    includePublishDetails?: boolean;
}
interface EntriesQueryParams {
    locale?: string;
    limit?: number;
    skip?: number;
    includePublishDetails?: boolean;
    query?: Record<string, unknown>;
}
interface AssetsQueryParams {
    folder?: string;
    limit?: number;
    skip?: number;
}
interface CreateEntryVariables {
    contentTypeUid: string;
    entry: Record<string, unknown>;
    locale?: string;
}
interface UpdateEntryVariables {
    contentTypeUid: string;
    entryUid: string;
    entry: Record<string, unknown>;
    locale?: string;
}
interface DeleteEntryVariables {
    contentTypeUid: string;
    entryUid: string;
    locale?: string;
    deleteAllLocalized?: boolean;
}
interface PublishEntryVariables {
    contentTypeUid: string;
    entryUid: string;
    environments: string[];
    locales: string[];
    scheduledAt?: string;
}
declare function buildEntryParams(options?: EntryQueryParams): Record<string, string> | undefined;
declare function buildEntriesParams(options?: EntriesQueryParams): Record<string, string> | undefined;
declare function buildAssetsParams(options?: AssetsQueryParams): Record<string, string> | undefined;
declare function buildCreateEntryRequest(vars: CreateEntryVariables): {
    path: string;
    body: unknown;
};
declare function buildUpdateEntryRequest(vars: UpdateEntryVariables): {
    path: string;
    body: unknown;
};
declare function buildDeleteEntryRequest(vars: DeleteEntryVariables): {
    path: string;
};
declare function buildPublishEntryRequest(vars: PublishEntryVariables): {
    path: string;
    body: unknown;
};

export { type MergeRequest as $, type Asset as A, type BasePublishAction as B, type CreateEntryVariables as C, type DeleteEntryVariables as D, type DeliveryToken as E, type DeployAction as F, EntriesClient as G, type EntriesQueryParams as H, type Entry as I, type EntryGetOptions as J, type EntryListOptions as K, type EntryQueryParams as L, type Environment as M, EnvironmentsClient as N, type Extension as O, type PublishEntryVariables as P, ExtensionsClient as Q, type FieldSchema as R, type GlobalField as S, GlobalFieldsClient as T, type UpdateEntryVariables as U, type Label as V, LabelsClient as W, type Locale as X, LocalesClient as Y, type ManagementToken as Z, type MergeJob as _, type AssetFolder as a, type PreviewToken as a0, type PublishAction as a1, type PublishDetails as a2, type PublishRule as a3, PublishRulesClient as a4, type Release as a5, type ReleaseItem as a6, ReleasesClient as a7, type Role as a8, RolesClient as a9, TaxonomiesClient as aa, type Taxonomy as ab, type TaxonomyTerm as ac, TokensClient as ad, type Webhook as ae, WebhooksClient as af, type Workflow as ag, type WorkflowStage as ah, type WorkflowStageAction as ai, WorkflowsClient as aj, buildAssetsParams as ak, buildCreateEntryRequest as al, buildDeleteEntryRequest as am, buildEntriesParams as an, buildEntryParams as ao, buildPublishEntryRequest as ap, buildUpdateEntryRequest as aq, createCMAClient as ar, type AssetPublishAction as b, AssetsClient as c, type AssetsQueryParams as d, AuditLogClient as e, type AuditLogEntry as f, type Branch as g, type BranchAlias as h, BranchAliasesClient as i, BranchesClient as j, type BulkEntry as k, BulkOperationsClient as l, type BulkPublishAction as m, type BulkWorkflowAction as n, type CMAClient as o, type CMAClientAuth as p, type CMAClientAuthtokenAuth as q, type CMAClientConfig as r, type CMAClientCredentialsAuth as s, type CMAClientManagementTokenAuth as t, type CMAClientOAuthAuth as u, type CMAClientOAuthFlowAuth as v, type ContentType as w, ContentTypesClient as x, CrudClient as y, type CrudConfig as z };