import * as i0 from '@angular/core';
import { InjectionToken, EnvironmentProviders, WritableSignal, EventEmitter, Injector, Type, OnInit, OnDestroy, ElementRef, OnChanges, SimpleChanges } from '@angular/core';
import { ValidatorFn, FormGroup, FormBuilder, ControlValueAccessor, NgControl, Validator, AbstractControl, FormControl } from '@angular/forms';
import { HttpClient, HttpInterceptorFn } from '@angular/common/http';
import * as rxjs from 'rxjs';
import { Observable, Subject } from 'rxjs';
import { TranslocoService } from '@jsverse/transloco';
import { Toolbar, Editor } from 'ngx-editor';

interface TickeraComponentsConfig {
    apiUrl: string;
    accessTokenKey?: string;
}
declare const TICKERA_COMPONENTS_CONFIG: InjectionToken<TickeraComponentsConfig>;
declare function provideTickeraComponents(config: TickeraComponentsConfig): EnvironmentProviders;

declare const ALERT_BASE_CLASSES = "border rounded relative flex items-center gap-2 px-4 py-2";
declare const ALERT_COLOR_CLASSES: {
    success: string;
    error: string;
    warning: string;
    info: string;
};
declare const ALERT_SIZE_CLASSES: {
    xs: string;
    sm: string;
    md: string;
    lg: string;
};
declare const ALERT_ICONS: {
    success: string;
    error: string;
    warning: string;
    info: string;
};

declare const BUTTON_VARIANT_CLASSES: {
    primary: string;
    secondary: string;
    terciary: string;
    success: string;
    transparent: string;
};
declare const BASE_BUTTON_CLASSES: string;
declare const BUTTON_SIZES_CLASSES: {
    xs: string;
    sm: string;
    md: string;
    lg: string;
};

declare const FORM_ERROR_MESSAGES: Record<string, string>;

declare const BASE_INPUT_CLASSES: string;
declare const ERROR_INPUT_CLASSES: string;

declare const ADMIN_API_ROUTES: {
    FIND_ALL: string;
    CREATE: string;
    updateOne: (id: number) => string;
    deleteOne: (id: number) => string;
};

declare const CITY_API_ENDPOINTS: {
    findAll: string;
    create: string;
    findById: (id: number) => string;
    update: (id: number) => string;
    delete: (id: number) => string;
};

declare const COUNTRY_API_ENDPOINTS: {
    findAll: string;
    create: string;
    findById: (id: number) => string;
    update: (id: number) => string;
    delete: (id: number) => string;
};

declare const STATE_API_ENDPOINTS: {
    findAll: string;
    create: string;
    findById: (id: number) => string;
    update: (id: number) => string;
    delete: (id: number) => string;
};

declare const PERFORMANCES_API_ROUTES: {
    findAll: string;
    create: string;
    createBulk: string;
    findOneById: (id: number) => string;
    findOneBookingData: (id: number) => string;
    update: (id: number) => string;
    delete: (id: number) => string;
    deleteMany: string;
    cancel: (id: number) => string;
    publishInventory: (id: number) => string;
    reserve: (id: number) => string;
    ticketQrToken: (uuid: string) => string;
    getAvailableDays: string;
    publicAvailablePerformances: string;
};

declare const PRODUCTS_API_ROUTES: {
    FIND_ALL: string;
    CREATE: string;
    findOneById: (id: number) => string;
    update: (id: number) => string;
    delete: (id: number) => string;
};

declare const SHOWS_API_ROUTES: {
    findAll: string;
    create: string;
    findOneById: (id: number) => string;
    update: (id: number) => string;
    delete: (id: number) => string;
    getImages: (id: number) => string;
    uploadGallery: (id: number) => string;
    deleteOneImage: (showId: number, imageId: number) => string;
    publicAvailablePerformances: string;
};

declare const CUSTOMERS_API_ROUTES: {
    findAll: string;
    create: string;
    findOne: (id: number) => string;
    update: (id: number) => string;
    delete: (id: number) => string;
};

declare const PRICE_ZONES_API_ROUTES: {
    FIND_ALL: string;
    CREATE: string;
    findOneById: (id: number) => string;
    update: (id: number) => string;
    delete: (id: number) => string;
    updateElements: (id: number) => string;
    duplicate: (id: number) => string;
};

declare const VENUES_API_ROUTES: {
    findAll: string;
    create: string;
    findOneById: (id: number) => string;
    update: (id: number) => string;
    delete: (id: number) => string;
    getGallery: (id: number) => string;
    uploadGallery: (id: number) => string;
    deleteOneImage: (venueId: number, imageId: number) => string;
};

declare enum FileType {
    IMAGE = "image",
    PDF = "pdf",
    EXCEL = "excel",
    WORD = "word",
    TEXT = "text",
    DEFAULT = "default"
}

declare enum CouponApplicability {
    GENERAL = "GENERAL",
    CUSTOMER_EMAIL = "CUSTOMER_EMAIL",
    MEMBERSHIP_TYPE = "MEMBERSHIP_TYPE",
    SHOWS = "SHOWS",
    PERFORMANCES = "PERFORMANCES"
}

declare enum CouponDiscountType {
    PERCENTAGE = "PERCENTAGE",
    FIXED = "FIXED"
}

declare enum CorporateBondStatus {
    ACTIVE = "ACTIVE",
    INACTIVE = "INACTIVE",
    EXPIRED = "EXPIRED"
}

declare enum PerformanceStatus {
    ACTIVE = "active",
    CANCELLED = "cancelled",
    FINISHED = "finished",
    POSTPONED = "postponed"
}

declare enum PerformanceTicketStatus {
    AVAILABLE = "available",
    RESERVED = "reserved",
    SOLD = "sold",
    BLOCKED = "blocked"
}

declare enum RoomMapElementOrientation {
    TOP = "top",
    RIGHT = "right",
    BOTTOM = "bottom",
    LEFT = "left",
    CENTER = "center"
}

declare enum RoomMapElementType {
    SEAT_BLOCK = "seat_block",
    TABLE = "table",
    ZONE = "zone",
    EXIT = "exit",
    STAGE = "stage",
    PRODUCTION_AREA = "production_area",
    UNAVAILABLE_SPACE = "unavailable_space",
    STAIR = "stair",
    HALLWAY = "hallway"
}

declare enum OrderItemType {
    TICKET = "TICKET",
    PRODUCT = "PRODUCT"
}

declare enum OrderStatus {
    PENDING = "PENDING",
    COMPLETED = "COMPLETED",
    FAILED = "FAILED",
    CANCELLED = "CANCELLED"
}

interface RoomMapPosition {
    x: number;
    y: number;
}

interface RoomMapSize {
    width: number;
    height: number;
}

interface RoomMapBaseElement {
    id: string;
    type: RoomMapElementType;
    position: RoomMapPosition;
    size: RoomMapSize;
    rotation: number;
    name?: string;
    isLocked: boolean;
    isVisible: boolean;
    zIndex: number;
}

interface RoomMapExitElement extends RoomMapBaseElement {
    type: RoomMapElementType.EXIT;
    exitName?: string;
    exitType: 'emergency' | 'regular';
    width: number;
}

interface RoomMapProductionAreaElement extends RoomMapBaseElement {
    type: RoomMapElementType.PRODUCTION_AREA;
    areaName?: string;
    areaType: 'lighting' | 'sound' | 'backstage' | 'orchestra' | 'custom';
}

interface RoomMapSeatElement extends RoomMapBaseElement {
    type: RoomMapElementType.SEAT_BLOCK;
    seatNumber?: string;
    isAvailable: boolean;
    priceCategory?: string;
}

interface RoomMapStageElement extends RoomMapBaseElement {
    type: RoomMapElementType.STAGE;
    stageName?: string;
    orientation: RoomMapElementOrientation;
    isMainStage: boolean;
}

interface RoomMapTableElement extends RoomMapBaseElement {
    type: RoomMapElementType.TABLE;
    tableNumber?: string;
    capacity: number;
    shape: 'round' | 'rectangular' | 'square';
}

interface RoomMapUnavailableElement extends RoomMapBaseElement {
    type: RoomMapElementType.UNAVAILABLE_SPACE;
    reason?: string;
}

interface RoomMapZoneElement extends RoomMapBaseElement {
    type: RoomMapElementType.ZONE;
    zoneName: string;
    zoneType: 'vip' | 'general' | 'premium' | 'balcony' | 'custom';
    color: string;
    capacity?: number;
}

