/**
 * Management Client Types
 *
 * Type definitions for the SDK management client used for write operations.
 */
import type { LinkPayload, NavigationLinkInput } from '../../public-api/contracts';
import type { Theme } from '../../contracts';
export interface ManagementClientConfig {
    /**
     * Dashboard URL (e.g., http://localhost:4000 or https://dashboard.riverbankcms.com)
     */
    dashboardUrl: string;
    /**
     * Management API key (format: bld_mgmt_sk_...)
     */
    managementApiKey: string;
    /**
     * Site ID to operate on
     */
    siteId: string;
    /**
     * Request timeout in milliseconds
     * @default 30000
     */
    timeout?: number;
}
export interface ManagementEntry {
    id: string;
    identifier: string;
    contentType: string;
    /** Slug for URL routing - only present for routable content types */
    slug?: string;
    title: string;
    data: Record<string, unknown>;
    publishedData: Record<string, unknown> | null;
    status: 'draft' | 'published';
    hasUnpublishedChanges: boolean;
    createdAt: string;
    updatedAt: string;
    publishedAt: string | null;
}
export interface EntryUpsertInput {
    identifier: string;
    contentType: string;
    data: Record<string, unknown>;
    slug?: string;
}
export interface ManagementPage {
    id: string;
    identifier: string | null;
    title: string;
    path: string;
    status: 'draft' | 'published';
    hasUnpublishedChanges: boolean;
    createdAt: string;
    updatedAt: string;
    publishedAt: string | null;
}
export interface PageUpsertInput {
    identifier: string;
    title: string;
    path: string;
    seoTitle?: string;
    seoDescription?: string;
}
export interface ManagementBlock {
    id: string;
    identifier: string | null;
    kind: string;
    position: number;
    data: Record<string, unknown>;
    createdAt: string;
    updatedAt: string;
}
export interface BlockUpsertInput {
    identifier: string;
    kind: string;
    data: Record<string, unknown>;
    position?: number;
}
export interface ManagementNavigationMenu {
    id: string;
    identifier: string | null;
    name: string;
    isPrimary: boolean;
    isFooter: boolean;
    items: ManagementNavigationItem[];
    createdAt: string;
    updatedAt: string;
}
export interface ManagementNavigationItem {
    id: string;
    label: string;
    link: LinkPayload | null;
    /** Whether this item should render as a CTA-style navigation action. */
    isCta?: boolean;
    position: number;
    children?: ManagementNavigationItem[];
    /** Resolved identifier for internal links (populated on pull) */
    resolvedIdentifier?: string | null;
    /** Resolved content type key for entry links (populated on pull) */
    resolvedContentType?: string | null;
}
export interface PulledNavigationItem {
    id: string;
    menuId: string;
    label: string;
    link: LinkPayload | null;
    /** Whether this item should render as a CTA-style navigation action. */
    isCta?: boolean;
    position: number;
    parentId: string | null;
    children?: PulledNavigationItem[];
    /** Resolved identifier for internal links (populated on pull) */
    resolvedIdentifier?: string | null;
    /** Resolved content type key for entry links (populated on pull) */
    resolvedContentType?: string | null;
}
export interface PulledNavigationMenu {
    id: string;
    siteId: string;
    identifier: string | null;
    name: string;
    isPrimary: boolean;
    isFooter: boolean;
    items: PulledNavigationItem[];
    createdAt: string;
    updatedAt: string;
}
export interface NavigationMenuUpsertInput {
    name: string;
    isPrimary?: boolean;
    isFooter?: boolean;
    items: NavigationItemInput[];
}
export interface NavigationItemInput {
    label: string;
    /** Link configuration. Required for non-dropdown items. */
    link?: NavigationLinkInput;
    /** Whether this item should render as a CTA-style navigation action. */
    isCta?: boolean;
    children?: NavigationItemInput[];
}
export interface ManagementSettings {
    homepageId: string | null;
    seoDefaults: {
        title?: string;
        description?: string;
        ogImage?: string;
        allowIndexingInProduction?: boolean;
    } | null;
    logoIdentifier?: string | null;
    faviconIdentifier?: string | null;
}
export interface SettingsUpdateInput {
    homepageId?: string | null;
    seoDefaults?: {
        title?: string;
        description?: string;
        ogImage?: string;
        allowIndexingInProduction?: boolean;
    } | null;
    logoIdentifier?: string | null;
    faviconIdentifier?: string | null;
}
/**
 * Form field definition.
 */
