import type {
  PatternsFieldType,
  QueryOperator,
  NumberRange,
  StringLengthRange,
  BaseReferenceField,
  ReferenceField,
  MultiReferenceField,
  NonReferenceField,
  Field,
  FieldSpec,
  SchemaPermissions,
  ItemPermissions,
} from '@wix/bex-core';

export type {
  PatternsFieldType,
  QueryOperator,
  NumberRange,
  StringLengthRange,
  BaseReferenceField,
  ReferenceField,
  MultiReferenceField,
  NonReferenceField,
  Field,
  FieldSpec,
  SchemaPermissions,
  ItemPermissions,
};

export type {
  BackupConfig,
  BulkInsertError,
  BulkInsertResult,
} from '@wix/bex-core';

export interface CategoryCollectionInfo {
  collectionId: string;
  displayName: string;
}

export interface CursorQueryResult {
  items: any[];
  cursor?: string | undefined | null;
  total?: number | null;
}

export interface OffsetQueryResult {
  items: any[];
  total?: number | null;
  hasNext?: boolean;
}

export interface Query {
  limit: number;
  offset?: number;
  page: number;
  search?: string;
  cursor?: string | null;
  filters: Record<string, any>;
  sort?: { fieldName: string; order: 'asc' | 'desc' }[];
}

export interface FieldActions {
  editField?: (fieldId: string, updates: Partial<Field>) => Promise<any>;
  addField?: (field: Field) => Promise<any>;
  deleteField?: (fieldId: string) => Promise<any>;
  duplicateField?: (fieldId: string) => Promise<any>;
  duplicateFieldWithContent?: (fieldId: string) => Promise<any>;
  makePrimary?: (fieldId: string) => Promise<any>;
  renameField?: (fieldId: string, newName: string) => Promise<any>;
}

export interface SchemaConfig {
  id: string;
  fields: Record<string, Field | undefined>;
  displayField: string;
  idField: string;
  extensible?: { filterable?: boolean } | null;
  containsPii?: boolean;
  /**
   * Whether the schema's fields can be edited at all (e.g. native collections).
   * Gate field management on both this and `schemaPermissions`.
   */
  isSchemaEditable?: boolean;
  /** Field-management permissions for the current user. */
  schemaPermissions?: SchemaPermissions;
  /** Item CRUD permissions for the current user. */
  itemPermissions?: ItemPermissions;
  fieldActions?: FieldActions;
  refresh?: () => Promise<void>;
  actions: {
    get: (entityId: string) => Promise<any>;
    create: (newEntity: Record<string, any>) => Promise<any>;
    update: (updatedEntity: Record<string, any>) => Promise<any>;
    delete: (entityId: string) => Promise<any>;
    bulkDelete: (entityIds: string[]) => Promise<any>;
    find: (
      query: Query,
      options?: {
        searchableFieldIds?: string[];
      },
    ) => Promise<CursorQueryResult | OffsetQueryResult>;
    move?: (
      id: string,
      params: { moveAfterId: string | null | undefined },
    ) => Promise<void>;
    readonly backup?: {
      create: () => Promise<{ backupId: string }>;
      waitForCompletion: (
        backupId: string,
        options?: { signal?: AbortSignal },
      ) => Promise<void>;
      cancel?: (backupId: string) => Promise<void>;
      restore?: (backupId: string) => Promise<{ restorationId: string }>;
      waitForRestoration?: (
        restorationId: string,
        options?: { signal?: AbortSignal },
      ) => Promise<void>;
    };
    readonly bulkInsert?: (entities: Record<string, any>[]) => Promise<{
      succeeded?: number;
      failed?: number;
      errors?: { rowIndex: number; message?: string; code?: string }[];
    }>;
  };
}