type RoomMapCanvasElement = RoomMapSeatElement | RoomMapTableElement | RoomMapZoneElement | RoomMapExitElement | RoomMapStageElement | RoomMapProductionAreaElement | RoomMapUnavailableElement;

type RoomMapSeatDisplayState = 'normal' | 'accessible' | 'non_existent';

interface SelectOption {
    value: any;
    label: string;
    disabled?: boolean;
}

interface Admin {
    id: number;
    username: string;
    email: string;
    mobile: string;
    password: string;
    first_name: string;
    last_name: string;
    fullname?: string;
    principal_role: string;
    is_verified: boolean;
    verification_token: string;
    reset_password_token: string;
    reset_password_expires: Date;
    email_verified_at: Date;
    last_login: Date;
    created_at: Date;
    updated_at: Date;
    deleted_at: Date;
}

interface Auditable {
    created_at: Date;
    updated_at: Date;
    is_published?: boolean;
    published_at?: Date;
    created_by_admin?: Admin;
    updated_by_admin?: Admin;
    published_by_admin?: Admin;
}

interface FileUploadConfig {
    allowedExtensions?: string[];
    maxFileSize?: number;
    multiple?: boolean;
    maxFiles?: number;
}

interface DynamicTableHeader {
    label: string;
    key: string;
}

interface UploadedFile {
    file: File;
    preview?: string;
    name: string;
    size: number;
    type: string;
    extension: string;
}

interface DeleteConfirmationOpen {
    title: string;
    resourceName: string;
    confirmationText: string;
}

interface AdminsResponse {
    statusCode: number;
    data: {
        admins: Admin[];
        total: number;
    };
    message: string;
}

interface Country {
    id: string;
    name: string;
    iso2: string;
}

interface State {
    id: string;
    name: string;
    country_id: number;
    country?: Country;
}

interface City {
    id: string;
    name: string;
    search_text: string | null;
    state_id: number;
    state?: State;
}

interface VenueImage {
    id: number;
    path: string;
    full_url: string;
    original_name: string;
    extension: string;
    size: number;
    mime_type: string;
    width: number;
    height: number;
    venue_id: number;
    created_at: Date;
}

interface Venue extends Auditable {
    id: number;
    name: string;
    address: string;
    description: string;
    phone: string;
    email: string;
    website: string;
    country_id: number;
    country: Country;
    state_id: number;
    state: State;
    city_id: number;
    city: City;
    front_image: string;
    images: VenueImage[];
}

interface HallFloor {
    id: number;
    name: string;
    level: number;
    max_capacity: number;
    description: string;
    hall_id: number;
    created_at: Date;
    updated_at: Date;
    deleted_at: Date | null;
}

interface Hall {
    id: number;
    name: string;
    venue_id: number;
    venue?: Venue;
    hall_floors?: HallFloor[];
    created_at: Date;
    updated_at: Date;
    deleted_at: Date | null;
}

interface CountryResponse {
    data: Country;
    message: string;
    status: string;
}

interface CountriesResponse {
    data: {
        countries: Country[];
        total: number;
    };
    message: string;
    status: string;
}

interface StateResponse {
    data: State;
    message: string;
    status: string;
}

interface StatesResponse {
    data: {
        states: State[];
        total: number;
    };
    message: string;
    statusCode: number;
}

interface CityResponse {
    data: City;
    message: string;
    status: string;
}

interface CitiesResponse {
    data: {
        cities: City[];
        total: number;
    };
    message: string;
    status: string;
}

interface FetchCitiesParams {
    stateId?: number;
    page?: number;
    search?: string;
}

interface Customer {
    username: string;
    email: string;
    mobile: string;
    is_verified: false;
    verification_token: string | null;
    principal_role: string;
    provider: string | null;
    provider_id: string | null;
    first_name: string | null;
    last_name: string | null;
    fullname?: string | null;
    birthday_date: Date | null;
    document_type: string | null;
    document_number: number | string | null;
    address: string | null;
    postal_code: string | null;
    country_id: number | null;
    city_id: number | null;
    state_id: number | null;
    phone: string | null;
    verification_token_expires: Date | null;
    preferences: string | null;
    metadata: string | null;
    reset_password_token: string | null;
    reset_password_expires: Date | null;
    email_verified_at: Date | null;
    last_login: Date | null;
    membership_expires_at: Date | null;
    id: number;
    is_active: boolean;
    created_at: Date;
    updated_at: Date;
    deleted_at: Date | null;
}

interface CustomerResponse {
    statusCode: number;
    data: Customer;
    message: string;
}

interface CustomersResponse {
    statusCode: number;
    data: {
        customers: Customer[];
        total: number;
    };
    message: string;
}

type ShowType = 'play' | 'musical' | 'concert' | 'dance' | 'opera' | 'comedy' | 'other';

interface ShowImage {
    id: number;
    path: string;
    full_url: string;
    original_name: string;
    extension: string;
    size: number;
    mime_type: string;
    width: number;
    height: number;
    show_id: number;
    created_at: Date;
}

interface Show extends Auditable {
    id: number;
    title: string;
    slug: string;
    description: string;
    duration_minutes: number | null;
    type_of_costs: string | null;
    service_fee: number | null;
    show_type: ShowType | null;
    pulep: string | null;
    minimum_age: number | null;
    show_category_id: number | null;
    default_room_map_id: number | null;
    published_at?: Date;
    is_published: boolean;
    images: ShowImage[];
    terms_and_conditions: string;
    performances_quantity?: number;
}

interface ShowResponse {
    statusCode: number;
    data: Show;
    message: string;
}

interface ShowsResponseInterface {
    statusCode: number;
    data: {
        shows: Show[];
        total: number;
    };
    message: string;
}

interface FetchShowsParams {
    page?: number;
    limit?: number;
    search?: string;
    date?: string;
}

interface PriceZone {
    id: number;
    name: string;
    color: string;
    normal_price: number | null;
    is_active: boolean;
    elements: any[];
    room_map_id: number | null;
    created_at: Date;
    updated_at: Date;
    created_by: number;
    updated_by: number;
}

interface Product extends Auditable {
    id: number;
    name: string;
    description?: string;
    short_description?: string;
    price: number;
    stock_quantity: number;
    slug: string;
    sku?: string;
    is_limited_edition: boolean;
    is_active: boolean;
    deleted_at: Date | null;
    categories?: any[];
    tags?: any[];
    types?: any[];
    images?: any[];
}

interface NumerationConfig {
    start_row_letter: string;
    row_order: 'TOP_TO_BOTTOM' | 'BOTTOM_TO_TOP';
    start_column_number: number;
    column_order: 'LEFT_TO_RIGHT' | 'RIGHT_TO_LEFT';
}

interface RoomMapSeatState {
    is_accessible: boolean;
    is_non_existent: boolean;
}

interface RoomMapElementTemplate {
    id?: number;
    type: RoomMapElementType;
    name: string;
    element_name?: string;
    show_element_name?: boolean;
    icon?: string;
    color?: string;
    total_capacity?: number;
    normal_price?: number | null;
    presale_price?: number | null;
    presale_start_date?: Date | null;
    presale_end_date?: Date | null;
    konva_shape?: any;
    hall_floor_id?: number;
    hall_floor?: HallFloor;
    numeration_config?: NumerationConfig;
    seats?: RoomMapSeatState[][];
    room_map?: RoomMap;
    price_zone_id?: number;
    price_zone?: PriceZone;
}

interface RoomMap {
    id: number;
    name: string;
    canvas_settings: {
        width: number;
        height: number;
        background_color?: string;
    };
    elements: Array<RoomMapElementTemplate>;
    hall_id: number;
    hall_name?: string;
    hall: Hall;
    price_zones: PriceZone[];
    related_product_ids: number[];
    products?: Product[];
    venue_name?: string;
    created_at: Date;
    updated_at: Date;
}

interface RoomMapCanvasConfiguration {
    id: string;
    name: string;
    description?: string;
    width: number;
    height: number;
    gridSize: number;
    showGrid: boolean;
    snapToGrid: boolean;
    elements: RoomMapCanvasElement[];
    metadata: {
        createdAt: Date;
        updatedAt: Date;
        version: string;
    };
}

interface RoomMapChairPosition {
    position: RoomMapPosition;
    isOccupied: boolean;
}

interface RoomMapGridPosition {
    row: number;
    column: number;
}

interface DragDropEvent {
    element: RoomMapCanvasElement;
    newPosition: RoomMapPosition;
    oldPosition: RoomMapPosition;
}

interface ElementPropertiesTab {
    id: string;
    label: string;
    elements_access: string[];
}