export interface ManagementFormField {
    id: string;
    label: string;
    type: string;
    required?: boolean;
    placeholder?: string;
    helpText?: string;
    layout?: {
        width?: 'full' | 'half';
    };
    options?: Array<{
        value: string;
        label: string;
    }>;
    multiple?: boolean;
    minLength?: number;
    maxLength?: number;
    pattern?: string;
    min?: number;
    max?: number;
}
/**
 * Form schema structure containing field definitions.
 */
export interface ManagementFormSchema {
    version?: string;
    fields: ManagementFormField[];
}
/**
 * Form settings - generic object to support all form types.
 */
export type ManagementFormSettings = Record<string, unknown>;
/**
 * Form entity for SDK management operations.
 */
export interface ManagementForm {
    id: string;
    slug: string;
    name: string;
    schema: ManagementFormSchema;
    settings: ManagementFormSettings;
    createdAt: string;
    updatedAt: string;
}
/**
 * Input for creating or updating a form.
 */
export interface FormUpsertInput {
    slug: string;
    name: string;
    schema: ManagementFormSchema;
    settings?: ManagementFormSettings;
}
/**
 * Venue address structure.
 */
export interface VenueAddress {
    line1?: string;
    line2?: string;
    city?: string;
    region?: string;
    postcode?: string;
    country?: string;
}
/**
 * Venue location coordinates.
 */
export interface VenueLocation {
    lat?: number;
    lng?: number;
}
/**
 * Venue entity for SDK management operations.
 */
export interface ManagementVenue {
    id: string;
    slug: string;
    title: string;
    description: string | null;
    timezone: string | null;
    capacity: number | null;
    address: VenueAddress;
    location: VenueLocation | null;
    mapEmbed: string | null;
    createdAt: string;
    updatedAt: string;
}
/**
 * Input for creating or updating a venue.
 */
export interface VenueUpsertInput {
    slug: string;
    title: string;
    description?: string | null;
    timezone?: string | null;
    capacity?: number | null;
    address?: VenueAddress;
    location?: VenueLocation | null;
    mapEmbed?: string | null;
}
/**
 * Event category entity for SDK management operations.
 */
export interface ManagementEventCategory {
    id: string;
    identifier: string;
    name: string;
    description: string | null;
    color: string | null;
    sortOrder: number;
    createdAt: string;
    updatedAt: string;
}
/**
 * Input for creating or updating an event category.
 */
export interface EventCategoryUpsertInput {
    identifier: string;
    name: string;
    description?: string | null;
    color?: string | null;
    sortOrder?: number;
}
/**
 * Schedule configuration for an event series.
 */
export interface EventSchedule {
    recurrenceRule: string | null;
    /** Date used for the first occurrence; required for one-off SDK-managed events. */
    startDate?: string | null;
    defaultStartTime: string;
    durationMinutes: number;
}
/**
 * Pricing configuration for an event series.
 */
export interface EventPricing {
    requiresPayment: boolean;
    priceAmount: number | null;
    priceCurrency: string | null;
    priceDisplay: string | null;
    acceptsPasses: boolean;
    acceptsMemberships: boolean;
}
/**
 * Event content data (embedded from content_entry).
 */
export interface EventContent {
    summary?: string;
    body?: string | Record<string, unknown>;
    image?: string | Record<string, unknown>;
    [key: string]: unknown;
}
/**
 * Event series entity for SDK management operations.
 */
export interface ManagementEventSeries {
    id: string;
    identifier: string;
    title: string;
    slug: string;
    status: 'draft' | 'active' | 'archived' | 'cancelled' | 'completed';
    visibility: 'private' | 'public' | 'unlisted';
    schedule: EventSchedule;
    capacity: number | null;
    pricing: EventPricing;
    /** Venue slug reference */
    venueRef: string | null;
    /** Category identifier reference */
    categoryRef: string | null;
    /** Content entry data (embedded) */
    content: EventContent;
    /** Form slug reference for custom registration forms */
    formRef: string | null;
    settings: Record<string, unknown>;
    presentation: Record<string, unknown> | null;
    tags: string[];
    createdAt: string;
    updatedAt: string;
    /** Content entry updatedAt (for stale detection) */
    contentUpdatedAt: string | null;
}
/**
 * Input for creating or updating an event series.
 */