interface Performance {
    id: number;
    start_time: Date | string;
    end_time: Date | string;
    status: PerformanceStatus;
    published: boolean;
    show_id: number;
    show?: Show;
    room_map: RoomMap;
    room_map_id: number;
    created_at: Date;
    updated_at: Date;
}

interface PerformanceResponse {
    statusCode: number;
    data: Performance;
    message: string;
}

interface PerformancesResponseInterface {
    statusCode: number;
    data: {
        performances: Performance[];
        total: number;
    };
    message: string;
}

interface OrderItem {
    id: number;
    order: Order;
    item_type: OrderItemType;
    item_id: number;
    description: string;
    quantity: number;
    unit_price: number;
    normal_price: number;
    discounted_price: number;
    ticket_id?: number;
    ticket_uuid?: string;
    item: Show | Product;
    created_at: Date;
    updated_at: Date;
    created_by: number;
    updated_by: number;
}

interface Coupon extends Auditable {
    id: number;
    code: string;
    description?: string;
    discount_type: CouponDiscountType;
    discount_type_string?: string;
    discount_value: number;
    discount_value_string?: string;
    start_date: Date | null;
    end_date: Date | null;
    max_uses: number | null;
    max_uses_per_user?: number | null;
    uses_count: number;
    is_active: boolean;
    applicability_type: CouponApplicability;
    applicable_customer_emails: string[] | null;
    applicable_membership_types: string[] | null;
    applicable_show_ids: number[] | null;
    applicable_performance_ids?: number[];
    applicable_price_zone_ids?: number[];
    applies_to_service_fee?: boolean;
}

interface CorporateBond {
    id: number;
    name: string;
    description?: string;
    company_nit: string;
    prefix: string;
    suffix: string;
    quantity: number;
    status: CorporateBondStatus;
    value: number;
    codes: CorporateBondCode[];
    created_at: Date;
    updated_at: Date;
    created_by: number;
    updated_by: number;
}

interface CorporateBondCode {
    id: number;
    corporate_bond: CorporateBond;
    corporate_bond_id: number;
    code: string;
    is_used: boolean;
    used_at: Date | null;
    created_at: Date;
}

interface CorporateBondResponse {
    statusCode: number;
    data: CorporateBond;
    message: string;
}

interface ValidateCorporateBondResponse {
    data: {
        valid: boolean;
        message: string;
        code: string;
        bond?: CorporateBond;
    };
    message: string;
    statusCode: number;
}

interface Order {
    id: number;
    uuid: string;
    customer: Customer;
    customer_name?: string;
    customer_email?: string;
    order_items: OrderItem[];
    order_items_quantity?: number;
    discount_amount: number;
    total: number;
    total_discounted: number;
    sub_total: number;
    sub_total_discounted: number;
    service_fee: number;
    service_fee_discounted: number;
    coupon: Coupon;
    coupon_snapshot: Record<string, any>;
    corporate_bond_code: CorporateBondCode;
    corporate_bond_code_snapshot: Record<string, any>;
    status: OrderStatus;
    show_snapshot: Record<string, any>;
    performance_snapshot: Record<string, any>;
    created_at: Date;
    updated_at: Date;
    payment_method: string;
    terms_accepted: boolean;
    data_processing_accepted: boolean;
    billing_info: Partial<Customer>;
    comments: string;
    address_notes: string;
    created_by: number;
    updated_by: number;
}

interface OrderResponse {
    statusCode: number;
    data: Order;
    message: string;
}

interface OrdersResponse {
    statusCode: number;
    data: {
        orders: Order[];
        total: number;
    };
    message: string;
}

interface PerformanceTicket {
    id: number;
    uuid: string;
    is_accessible: boolean;
    performance_id: number;
    room_map_element_id: number;
    element_type: RoomMapElementType;
    seat_label: string | null;
    seat_numeration: string | null;
    normal_price: number;
    discount_price: number | null;
    presale_price: number | null;
    status: PerformanceTicketStatus;
    reserved_until: Date | null;
    order_id: number | null;
    customer_id: number | null;
    checked_in: boolean;
    checked_in_at: Date | null;
    order_items: OrderItem[];
    element_qty?: number;
    created_at: Date;
    updated_at: Date;
}

interface PerformanceBookingDataResponse {
    statusCode: number;
    data: {
        performance: Performance;
        room_map: RoomMap;
        show: Show;
        tickets: PerformanceTicket[];
    };
    message: string;
}

interface PerformanceAvailableDay {
    date: string;
    count: number;
}
interface PerformancesAvailableDaysResponse {
    statusCode: number;
    data: {
        days: PerformanceAvailableDay[];
    };
    message: string;
}

interface DailyPerformanceHall {
    name: string | null;
}

interface DailyPerformanceShow {
    id: number;
    title: string;
    slug: string;
    images: ShowImage[];
}

interface DailyPerformanceVenue {
    name: string | null;
    address: string | null;
    email: string | null;
}

interface DailyPerformancePriceZone {
    id: number;
    name: string;
    color: string | null;
    normal_price: number | null;
}

interface DailyPerformanceItem {
    id: number;
    start_time: Date;
    available_tickets_count: number;
    show: DailyPerformanceShow;
    hall: DailyPerformanceHall;
    venue: DailyPerformanceVenue;
    price_zones: DailyPerformancePriceZone[];
    zone_price_cheapest: number | null;
}

interface DailyPerformancesResponse {
    data: {
        performances: DailyPerformanceItem[];
        total: number;
    };
    message: string;
    statusCode: number;
}

interface FetchDailyPerformancesParams {
    date: string;
    page?: number;
    search?: string;
    show_id?: number;
    limit?: number;
}

interface ProductResponse {
    statusCode: number;
    data: Product;
    message: string;
}

interface ProductsResponseInterface {
    statusCode: number;
    data: {
        products: Product[];
        total: number;
    };
    message: string;
}

interface PriceZoneResponse {
    statusCode: number;
    data: PriceZone;
    message: string;
}

interface PriceZoneUpdateResponse {
    statusCode: number;
    data: {
        elements: any[];
        price_zone: PriceZone;
    };
    message: string;
}

interface PriceZonesResponseInterface {
    statusCode: number;
    data: {
        price_zones: PriceZone[];
        total: number;
    };
    message: string;
}

interface FindAllPriceZoneParams {
    roomMapId?: number;
    page?: number;
    search?: string;
    limit?: number;
}

interface CouponResponse {
    statusCode: number;
    data: Coupon;
    message: string;
}

interface ValidateCouponResponse {
    data: {
        coupon: Coupon;
        message: string;
    };
}

declare const getCustomerFullname: (customer: Customer) => string;

declare function parseJsonToFormDataAdvanced(imageGallery: any[]): FormData;

declare const transformImageToFile: (image: ShowImage | VenueImage) => UploadedFile;

declare const formatCitiesResponseToSelect: (res: CitiesResponse) => {
    value: string;
    label: string;
}[];

declare function MinTodayValidator(controlName: string): ValidatorFn;
declare function EndDateGreaterThanStartValidator(startDateControlName: string, endDateControlName: string): ValidatorFn;

declare function MustMatchValidator(controlName: string, matchingControlName: string): ValidatorFn;

declare class ApiService {
    private http;
    private platformId;
    private config;
    private apiUrl;
    constructor(http: HttpClient, platformId: Object, config: TickeraComponentsConfig);
    private getHeaders;
    private validateContentType;
    private handleError;
    get<T>(path: string): Observable<T>;
    post<T>(path: string, body: any): Observable<T>;
    patch<T>(path: string, body: any): Observable<T>;
    put<T>(path: string, body: any): Observable<T>;
    delete<T>(path: string, body?: any): Observable<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiService>;
}

type ToastType = 'success' | 'error' | 'info';
declare class ToastService {
    show(message: string, type?: ToastType): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;
}

declare class LoadingModalService {
    title: WritableSignal<string>;
    isOpen: WritableSignal<boolean>;
    get modalIsOpen(): WritableSignal<boolean>;
    open(title?: string): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingModalService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoadingModalService>;
}

declare class DeleteConfirmationService {
    title: WritableSignal<string>;
    resourceName: WritableSignal<string>;
    confirmationText: WritableSignal<string>;
    isOpen: WritableSignal<boolean>;
    confirmDeleteCallback: (() => void) | null;
    get modalTitle(): WritableSignal<string>;
    get modalResourceName(): WritableSignal<string>;
    get modalConfirmationText(): WritableSignal<string>;
    get modalIsOpen(): WritableSignal<boolean>;
    open({ title, resourceName, confirmationText }: DeleteConfirmationOpen, confirmCallback?: () => void): void;
    close(): void;
    getConfirmDeleteCallback(): (() => void) | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<DeleteConfirmationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DeleteConfirmationService>;
}

declare class ChangePasswordFormService {
    resourceId: WritableSignal<number>;
    isCustomer: WritableSignal<boolean>;
    isAdmin: WritableSignal<boolean>;
    isOpen: WritableSignal<boolean>;
    get modalIsOpen(): WritableSignal<boolean>;
    get isCustomerMode(): WritableSignal<boolean>;
    get isAdminMode(): WritableSignal<boolean>;
    get resourceIdValue(): WritableSignal<number>;
    open(resourceId: number, isAdmin?: boolean): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChangePasswordFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ChangePasswordFormService>;
}

declare class DateService {
    private locale;
    constructor(locale: string);
    formatDate(date: Date, format?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DateService>;
}

declare class AdminService {
    private apiService;
    constructor(apiService: ApiService);
    fetchAdmins(page?: number, search?: string, limit?: number): Observable<AdminsResponse>;
    deleteOne(id: number): Observable<any>;
    createOne(data: any): Observable<any>;
    updateOne(id: number, data: any): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AdminService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AdminService>;
}

declare class CitiesService {
    private apiService;
    constructor(apiService: ApiService);
    fetchCities({ page, search, stateId }: FetchCitiesParams): Observable<CitiesResponse>;
    createOne(data: City): Observable<CityResponse>;
    updateOne(id: number, data: City): Observable<CityResponse>;
    deleteOne(id: number): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CitiesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CitiesService>;
}

declare class CountryService {
    private apiService;
    constructor(apiService: ApiService);
    fetchCountries(page?: number, search?: string): Observable<CountriesResponse>;
    createOne(data: Country): Observable<CountryResponse>;
    updateOne(id: number, data: Country): Observable<CountryResponse>;
    deleteOne(id: number): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CountryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CountryService>;
}

declare class StatesService {
    private apiService;
    constructor(apiService: ApiService);
    fetchStates(page?: number, search?: string, countryId?: number): Observable<StatesResponse>;
    fetchStatesByCountryId(countryId: number): Observable<StatesResponse>;
    createOne(data: State): Observable<StateResponse>;
    updateOne(id: number, data: State): Observable<StateResponse>;
    deleteOne(id: number): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<StatesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StatesService>;
}

declare class PerformanceService {
    private apiService;
    private performancesSubject;
    performances$: Observable<Performance[]>;
    constructor(apiService: ApiService);
    fetchPerformances(showId?: number, search?: string): Observable<PerformancesResponseInterface>;
    fetchDailyPerformances({ show_id, search, limit, date, }: FetchDailyPerformancesParams): Observable<DailyPerformancesResponse>;
    loadPerformances({ showId, search }?: {
        showId?: number;
        search?: string;
    }): void;
    getCurrentPerformances(): Performance[];
    fetchOneById(id: number): Observable<PerformanceResponse>;
    fetchOneBookingData(id: number): Observable<PerformanceBookingDataResponse>;
    fetchAvailableDays(params?: {
        show_id?: number;
    }): Observable<PerformancesAvailableDaysResponse>;
    createOne(data: Performance): Observable<any>;
    createMany(data: Partial<Performance>[]): Observable<any>;
    updateOne(id: number, data: any): Observable<PerformanceResponse>;
    deleteOne(id: number): Observable<any>;
    deleteMany(ids: number[]): Observable<any>;
    cancelPerformance(id: number, notifyUsers: boolean): Observable<any>;
    publishInvenotry(id: number): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PerformanceService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PerformanceService>;
}

declare class ProductService {
    private apiService;
    private productsSubject;
    products$: Observable<Product[]>;
    constructor(apiService: ApiService);
    fetchProducts(page: number, search: string): Observable<ProductsResponseInterface>;
    loadProducts({ page, search }?: {
        page?: number;
        search?: string;
    }): void;
    getCurrentProducts(): Product[];
    fetchOneById(id: number): Observable<ProductResponse>;
    createOne(data: Product): Observable<any>;
    updateOne(id: number, data: any): Observable<ProductResponse>;
    deleteOne(id: number): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProductService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ProductService>;
}

declare class ShowService {
    private apiService;
    private showsSubject;
    shows$: Observable<Show[]>;
    constructor(apiService: ApiService);
    loadShows({ page, search }?: FetchShowsParams): void;
    getCurrentShows(): Show[];
    fetchShows({ limit, page, search }: FetchShowsParams): Observable<ShowsResponseInterface>;
    fetchAvailableShows({ date, limit, page, search, }: FetchShowsParams): Observable<ShowsResponseInterface>;
    fetchOneById(id: number): Observable<ShowResponse>;
    createOne(data: Show): Observable<ShowResponse>;
    updateOne(id: number, data: any): Observable<ShowResponse>;
    deleteOne(id: number): Observable<any>;
    fetchImages(id: number): Observable<{
        data: ShowImage[];
    }>;
    uploadImages(id: number, files?: FormData): Observable<{
        data: ShowImage[];
    }>;
    deleteOneImage(showId: number, imageId: number): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShowService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ShowService>;
}

declare class CustomerService {
    private apiService;
    constructor(apiService: ApiService);
    createOne(data: Customer): Observable<CustomerResponse>;
    fetchCustomers(page: number, search: string, limit?: number): Observable<CustomersResponse>;
    fetchOneById(id: number): Observable<CustomerResponse>;
    updateOne(id: number, data: any): Observable<CustomerResponse>;
    deleteOne(id: number): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CustomerService>;
}

declare class PriceZoneService {
    private apiService;
    private priceZonesSubject;
    priceZones$: Observable<PriceZone[]>;
    constructor(apiService: ApiService);
    fetchPriceZones({ roomMapId, page, search, limit, }?: FindAllPriceZoneParams): Observable<PriceZonesResponseInterface>;
    loadPriceZones({ roomMapId, page, search, limit }?: FindAllPriceZoneParams): void;
    getCurrentPriceZones(): PriceZone[];
    fetchOneById(id: number): Observable<PriceZoneResponse>;
    createOne(data: PriceZone): Observable<any>;
    duplicateOne(id: number, name: string): Observable<any>;
    updateOne(id: number, data: any): Observable<PriceZoneUpdateResponse>;
    deleteOne(id: number): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PriceZoneService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PriceZoneService>;
}

declare class PriceZoneEventService {
    private priceZoneDeleted$;
    private priceZoneSaved$;
    private _selectedPriceZone;
    readonly selectedPriceZone$: rxjs.Observable<PriceZone | null>;
    onPriceZoneDeleted(): void;
    getPriceZoneDeleted(): rxjs.Observable<void>;
    onPriceZoneSaved(): void;
    getPriceZoneSaved(): rxjs.Observable<void>;
    setSelectedPriceZone(priceZone: PriceZone | null): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PriceZoneEventService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PriceZoneEventService>;
}

declare class PriceZoneFormModalService {
    private priceZoneEventService;
    priceZone: WritableSignal<PriceZone | null>;
    isOpen: WritableSignal<boolean>;
    constructor(priceZoneEventService: PriceZoneEventService);
    get modalIsOpen(): WritableSignal<boolean>;
    get currentPriceZone(): WritableSignal<PriceZone | null>;
    open(priceZone?: PriceZone | null): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PriceZoneFormModalService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PriceZoneFormModalService>;
}

declare const authInterceptor: HttpInterceptorFn;

declare class AppButtonComponent {
    clicked: EventEmitter<void>;
    disabled: boolean;
    loading: boolean;
    type: 'button' | 'submit';
    variant: 'primary' | 'secondary' | 'terciary' | 'success' | 'transparent';
    text: string;
    size: 'xs' | 'sm' | 'md' | 'lg';
    loadingText: string;
    icon: string;
    handleClick(): void;
    get buttonClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AppButtonComponent, "app-button", never, { "disabled": { "alias": "disabled"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "type": { "alias": "type"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "text": { "alias": "text"; "required": false; }; "size": { "alias": "size"; "required": false; }; "loadingText": { "alias": "loadingText"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}

declare class AppLinkButtonComponent {
    protected readonly BASE_BUTTON_CLASSES: string;
    disabled: boolean;
    loading: boolean;
    target: '_blank' | '_self' | '_parent' | '_top';
    text: string;
    icon: string;
    loadingText: string;
    route: string;
    queryParams: Record<string, any>;
    size: 'xs' | 'sm' | 'md' | 'lg';
    variant: 'primary' | 'secondary' | 'terciary' | 'success' | 'transparent';
    get buttonClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppLinkButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AppLinkButtonComponent, "app-link-button", never, { "disabled": { "alias": "disabled"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "target": { "alias": "target"; "required": false; }; "text": { "alias": "text"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "loadingText": { "alias": "loadingText"; "required": false; }; "route": { "alias": "route"; "required": false; }; "queryParams": { "alias": "queryParams"; "required": false; }; "size": { "alias": "size"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, {}, never, never, true, never>;
}

declare class AppAlertComponent {
    type: 'success' | 'error' | 'warning' | 'info';
    text: string;
    closeable: boolean;
    size: 'xs' | 'sm' | 'md' | 'lg';
    get alertColorClasses(): string;
    get alertSizeClasses(): string;
    get alertClasses(): string;
    get alertIcon(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppAlertComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AppAlertComponent, "app-alert", never, { "type": { "alias": "type"; "required": false; }; "text": { "alias": "text"; "required": false; }; "closeable": { "alias": "closeable"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LoadingmModalComponent {
    private loadingModalService;
    constructor(loadingModalService: LoadingModalService);
    get isOpen(): i0.WritableSignal<boolean>;
    get title(): i0.WritableSignal<string>;
    closeModal(): void;
    onCitySaved(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingmModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingmModalComponent, "loading-modal", never, {}, {}, never, never, true, never>;
}

declare class DeleteConfirmationComponent {
    private fb;
    private deleteConfirmationService;
    protected transloco: TranslocoService;
    deleteConfirmationForm: FormGroup;
    constructor(fb: FormBuilder, deleteConfirmationService: DeleteConfirmationService, transloco: TranslocoService);
    get title(): string;
    get resourceName(): string;
    get confirmationText(): string;
    get isOpen(): i0.WritableSignal<boolean>;
    get isConfirmationValid(): boolean;
    onCloseModal(): void;
    onConfirmDelete(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DeleteConfirmationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DeleteConfirmationComponent, "delete-confirmation", never, {}, {}, never, never, true, never>;
}

declare class AppModalComponent {
    title: string;
    disableClose: boolean;
    isOpen: WritableSignal<boolean>;
    size: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl';
    closeModal: EventEmitter<void>;
    onCloseModal(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AppModalComponent, "app-modal", never, { "title": { "alias": "title"; "required": false; }; "disableClose": { "alias": "disableClose"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "closeModal": "closeModal"; }, never, ["*"], true, never>;
}

declare class AuditInformationComponent {
    data: Auditable | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuditInformationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AuditInformationComponent, "app-audit-information", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
}

declare class DynamicTableComponent {
    private injector;
    constructor(injector: Injector);
    title: string;
    data: any[];
    headers: any[];
    columnComponents: {
        [key: string]: Type<any>;
    };
    isLoading: boolean;
    totalItems: number;
    itemsPerPage: number;
    currentPage: number;
    pageChange: EventEmitter<number>;
    searchChange: EventEmitter<string>;
    showPagination: boolean;
    showSearch: boolean;
    showTitle: boolean;
    get totalPages(): number;
    onSearch(event: any): void;
    changePage(delta: number): void;
    createInjector(row: any): Injector;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicTableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicTableComponent, "dynamic-table", never, { "title": { "alias": "title"; "required": false; }; "data": { "alias": "data"; "required": false; }; "headers": { "alias": "headers"; "required": false; }; "columnComponents": { "alias": "columnComponents"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; "totalItems": { "alias": "totalItems"; "required": false; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; "showPagination": { "alias": "showPagination"; "required": false; }; "showSearch": { "alias": "showSearch"; "required": false; }; "showTitle": { "alias": "showTitle"; "required": false; }; }, { "pageChange": "pageChange"; "searchChange": "searchChange"; }, never, never, true, never>;
}

declare class LanguageSwitcherComponent {
    protected transloco: TranslocoService;
    availableLangs: string[];
    constructor(transloco: TranslocoService);
    get activeLang(): string;
    switchLang(lang: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageSwitcherComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LanguageSwitcherComponent, "language-switcher", never, {}, {}, never, never, true, never>;
}

declare class FormInputComponent implements ControlValueAccessor {
    ngControl: NgControl;
    private transloco;
    label: string;
    type: string;
    name: string;
    id: string;
    placeholder: string;
    required: boolean;
    readonly: boolean;
    minlength: number | null;
    min: number | null;
    step: number | null;
    pattern: string | null;
    fieldGroupClass: string;
    autocomplete: boolean;
    value: any;
    disabled: boolean;
    onChange: any;
    onTouched: any;
    constructor(ngControl: NgControl, transloco: TranslocoService);
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    onInput(value: any): void;
    get inputId(): string;
    get showError(): boolean;
    get errorMessage(): string;
    get inputClasses(): string;
    get fieldGroupClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormInputComponent, [{ optional: true; self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormInputComponent, "form-input", never, { "label": { "alias": "label"; "required": false; }; "type": { "alias": "type"; "required": false; }; "name": { "alias": "name"; "required": false; }; "id": { "alias": "id"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "minlength": { "alias": "minlength"; "required": false; }; "min": { "alias": "min"; "required": false; }; "step": { "alias": "step"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "fieldGroupClass": { "alias": "fieldGroupClass"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FormSelectComponent implements ControlValueAccessor {
    ngControl: NgControl;
    private transloco;
    label: string;
    name: string;
    id: string;
    placeholder: string;
    required: boolean;
    disabled: boolean;
    readonly: boolean;
    options: SelectOption[];
    fieldGroupClass: string;
    showDefaultOption: boolean;
    defaultOptionLabel: string;
    value: any;
    onChange: any;
    onTouched: any;
    constructor(ngControl: NgControl, transloco: TranslocoService);
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    onSelectChange(value: any): void;
    get inputId(): string;
    get showError(): boolean;
    get errorMessage(): string;
    get resolvedDefaultOptionLabel(): string;
    get selectClasses(): string;
    get fieldGroupClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormSelectComponent, [{ optional: true; self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormSelectComponent, "form-select", never, { "label": { "alias": "label"; "required": false; }; "name": { "alias": "name"; "required": false; }; "id": { "alias": "id"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "options": { "alias": "options"; "required": false; }; "fieldGroupClass": { "alias": "fieldGroupClass"; "required": false; }; "showDefaultOption": { "alias": "showDefaultOption"; "required": false; }; "defaultOptionLabel": { "alias": "defaultOptionLabel"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FormTextareaComponent implements ControlValueAccessor {
    ngControl: NgControl;
    private transloco;
    label: string;
    name: string;
    id: string;
    placeholder: string;
    required: boolean;
    readonly: boolean;
    minlength: number | null;
    maxlength: number | null;
    rows: number;
    cols: number | null;
    fieldGroupClass: string;
    value: any;
    disabled: boolean;
    onChange: any;
    onTouched: any;
    constructor(ngControl: NgControl, transloco: TranslocoService);
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    onInput(value: any): void;
    get inputId(): string;
    get showError(): boolean;
    get errorMessage(): string;
    get inputClasses(): string;
    get fieldGroupClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormTextareaComponent, [{ optional: true; self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormTextareaComponent, "form-textarea", never, { "label": { "alias": "label"; "required": false; }; "name": { "alias": "name"; "required": false; }; "id": { "alias": "id"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "minlength": { "alias": "minlength"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "cols": { "alias": "cols"; "required": false; }; "fieldGroupClass": { "alias": "fieldGroupClass"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FormEditorComponent implements ControlValueAccessor, OnInit, OnDestroy {
    ngControl: NgControl;
    private transloco;
    label: string;
    name: string;
    id: string;
    placeholder: string;
    required: boolean;
    readonly: boolean;
    toolbar: Toolbar;
    fieldGroupClass: string;
    editor: Editor;
    value: string;
    disabled: boolean;
    onChange: any;
    onTouched: any;
    private subscription;
    constructor(ngControl: NgControl, transloco: TranslocoService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    get inputId(): string;
    get showError(): boolean;
    get errorMessage(): string;
    get fieldGroupClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormEditorComponent, [{ optional: true; self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormEditorComponent, "form-editor", never, { "label": { "alias": "label"; "required": false; }; "name": { "alias": "name"; "required": false; }; "id": { "alias": "id"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "toolbar": { "alias": "toolbar"; "required": false; }; "fieldGroupClass": { "alias": "fieldGroupClass"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ColorPickerComponent implements ControlValueAccessor {
    ngControl: NgControl;
    private elementRef;
    label: string;
    name: string;
    id: string;
    placeholder: string;
    required: boolean;
    readonly: boolean;
    fieldGroupClass: string;
    showPreview: boolean;
    presetColors: string[];
    colorChange: EventEmitter<string>;
    value: string;
    disabled: boolean;
    isDropdownOpen: boolean;
    onChange: any;
    onTouched: any;
    constructor(ngControl: NgControl, elementRef: ElementRef);
    onDocumentClick(event: MouseEvent): void;
    writeValue(value: string): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    onColorChange(color: string): void;
    onInputColorChange(event: Event): void;
    toggleDropdown(): void;
    selectPresetColor(color: string): void;
    get inputId(): string;
    get showError(): boolean;
    get inputClasses(): string;
    get fieldGroupClasses(): string;
    isValidHexColor(color: string): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPickerComponent, [{ optional: true; self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ColorPickerComponent, "color-picker", never, { "label": { "alias": "label"; "required": false; }; "name": { "alias": "name"; "required": false; }; "id": { "alias": "id"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "fieldGroupClass": { "alias": "fieldGroupClass"; "required": false; }; "showPreview": { "alias": "showPreview"; "required": false; }; "presetColors": { "alias": "presetColors"; "required": false; }; }, { "colorChange": "colorChange"; }, never, never, true, never>;
}

declare class DateInputComponent implements ControlValueAccessor {
    ngControl: NgControl;
    private transloco;
    label: string;
    type: string;
    includeTime: boolean;
    name: string;
    id: string;
    placeholder: string;
    required: boolean;
    readonly: boolean;
    min: string | null;
    max: string | null;
    fieldGroupClass: string;
    dateFormat: string;
    value: any;
    disabled: boolean;
    onChange: any;
    onTouched: any;
    constructor(ngControl: NgControl, transloco: TranslocoService);
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    onInput(value: any): void;
    private formatDateForInput;
    private parseDateFromString;
    get inputId(): string;
    get showError(): boolean;
    get errorMessage(): string;
    get inputClasses(): string;
    get fieldGroupClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateInputComponent, [{ optional: true; self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateInputComponent, "date-input", never, { "label": { "alias": "label"; "required": false; }; "type": { "alias": "type"; "required": false; }; "includeTime": { "alias": "includeTime"; "required": false; }; "name": { "alias": "name"; "required": false; }; "id": { "alias": "id"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "fieldGroupClass": { "alias": "fieldGroupClass"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ToggleSwitchComponent implements ControlValueAccessor {
    ngControl: NgControl;
    label: string;
    name: string;
    id: string;
    required: boolean;
    disabled: boolean;
    size: 'sm' | 'md' | 'lg';
    fieldGroupClass: string;
    description: string;
    toggleClick: EventEmitter<boolean>;
    value: boolean;
    onChange: any;
    onTouched: any;
    constructor(ngControl: NgControl);
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    onToggle(): void;
    get inputId(): string;
    get toggleSizeClasses(): string;
    get toggleThumbSizeClasses(): string;
    get toggleThumbTranslateClasses(): string;
    get fieldGroupClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleSwitchComponent, [{ optional: true; self: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleSwitchComponent, "toggle-switch", never, { "label": { "alias": "label"; "required": false; }; "name": { "alias": "name"; "required": false; }; "id": { "alias": "id"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "size": { "alias": "size"; "required": false; }; "fieldGroupClass": { "alias": "fieldGroupClass"; "required": false; }; "description": { "alias": "description"; "required": false; }; }, { "toggleClick": "toggleClick"; }, never, never, true, never>;
}

declare class FileUploadComponent implements ControlValueAccessor {
    ngControl: NgControl;
    private transloco;
    label: string;
    name: string;
    id: string;
    required: boolean;
    readonly: boolean;
    fieldGroupClass: string;
    config: FileUploadConfig;
    accept: string;
    fileSelected: EventEmitter<UploadedFile[]>;
    fileRemoved: EventEmitter<UploadedFile>;
    validationError: EventEmitter<string>;
    files: UploadedFile[];
    disabled: boolean;
    onChange: any;
    onTouched: any;
    dragOver: boolean;
    constructor(ngControl: NgControl, transloco: TranslocoService);
    writeValue(value: UploadedFile[] | null): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    onFileSelect(event: Event): void;
    onDrop(event: DragEvent): void;
    onDragOver(event: DragEvent): void;
    onDragLeave(event: DragEvent): void;
    private handleFiles;
    private validateFile;
    private getFileExtension;
    private isImage;
    private generateImagePreview;
    removeFile(index: number): void;
    getFileType(file: UploadedFile): FileType;
    getFileIcon(fileType: FileType): string;
    getFileTypeIcon(file: UploadedFile): string;
    triggerFileInput(): void;
    formatFileSize(bytes: number): string;
    get inputId(): string;
    get showError(): boolean;
    get errorMessage(): string;
    get fieldGroupClasses(): string;
    get uploadAreaClasses(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadComponent, [{ optional: true; self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileUploadComponent, "file-upload", never, { "label": { "alias": "label"; "required": false; }; "name": { "alias": "name"; "required": false; }; "id": { "alias": "id"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "fieldGroupClass": { "alias": "fieldGroupClass"; "required": false; }; "config": { "alias": "config"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; }, { "fileSelected": "fileSelected"; "fileRemoved": "fileRemoved"; "validationError": "validationError"; }, never, never, true, never>;
}

declare class FileUploadPreviewComponent {
    file: UploadedFile;
    remove: EventEmitter<UploadedFile>;
    removeFile(): void;
    getFileType(file: UploadedFile): FileType;
    getFileIcon(fileType: FileType): string;
    getFileTypeIcon(file: UploadedFile): string;
    formatFileSize(bytes: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadPreviewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileUploadPreviewComponent, "file-upload-preview", never, { "file": { "alias": "file"; "required": true; }; }, { "remove": "remove"; }, never, never, true, never>;
}

interface AsyncSelectConfig<T = any> {
    load: (params?: {
        search?: string;
        parentId?: number;
    }) => Observable<T>;
    map: (response: T) => SelectOption[];
}
declare class AsyncSelectComponent implements OnInit, OnDestroy, OnChanges, ControlValueAccessor {
    config?: AsyncSelectConfig<any>;
    items: SelectOption[];
    parentId?: number | null;
    label: string;
    placeholder: string;
    name: string;
    required: boolean;
    multiple: boolean;
    clearable: boolean;
    searchable: boolean;
    loading: boolean;
    virtualScroll: boolean;
    notFoundText: string;
    bindLabel: string;
    bindValue: string;
    value: any;
    onChange: any;
    onTouched: any;
    displayItems: SelectOption[];
    loadingSignal: i0.WritableSignal<boolean>;
    private searchTerm$;
    private destroy$;
    private injector;
    private _ngControl;
    constructor();
    private get ngControl();
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private setupSearch;
    private searchMode;
    private loadAndMap;
    private fetchData;
    private handleParentIdChange;
    onSearch(event: any): void;
    onSelectChange(value: any): void;
    get typeahead$(): Subject<string>;
    get showError(): boolean;
    get errorMessage(): string;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AsyncSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AsyncSelectComponent, "async-select", never, { "config": { "alias": "config"; "required": false; }; "items": { "alias": "items"; "required": false; }; "parentId": { "alias": "parentId"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "name": { "alias": "name"; "required": false; }; "required": { "alias": "required"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; }; "notFoundText": { "alias": "notFoundText"; "required": false; }; "bindLabel": { "alias": "bindLabel"; "required": false; }; "bindValue": { "alias": "bindValue"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ChangePasswordFormComponent {
    private fb;
    private changePasswordFormService;
    private customerService;
    private adminService;
    private toastService;
    private transloco;
    changePasswordForm: FormGroup;
    loading: WritableSignal<boolean>;
    constructor(fb: FormBuilder, changePasswordFormService: ChangePasswordFormService, customerService: CustomerService, adminService: AdminService, toastService: ToastService, transloco: TranslocoService);
    get isOpen(): WritableSignal<boolean>;
    get resourceId(): WritableSignal<number>;
    onCloseModal(): void;
    onConfirmDelete(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChangePasswordFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChangePasswordFormComponent, "change-password-form", never, {}, {}, never, never, true, never>;
}

declare class AdminSelectComponent implements OnInit, OnDestroy, ControlValueAccessor, Validator {
    private platformId;
    private adminService;
    label: string;
    placeholder: string;
    name: string;
    required: boolean;
    readonly: boolean;
    showError: boolean;
    customClass: string;
    control?: AbstractControl | null;
    adminChange: EventEmitter<number | null>;
    admins: WritableSignal<SelectOption[]>;
    loading: WritableSignal<boolean>;
    private destroy$;
    value: number | null;
    onChange: any;
    onTouched: any;
    constructor(platformId: string, adminService: AdminService);
    ngOnInit(): void;
    get formControl(): FormControl;
    ngOnDestroy(): void;
    loadAdmins(): void;
    onAdminSelected(event: Event): void;
    writeValue(value: number | null): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    validate(control: FormControl): {
        required: boolean;
    } | null;
    get isInvalid(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<AdminSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AdminSelectComponent, "admin-select", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "name": { "alias": "name"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "showError": { "alias": "showError"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "control": { "alias": "control"; "required": false; }; }, { "adminChange": "adminChange"; }, never, never, true, never>;
}

declare class CitySelectComponent implements OnInit, OnDestroy, OnChanges, ControlValueAccessor, Validator {
    private citiesService;
    label: string;
    name: string;
    placeholder: string;
    required: boolean;
    disabled: boolean;
    readonly: boolean;
    stateId: number | null;
    showError: boolean;
    customClass: string;
    control?: AbstractControl | null;
    cityChange: EventEmitter<number | null>;
    cities: WritableSignal<SelectOption[]>;
    loading: boolean;
    private destroy$;
    value: number | null;
    onChange: any;
    onTouched: any;
    constructor(citiesService: CitiesService);
    get formControl(): FormControl;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    loadCities(): void;
    onCitySelected(event: Event): void;
    writeValue(value: number | null): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    validate(control: FormControl): {
        required: boolean;
    } | null;
    get isInvalid(): boolean;
    get isDisabled(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<CitySelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CitySelectComponent, "city-select", never, { "label": { "alias": "label"; "required": false; }; "name": { "alias": "name"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "stateId": { "alias": "stateId"; "required": false; }; "showError": { "alias": "showError"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "control": { "alias": "control"; "required": false; }; }, { "cityChange": "cityChange"; }, never, never, true, never>;
}

declare class CountrySelectComponent implements OnInit, OnDestroy, ControlValueAccessor, Validator {
    private platformId;
    private countryService;
    label: string;
    placeholder: string;
    name: string;
    required: boolean;
    readonly: boolean;
    showError: boolean;
    customClass: string;
    control?: AbstractControl | null;
    countryChange: EventEmitter<number | null>;
    countries: WritableSignal<SelectOption[]>;
    loading: WritableSignal<boolean>;
    private destroy$;
    value: number | null;
    onChange: any;
    onTouched: any;
    constructor(platformId: string, countryService: CountryService);
    ngOnInit(): void;
    get formControl(): FormControl;
    ngOnDestroy(): void;
    loadCountries(): void;
    onCountrySelected(event: Event): void;
    writeValue(value: number | null): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    validate(control: FormControl): {
        required: boolean;
    } | null;
    get isInvalid(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<CountrySelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CountrySelectComponent, "country-select", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "name": { "alias": "name"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "showError": { "alias": "showError"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "control": { "alias": "control"; "required": false; }; }, { "countryChange": "countryChange"; }, never, never, true, never>;
}

declare class StateSelectComponent implements OnInit, OnDestroy, OnChanges, ControlValueAccessor, Validator {
    private statesService;
    label: string;
    name: string;
    placeholder: string;
    required: boolean;
    readonly: boolean;
    countryId: number | null;
    showError: boolean;
    customClass: string;
    control?: AbstractControl | null;
    stateChange: EventEmitter<number | null>;
    states: WritableSignal<SelectOption[]>;
    loading: boolean;
    private destroy$;
    value: number | null;
    onChange: any;
    onTouched: any;
    constructor(statesService: StatesService);
    ngOnInit(): void;
    get formControl(): FormControl;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    loadStates(): void;
    onStateSelected(event: Event): void;
    writeValue(value: number | null): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    validate(control: FormControl): {
        required: boolean;
    } | null;
    get isInvalid(): boolean;
    get isDisabled(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<StateSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StateSelectComponent, "state-select", never, { "label": { "alias": "label"; "required": false; }; "name": { "alias": "name"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "countryId": { "alias": "countryId"; "required": false; }; "showError": { "alias": "showError"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "control": { "alias": "control"; "required": false; }; }, { "stateChange": "stateChange"; }, never, never, true, never>;
}

declare class CustomerSelectComponent implements ControlValueAccessor, Validator {
    private customerService;
    label: string;
    placeholder: string;
    name: string;
    required: boolean;
    readonly: boolean;
    multiple: boolean;
    customerChange: EventEmitter<number | null>;
    value: number | null;
    onChange: any;
    onTouched: any;
    config: AsyncSelectConfig;
    constructor(customerService: CustomerService);
    onInternalChange(value: any): void;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    validate(control: FormControl): {
        required: boolean;
    } | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomerSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CustomerSelectComponent, "customer-select", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "name": { "alias": "name"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; }, { "customerChange": "customerChange"; }, never, never, true, never>;
}

declare class PerformanceSelectComponent implements OnInit, OnDestroy, ControlValueAccessor, Validator {
    private platformId;
    private performanceService;
    label: string;
    placeholder: string;
    name: string;
    required: boolean;
    readonly: boolean;
    showError: boolean;
    customClass: string;
    control?: AbstractControl | null;
    performanceChange: EventEmitter<number | null>;
    performances: WritableSignal<SelectOption[]>;
    loading: WritableSignal<boolean>;
    searchTerm: string;
    private searchSubject;
    private destroy$;
    value: number | null;
    onChange: any;
    onTouched: any;
    constructor(platformId: string, performanceService: PerformanceService);
    ngOnInit(): void;
    get formControl(): FormControl;
    ngOnDestroy(): void;
    onSearchChange(search: string): void;
    onPerformanceSelected(event: Event): void;
    writeValue(value: number | null): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    validate(control: FormControl): {
        required: boolean;
    } | null;
    get isInvalid(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<PerformanceSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PerformanceSelectComponent, "performance-select", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "name": { "alias": "name"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "showError": { "alias": "showError"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "control": { "alias": "control"; "required": false; }; }, { "performanceChange": "performanceChange"; }, never, never, true, never>;
}

declare class PerformanceMultiSelectComponent implements OnInit, OnDestroy, ControlValueAccessor {
    private platformId;
    private performanceService;
    label: string;
    placeholder: string;
    allPerformances: WritableSignal<SelectOption[]>;
    filteredPerformances: WritableSignal<SelectOption[]>;
    loading: WritableSignal<boolean>;
    selectedIds: number[];
    searchTerm: string;
    private searchSubject;
    private destroy$;
    onChange: any;
    onTouched: any;
    constructor(platformId: string, performanceService: PerformanceService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private applyFilter;
    onSearchChange(event: Event): void;
    isSelected(id: number): boolean;
    togglePerformance(id: number): void;
    removePerformance(id: number): void;
    getPerformanceLabel(id: number): string;
    writeValue(value: number[] | null): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PerformanceMultiSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PerformanceMultiSelectComponent, "performance-multi-select", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ProductSelectComponent implements OnInit, OnDestroy, ControlValueAccessor, Validator {
    private platformId;
    private productService;
    label: string;
    placeholder: string;
    name: string;
    required: boolean;
    readonly: boolean;
    showError: boolean;
    customClass: string;
    control?: AbstractControl | null;
    productChange: EventEmitter<number | null>;
    products: WritableSignal<SelectOption[]>;
    loading: WritableSignal<boolean>;
    searchTerm: string;
    private searchSubject;
    private destroy$;
    value: number | null;
    onChange: any;
    onTouched: any;
    constructor(platformId: string, productService: ProductService);
    ngOnInit(): void;
    get formControl(): FormControl;
    ngOnDestroy(): void;
    onSearchChange(search: string): void;
    onProductSelected(event: Event): void;
    writeValue(value: number | null): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    validate(control: FormControl): {
        required: boolean;
    } | null;
    get isInvalid(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProductSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProductSelectComponent, "product-select", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "name": { "alias": "name"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "showError": { "alias": "showError"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "control": { "alias": "control"; "required": false; }; }, { "productChange": "productChange"; }, never, never, true, never>;
}

interface ProductOption {
    value: number;
    label: string;
    imageUrl: string | null;
}
declare class ProductMultiSelectComponent implements OnInit, OnDestroy, ControlValueAccessor {
    private platformId;
    private productService;
    label: string;
    placeholder: string;
    set initialSelection(ids: number[] | null);
    selectionChange: EventEmitter<number[]>;
    allProducts: WritableSignal<ProductOption[]>;
    filteredProducts: WritableSignal<ProductOption[]>;
    loading: WritableSignal<boolean>;
    selectedIds: number[];
    searchTerm: string;
    private searchSubject;
    private destroy$;
    onChange: any;
    onTouched: any;
    constructor(platformId: string, productService: ProductService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private applyFilter;
    onSearchChange(event: Event): void;
    isSelected(id: number): boolean;
    toggleProduct(id: number): void;
    removeProduct(id: number): void;
    getProductOption(id: number): ProductOption | undefined;
    writeValue(value: number[] | null): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProductMultiSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProductMultiSelectComponent, "product-multi-select", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "initialSelection": { "alias": "initialSelection"; "required": false; }; }, { "selectionChange": "selectionChange"; }, never, never, true, never>;
}

declare class ShowSelectComponent implements OnInit, OnDestroy, ControlValueAccessor, Validator {
    private platformId;
    private showService;
    label: string;
    placeholder: string;
    name: string;
    required: boolean;
    readonly: boolean;
    showError: boolean;
    customClass: string;
    control?: AbstractControl | null;
    showChange: EventEmitter<number | null>;
    shows: WritableSignal<SelectOption[]>;
    loading: WritableSignal<boolean>;
    searchTerm: string;
    private searchSubject;
    private destroy$;
    value: number | null;
    onChange: any;
    onTouched: any;
    constructor(platformId: string, showService: ShowService);
    ngOnInit(): void;
    get formControl(): FormControl;
    ngOnDestroy(): void;
    onSearchChange(search: string): void;
    onShowSelected(event: Event): void;
    writeValue(value: number | null): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    validate(control: FormControl): {
        required: boolean;
    } | null;
    get isInvalid(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShowSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ShowSelectComponent, "show-select", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "name": { "alias": "name"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "showError": { "alias": "showError"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "control": { "alias": "control"; "required": false; }; }, { "showChange": "showChange"; }, never, never, true, never>;
}

declare class ShowMultiSelectComponent implements OnInit, OnDestroy, ControlValueAccessor {
    private platformId;
    private showService;
    label: string;
    placeholder: string;
    allShows: WritableSignal<SelectOption[]>;
    filteredShows: WritableSignal<SelectOption[]>;
    loading: WritableSignal<boolean>;
    selectedIds: number[];
    searchTerm: string;
    private searchSubject;
    private destroy$;
    onChange: any;
    onTouched: any;
    constructor(platformId: string, showService: ShowService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private applyFilter;
    onSearchChange(event: Event): void;
    isSelected(id: number): boolean;
    toggleShow(id: number): void;
    removeShow(id: number): void;
    getShowLabel(id: number): string;
    writeValue(value: number[] | null): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ShowMultiSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ShowMultiSelectComponent, "show-multi-select", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, {}, never, never, true, never>;
}

declare class PriceZoneSelectComponent implements OnInit, OnDestroy, ControlValueAccessor, Validator {
    private platformId;
    private priceZoneService;
    label: string;
    placeholder: string;
    name: string;
    required: boolean;
    readonly: boolean;
    showError: boolean;
    customClass: string;
    control?: AbstractControl | null;
    priceZoneChange: EventEmitter<number | null>;
    priceZones: WritableSignal<SelectOption[]>;
    loading: WritableSignal<boolean>;
    searchTerm: string;
    private searchSubject;
    private destroy$;
    value: number | null;
    onChange: any;
    onTouched: any;
    constructor(platformId: string, priceZoneService: PriceZoneService);
    ngOnInit(): void;
    get formControl(): FormControl;
    ngOnDestroy(): void;
    onSearchChange(search: string): void;
    onPriceZoneSelected(event: Event): void;
    writeValue(value: number | null): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    validate(control: FormControl): {
        required: boolean;
    } | null;
    get isInvalid(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<PriceZoneSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PriceZoneSelectComponent, "price-zone-select", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "name": { "alias": "name"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "showError": { "alias": "showError"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "control": { "alias": "control"; "required": false; }; }, { "priceZoneChange": "priceZoneChange"; }, never, never, true, never>;
}

export { ADMIN_API_ROUTES, ALERT_BASE_CLASSES, ALERT_COLOR_CLASSES, ALERT_ICONS, ALERT_SIZE_CLASSES, AdminSelectComponent, AdminService, ApiService, AppAlertComponent, AppButtonComponent, AppLinkButtonComponent, AppModalComponent, AsyncSelectComponent, AuditInformationComponent, BASE_BUTTON_CLASSES, BASE_INPUT_CLASSES, BUTTON_SIZES_CLASSES, BUTTON_VARIANT_CLASSES, CITY_API_ENDPOINTS, COUNTRY_API_ENDPOINTS, CUSTOMERS_API_ROUTES, ChangePasswordFormComponent, ChangePasswordFormService, CitiesService, CitySelectComponent, ColorPickerComponent, CorporateBondStatus, CountrySelectComponent, CountryService, CouponApplicability, CouponDiscountType, CustomerSelectComponent, CustomerService, DateInputComponent, DateService, DeleteConfirmationComponent, DeleteConfirmationService, DynamicTableComponent, ERROR_INPUT_CLASSES, EndDateGreaterThanStartValidator, FORM_ERROR_MESSAGES, FileType, FileUploadComponent, FileUploadPreviewComponent, FormEditorComponent, FormInputComponent, FormSelectComponent, FormTextareaComponent, LanguageSwitcherComponent, LoadingModalService, LoadingmModalComponent, MinTodayValidator, MustMatchValidator, OrderItemType, OrderStatus, PERFORMANCES_API_ROUTES, PRICE_ZONES_API_ROUTES, PRODUCTS_API_ROUTES, PerformanceMultiSelectComponent, PerformanceSelectComponent, PerformanceService, PerformanceStatus, PerformanceTicketStatus, PriceZoneEventService, PriceZoneFormModalService, PriceZoneSelectComponent, PriceZoneService, ProductMultiSelectComponent, ProductSelectComponent, ProductService, RoomMapElementOrientation, RoomMapElementType, SHOWS_API_ROUTES, STATE_API_ENDPOINTS, ShowMultiSelectComponent, ShowSelectComponent, ShowService, StateSelectComponent, StatesService, TICKERA_COMPONENTS_CONFIG, ToastService, ToggleSwitchComponent, VENUES_API_ROUTES, authInterceptor, formatCitiesResponseToSelect, getCustomerFullname, parseJsonToFormDataAdvanced, provideTickeraComponents, transformImageToFile };
export type { Admin, AdminsResponse, AsyncSelectConfig, Auditable, CitiesResponse, City, CityResponse, CorporateBond, CorporateBondCode, CorporateBondResponse, CountriesResponse, Country, CountryResponse, Coupon, CouponResponse, Customer, CustomerResponse, CustomersResponse, DailyPerformanceHall, DailyPerformanceItem, DailyPerformancePriceZone, DailyPerformanceShow, DailyPerformanceVenue, DailyPerformancesResponse, DeleteConfirmationOpen, DragDropEvent, DynamicTableHeader, ElementPropertiesTab, FetchCitiesParams, FetchDailyPerformancesParams, FetchShowsParams, FileUploadConfig, FindAllPriceZoneParams, Hall, HallFloor, NumerationConfig, Order, OrderItem, OrderResponse, OrdersResponse, Performance, PerformanceAvailableDay, PerformanceBookingDataResponse, PerformanceResponse, PerformanceTicket, PerformancesAvailableDaysResponse, PerformancesResponseInterface, PriceZone, PriceZoneResponse, PriceZoneUpdateResponse, PriceZonesResponseInterface, Product, ProductResponse, ProductsResponseInterface, RoomMap, RoomMapBaseElement, RoomMapCanvasConfiguration, RoomMapCanvasElement, RoomMapChairPosition, RoomMapElementTemplate, RoomMapExitElement, RoomMapGridPosition, RoomMapPosition, RoomMapProductionAreaElement, RoomMapSeatDisplayState, RoomMapSeatElement, RoomMapSeatState, RoomMapSize, RoomMapStageElement, RoomMapTableElement, RoomMapUnavailableElement, RoomMapZoneElement, SelectOption, Show, ShowImage, ShowResponse, ShowType, ShowsResponseInterface, State, StateResponse, StatesResponse, TickeraComponentsConfig, UploadedFile, ValidateCorporateBondResponse, ValidateCouponResponse, Venue, VenueImage };