export interface EventSeriesUpsertInput {
    identifier: string;
    title: string;
    slug: string;
    status?: 'draft' | 'active' | 'archived' | 'cancelled';
    visibility?: 'private' | 'public' | 'unlisted';
    schedule: EventSchedule;
    capacity?: number | null;
    pricing?: Partial<EventPricing>;
    /** Venue slug - resolved to venue_id on push */
    venueRef?: string | null;
    /** Category identifier - resolved to event_category_id on push */
    categoryRef?: string | null;
    /** Content to embed in content_entry */
    content?: EventContent;
    /** Form slug - resolved to form_id on push */
    formRef?: string | null;
    settings?: Record<string, unknown>;
    presentation?: Record<string, unknown> | null;
    tags?: string[];
}
export interface CourseSession {
    startsAt: string;
    endsAt: string;
}
export interface CourseProgramContent {
    identifier: string | null;
    data: Record<string, unknown>;
}
export interface ManagementCourseRun {
    id: string;
    seriesId: string;
    identifier: string;
    title: string;
    slug: string;
    status: 'draft' | 'active' | 'cancelled' | 'completed';
    visibility: 'private' | 'public' | 'unlisted';
    venueRef: string | null;
    categoryRef: string | null;
    formRef: string | null;
    capacity: number | null;
    enrollmentCapacity: number | null;
    acceptsMemberships: boolean;
    priceCents: number | null;
    currency: string;
    sessions: CourseSession[];
    programRef: string | null;
    program: CourseProgramContent | null;
    createdAt: string;
    updatedAt: string;
}
export interface CourseRunUpsertInput {
    identifier: string;
    title: string;
    slug: string;
    status?: 'draft' | 'active' | 'cancelled';
    visibility?: 'private' | 'public' | 'unlisted';
    venueRef?: string | null;
    categoryRef?: string | null;
    formRef?: string | null;
    capacity?: number | null;
    enrollmentCapacity?: number | null;
    acceptsMemberships?: boolean;
    priceCents?: number | null;
    currency?: string;
    sessions: CourseSession[];
    programRef?: string | null;
    program?: CourseProgramContent | null;
}
export interface CourseSessionConflict {
    code: 'course_sessions_enrolled_conflict';
    identifier: string;
    enrollmentCount: number;
    message: string;
}
export interface ManagementMediaAsset {
    id: string;
    siteId: string;
    identifier: string | null;
    storageBucket: string;
    storagePath: string;
    filename: string;
    mimeType: string;
    width: number | null;
    height: number | null;
    bytes: number | null;
    checksumSha256: string | null;
    createdAt: string;
    updatedAt: string;
}
export interface MediaResolveResponse {
    assets: ManagementMediaAsset[];
    missingIdentifiers: string[];
    missingAssetIds: string[];
}
/**
 * Input for creating or updating a theme.
 * Include themeId/selectionId for idempotent updates (push after pull).
 */
export interface ThemeUpsertInput {
    theme: Theme;
    /** Optional: update existing theme row (for idempotent push) */
    themeId?: string;
    /** Optional: update existing selection row (for idempotent push) */
    selectionId?: string;
}
/**
 * Response from theme upsert operation.
 */
export interface ThemeUpsertResult {
    themeId: string;
    selectionId: string;
    savedAt: string;
}
/**
 * Footer content for SDK management operations.
 * Matches the structure stored in site_settings.footer_content_json (bottomText only).
 */
export interface FooterContent {
    /** Rich text content in ProseMirror JSON format */
    bottomText?: Record<string, unknown>;
}
/**
 * Footer content as returned from CMS.
 */
export interface ManagementFooterContent {
    /** Rich text content in ProseMirror JSON format */
    bottomText: Record<string, unknown>;
}
/**
 * Input for upserting footer content.
 */
export interface FooterContentUpsertInput {
    /** Set to null to clear. */
    bottomText?: Record<string, unknown> | null;
}
export interface PulledFooter {
    footer: ManagementFooterContent | null;
    meta: {
        pulledAt: string;
        updatedAt: string | null;
    };
}
export interface PulledEntries {
    contentType: string;
    entries: Array<{
        identifier: string;
        data: Record<string, unknown>;
        status: 'draft' | 'published';
        hasUnpublishedChanges: boolean;
        /** Slug for URL routing - only present for routable content types */
        slug?: string;
        /**
         * Canonical entry title (route title for routable content types).
         */
        title: string;
    }>;
    meta: {
        pulledAt: string;
        entries: Record<string, {
            createdAt: string;
            updatedAt: string;
            publishedAt: string | null;
        }>;
    };
    pagination: {
        page: number;
        limit: number;
        total: number;
        hasMore: boolean;
    };
}
export interface PulledPages {
    pages: Array<{
        id: string;
        identifier: string;
        title: string;
        path: string;
        status: 'draft' | 'published';
        hasUnpublishedChanges: boolean;
        updatedAt: string;
        createdAt: string;
        publishedAt: string | null;
        blocks: Array<{
            id: string;
            identifier: string;
            kind: string;
            position: number;
            data: Record<string, unknown>;
            createdAt: string;
            updatedAt: string;
        }>;
    }>;
    meta: {
        pulledAt: string;
    };
}
export interface PulledNavigation {
    menus: PulledNavigationMenu[];
    meta: {
        pulledAt: string;
    };
}
export interface PulledSettings {
    settings: ManagementSettings;
    warnings?: string[];
    meta: {
        pulledAt: string;
    };
}
export interface PulledForms {
    forms: Array<{
        slug: string;
        name: string;
        schema: ManagementFormSchema;
        settings: ManagementFormSettings;
        updatedAt: string;
        createdAt: string;
    }>;
    meta: {
        pulledAt: string;
    };
}
export interface PulledTheme {
    theme: Theme | null;
    themeId: string | null;
    selectionId: string | null;
    meta: {
        pulledAt: string;
        updatedAt: string | null;
    };
}
export interface PulledVenues {
    venues: Array<{
        slug: string;
        title: string;
        description: string | null;
        timezone: string | null;
        capacity: number | null;
        address: VenueAddress;
        location: VenueLocation | null;
        mapEmbed: string | null;
        updatedAt: string;
        createdAt: string;
    }>;
    meta: {
        pulledAt: string;
    };
}
export interface PulledEventCategories {
    eventCategories: Array<{
        identifier: string;
        name: string;
        description: string | null;
        color: string | null;
        sortOrder: number;
        updatedAt: string;
        createdAt: string;
    }>;
    meta: {
        pulledAt: string;
    };
}
export interface PulledEvents {
    events: Array<{
        identifier: string;
        title: string;
        slug: string;
        status: 'draft' | 'active' | 'archived' | 'cancelled' | 'completed';
        visibility: 'private' | 'public' | 'unlisted';
        schedule: EventSchedule;
        capacity: number | null;
        pricing: EventPricing;
        venueRef: string | null;
        categoryRef: string | null;
        content: EventContent;
        formRef: string | null;
        settings: Record<string, unknown>;
        presentation: Record<string, unknown> | null;
        tags: string[];
        updatedAt: string;
        createdAt: string;
        contentUpdatedAt: string | null;
    }>;
    meta: {
        pulledAt: string;
    };
}
export interface PulledCourses {
    courses: Array<{
        identifier: string;
        title: string;
        slug: string;
        status: 'draft' | 'active' | 'cancelled' | 'completed';
        visibility?: 'private' | 'public' | 'unlisted';
        venueRef: string | null;
        categoryRef: string | null;
        formRef: string | null;
        capacity: number | null;
        enrollmentCapacity: number | null;
        acceptsMemberships: boolean;
        priceCents: number | null;
        currency: string;
        sessions: CourseSession[];
        programRef: string | null;
        program: CourseProgramContent | null;
        updatedAt: string;
        createdAt: string;
    }>;
    meta: {
        pulledAt: string;
    };
}
/**
 * Site info returned by the siteInfo() method.
 * Contains configuration data from the CMS server.
 */
export interface PulledSiteInfo {
    /** Supabase URL for direct storage access */
    supabaseUrl: string;
    meta: {
        fetchedAt: string;
    };
}
/**
 * Content type info returned by the pull.contentTypes() method.
 */
export interface PulledContentType {
    key: string;
    name: string;
    hasPages: boolean;
    routePattern: string | null;
    isSingleton: boolean;
}
/**
 * Response from pulling content types.
 */
export interface PulledContentTypes {
    contentTypes: PulledContentType[];
    meta: {
        pulledAt: string;
    };
}
export interface PulledContent {
    entries: Record<string, PulledEntries['entries']>;
    pages: PulledPages['pages'];
    navigation: PulledNavigationMenu[];
    settings: ManagementSettings;
    settingsWarnings?: string[];
    forms: PulledForms['forms'];
    venues?: PulledVenues['venues'];
    eventCategories?: PulledEventCategories['eventCategories'];
    events?: PulledEvents['events'];
    courses?: PulledCourses['courses'];
    meta: {
        pulledAt: string;
        /** Whether the response was truncated due to size limits */
        truncated?: boolean;
        /** Message explaining what was truncated */
        truncationMessage?: string;
        entries?: Record<string, {
            createdAt: string;
            updatedAt: string;
            publishedAt: string | null;
        }>;
    };
}
export interface PaginationOptions {
    page?: number;
    limit?: number;
}
export interface PaginatedResult<T> {
    items: T[];
    pagination: {
        page: number;
        limit: number;
        total: number;
        hasMore: boolean;
    };
}
export interface ApiSuccessResponse<T> {
    success: true;
    data: T;
}
export interface ApiErrorResponse {
    success: false;
    error: {
        code: string;
        message: string;
        details?: unknown;
        fieldErrors?: Array<{
            field: string;
            code: string;
            message: string;
        }>;
    };
}
export type ApiResponse<T> = ApiSuccessResponse<T> | ApiErrorResponse;
export interface EntryOperations {
    list(contentType: string, options?: PaginationOptions): Promise<PaginatedResult<ManagementEntry>>;
    get(contentType: string, identifier: string): Promise<ManagementEntry | null>;
    upsert(input: EntryUpsertInput): Promise<ManagementEntry>;
    publish(contentType: string, identifier: string): Promise<void>;
    unpublish(contentType: string, identifier: string): Promise<void>;
    delete(contentType: string, identifier: string): Promise<void>;
}
export interface PageOperations {
    list(options?: PaginationOptions): Promise<PaginatedResult<ManagementPage>>;
    get(identifier: string): Promise<ManagementPage | null>;
    upsert(input: PageUpsertInput): Promise<ManagementPage>;
    publish(identifier: string): Promise<void>;
    unpublish(identifier: string): Promise<void>;
}
export interface BlockOperations {
    list(pageIdentifier: string): Promise<ManagementBlock[]>;
    get(pageIdentifier: string, blockIdentifier: string): Promise<ManagementBlock | null>;
    upsert(pageIdentifier: string, input: BlockUpsertInput): Promise<ManagementBlock>;
    reorder(pageIdentifier: string, blockIdentifiers: string[]): Promise<void>;
    delete(pageIdentifier: string, blockIdentifier: string): Promise<void>;
}
export interface NavigationOperations {
    list(): Promise<ManagementNavigationMenu[]>;
    get(name: string): Promise<ManagementNavigationMenu | null>;
    upsert(input: NavigationMenuUpsertInput): Promise<ManagementNavigationMenu>;
}
export interface SettingsOperations {
    get(): Promise<ManagementSettings>;
    update(input: SettingsUpdateInput): Promise<ManagementSettings>;
}
export interface FormOperations {
    list(): Promise<ManagementForm[]>;
    get(slug: string): Promise<ManagementForm | null>;
    upsert(input: FormUpsertInput): Promise<ManagementForm>;
    delete(slug: string): Promise<void>;
}
export interface ThemeOperations {
    upsert(input: ThemeUpsertInput): Promise<ThemeUpsertResult>;
}
export interface FooterOperations {
    /** Get footer content */
    get(): Promise<ManagementFooterContent | null>;
    /** Upsert footer content */
    upsert(input: FooterContentUpsertInput): Promise<ManagementFooterContent | null>;
}
export interface VenueOperations {
    list(): Promise<ManagementVenue[]>;
    get(slug: string): Promise<ManagementVenue | null>;
    upsert(input: VenueUpsertInput): Promise<ManagementVenue>;
    delete(slug: string): Promise<void>;
}
export interface EventCategoryOperations {
    list(): Promise<ManagementEventCategory[]>;
    get(identifier: string): Promise<ManagementEventCategory | null>;
    upsert(input: EventCategoryUpsertInput): Promise<ManagementEventCategory>;
    delete(identifier: string): Promise<void>;
}
export interface EventOperations {
    list(): Promise<ManagementEventSeries[]>;
    get(identifier: string): Promise<ManagementEventSeries | null>;
    upsert(input: EventSeriesUpsertInput): Promise<ManagementEventSeries>;
    delete(identifier: string): Promise<void>;
}
export interface CourseOperations {
    list(): Promise<ManagementCourseRun[]>;
    get(identifier: string): Promise<ManagementCourseRun | null>;
    upsert(input: CourseRunUpsertInput): Promise<ManagementCourseRun>;
    delete(identifier: string): Promise<void>;
}
export interface PullOperations {
    entries(contentType?: string, options?: PaginationOptions): Promise<PulledEntries>;
    pages(): Promise<PulledPages>;
    navigation(): Promise<PulledNavigation>;
    settings(): Promise<PulledSettings>;
    forms(): Promise<PulledForms>;
    theme(): Promise<PulledTheme>;
    footer(): Promise<PulledFooter>;
    venues(): Promise<PulledVenues>;
    eventCategories(): Promise<PulledEventCategories>;
    events(): Promise<PulledEvents>;
    courses(): Promise<PulledCourses>;
    all(): Promise<PulledContent>;
    /**
     * Get site configuration info from the CMS server.
     * Used to get values like Supabase URL for media sync without
     * requiring additional env vars on SDK sites.
     */
    siteInfo(): Promise<PulledSiteInfo>;
    /**
     * Get all content types for the site.
     * Returns key, name, hasPages, routePattern, and isSingleton for each type.
     */
    contentTypes(): Promise<PulledContentTypes>;
}
export interface BackfillPageResult {
    pagesUpdated: number;
    identifiersAssigned: Record<string, string>;
}
export interface BackfillBlockResult {
    blocksUpdated: number;
    identifiersAssigned: Record<string, string>;
}
export interface BackfillEntryResult {
    entriesUpdated: number;
    identifiersAssigned: Record<string, string>;
}
export interface BackfillResult {
    pages: BackfillPageResult;
    blocks: {
        total: number;
        byPage: Record<string, BackfillBlockResult>;
    };
    entries: BackfillEntryResult;
}
export interface IdentifiersOperations {
    /**
     * Backfill identifiers for pages, blocks, and entries that don't have one.
     * This is useful for migrating content created before the SDK was available.
     * The operation is idempotent - running it multiple times won't overwrite existing identifiers.
     */
    backfill(): Promise<BackfillResult>;
}
export interface MediaUploadResult {
    storagePath: string;
    status: 'created' | 'exists';
    assetId?: string;
    identifier?: string | null;
}
export interface MediaOperations {
    /**
     * Upload a media file to the target environment.
     * If the file already exists, returns success without re-uploading.
     */
    upload(file: {
        data: Buffer;
        filename: string;
        contentType: string;
        storagePath?: string;
        title?: string;
        identifier?: string;
    }): Promise<MediaUploadResult>;
    /**
     * Check if a media file exists at the given storage path.
     */
    exists(storagePath: string): Promise<boolean>;
    /**
     * Resolve media assets by identifiers or asset IDs.
     */
    resolve(input: {
        identifiers?: string[];
        assetIds?: string[];
    }): Promise<MediaResolveResponse>;
    /**
     * Find media assets by checksum for dedupe.
     */
    findByChecksum(checksums: string[]): Promise<ManagementMediaAsset[]>;
    /**
     * Assign or update a media identifier.
     */
    assignIdentifier(input: {
        assetId: string;
        identifier: string | null;
        force?: boolean;
    }): Promise<ManagementMediaAsset>;
}
export interface ManagementClient {
    entries: EntryOperations;
    pages: PageOperations;
    blocks: BlockOperations;
    navigation: NavigationOperations;
    settings: SettingsOperations;
    forms: FormOperations;
    theme: ThemeOperations;
    footer: FooterOperations;
    venues: VenueOperations;
    eventCategories: EventCategoryOperations;
    events: EventOperations;
    courses: CourseOperations;
    pull: PullOperations;
    identifiers: IdentifiersOperations;
    media: MediaOperations;
}
