library dataconnect_generated;
import 'package:firebase_data_connect/firebase_data_connect.dart';
import 'package:flutter/foundation.dart';
import 'dart:convert';
import 'package:flutter/foundation.dart';

part 'create_recent_payment.dart';

part 'update_recent_payment.dart';

part 'delete_recent_payment.dart';

part 'create_staff.dart';

part 'update_staff.dart';

part 'delete_staff.dart';

part 'get_staff_document_by_key.dart';

part 'list_staff_documents_by_staff_id.dart';

part 'list_staff_documents_by_document_type.dart';

part 'list_staff_documents_by_status.dart';

part 'list_tax_forms.dart';

part 'get_tax_form_by_id.dart';

part 'get_tax_forms_by_staff_id.dart';

part 'list_tax_forms_where.dart';

part 'list_team_hubs.dart';

part 'get_team_hub_by_id.dart';

part 'get_team_hubs_by_team_id.dart';

part 'list_team_hubs_by_owner_id.dart';

part 'create_activity_log.dart';

part 'update_activity_log.dart';

part 'mark_activity_log_as_read.dart';

part 'mark_activity_logs_as_read.dart';

part 'delete_activity_log.dart';

part 'create_level.dart';

part 'update_level.dart';

part 'delete_level.dart';

part 'create_member_task.dart';

part 'delete_member_task.dart';

part 'list_shifts.dart';

part 'get_shift_by_id.dart';

part 'filter_shifts.dart';

part 'get_shifts_by_business_id.dart';

part 'get_shifts_by_vendor_id.dart';

part 'list_staff.dart';

part 'get_staff_by_id.dart';

part 'get_staff_by_user_id.dart';

part 'filter_staff.dart';

part 'list_teams.dart';

part 'get_team_by_id.dart';

part 'get_teams_by_owner_id.dart';

part 'create_team_member.dart';

part 'update_team_member.dart';

part 'update_team_member_invite_status.dart';

part 'accept_invite_by_code.dart';

part 'cancel_invite_by_code.dart';

part 'delete_team_member.dart';

part 'create_course.dart';

part 'update_course.dart';

part 'delete_course.dart';

part 'create_document.dart';

part 'update_document.dart';

part 'delete_document.dart';

part 'create_invoice.dart';

part 'update_invoice.dart';

part 'delete_invoice.dart';

part 'get_my_tasks.dart';

part 'get_member_task_by_id_key.dart';

part 'get_member_tasks_by_task_id.dart';

part 'get_shift_role_by_id.dart';

part 'list_shift_roles_by_shift_id.dart';

part 'list_shift_roles_by_role_id.dart';

part 'list_shift_roles_by_shift_id_and_time_range.dart';

part 'list_shift_roles_by_vendor_id.dart';

part 'list_shift_roles_by_business_and_date_range.dart';

part 'list_shift_roles_by_business_and_order.dart';

part 'list_shift_roles_by_business_date_range_completed_orders.dart';

part 'list_shift_roles_by_business_and_dates_summary.dart';

part 'get_completed_shifts_by_business_id.dart';

part 'create_staff_document.dart';

part 'update_staff_document.dart';

part 'delete_staff_document.dart';

part 'list_tasks.dart';

part 'get_task_by_id.dart';

part 'get_tasks_by_owner_id.dart';

part 'filter_tasks.dart';

part 'create_vendor.dart';

part 'update_vendor.dart';

part 'delete_vendor.dart';

part 'create_shift.dart';

part 'update_shift.dart';

part 'delete_shift.dart';

part 'list_applications.dart';

part 'get_application_by_id.dart';

part 'get_applications_by_shift_id.dart';

part 'get_applications_by_shift_id_and_status.dart';

part 'get_applications_by_staff_id.dart';

part 'list_accepted_applications_by_shift_role_key.dart';

part 'list_accepted_applications_by_business_for_day.dart';

part 'list_staffs_applications_by_business_for_day.dart';

part 'list_benefits_data.dart';

part 'get_benefits_data_by_key.dart';

part 'list_benefits_data_by_staff_id.dart';

part 'list_benefits_data_by_vendor_benefit_plan_id.dart';

part 'list_benefits_data_by_vendor_benefit_plan_ids.dart';

part 'list_certificates.dart';

part 'get_certificate_by_id.dart';

part 'list_certificates_by_staff_id.dart';

part 'list_conversations.dart';

part 'get_conversation_by_id.dart';

part 'list_conversations_by_type.dart';

part 'list_conversations_by_status.dart';

part 'filter_conversations.dart';

part 'create_staff_role.dart';

part 'delete_staff_role.dart';

part 'create_vendor_benefit_plan.dart';

part 'update_vendor_benefit_plan.dart';

part 'delete_vendor_benefit_plan.dart';

part 'create_vendor_rate.dart';

part 'update_vendor_rate.dart';

part 'delete_vendor_rate.dart';

part 'create_faq_data.dart';

part 'update_faq_data.dart';

part 'delete_faq_data.dart';

part 'create_order.dart';

part 'update_order.dart';

part 'delete_order.dart';

part 'create_role.dart';

part 'update_role.dart';

part 'delete_role.dart';

part 'create_user_conversation.dart';

part 'update_user_conversation.dart';

part 'mark_conversation_as_read.dart';

part 'increment_unread_for_user.dart';

part 'delete_user_conversation.dart';

part 'create_staff_course.dart';

part 'update_staff_course.dart';

part 'delete_staff_course.dart';

part 'list_vendor_benefit_plans.dart';

part 'get_vendor_benefit_plan_by_id.dart';

part 'list_vendor_benefit_plans_by_vendor_id.dart';

part 'list_active_vendor_benefit_plans_by_vendor_id.dart';

part 'filter_vendor_benefit_plans.dart';

part 'list_vendor_rates.dart';

part 'get_vendor_rate_by_id.dart';

part 'get_workforce_by_id.dart';

part 'get_workforce_by_vendor_and_staff.dart';

part 'list_workforce_by_vendor_id.dart';

part 'list_workforce_by_staff_id.dart';

part 'get_workforce_by_vendor_and_number.dart';

part 'list_activity_logs.dart';

part 'get_activity_log_by_id.dart';

part 'list_activity_logs_by_user_id.dart';

part 'list_unread_activity_logs_by_user_id.dart';

part 'filter_activity_logs.dart';

part 'list_businesses.dart';

part 'get_businesses_by_user_id.dart';

part 'get_business_by_id.dart';

part 'create_shift_role.dart';

part 'update_shift_role.dart';

part 'delete_shift_role.dart';

part 'create_task.dart';

part 'update_task.dart';

part 'delete_task.dart';

part 'create_team_hud_department.dart';

part 'update_team_hud_department.dart';

part 'delete_team_hud_department.dart';

part 'create_workforce.dart';

part 'update_workforce.dart';

part 'deactivate_workforce.dart';

part 'create_account.dart';

part 'update_account.dart';

part 'delete_account.dart';

part 'list_faq_datas.dart';

part 'get_faq_data_by_id.dart';

part 'filter_faq_datas.dart';

part 'create_staff_availability_stats.dart';

part 'update_staff_availability_stats.dart';

part 'delete_staff_availability_stats.dart';

part 'list_team_members.dart';

part 'get_team_member_by_id.dart';

part 'get_team_members_by_team_id.dart';

part 'list_user_conversations.dart';

part 'get_user_conversation_by_key.dart';

part 'list_user_conversations_by_user_id.dart';

part 'list_unread_user_conversations_by_user_id.dart';

part 'list_user_conversations_by_conversation_id.dart';

part 'filter_user_conversations.dart';

part 'get_vendor_by_id.dart';

part 'get_vendor_by_user_id.dart';

part 'list_vendors.dart';

part 'list_courses.dart';

part 'get_course_by_id.dart';

part 'filter_courses.dart';

part 'create_message.dart';

part 'update_message.dart';

part 'delete_message.dart';

part 'list_roles.dart';

part 'get_role_by_id.dart';

part 'list_roles_by_vendor_id.dart';

part 'list_roles_byrole_category_id.dart';

part 'create_tax_form.dart';

part 'update_tax_form.dart';

part 'delete_tax_form.dart';

part 'create_application.dart';

part 'update_application_status.dart';

part 'delete_application.dart';

part 'list_assignments.dart';

part 'get_assignment_by_id.dart';

part 'list_assignments_by_workforce_id.dart';

part 'list_assignments_by_workforce_ids.dart';

part 'list_assignments_by_shift_role.dart';

part 'filter_assignments.dart';

part 'create_category.dart';

part 'update_category.dart';

part 'delete_category.dart';

part 'list_levels.dart';

part 'get_level_by_id.dart';

part 'filter_levels.dart';

part 'create_business.dart';

part 'update_business.dart';

part 'delete_business.dart';

part 'create_client_feedback.dart';

part 'update_client_feedback.dart';

part 'delete_client_feedback.dart';

part 'create_hub.dart';

part 'update_hub.dart';

part 'delete_hub.dart';

part 'list_hubs.dart';

part 'get_hub_by_id.dart';

part 'get_hubs_by_owner_id.dart';

part 'filter_hubs.dart';

part 'list_recent_payments.dart';

part 'get_recent_payment_by_id.dart';

part 'list_recent_payments_by_staff_id.dart';

part 'list_recent_payments_by_application_id.dart';

part 'list_recent_payments_by_invoice_id.dart';

part 'list_recent_payments_by_status.dart';

part 'list_recent_payments_by_invoice_ids.dart';

part 'list_recent_payments_by_business_id.dart';

part 'create_role_category.dart';

part 'update_role_category.dart';

part 'delete_role_category.dart';

part 'create_team.dart';

part 'update_team.dart';

part 'delete_team.dart';

part 'list_client_feedbacks.dart';

part 'get_client_feedback_by_id.dart';

part 'list_client_feedbacks_by_business_id.dart';

part 'list_client_feedbacks_by_vendor_id.dart';

part 'list_client_feedbacks_by_business_and_vendor.dart';

part 'filter_client_feedbacks.dart';

part 'list_client_feedback_ratings_by_vendor_id.dart';

part 'create_conversation.dart';

part 'update_conversation.dart';

part 'update_conversation_last_message.dart';

part 'delete_conversation.dart';

part 'list_shifts_for_coverage.dart';

part 'list_applications_for_coverage.dart';

part 'list_shifts_for_daily_ops_by_business.dart';

part 'list_shifts_for_daily_ops_by_vendor.dart';

part 'list_applications_for_daily_ops.dart';

part 'list_shifts_for_forecast_by_business.dart';

part 'list_shifts_for_forecast_by_vendor.dart';

part 'list_shifts_for_no_show_range_by_business.dart';

part 'list_shifts_for_no_show_range_by_vendor.dart';

part 'list_applications_for_no_show_range.dart';

part 'list_staff_for_no_show_report.dart';

part 'list_invoices_for_spend_by_business.dart';

part 'list_invoices_for_spend_by_vendor.dart';

part 'list_invoices_for_spend_by_order.dart';

part 'list_timesheets_for_spend.dart';

part 'list_shifts_for_performance_by_business.dart';

part 'list_shifts_for_performance_by_vendor.dart';

part 'list_applications_for_performance.dart';

part 'list_staff_for_performance.dart';

part 'create_staff_availability.dart';

part 'update_staff_availability.dart';

part 'delete_staff_availability.dart';

part 'list_team_hud_departments.dart';

part 'get_team_hud_department_by_id.dart';

part 'list_team_hud_departments_by_team_hub_id.dart';

part 'list_users.dart';

part 'get_user_by_id.dart';

part 'filter_users.dart';

part 'list_accounts.dart';

part 'get_account_by_id.dart';

part 'get_accounts_by_owner_id.dart';

part 'filter_accounts.dart';

part 'create_assignment.dart';

part 'update_assignment.dart';

part 'delete_assignment.dart';

part 'list_attire_options.dart';

part 'get_attire_option_by_id.dart';

part 'filter_attire_options.dart';

part 'list_invoices.dart';

part 'get_invoice_by_id.dart';

part 'list_invoices_by_vendor_id.dart';

part 'list_invoices_by_business_id.dart';

part 'list_invoices_by_order_id.dart';

part 'list_invoices_by_status.dart';

part 'filter_invoices.dart';

part 'list_overdue_invoices.dart';

part 'list_messages.dart';

part 'get_message_by_id.dart';

part 'get_messages_by_conversation_id.dart';

part 'list_task_comments.dart';

part 'get_task_comment_by_id.dart';

part 'get_task_comments_by_task_id.dart';

part 'create_user.dart';

part 'update_user.dart';

part 'delete_user.dart';

part 'list_categories.dart';

part 'get_category_by_id.dart';

part 'filter_categories.dart';

part 'list_custom_rate_cards.dart';

part 'get_custom_rate_card_by_id.dart';

part 'list_documents.dart';

part 'get_document_by_id.dart';

part 'filter_documents.dart';

part 'create_invoice_template.dart';

part 'update_invoice_template.dart';

part 'delete_invoice_template.dart';

part 'list_staff_availability_stats.dart';

part 'get_staff_availability_stats_by_staff_id.dart';

part 'filter_staff_availability_stats.dart';

part 'create_benefits_data.dart';

part 'update_benefits_data.dart';

part 'delete_benefits_data.dart';

part 'create_custom_rate_card.dart';

part 'update_custom_rate_card.dart';

part 'delete_custom_rate_card.dart';

part 'create_emergency_contact.dart';

part 'update_emergency_contact.dart';

part 'delete_emergency_contact.dart';

part 'list_staff_availabilities.dart';

part 'list_staff_availabilities_by_staff_id.dart';

part 'get_staff_availability_by_key.dart';

part 'list_staff_availabilities_by_day.dart';

part 'get_staff_course_by_id.dart';

part 'list_staff_courses_by_staff_id.dart';

part 'list_staff_courses_by_course_id.dart';

part 'get_staff_course_by_staff_and_course.dart';

part 'list_staff_roles.dart';

part 'get_staff_role_by_key.dart';

part 'list_staff_roles_by_staff_id.dart';

part 'list_staff_roles_by_role_id.dart';

part 'filter_staff_roles.dart';

part 'create_certificate.dart';

part 'update_certificate.dart';

part 'delete_certificate.dart';

part 'list_emergency_contacts.dart';

part 'get_emergency_contact_by_id.dart';

part 'get_emergency_contacts_by_staff_id.dart';

part 'list_invoice_templates.dart';

part 'get_invoice_template_by_id.dart';

part 'list_invoice_templates_by_owner_id.dart';

part 'list_invoice_templates_by_vendor_id.dart';

part 'list_invoice_templates_by_business_id.dart';

part 'list_invoice_templates_by_order_id.dart';

part 'search_invoice_templates_by_owner_and_name.dart';

part 'list_orders.dart';

part 'get_order_by_id.dart';

part 'get_orders_by_business_id.dart';

part 'get_orders_by_vendor_id.dart';

part 'get_orders_by_status.dart';

part 'get_orders_by_date_range.dart';

part 'get_rapid_orders.dart';

part 'list_orders_by_business_and_team_hub.dart';

part 'list_role_categories.dart';

part 'get_role_category_by_id.dart';

part 'get_role_categories_by_category.dart';

part 'create_task_comment.dart';

part 'update_task_comment.dart';

part 'delete_task_comment.dart';

part 'create_team_hub.dart';

part 'update_team_hub.dart';

part 'delete_team_hub.dart';

part 'create_attire_option.dart';

part 'update_attire_option.dart';

part 'delete_attire_option.dart';



  enum AccountType {
    
      CHECKING,
    
      SAVINGS,
    
  }
  
  String accountTypeSerializer(EnumValue<AccountType> e) {
    return e.stringValue;
  }
  EnumValue<AccountType> accountTypeDeserializer(dynamic data) {
    switch (data) {
      
      case 'CHECKING':
        return const Known(AccountType.CHECKING);
      
      case 'SAVINGS':
        return const Known(AccountType.SAVINGS);
      
      default:
        return Unknown(data);
    }
  }
  

  enum ActivityIconType {
    
      INVOICE,
    
      CHECK,
    
      ALERT,
    
      MESSAGE,
    
      CALENDAR,
    
  }
  
  String activityIconTypeSerializer(EnumValue<ActivityIconType> e) {
    return e.stringValue;
  }
  EnumValue<ActivityIconType> activityIconTypeDeserializer(dynamic data) {
    switch (data) {
      
      case 'INVOICE':
        return const Known(ActivityIconType.INVOICE);
      
      case 'CHECK':
        return const Known(ActivityIconType.CHECK);
      
      case 'ALERT':
        return const Known(ActivityIconType.ALERT);
      
      case 'MESSAGE':
        return const Known(ActivityIconType.MESSAGE);
      
      case 'CALENDAR':
        return const Known(ActivityIconType.CALENDAR);
      
      default:
        return Unknown(data);
    }
  }
  

  enum ActivityType {
    
      ORDER_CREATED,
    
      SHIFT_UPDATE,
    
      COMPLIANCE_ALERT,
    
      MESSAGE_RECEIVED,
    
      SYSTEM_UPDATE,
    
  }
  
  String activityTypeSerializer(EnumValue<ActivityType> e) {
    return e.stringValue;
  }
  EnumValue<ActivityType> activityTypeDeserializer(dynamic data) {
    switch (data) {
      
      case 'ORDER_CREATED':
        return const Known(ActivityType.ORDER_CREATED);
      
      case 'SHIFT_UPDATE':
        return const Known(ActivityType.SHIFT_UPDATE);
      
      case 'COMPLIANCE_ALERT':
        return const Known(ActivityType.COMPLIANCE_ALERT);
      
      case 'MESSAGE_RECEIVED':
        return const Known(ActivityType.MESSAGE_RECEIVED);
      
      case 'SYSTEM_UPDATE':
        return const Known(ActivityType.SYSTEM_UPDATE);
      
      default:
        return Unknown(data);
    }
  }
  

  enum ApplicationOrigin {
    
      STAFF,
    
      EMPLOYER,
    
  }
  
  String applicationOriginSerializer(EnumValue<ApplicationOrigin> e) {
    return e.stringValue;
  }
  EnumValue<ApplicationOrigin> applicationOriginDeserializer(dynamic data) {
    switch (data) {
      
      case 'STAFF':
        return const Known(ApplicationOrigin.STAFF);
      
      case 'EMPLOYER':
        return const Known(ApplicationOrigin.EMPLOYER);
      
      default:
        return Unknown(data);
    }
  }
  

  enum ApplicationStatus {
    
      PENDING,
    
      ACCEPTED,
    
      REJECTED,
    
      CONFIRMED,
    
      CHECKED_IN,
    
      CHECKED_OUT,
    
      LATE,
    
      NO_SHOW,
    
  }
  
  String applicationStatusSerializer(EnumValue<ApplicationStatus> e) {
    return e.stringValue;
  }
  EnumValue<ApplicationStatus> applicationStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'PENDING':
        return const Known(ApplicationStatus.PENDING);
      
      case 'ACCEPTED':
        return const Known(ApplicationStatus.ACCEPTED);
      
      case 'REJECTED':
        return const Known(ApplicationStatus.REJECTED);
      
      case 'CONFIRMED':
        return const Known(ApplicationStatus.CONFIRMED);
      
      case 'CHECKED_IN':
        return const Known(ApplicationStatus.CHECKED_IN);
      
      case 'CHECKED_OUT':
        return const Known(ApplicationStatus.CHECKED_OUT);
      
      case 'LATE':
        return const Known(ApplicationStatus.LATE);
      
      case 'NO_SHOW':
        return const Known(ApplicationStatus.NO_SHOW);
      
      default:
        return Unknown(data);
    }
  }
  

  enum ApprovalStatus {
    
      APPROVED,
    
  }
  
  String approvalStatusSerializer(EnumValue<ApprovalStatus> e) {
    return e.stringValue;
  }
  EnumValue<ApprovalStatus> approvalStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'APPROVED':
        return const Known(ApprovalStatus.APPROVED);
      
      default:
        return Unknown(data);
    }
  }
  

  enum AssignmentStatus {
    
      PENDING,
    
      CONFIRMED,
    
      OPEN,
    
      COMPLETED,
    
      CANCELED,
    
      ACTIVE,
    
  }
  
  String assignmentStatusSerializer(EnumValue<AssignmentStatus> e) {
    return e.stringValue;
  }
  EnumValue<AssignmentStatus> assignmentStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'PENDING':
        return const Known(AssignmentStatus.PENDING);
      
      case 'CONFIRMED':
        return const Known(AssignmentStatus.CONFIRMED);
      
      case 'OPEN':
        return const Known(AssignmentStatus.OPEN);
      
      case 'COMPLETED':
        return const Known(AssignmentStatus.COMPLETED);
      
      case 'CANCELED':
        return const Known(AssignmentStatus.CANCELED);
      
      case 'ACTIVE':
        return const Known(AssignmentStatus.ACTIVE);
      
      default:
        return Unknown(data);
    }
  }
  

  enum AvailabilitySlot {
    
      MORNING,
    
      AFTERNOON,
    
      EVENING,
    
  }
  
  String availabilitySlotSerializer(EnumValue<AvailabilitySlot> e) {
    return e.stringValue;
  }
  EnumValue<AvailabilitySlot> availabilitySlotDeserializer(dynamic data) {
    switch (data) {
      
      case 'MORNING':
        return const Known(AvailabilitySlot.MORNING);
      
      case 'AFTERNOON':
        return const Known(AvailabilitySlot.AFTERNOON);
      
      case 'EVENING':
        return const Known(AvailabilitySlot.EVENING);
      
      default:
        return Unknown(data);
    }
  }
  

  enum AvailabilityStatus {
    
      CONFIRMED_AVAILABLE,
    
      UNKNOWN,
    
      BLOCKED,
    
  }
  
  String availabilityStatusSerializer(EnumValue<AvailabilityStatus> e) {
    return e.stringValue;
  }
  EnumValue<AvailabilityStatus> availabilityStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'CONFIRMED_AVAILABLE':
        return const Known(AvailabilityStatus.CONFIRMED_AVAILABLE);
      
      case 'UNKNOWN':
        return const Known(AvailabilityStatus.UNKNOWN);
      
      case 'BLOCKED':
        return const Known(AvailabilityStatus.BLOCKED);
      
      default:
        return Unknown(data);
    }
  }
  

  enum BackgroundCheckStatus {
    
      PENDING,
    
      CLEARED,
    
      FAILED,
    
      EXPIRED,
    
      NOT_REQUIRED,
    
  }
  
  String backgroundCheckStatusSerializer(EnumValue<BackgroundCheckStatus> e) {
    return e.stringValue;
  }
  EnumValue<BackgroundCheckStatus> backgroundCheckStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'PENDING':
        return const Known(BackgroundCheckStatus.PENDING);
      
      case 'CLEARED':
        return const Known(BackgroundCheckStatus.CLEARED);
      
      case 'FAILED':
        return const Known(BackgroundCheckStatus.FAILED);
      
      case 'EXPIRED':
        return const Known(BackgroundCheckStatus.EXPIRED);
      
      case 'NOT_REQUIRED':
        return const Known(BackgroundCheckStatus.NOT_REQUIRED);
      
      default:
        return Unknown(data);
    }
  }
  

  enum BreakDuration {
    
      MIN_15,
    
      MIN_30,
    
      NO_BREAK,
    
  }
  
  String breakDurationSerializer(EnumValue<BreakDuration> e) {
    return e.stringValue;
  }
  EnumValue<BreakDuration> breakDurationDeserializer(dynamic data) {
    switch (data) {
      
      case 'MIN_15':
        return const Known(BreakDuration.MIN_15);
      
      case 'MIN_30':
        return const Known(BreakDuration.MIN_30);
      
      case 'NO_BREAK':
        return const Known(BreakDuration.NO_BREAK);
      
      default:
        return Unknown(data);
    }
  }
  

  enum BusinessArea {
    
      BAY_AREA,
    
      SOUTHERN_CALIFORNIA,
    
      NORTHERN_CALIFORNIA,
    
      CENTRAL_VALLEY,
    
      OTHER,
    
  }
  
  String businessAreaSerializer(EnumValue<BusinessArea> e) {
    return e.stringValue;
  }
  EnumValue<BusinessArea> businessAreaDeserializer(dynamic data) {
    switch (data) {
      
      case 'BAY_AREA':
        return const Known(BusinessArea.BAY_AREA);
      
      case 'SOUTHERN_CALIFORNIA':
        return const Known(BusinessArea.SOUTHERN_CALIFORNIA);
      
      case 'NORTHERN_CALIFORNIA':
        return const Known(BusinessArea.NORTHERN_CALIFORNIA);
      
      case 'CENTRAL_VALLEY':
        return const Known(BusinessArea.CENTRAL_VALLEY);
      
      case 'OTHER':
        return const Known(BusinessArea.OTHER);
      
      default:
        return Unknown(data);
    }
  }
  

  enum BusinessRateGroup {
    
      STANDARD,
    
      PREMIUM,
    
      ENTERPRISE,
    
      CUSTOM,
    
  }
  
  String businessRateGroupSerializer(EnumValue<BusinessRateGroup> e) {
    return e.stringValue;
  }
  EnumValue<BusinessRateGroup> businessRateGroupDeserializer(dynamic data) {
    switch (data) {
      
      case 'STANDARD':
        return const Known(BusinessRateGroup.STANDARD);
      
      case 'PREMIUM':
        return const Known(BusinessRateGroup.PREMIUM);
      
      case 'ENTERPRISE':
        return const Known(BusinessRateGroup.ENTERPRISE);
      
      case 'CUSTOM':
        return const Known(BusinessRateGroup.CUSTOM);
      
      default:
        return Unknown(data);
    }
  }
  

  enum BusinessSector {
    
      BON_APPETIT,
    
      EUREST,
    
      ARAMARK,
    
      EPICUREAN_GROUP,
    
      CHARTWELLS,
    
      OTHER,
    
  }
  
  String businessSectorSerializer(EnumValue<BusinessSector> e) {
    return e.stringValue;
  }
  EnumValue<BusinessSector> businessSectorDeserializer(dynamic data) {
    switch (data) {
      
      case 'BON_APPETIT':
        return const Known(BusinessSector.BON_APPETIT);
      
      case 'EUREST':
        return const Known(BusinessSector.EUREST);
      
      case 'ARAMARK':
        return const Known(BusinessSector.ARAMARK);
      
      case 'EPICUREAN_GROUP':
        return const Known(BusinessSector.EPICUREAN_GROUP);
      
      case 'CHARTWELLS':
        return const Known(BusinessSector.CHARTWELLS);
      
      case 'OTHER':
        return const Known(BusinessSector.OTHER);
      
      default:
        return Unknown(data);
    }
  }
  

  enum BusinessStatus {
    
      ACTIVE,
    
      INACTIVE,
    
      PENDING,
    
  }
  
  String businessStatusSerializer(EnumValue<BusinessStatus> e) {
    return e.stringValue;
  }
  EnumValue<BusinessStatus> businessStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'ACTIVE':
        return const Known(BusinessStatus.ACTIVE);
      
      case 'INACTIVE':
        return const Known(BusinessStatus.INACTIVE);
      
      case 'PENDING':
        return const Known(BusinessStatus.PENDING);
      
      default:
        return Unknown(data);
    }
  }
  

  enum CategoryType {
    
      KITCHEN_AND_CULINARY,
    
      CONCESSIONS,
    
      FACILITIES,
    
      BARTENDING,
    
      SECURITY,
    
      EVENT_STAFF,
    
      MANAGEMENT,
    
      TECHNICAL,
    
      OTHER,
    
  }
  
  String categoryTypeSerializer(EnumValue<CategoryType> e) {
    return e.stringValue;
  }
  EnumValue<CategoryType> categoryTypeDeserializer(dynamic data) {
    switch (data) {
      
      case 'KITCHEN_AND_CULINARY':
        return const Known(CategoryType.KITCHEN_AND_CULINARY);
      
      case 'CONCESSIONS':
        return const Known(CategoryType.CONCESSIONS);
      
      case 'FACILITIES':
        return const Known(CategoryType.FACILITIES);
      
      case 'BARTENDING':
        return const Known(CategoryType.BARTENDING);
      
      case 'SECURITY':
        return const Known(CategoryType.SECURITY);
      
      case 'EVENT_STAFF':
        return const Known(CategoryType.EVENT_STAFF);
      
      case 'MANAGEMENT':
        return const Known(CategoryType.MANAGEMENT);
      
      case 'TECHNICAL':
        return const Known(CategoryType.TECHNICAL);
      
      case 'OTHER':
        return const Known(CategoryType.OTHER);
      
      default:
        return Unknown(data);
    }
  }
  

  enum CertificateStatus {
    
      CURRENT,
    
      EXPIRING_SOON,
    
      COMPLETED,
    
      PENDING,
    
      EXPIRED,
    
      EXPIRING,
    
      NOT_STARTED,
    
  }
  
  String certificateStatusSerializer(EnumValue<CertificateStatus> e) {
    return e.stringValue;
  }
  EnumValue<CertificateStatus> certificateStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'CURRENT':
        return const Known(CertificateStatus.CURRENT);
      
      case 'EXPIRING_SOON':
        return const Known(CertificateStatus.EXPIRING_SOON);
      
      case 'COMPLETED':
        return const Known(CertificateStatus.COMPLETED);
      
      case 'PENDING':
        return const Known(CertificateStatus.PENDING);
      
      case 'EXPIRED':
        return const Known(CertificateStatus.EXPIRED);
      
      case 'EXPIRING':
        return const Known(CertificateStatus.EXPIRING);
      
      case 'NOT_STARTED':
        return const Known(CertificateStatus.NOT_STARTED);
      
      default:
        return Unknown(data);
    }
  }
  

  enum CitizenshipStatus {
    
      CITIZEN,
    
      NONCITIZEN,
    
      PERMANENT_RESIDENT,
    
      ALIEN,
    
  }
  
  String citizenshipStatusSerializer(EnumValue<CitizenshipStatus> e) {
    return e.stringValue;
  }
  EnumValue<CitizenshipStatus> citizenshipStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'CITIZEN':
        return const Known(CitizenshipStatus.CITIZEN);
      
      case 'NONCITIZEN':
        return const Known(CitizenshipStatus.NONCITIZEN);
      
      case 'PERMANENT_RESIDENT':
        return const Known(CitizenshipStatus.PERMANENT_RESIDENT);
      
      case 'ALIEN':
        return const Known(CitizenshipStatus.ALIEN);
      
      default:
        return Unknown(data);
    }
  }
  

  enum ComplianceType {
    
      BACKGROUND_CHECK,
    
      FOOD_HANDLER,
    
      RBS,
    
      LEGAL,
    
      OPERATIONAL,
    
      SAFETY,
    
      TRAINING,
    
      LICENSE,
    
      OTHER,
    
  }
  
  String complianceTypeSerializer(EnumValue<ComplianceType> e) {
    return e.stringValue;
  }
  EnumValue<ComplianceType> complianceTypeDeserializer(dynamic data) {
    switch (data) {
      
      case 'BACKGROUND_CHECK':
        return const Known(ComplianceType.BACKGROUND_CHECK);
      
      case 'FOOD_HANDLER':
        return const Known(ComplianceType.FOOD_HANDLER);
      
      case 'RBS':
        return const Known(ComplianceType.RBS);
      
      case 'LEGAL':
        return const Known(ComplianceType.LEGAL);
      
      case 'OPERATIONAL':
        return const Known(ComplianceType.OPERATIONAL);
      
      case 'SAFETY':
        return const Known(ComplianceType.SAFETY);
      
      case 'TRAINING':
        return const Known(ComplianceType.TRAINING);
      
      case 'LICENSE':
        return const Known(ComplianceType.LICENSE);
      
      case 'OTHER':
        return const Known(ComplianceType.OTHER);
      
      default:
        return Unknown(data);
    }
  }
  

  enum ConversationStatus {
    
      ACTIVE,
    
  }
  
  String conversationStatusSerializer(EnumValue<ConversationStatus> e) {
    return e.stringValue;
  }
  EnumValue<ConversationStatus> conversationStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'ACTIVE':
        return const Known(ConversationStatus.ACTIVE);
      
      default:
        return Unknown(data);
    }
  }
  

  enum ConversationType {
    
      CLIENT_VENDOR,
    
      GROUP_STAFF,
    
      STAFF_CLIENT,
    
      STAFF_ADMIN,
    
      VENDOR_ADMIN,
    
      CLIENT_ADMIN,
    
      GROUP_ORDER_STAFF,
    
  }
  
  String conversationTypeSerializer(EnumValue<ConversationType> e) {
    return e.stringValue;
  }
  EnumValue<ConversationType> conversationTypeDeserializer(dynamic data) {
    switch (data) {
      
      case 'CLIENT_VENDOR':
        return const Known(ConversationType.CLIENT_VENDOR);
      
      case 'GROUP_STAFF':
        return const Known(ConversationType.GROUP_STAFF);
      
      case 'STAFF_CLIENT':
        return const Known(ConversationType.STAFF_CLIENT);
      
      case 'STAFF_ADMIN':
        return const Known(ConversationType.STAFF_ADMIN);
      
      case 'VENDOR_ADMIN':
        return const Known(ConversationType.VENDOR_ADMIN);
      
      case 'CLIENT_ADMIN':
        return const Known(ConversationType.CLIENT_ADMIN);
      
      case 'GROUP_ORDER_STAFF':
        return const Known(ConversationType.GROUP_ORDER_STAFF);
      
      default:
        return Unknown(data);
    }
  }
  

  enum DayOfWeek {
    
      SUNDAY,
    
      MONDAY,
    
      TUESDAY,
    
      WEDNESDAY,
    
      THURSDAY,
    
      FRIDAY,
    
      SATURDAY,
    
  }
  
  String dayOfWeekSerializer(EnumValue<DayOfWeek> e) {
    return e.stringValue;
  }
  EnumValue<DayOfWeek> dayOfWeekDeserializer(dynamic data) {
    switch (data) {
      
      case 'SUNDAY':
        return const Known(DayOfWeek.SUNDAY);
      
      case 'MONDAY':
        return const Known(DayOfWeek.MONDAY);
      
      case 'TUESDAY':
        return const Known(DayOfWeek.TUESDAY);
      
      case 'WEDNESDAY':
        return const Known(DayOfWeek.WEDNESDAY);
      
      case 'THURSDAY':
        return const Known(DayOfWeek.THURSDAY);
      
      case 'FRIDAY':
        return const Known(DayOfWeek.FRIDAY);
      
      case 'SATURDAY':
        return const Known(DayOfWeek.SATURDAY);
      
      default:
        return Unknown(data);
    }
  }
  

  enum DepartmentType {
    
      OPERATIONS,
    
      SALES,
    
      HR,
    
      FINANCE,
    
      IT,
    
      MARKETING,
    
      CUSTOMER_SERVICE,
    
      LOGISTICS,
    
  }
  
  String departmentTypeSerializer(EnumValue<DepartmentType> e) {
    return e.stringValue;
  }
  EnumValue<DepartmentType> departmentTypeDeserializer(dynamic data) {
    switch (data) {
      
      case 'OPERATIONS':
        return const Known(DepartmentType.OPERATIONS);
      
      case 'SALES':
        return const Known(DepartmentType.SALES);
      
      case 'HR':
        return const Known(DepartmentType.HR);
      
      case 'FINANCE':
        return const Known(DepartmentType.FINANCE);
      
      case 'IT':
        return const Known(DepartmentType.IT);
      
      case 'MARKETING':
        return const Known(DepartmentType.MARKETING);
      
      case 'CUSTOMER_SERVICE':
        return const Known(DepartmentType.CUSTOMER_SERVICE);
      
      case 'LOGISTICS':
        return const Known(DepartmentType.LOGISTICS);
      
      default:
        return Unknown(data);
    }
  }
  

  enum DocumentStatus {
    
      UPLOADED,
    
      PENDING,
    
      EXPIRING,
    
      MISSING,
    
      VERIFIED,
    
  }
  
  String documentStatusSerializer(EnumValue<DocumentStatus> e) {
    return e.stringValue;
  }
  EnumValue<DocumentStatus> documentStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'UPLOADED':
        return const Known(DocumentStatus.UPLOADED);
      
      case 'PENDING':
        return const Known(DocumentStatus.PENDING);
      
      case 'EXPIRING':
        return const Known(DocumentStatus.EXPIRING);
      
      case 'MISSING':
        return const Known(DocumentStatus.MISSING);
      
      case 'VERIFIED':
        return const Known(DocumentStatus.VERIFIED);
      
      default:
        return Unknown(data);
    }
  }
  

  enum DocumentType {
    
      W4_FORM,
    
      I9_FORM,
    
      STATE_TAX_FORM,
    
      DIRECT_DEPOSIT,
    
      ID_COPY,
    
      SSN_CARD,
    
      WORK_PERMIT,
    
  }
  
  String documentTypeSerializer(EnumValue<DocumentType> e) {
    return e.stringValue;
  }
  EnumValue<DocumentType> documentTypeDeserializer(dynamic data) {
    switch (data) {
      
      case 'W4_FORM':
        return const Known(DocumentType.W4_FORM);
      
      case 'I9_FORM':
        return const Known(DocumentType.I9_FORM);
      
      case 'STATE_TAX_FORM':
        return const Known(DocumentType.STATE_TAX_FORM);
      
      case 'DIRECT_DEPOSIT':
        return const Known(DocumentType.DIRECT_DEPOSIT);
      
      case 'ID_COPY':
        return const Known(DocumentType.ID_COPY);
      
      case 'SSN_CARD':
        return const Known(DocumentType.SSN_CARD);
      
      case 'WORK_PERMIT':
        return const Known(DocumentType.WORK_PERMIT);
      
      default:
        return Unknown(data);
    }
  }
  

  enum EmploymentType {
    
      FULL_TIME,
    
      PART_TIME,
    
      ON_CALL,
    
      WEEKENDS,
    
      SPECIFIC_DAYS,
    
      SEASONAL,
    
      MEDICAL_LEAVE,
    
  }
  
  String employmentTypeSerializer(EnumValue<EmploymentType> e) {
    return e.stringValue;
  }
  EnumValue<EmploymentType> employmentTypeDeserializer(dynamic data) {
    switch (data) {
      
      case 'FULL_TIME':
        return const Known(EmploymentType.FULL_TIME);
      
      case 'PART_TIME':
        return const Known(EmploymentType.PART_TIME);
      
      case 'ON_CALL':
        return const Known(EmploymentType.ON_CALL);
      
      case 'WEEKENDS':
        return const Known(EmploymentType.WEEKENDS);
      
      case 'SPECIFIC_DAYS':
        return const Known(EmploymentType.SPECIFIC_DAYS);
      
      case 'SEASONAL':
        return const Known(EmploymentType.SEASONAL);
      
      case 'MEDICAL_LEAVE':
        return const Known(EmploymentType.MEDICAL_LEAVE);
      
      default:
        return Unknown(data);
    }
  }
  

  enum EnglishProficiency {
    
      FLUENT,
    
      INTERMEDIATE,
    
      BASIC,
    
      NONE,
    
  }
  
  String englishProficiencySerializer(EnumValue<EnglishProficiency> e) {
    return e.stringValue;
  }
  EnumValue<EnglishProficiency> englishProficiencyDeserializer(dynamic data) {
    switch (data) {
      
      case 'FLUENT':
        return const Known(EnglishProficiency.FLUENT);
      
      case 'INTERMEDIATE':
        return const Known(EnglishProficiency.INTERMEDIATE);
      
      case 'BASIC':
        return const Known(EnglishProficiency.BASIC);
      
      case 'NONE':
        return const Known(EnglishProficiency.NONE);
      
      default:
        return Unknown(data);
    }
  }
  

  enum InovicePaymentTerms {
    
      NET_30,
    
      NET_45,
    
      NET_60,
    
  }
  
  String inovicePaymentTermsSerializer(EnumValue<InovicePaymentTerms> e) {
    return e.stringValue;
  }
  EnumValue<InovicePaymentTerms> inovicePaymentTermsDeserializer(dynamic data) {
    switch (data) {
      
      case 'NET_30':
        return const Known(InovicePaymentTerms.NET_30);
      
      case 'NET_45':
        return const Known(InovicePaymentTerms.NET_45);
      
      case 'NET_60':
        return const Known(InovicePaymentTerms.NET_60);
      
      default:
        return Unknown(data);
    }
  }
  

  enum InovicePaymentTermsTemp {
    
      NET_30,
    
      NET_45,
    
      NET_60,
    
  }
  
  String inovicePaymentTermsTempSerializer(EnumValue<InovicePaymentTermsTemp> e) {
    return e.stringValue;
  }
  EnumValue<InovicePaymentTermsTemp> inovicePaymentTermsTempDeserializer(dynamic data) {
    switch (data) {
      
      case 'NET_30':
        return const Known(InovicePaymentTermsTemp.NET_30);
      
      case 'NET_45':
        return const Known(InovicePaymentTermsTemp.NET_45);
      
      case 'NET_60':
        return const Known(InovicePaymentTermsTemp.NET_60);
      
      default:
        return Unknown(data);
    }
  }
  

  enum InvoiceStatus {
    
      PAID,
    
      PENDING,
    
      OVERDUE,
    
      PENDING_REVIEW,
    
      APPROVED,
    
      DISPUTED,
    
      DRAFT,
    
  }
  
  String invoiceStatusSerializer(EnumValue<InvoiceStatus> e) {
    return e.stringValue;
  }
  EnumValue<InvoiceStatus> invoiceStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'PAID':
        return const Known(InvoiceStatus.PAID);
      
      case 'PENDING':
        return const Known(InvoiceStatus.PENDING);
      
      case 'OVERDUE':
        return const Known(InvoiceStatus.OVERDUE);
      
      case 'PENDING_REVIEW':
        return const Known(InvoiceStatus.PENDING_REVIEW);
      
      case 'APPROVED':
        return const Known(InvoiceStatus.APPROVED);
      
      case 'DISPUTED':
        return const Known(InvoiceStatus.DISPUTED);
      
      case 'DRAFT':
        return const Known(InvoiceStatus.DRAFT);
      
      default:
        return Unknown(data);
    }
  }
  

  enum MaritalStatus {
    
      SINGLE,
    
      MARRIED,
    
      HEAD,
    
  }
  
  String maritalStatusSerializer(EnumValue<MaritalStatus> e) {
    return e.stringValue;
  }
  EnumValue<MaritalStatus> maritalStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'SINGLE':
        return const Known(MaritalStatus.SINGLE);
      
      case 'MARRIED':
        return const Known(MaritalStatus.MARRIED);
      
      case 'HEAD':
        return const Known(MaritalStatus.HEAD);
      
      default:
        return Unknown(data);
    }
  }
  

  enum OrderDuration {
    
      WEEKLY,
    
      MONTHLY,
    
  }
  
  String orderDurationSerializer(EnumValue<OrderDuration> e) {
    return e.stringValue;
  }
  EnumValue<OrderDuration> orderDurationDeserializer(dynamic data) {
    switch (data) {
      
      case 'WEEKLY':
        return const Known(OrderDuration.WEEKLY);
      
      case 'MONTHLY':
        return const Known(OrderDuration.MONTHLY);
      
      default:
        return Unknown(data);
    }
  }
  

  enum OrderStatus {
    
      DRAFT,
    
      POSTED,
    
      FILLED,
    
      COMPLETED,
    
      CANCELLED,
    
      PENDING,
    
      FULLY_STAFFED,
    
      PARTIAL_STAFFED,
    
  }
  
  String orderStatusSerializer(EnumValue<OrderStatus> e) {
    return e.stringValue;
  }
  EnumValue<OrderStatus> orderStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'DRAFT':
        return const Known(OrderStatus.DRAFT);
      
      case 'POSTED':
        return const Known(OrderStatus.POSTED);
      
      case 'FILLED':
        return const Known(OrderStatus.FILLED);
      
      case 'COMPLETED':
        return const Known(OrderStatus.COMPLETED);
      
      case 'CANCELLED':
        return const Known(OrderStatus.CANCELLED);
      
      case 'PENDING':
        return const Known(OrderStatus.PENDING);
      
      case 'FULLY_STAFFED':
        return const Known(OrderStatus.FULLY_STAFFED);
      
      case 'PARTIAL_STAFFED':
        return const Known(OrderStatus.PARTIAL_STAFFED);
      
      default:
        return Unknown(data);
    }
  }
  

  enum OrderType {
    
      ONE_TIME,
    
      PERMANENT,
    
      RECURRING,
    
      RAPID,
    
  }
  
  String orderTypeSerializer(EnumValue<OrderType> e) {
    return e.stringValue;
  }
  EnumValue<OrderType> orderTypeDeserializer(dynamic data) {
    switch (data) {
      
      case 'ONE_TIME':
        return const Known(OrderType.ONE_TIME);
      
      case 'PERMANENT':
        return const Known(OrderType.PERMANENT);
      
      case 'RECURRING':
        return const Known(OrderType.RECURRING);
      
      case 'RAPID':
        return const Known(OrderType.RAPID);
      
      default:
        return Unknown(data);
    }
  }
  

  enum RecentPaymentStatus {
    
      PAID,
    
      PENDING,
    
      FAILED,
    
  }
  
  String recentPaymentStatusSerializer(EnumValue<RecentPaymentStatus> e) {
    return e.stringValue;
  }
  EnumValue<RecentPaymentStatus> recentPaymentStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'PAID':
        return const Known(RecentPaymentStatus.PAID);
      
      case 'PENDING':
        return const Known(RecentPaymentStatus.PENDING);
      
      case 'FAILED':
        return const Known(RecentPaymentStatus.FAILED);
      
      default:
        return Unknown(data);
    }
  }
  

  enum RelationshipType {
    
      FAMILY,
    
      SPOUSE,
    
      FRIEND,
    
      OTHER,
    
  }
  
  String relationshipTypeSerializer(EnumValue<RelationshipType> e) {
    return e.stringValue;
  }
  EnumValue<RelationshipType> relationshipTypeDeserializer(dynamic data) {
    switch (data) {
      
      case 'FAMILY':
        return const Known(RelationshipType.FAMILY);
      
      case 'SPOUSE':
        return const Known(RelationshipType.SPOUSE);
      
      case 'FRIEND':
        return const Known(RelationshipType.FRIEND);
      
      case 'OTHER':
        return const Known(RelationshipType.OTHER);
      
      default:
        return Unknown(data);
    }
  }
  

  enum RoleCategoryType {
    
      KITCHEN_AND_CULINARY,
    
      CONCESSIONS,
    
      FACILITIES,
    
      BARTENDING,
    
      SECURITY,
    
      EVENT_STAFF,
    
      MANAGEMENT,
    
      TECHNICAL,
    
      OTHER,
    
  }
  
  String roleCategoryTypeSerializer(EnumValue<RoleCategoryType> e) {
    return e.stringValue;
  }
  EnumValue<RoleCategoryType> roleCategoryTypeDeserializer(dynamic data) {
    switch (data) {
      
      case 'KITCHEN_AND_CULINARY':
        return const Known(RoleCategoryType.KITCHEN_AND_CULINARY);
      
      case 'CONCESSIONS':
        return const Known(RoleCategoryType.CONCESSIONS);
      
      case 'FACILITIES':
        return const Known(RoleCategoryType.FACILITIES);
      
      case 'BARTENDING':
        return const Known(RoleCategoryType.BARTENDING);
      
      case 'SECURITY':
        return const Known(RoleCategoryType.SECURITY);
      
      case 'EVENT_STAFF':
        return const Known(RoleCategoryType.EVENT_STAFF);
      
      case 'MANAGEMENT':
        return const Known(RoleCategoryType.MANAGEMENT);
      
      case 'TECHNICAL':
        return const Known(RoleCategoryType.TECHNICAL);
      
      case 'OTHER':
        return const Known(RoleCategoryType.OTHER);
      
      default:
        return Unknown(data);
    }
  }
  

  enum RoleType {
    
      SKILLED,
    
      BEGINNER,
    
      CROSS_TRAINED,
    
  }
  
  String roleTypeSerializer(EnumValue<RoleType> e) {
    return e.stringValue;
  }
  EnumValue<RoleType> roleTypeDeserializer(dynamic data) {
    switch (data) {
      
      case 'SKILLED':
        return const Known(RoleType.SKILLED);
      
      case 'BEGINNER':
        return const Known(RoleType.BEGINNER);
      
      case 'CROSS_TRAINED':
        return const Known(RoleType.CROSS_TRAINED);
      
      default:
        return Unknown(data);
    }
  }
  

  enum ShiftStatus {
    
      DRAFT,
    
      FILLED,
    
      PENDING,
    
      ASSIGNED,
    
      CONFIRMED,
    
      OPEN,
    
      IN_PROGRESS,
    
      COMPLETED,
    
      CANCELED,
    
  }
  
  String shiftStatusSerializer(EnumValue<ShiftStatus> e) {
    return e.stringValue;
  }
  EnumValue<ShiftStatus> shiftStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'DRAFT':
        return const Known(ShiftStatus.DRAFT);
      
      case 'FILLED':
        return const Known(ShiftStatus.FILLED);
      
      case 'PENDING':
        return const Known(ShiftStatus.PENDING);
      
      case 'ASSIGNED':
        return const Known(ShiftStatus.ASSIGNED);
      
      case 'CONFIRMED':
        return const Known(ShiftStatus.CONFIRMED);
      
      case 'OPEN':
        return const Known(ShiftStatus.OPEN);
      
      case 'IN_PROGRESS':
        return const Known(ShiftStatus.IN_PROGRESS);
      
      case 'COMPLETED':
        return const Known(ShiftStatus.COMPLETED);
      
      case 'CANCELED':
        return const Known(ShiftStatus.CANCELED);
      
      default:
        return Unknown(data);
    }
  }
  

  enum TaskPriority {
    
      LOW,
    
      NORMAL,
    
      HIGH,
    
  }
  
  String taskPrioritySerializer(EnumValue<TaskPriority> e) {
    return e.stringValue;
  }
  EnumValue<TaskPriority> taskPriorityDeserializer(dynamic data) {
    switch (data) {
      
      case 'LOW':
        return const Known(TaskPriority.LOW);
      
      case 'NORMAL':
        return const Known(TaskPriority.NORMAL);
      
      case 'HIGH':
        return const Known(TaskPriority.HIGH);
      
      default:
        return Unknown(data);
    }
  }
  

  enum TaskStatus {
    
      PENDING,
    
      IN_PROGRESS,
    
      COMPLETED,
    
  }
  
  String taskStatusSerializer(EnumValue<TaskStatus> e) {
    return e.stringValue;
  }
  EnumValue<TaskStatus> taskStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'PENDING':
        return const Known(TaskStatus.PENDING);
      
      case 'IN_PROGRESS':
        return const Known(TaskStatus.IN_PROGRESS);
      
      case 'COMPLETED':
        return const Known(TaskStatus.COMPLETED);
      
      default:
        return Unknown(data);
    }
  }
  

  enum TaxFormStatus {
    
      NOT_STARTED,
    
      DRAFT,
    
      SUBMITTED,
    
      APPROVED,
    
      REJECTED,
    
  }
  
  String taxFormStatusSerializer(EnumValue<TaxFormStatus> e) {
    return e.stringValue;
  }
  EnumValue<TaxFormStatus> taxFormStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'NOT_STARTED':
        return const Known(TaxFormStatus.NOT_STARTED);
      
      case 'DRAFT':
        return const Known(TaxFormStatus.DRAFT);
      
      case 'SUBMITTED':
        return const Known(TaxFormStatus.SUBMITTED);
      
      case 'APPROVED':
        return const Known(TaxFormStatus.APPROVED);
      
      case 'REJECTED':
        return const Known(TaxFormStatus.REJECTED);
      
      default:
        return Unknown(data);
    }
  }
  

  enum TaxFormType {
    
      I9,
    
      W4,
    
  }
  
  String taxFormTypeSerializer(EnumValue<TaxFormType> e) {
    return e.stringValue;
  }
  EnumValue<TaxFormType> taxFormTypeDeserializer(dynamic data) {
    switch (data) {
      
      case 'I9':
        return const Known(TaxFormType.I9);
      
      case 'W4':
        return const Known(TaxFormType.W4);
      
      default:
        return Unknown(data);
    }
  }
  

  enum TeamMemberInviteStatus {
    
      PENDING,
    
      ACCEPTED,
    
      CANCELLED,
    
  }
  
  String teamMemberInviteStatusSerializer(EnumValue<TeamMemberInviteStatus> e) {
    return e.stringValue;
  }
  EnumValue<TeamMemberInviteStatus> teamMemberInviteStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'PENDING':
        return const Known(TeamMemberInviteStatus.PENDING);
      
      case 'ACCEPTED':
        return const Known(TeamMemberInviteStatus.ACCEPTED);
      
      case 'CANCELLED':
        return const Known(TeamMemberInviteStatus.CANCELLED);
      
      default:
        return Unknown(data);
    }
  }
  

  enum TeamMemberRole {
    
      OWNER,
    
      ADMIN,
    
      MEMBER,
    
      MANAGER,
    
      VIEWER,
    
  }
  
  String teamMemberRoleSerializer(EnumValue<TeamMemberRole> e) {
    return e.stringValue;
  }
  EnumValue<TeamMemberRole> teamMemberRoleDeserializer(dynamic data) {
    switch (data) {
      
      case 'OWNER':
        return const Known(TeamMemberRole.OWNER);
      
      case 'ADMIN':
        return const Known(TeamMemberRole.ADMIN);
      
      case 'MEMBER':
        return const Known(TeamMemberRole.MEMBER);
      
      case 'MANAGER':
        return const Known(TeamMemberRole.MANAGER);
      
      case 'VIEWER':
        return const Known(TeamMemberRole.VIEWER);
      
      default:
        return Unknown(data);
    }
  }
  

  enum UserBaseRole {
    
      ADMIN,
    
      USER,
    
  }
  
  String userBaseRoleSerializer(EnumValue<UserBaseRole> e) {
    return e.stringValue;
  }
  EnumValue<UserBaseRole> userBaseRoleDeserializer(dynamic data) {
    switch (data) {
      
      case 'ADMIN':
        return const Known(UserBaseRole.ADMIN);
      
      case 'USER':
        return const Known(UserBaseRole.USER);
      
      default:
        return Unknown(data);
    }
  }
  

  enum ValidationStatus {
    
      APPROVED,
    
      PENDING_EXPERT_REVIEW,
    
      REJECTED,
    
      AI_VERIFIED,
    
      AI_FLAGGED,
    
      MANUAL_REVIEW_NEEDED,
    
  }
  
  String validationStatusSerializer(EnumValue<ValidationStatus> e) {
    return e.stringValue;
  }
  EnumValue<ValidationStatus> validationStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'APPROVED':
        return const Known(ValidationStatus.APPROVED);
      
      case 'PENDING_EXPERT_REVIEW':
        return const Known(ValidationStatus.PENDING_EXPERT_REVIEW);
      
      case 'REJECTED':
        return const Known(ValidationStatus.REJECTED);
      
      case 'AI_VERIFIED':
        return const Known(ValidationStatus.AI_VERIFIED);
      
      case 'AI_FLAGGED':
        return const Known(ValidationStatus.AI_FLAGGED);
      
      case 'MANUAL_REVIEW_NEEDED':
        return const Known(ValidationStatus.MANUAL_REVIEW_NEEDED);
      
      default:
        return Unknown(data);
    }
  }
  

  enum VendorTier {
    
      PREFERRED,
    
      APPROVED,
    
      STANDARD,
    
  }
  
  String vendorTierSerializer(EnumValue<VendorTier> e) {
    return e.stringValue;
  }
  EnumValue<VendorTier> vendorTierDeserializer(dynamic data) {
    switch (data) {
      
      case 'PREFERRED':
        return const Known(VendorTier.PREFERRED);
      
      case 'APPROVED':
        return const Known(VendorTier.APPROVED);
      
      case 'STANDARD':
        return const Known(VendorTier.STANDARD);
      
      default:
        return Unknown(data);
    }
  }
  

  enum WorkforceEmploymentType {
    
      W2,
    
      W1099,
    
      TEMPORARY,
    
      CONTRACT,
    
  }
  
  String workforceEmploymentTypeSerializer(EnumValue<WorkforceEmploymentType> e) {
    return e.stringValue;
  }
  EnumValue<WorkforceEmploymentType> workforceEmploymentTypeDeserializer(dynamic data) {
    switch (data) {
      
      case 'W2':
        return const Known(WorkforceEmploymentType.W2);
      
      case 'W1099':
        return const Known(WorkforceEmploymentType.W1099);
      
      case 'TEMPORARY':
        return const Known(WorkforceEmploymentType.TEMPORARY);
      
      case 'CONTRACT':
        return const Known(WorkforceEmploymentType.CONTRACT);
      
      default:
        return Unknown(data);
    }
  }
  

  enum WorkforceStatus {
    
      ACTIVE,
    
      INACTIVE,
    
  }
  
  String workforceStatusSerializer(EnumValue<WorkforceStatus> e) {
    return e.stringValue;
  }
  EnumValue<WorkforceStatus> workforceStatusDeserializer(dynamic data) {
    switch (data) {
      
      case 'ACTIVE':
        return const Known(WorkforceStatus.ACTIVE);
      
      case 'INACTIVE':
        return const Known(WorkforceStatus.INACTIVE);
      
      default:
        return Unknown(data);
    }
  }
  



String enumSerializer(Enum e) {
  return e.name;
}



/// A sealed class representing either a known enum value or an unknown string value.
@immutable
sealed class EnumValue<T extends Enum> {
  const EnumValue();

  

  /// The string representation of the value.
  String get stringValue;
  @override
  String toString() {
    return "EnumValue($stringValue)";
  }
}

/// Represents a known, valid enum value.
class Known<T extends Enum> extends EnumValue<T> {
  /// The actual enum value.
  final T value;

  const Known(this.value);

  @override
  String get stringValue => value.name;

  @override
  String toString() {
    return "Known($stringValue)";
  }
}
/// Represents an unknown or unrecognized enum value.
class Unknown extends EnumValue<Never> {
  /// The raw string value that couldn't be mapped to a known enum.
  @override
  final String stringValue;

  const Unknown(this.stringValue);
  @override
  String toString() {
    return "Unknown($stringValue)";
  }
}

class ExampleConnector {
  
  
  CreateRecentPaymentVariablesBuilder createRecentPayment ({required String staffId, required String applicationId, required String invoiceId, }) {
    return CreateRecentPaymentVariablesBuilder(dataConnect, staffId: staffId,applicationId: applicationId,invoiceId: invoiceId,);
  }
  
  
  UpdateRecentPaymentVariablesBuilder updateRecentPayment ({required String id, }) {
    return UpdateRecentPaymentVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteRecentPaymentVariablesBuilder deleteRecentPayment ({required String id, }) {
    return DeleteRecentPaymentVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateStaffVariablesBuilder createStaff ({required String userId, required String fullName, }) {
    return CreateStaffVariablesBuilder(dataConnect, userId: userId,fullName: fullName,);
  }
  
  
  UpdateStaffVariablesBuilder updateStaff ({required String id, }) {
    return UpdateStaffVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteStaffVariablesBuilder deleteStaff ({required String id, }) {
    return DeleteStaffVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetStaffDocumentByKeyVariablesBuilder getStaffDocumentByKey ({required String staffId, required String documentId, }) {
    return GetStaffDocumentByKeyVariablesBuilder(dataConnect, staffId: staffId,documentId: documentId,);
  }
  
  
  ListStaffDocumentsByStaffIdVariablesBuilder listStaffDocumentsByStaffId ({required String staffId, }) {
    return ListStaffDocumentsByStaffIdVariablesBuilder(dataConnect, staffId: staffId,);
  }
  
  
  ListStaffDocumentsByDocumentTypeVariablesBuilder listStaffDocumentsByDocumentType ({required DocumentType documentType, }) {
    return ListStaffDocumentsByDocumentTypeVariablesBuilder(dataConnect, documentType: documentType,);
  }
  
  
  ListStaffDocumentsByStatusVariablesBuilder listStaffDocumentsByStatus ({required DocumentStatus status, }) {
    return ListStaffDocumentsByStatusVariablesBuilder(dataConnect, status: status,);
  }
  
  
  ListTaxFormsVariablesBuilder listTaxForms () {
    return ListTaxFormsVariablesBuilder(dataConnect, );
  }
  
  
  GetTaxFormByIdVariablesBuilder getTaxFormById ({required String id, }) {
    return GetTaxFormByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetTaxFormsByStaffIdVariablesBuilder getTaxFormsByStaffId ({required String staffId, }) {
    return GetTaxFormsByStaffIdVariablesBuilder(dataConnect, staffId: staffId,);
  }
  
  
  ListTaxFormsWhereVariablesBuilder listTaxFormsWhere () {
    return ListTaxFormsWhereVariablesBuilder(dataConnect, );
  }
  
  
  ListTeamHubsVariablesBuilder listTeamHubs () {
    return ListTeamHubsVariablesBuilder(dataConnect, );
  }
  
  
  GetTeamHubByIdVariablesBuilder getTeamHubById ({required String id, }) {
    return GetTeamHubByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetTeamHubsByTeamIdVariablesBuilder getTeamHubsByTeamId ({required String teamId, }) {
    return GetTeamHubsByTeamIdVariablesBuilder(dataConnect, teamId: teamId,);
  }
  
  
  ListTeamHubsByOwnerIdVariablesBuilder listTeamHubsByOwnerId ({required String ownerId, }) {
    return ListTeamHubsByOwnerIdVariablesBuilder(dataConnect, ownerId: ownerId,);
  }
  
  
  CreateActivityLogVariablesBuilder createActivityLog ({required String userId, required Timestamp date, required String title, required String description, required ActivityType activityType, }) {
    return CreateActivityLogVariablesBuilder(dataConnect, userId: userId,date: date,title: title,description: description,activityType: activityType,);
  }
  
  
  UpdateActivityLogVariablesBuilder updateActivityLog ({required String id, }) {
    return UpdateActivityLogVariablesBuilder(dataConnect, id: id,);
  }
  
  
  MarkActivityLogAsReadVariablesBuilder markActivityLogAsRead ({required String id, }) {
    return MarkActivityLogAsReadVariablesBuilder(dataConnect, id: id,);
  }
  
  
  MarkActivityLogsAsReadVariablesBuilder markActivityLogsAsRead ({required List<String> ids, }) {
    return MarkActivityLogsAsReadVariablesBuilder(dataConnect, ids: ids,);
  }
  
  
  DeleteActivityLogVariablesBuilder deleteActivityLog ({required String id, }) {
    return DeleteActivityLogVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateLevelVariablesBuilder createLevel ({required String name, required int xpRequired, }) {
    return CreateLevelVariablesBuilder(dataConnect, name: name,xpRequired: xpRequired,);
  }
  
  
  UpdateLevelVariablesBuilder updateLevel ({required String id, }) {
    return UpdateLevelVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteLevelVariablesBuilder deleteLevel ({required String id, }) {
    return DeleteLevelVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateMemberTaskVariablesBuilder createMemberTask ({required String teamMemberId, required String taskId, }) {
    return CreateMemberTaskVariablesBuilder(dataConnect, teamMemberId: teamMemberId,taskId: taskId,);
  }
  
  
  DeleteMemberTaskVariablesBuilder deleteMemberTask ({required String teamMemberId, required String taskId, }) {
    return DeleteMemberTaskVariablesBuilder(dataConnect, teamMemberId: teamMemberId,taskId: taskId,);
  }
  
  
  ListShiftsVariablesBuilder listShifts () {
    return ListShiftsVariablesBuilder(dataConnect, );
  }
  
  
  GetShiftByIdVariablesBuilder getShiftById ({required String id, }) {
    return GetShiftByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  FilterShiftsVariablesBuilder filterShifts () {
    return FilterShiftsVariablesBuilder(dataConnect, );
  }
  
  
  GetShiftsByBusinessIdVariablesBuilder getShiftsByBusinessId ({required String businessId, }) {
    return GetShiftsByBusinessIdVariablesBuilder(dataConnect, businessId: businessId,);
  }
  
  
  GetShiftsByVendorIdVariablesBuilder getShiftsByVendorId ({required String vendorId, }) {
    return GetShiftsByVendorIdVariablesBuilder(dataConnect, vendorId: vendorId,);
  }
  
  
  ListStaffVariablesBuilder listStaff () {
    return ListStaffVariablesBuilder(dataConnect, );
  }
  
  
  GetStaffByIdVariablesBuilder getStaffById ({required String id, }) {
    return GetStaffByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetStaffByUserIdVariablesBuilder getStaffByUserId ({required String userId, }) {
    return GetStaffByUserIdVariablesBuilder(dataConnect, userId: userId,);
  }
  
  
  FilterStaffVariablesBuilder filterStaff () {
    return FilterStaffVariablesBuilder(dataConnect, );
  }
  
  
  ListTeamsVariablesBuilder listTeams () {
    return ListTeamsVariablesBuilder(dataConnect, );
  }
  
  
  GetTeamByIdVariablesBuilder getTeamById ({required String id, }) {
    return GetTeamByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetTeamsByOwnerIdVariablesBuilder getTeamsByOwnerId ({required String ownerId, }) {
    return GetTeamsByOwnerIdVariablesBuilder(dataConnect, ownerId: ownerId,);
  }
  
  
  CreateTeamMemberVariablesBuilder createTeamMember ({required String teamId, required TeamMemberRole role, required String userId, }) {
    return CreateTeamMemberVariablesBuilder(dataConnect, teamId: teamId,role: role,userId: userId,);
  }
  
  
  UpdateTeamMemberVariablesBuilder updateTeamMember ({required String id, }) {
    return UpdateTeamMemberVariablesBuilder(dataConnect, id: id,);
  }
  
  
  UpdateTeamMemberInviteStatusVariablesBuilder updateTeamMemberInviteStatus ({required String id, required TeamMemberInviteStatus inviteStatus, }) {
    return UpdateTeamMemberInviteStatusVariablesBuilder(dataConnect, id: id,inviteStatus: inviteStatus,);
  }
  
  
  AcceptInviteByCodeVariablesBuilder acceptInviteByCode ({required String inviteCode, }) {
    return AcceptInviteByCodeVariablesBuilder(dataConnect, inviteCode: inviteCode,);
  }
  
  
  CancelInviteByCodeVariablesBuilder cancelInviteByCode ({required String inviteCode, }) {
    return CancelInviteByCodeVariablesBuilder(dataConnect, inviteCode: inviteCode,);
  }
  
  
  DeleteTeamMemberVariablesBuilder deleteTeamMember ({required String id, }) {
    return DeleteTeamMemberVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateCourseVariablesBuilder createCourse ({required String categoryId, }) {
    return CreateCourseVariablesBuilder(dataConnect, categoryId: categoryId,);
  }
  
  
  UpdateCourseVariablesBuilder updateCourse ({required String id, required String categoryId, }) {
    return UpdateCourseVariablesBuilder(dataConnect, id: id,categoryId: categoryId,);
  }
  
  
  DeleteCourseVariablesBuilder deleteCourse ({required String id, }) {
    return DeleteCourseVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateDocumentVariablesBuilder createDocument ({required DocumentType documentType, required String name, }) {
    return CreateDocumentVariablesBuilder(dataConnect, documentType: documentType,name: name,);
  }
  
  
  UpdateDocumentVariablesBuilder updateDocument ({required String id, }) {
    return UpdateDocumentVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteDocumentVariablesBuilder deleteDocument ({required String id, }) {
    return DeleteDocumentVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateInvoiceVariablesBuilder createInvoice ({required InvoiceStatus status, required String vendorId, required String businessId, required String orderId, required String invoiceNumber, required Timestamp issueDate, required Timestamp dueDate, required double amount, }) {
    return CreateInvoiceVariablesBuilder(dataConnect, status: status,vendorId: vendorId,businessId: businessId,orderId: orderId,invoiceNumber: invoiceNumber,issueDate: issueDate,dueDate: dueDate,amount: amount,);
  }
  
  
  UpdateInvoiceVariablesBuilder updateInvoice ({required String id, }) {
    return UpdateInvoiceVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteInvoiceVariablesBuilder deleteInvoice ({required String id, }) {
    return DeleteInvoiceVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetMyTasksVariablesBuilder getMyTasks ({required String teamMemberId, }) {
    return GetMyTasksVariablesBuilder(dataConnect, teamMemberId: teamMemberId,);
  }
  
  
  GetMemberTaskByIdKeyVariablesBuilder getMemberTaskByIdKey ({required String teamMemberId, required String taskId, }) {
    return GetMemberTaskByIdKeyVariablesBuilder(dataConnect, teamMemberId: teamMemberId,taskId: taskId,);
  }
  
  
  GetMemberTasksByTaskIdVariablesBuilder getMemberTasksByTaskId ({required String taskId, }) {
    return GetMemberTasksByTaskIdVariablesBuilder(dataConnect, taskId: taskId,);
  }
  
  
  GetShiftRoleByIdVariablesBuilder getShiftRoleById ({required String shiftId, required String roleId, }) {
    return GetShiftRoleByIdVariablesBuilder(dataConnect, shiftId: shiftId,roleId: roleId,);
  }
  
  
  ListShiftRolesByShiftIdVariablesBuilder listShiftRolesByShiftId ({required String shiftId, }) {
    return ListShiftRolesByShiftIdVariablesBuilder(dataConnect, shiftId: shiftId,);
  }
  
  
  ListShiftRolesByRoleIdVariablesBuilder listShiftRolesByRoleId ({required String roleId, }) {
    return ListShiftRolesByRoleIdVariablesBuilder(dataConnect, roleId: roleId,);
  }
  
  
  ListShiftRolesByShiftIdAndTimeRangeVariablesBuilder listShiftRolesByShiftIdAndTimeRange ({required String shiftId, required Timestamp start, required Timestamp end, }) {
    return ListShiftRolesByShiftIdAndTimeRangeVariablesBuilder(dataConnect, shiftId: shiftId,start: start,end: end,);
  }
  
  
  ListShiftRolesByVendorIdVariablesBuilder listShiftRolesByVendorId ({required String vendorId, }) {
    return ListShiftRolesByVendorIdVariablesBuilder(dataConnect, vendorId: vendorId,);
  }
  
  
  ListShiftRolesByBusinessAndDateRangeVariablesBuilder listShiftRolesByBusinessAndDateRange ({required String businessId, required Timestamp start, required Timestamp end, }) {
    return ListShiftRolesByBusinessAndDateRangeVariablesBuilder(dataConnect, businessId: businessId,start: start,end: end,);
  }
  
  
  ListShiftRolesByBusinessAndOrderVariablesBuilder listShiftRolesByBusinessAndOrder ({required String businessId, required String orderId, }) {
    return ListShiftRolesByBusinessAndOrderVariablesBuilder(dataConnect, businessId: businessId,orderId: orderId,);
  }
  
  
  ListShiftRolesByBusinessDateRangeCompletedOrdersVariablesBuilder listShiftRolesByBusinessDateRangeCompletedOrders ({required String businessId, required Timestamp start, required Timestamp end, }) {
    return ListShiftRolesByBusinessDateRangeCompletedOrdersVariablesBuilder(dataConnect, businessId: businessId,start: start,end: end,);
  }
  
  
  ListShiftRolesByBusinessAndDatesSummaryVariablesBuilder listShiftRolesByBusinessAndDatesSummary ({required String businessId, required Timestamp start, required Timestamp end, }) {
    return ListShiftRolesByBusinessAndDatesSummaryVariablesBuilder(dataConnect, businessId: businessId,start: start,end: end,);
  }
  
  
  GetCompletedShiftsByBusinessIdVariablesBuilder getCompletedShiftsByBusinessId ({required String businessId, required Timestamp dateFrom, required Timestamp dateTo, }) {
    return GetCompletedShiftsByBusinessIdVariablesBuilder(dataConnect, businessId: businessId,dateFrom: dateFrom,dateTo: dateTo,);
  }
  
  
  CreateStaffDocumentVariablesBuilder createStaffDocument ({required String staffId, required String staffName, required String documentId, required DocumentStatus status, }) {
    return CreateStaffDocumentVariablesBuilder(dataConnect, staffId: staffId,staffName: staffName,documentId: documentId,status: status,);
  }
  
  
  UpdateStaffDocumentVariablesBuilder updateStaffDocument ({required String staffId, required String documentId, }) {
    return UpdateStaffDocumentVariablesBuilder(dataConnect, staffId: staffId,documentId: documentId,);
  }
  
  
  DeleteStaffDocumentVariablesBuilder deleteStaffDocument ({required String staffId, required String documentId, }) {
    return DeleteStaffDocumentVariablesBuilder(dataConnect, staffId: staffId,documentId: documentId,);
  }
  
  
  ListTasksVariablesBuilder listTasks () {
    return ListTasksVariablesBuilder(dataConnect, );
  }
  
  
  GetTaskByIdVariablesBuilder getTaskById ({required String id, }) {
    return GetTaskByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetTasksByOwnerIdVariablesBuilder getTasksByOwnerId ({required String ownerId, }) {
    return GetTasksByOwnerIdVariablesBuilder(dataConnect, ownerId: ownerId,);
  }
  
  
  FilterTasksVariablesBuilder filterTasks () {
    return FilterTasksVariablesBuilder(dataConnect, );
  }
  
  
  CreateVendorVariablesBuilder createVendor ({required String userId, required String companyName, }) {
    return CreateVendorVariablesBuilder(dataConnect, userId: userId,companyName: companyName,);
  }
  
  
  UpdateVendorVariablesBuilder updateVendor ({required String id, }) {
    return UpdateVendorVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteVendorVariablesBuilder deleteVendor ({required String id, }) {
    return DeleteVendorVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateShiftVariablesBuilder createShift ({required String title, required String orderId, }) {
    return CreateShiftVariablesBuilder(dataConnect, title: title,orderId: orderId,);
  }
  
  
  UpdateShiftVariablesBuilder updateShift ({required String id, }) {
    return UpdateShiftVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteShiftVariablesBuilder deleteShift ({required String id, }) {
    return DeleteShiftVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListApplicationsVariablesBuilder listApplications () {
    return ListApplicationsVariablesBuilder(dataConnect, );
  }
  
  
  GetApplicationByIdVariablesBuilder getApplicationById ({required String id, }) {
    return GetApplicationByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetApplicationsByShiftIdVariablesBuilder getApplicationsByShiftId ({required String shiftId, }) {
    return GetApplicationsByShiftIdVariablesBuilder(dataConnect, shiftId: shiftId,);
  }
  
  
  GetApplicationsByShiftIdAndStatusVariablesBuilder getApplicationsByShiftIdAndStatus ({required String shiftId, required ApplicationStatus status, }) {
    return GetApplicationsByShiftIdAndStatusVariablesBuilder(dataConnect, shiftId: shiftId,status: status,);
  }
  
  
  GetApplicationsByStaffIdVariablesBuilder getApplicationsByStaffId ({required String staffId, }) {
    return GetApplicationsByStaffIdVariablesBuilder(dataConnect, staffId: staffId,);
  }
  
  
  ListAcceptedApplicationsByShiftRoleKeyVariablesBuilder listAcceptedApplicationsByShiftRoleKey ({required String shiftId, required String roleId, }) {
    return ListAcceptedApplicationsByShiftRoleKeyVariablesBuilder(dataConnect, shiftId: shiftId,roleId: roleId,);
  }
  
  
  ListAcceptedApplicationsByBusinessForDayVariablesBuilder listAcceptedApplicationsByBusinessForDay ({required String businessId, required Timestamp dayStart, required Timestamp dayEnd, }) {
    return ListAcceptedApplicationsByBusinessForDayVariablesBuilder(dataConnect, businessId: businessId,dayStart: dayStart,dayEnd: dayEnd,);
  }
  
  
  ListStaffsApplicationsByBusinessForDayVariablesBuilder listStaffsApplicationsByBusinessForDay ({required String businessId, required Timestamp dayStart, required Timestamp dayEnd, }) {
    return ListStaffsApplicationsByBusinessForDayVariablesBuilder(dataConnect, businessId: businessId,dayStart: dayStart,dayEnd: dayEnd,);
  }
  
  
  ListBenefitsDataVariablesBuilder listBenefitsData () {
    return ListBenefitsDataVariablesBuilder(dataConnect, );
  }
  
  
  GetBenefitsDataByKeyVariablesBuilder getBenefitsDataByKey ({required String staffId, required String vendorBenefitPlanId, }) {
    return GetBenefitsDataByKeyVariablesBuilder(dataConnect, staffId: staffId,vendorBenefitPlanId: vendorBenefitPlanId,);
  }
  
  
  ListBenefitsDataByStaffIdVariablesBuilder listBenefitsDataByStaffId ({required String staffId, }) {
    return ListBenefitsDataByStaffIdVariablesBuilder(dataConnect, staffId: staffId,);
  }
  
  
  ListBenefitsDataByVendorBenefitPlanIdVariablesBuilder listBenefitsDataByVendorBenefitPlanId ({required String vendorBenefitPlanId, }) {
    return ListBenefitsDataByVendorBenefitPlanIdVariablesBuilder(dataConnect, vendorBenefitPlanId: vendorBenefitPlanId,);
  }
  
  
  ListBenefitsDataByVendorBenefitPlanIdsVariablesBuilder listBenefitsDataByVendorBenefitPlanIds ({required List<String> vendorBenefitPlanIds, }) {
    return ListBenefitsDataByVendorBenefitPlanIdsVariablesBuilder(dataConnect, vendorBenefitPlanIds: vendorBenefitPlanIds,);
  }
  
  
  ListCertificatesVariablesBuilder listCertificates () {
    return ListCertificatesVariablesBuilder(dataConnect, );
  }
  
  
  GetCertificateByIdVariablesBuilder getCertificateById ({required String id, }) {
    return GetCertificateByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListCertificatesByStaffIdVariablesBuilder listCertificatesByStaffId ({required String staffId, }) {
    return ListCertificatesByStaffIdVariablesBuilder(dataConnect, staffId: staffId,);
  }
  
  
  ListConversationsVariablesBuilder listConversations () {
    return ListConversationsVariablesBuilder(dataConnect, );
  }
  
  
  GetConversationByIdVariablesBuilder getConversationById ({required String id, }) {
    return GetConversationByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListConversationsByTypeVariablesBuilder listConversationsByType ({required ConversationType conversationType, }) {
    return ListConversationsByTypeVariablesBuilder(dataConnect, conversationType: conversationType,);
  }
  
  
  ListConversationsByStatusVariablesBuilder listConversationsByStatus ({required ConversationStatus status, }) {
    return ListConversationsByStatusVariablesBuilder(dataConnect, status: status,);
  }
  
  
  FilterConversationsVariablesBuilder filterConversations () {
    return FilterConversationsVariablesBuilder(dataConnect, );
  }
  
  
  CreateStaffRoleVariablesBuilder createStaffRole ({required String staffId, required String roleId, }) {
    return CreateStaffRoleVariablesBuilder(dataConnect, staffId: staffId,roleId: roleId,);
  }
  
  
  DeleteStaffRoleVariablesBuilder deleteStaffRole ({required String staffId, required String roleId, }) {
    return DeleteStaffRoleVariablesBuilder(dataConnect, staffId: staffId,roleId: roleId,);
  }
  
  
  CreateVendorBenefitPlanVariablesBuilder createVendorBenefitPlan ({required String vendorId, required String title, }) {
    return CreateVendorBenefitPlanVariablesBuilder(dataConnect, vendorId: vendorId,title: title,);
  }
  
  
  UpdateVendorBenefitPlanVariablesBuilder updateVendorBenefitPlan ({required String id, }) {
    return UpdateVendorBenefitPlanVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteVendorBenefitPlanVariablesBuilder deleteVendorBenefitPlan ({required String id, }) {
    return DeleteVendorBenefitPlanVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateVendorRateVariablesBuilder createVendorRate ({required String vendorId, }) {
    return CreateVendorRateVariablesBuilder(dataConnect, vendorId: vendorId,);
  }
  
  
  UpdateVendorRateVariablesBuilder updateVendorRate ({required String id, }) {
    return UpdateVendorRateVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteVendorRateVariablesBuilder deleteVendorRate ({required String id, }) {
    return DeleteVendorRateVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateFaqDataVariablesBuilder createFaqData ({required String category, }) {
    return CreateFaqDataVariablesBuilder(dataConnect, category: category,);
  }
  
  
  UpdateFaqDataVariablesBuilder updateFaqData ({required String id, }) {
    return UpdateFaqDataVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteFaqDataVariablesBuilder deleteFaqData ({required String id, }) {
    return DeleteFaqDataVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateOrderVariablesBuilder createOrder ({required String businessId, required OrderType orderType, required String teamHubId, }) {
    return CreateOrderVariablesBuilder(dataConnect, businessId: businessId,orderType: orderType,teamHubId: teamHubId,);
  }
  
  
  UpdateOrderVariablesBuilder updateOrder ({required String id, required String teamHubId, }) {
    return UpdateOrderVariablesBuilder(dataConnect, id: id,teamHubId: teamHubId,);
  }
  
  
  DeleteOrderVariablesBuilder deleteOrder ({required String id, }) {
    return DeleteOrderVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateRoleVariablesBuilder createRole ({required String name, required double costPerHour, required String vendorId, required String roleCategoryId, }) {
    return CreateRoleVariablesBuilder(dataConnect, name: name,costPerHour: costPerHour,vendorId: vendorId,roleCategoryId: roleCategoryId,);
  }
  
  
  UpdateRoleVariablesBuilder updateRole ({required String id, required String roleCategoryId, }) {
    return UpdateRoleVariablesBuilder(dataConnect, id: id,roleCategoryId: roleCategoryId,);
  }
  
  
  DeleteRoleVariablesBuilder deleteRole ({required String id, }) {
    return DeleteRoleVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateUserConversationVariablesBuilder createUserConversation ({required String conversationId, required String userId, }) {
    return CreateUserConversationVariablesBuilder(dataConnect, conversationId: conversationId,userId: userId,);
  }
  
  
  UpdateUserConversationVariablesBuilder updateUserConversation ({required String conversationId, required String userId, }) {
    return UpdateUserConversationVariablesBuilder(dataConnect, conversationId: conversationId,userId: userId,);
  }
  
  
  MarkConversationAsReadVariablesBuilder markConversationAsRead ({required String conversationId, required String userId, }) {
    return MarkConversationAsReadVariablesBuilder(dataConnect, conversationId: conversationId,userId: userId,);
  }
  
  
  IncrementUnreadForUserVariablesBuilder incrementUnreadForUser ({required String conversationId, required String userId, required int unreadCount, }) {
    return IncrementUnreadForUserVariablesBuilder(dataConnect, conversationId: conversationId,userId: userId,unreadCount: unreadCount,);
  }
  
  
  DeleteUserConversationVariablesBuilder deleteUserConversation ({required String conversationId, required String userId, }) {
    return DeleteUserConversationVariablesBuilder(dataConnect, conversationId: conversationId,userId: userId,);
  }
  
  
  CreateStaffCourseVariablesBuilder createStaffCourse ({required String staffId, required String courseId, }) {
    return CreateStaffCourseVariablesBuilder(dataConnect, staffId: staffId,courseId: courseId,);
  }
  
  
  UpdateStaffCourseVariablesBuilder updateStaffCourse ({required String id, }) {
    return UpdateStaffCourseVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteStaffCourseVariablesBuilder deleteStaffCourse ({required String id, }) {
    return DeleteStaffCourseVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListVendorBenefitPlansVariablesBuilder listVendorBenefitPlans () {
    return ListVendorBenefitPlansVariablesBuilder(dataConnect, );
  }
  
  
  GetVendorBenefitPlanByIdVariablesBuilder getVendorBenefitPlanById ({required String id, }) {
    return GetVendorBenefitPlanByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListVendorBenefitPlansByVendorIdVariablesBuilder listVendorBenefitPlansByVendorId ({required String vendorId, }) {
    return ListVendorBenefitPlansByVendorIdVariablesBuilder(dataConnect, vendorId: vendorId,);
  }
  
  
  ListActiveVendorBenefitPlansByVendorIdVariablesBuilder listActiveVendorBenefitPlansByVendorId ({required String vendorId, }) {
    return ListActiveVendorBenefitPlansByVendorIdVariablesBuilder(dataConnect, vendorId: vendorId,);
  }
  
  
  FilterVendorBenefitPlansVariablesBuilder filterVendorBenefitPlans () {
    return FilterVendorBenefitPlansVariablesBuilder(dataConnect, );
  }
  
  
  ListVendorRatesVariablesBuilder listVendorRates () {
    return ListVendorRatesVariablesBuilder(dataConnect, );
  }
  
  
  GetVendorRateByIdVariablesBuilder getVendorRateById ({required String id, }) {
    return GetVendorRateByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetWorkforceByIdVariablesBuilder getWorkforceById ({required String id, }) {
    return GetWorkforceByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetWorkforceByVendorAndStaffVariablesBuilder getWorkforceByVendorAndStaff ({required String vendorId, required String staffId, }) {
    return GetWorkforceByVendorAndStaffVariablesBuilder(dataConnect, vendorId: vendorId,staffId: staffId,);
  }
  
  
  ListWorkforceByVendorIdVariablesBuilder listWorkforceByVendorId ({required String vendorId, }) {
    return ListWorkforceByVendorIdVariablesBuilder(dataConnect, vendorId: vendorId,);
  }
  
  
  ListWorkforceByStaffIdVariablesBuilder listWorkforceByStaffId ({required String staffId, }) {
    return ListWorkforceByStaffIdVariablesBuilder(dataConnect, staffId: staffId,);
  }
  
  
  GetWorkforceByVendorAndNumberVariablesBuilder getWorkforceByVendorAndNumber ({required String vendorId, required String workforceNumber, }) {
    return GetWorkforceByVendorAndNumberVariablesBuilder(dataConnect, vendorId: vendorId,workforceNumber: workforceNumber,);
  }
  
  
  ListActivityLogsVariablesBuilder listActivityLogs () {
    return ListActivityLogsVariablesBuilder(dataConnect, );
  }
  
  
  GetActivityLogByIdVariablesBuilder getActivityLogById ({required String id, }) {
    return GetActivityLogByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListActivityLogsByUserIdVariablesBuilder listActivityLogsByUserId ({required String userId, }) {
    return ListActivityLogsByUserIdVariablesBuilder(dataConnect, userId: userId,);
  }
  
  
  ListUnreadActivityLogsByUserIdVariablesBuilder listUnreadActivityLogsByUserId ({required String userId, }) {
    return ListUnreadActivityLogsByUserIdVariablesBuilder(dataConnect, userId: userId,);
  }
  
  
  FilterActivityLogsVariablesBuilder filterActivityLogs () {
    return FilterActivityLogsVariablesBuilder(dataConnect, );
  }
  
  
  ListBusinessesVariablesBuilder listBusinesses () {
    return ListBusinessesVariablesBuilder(dataConnect, );
  }
  
  
  GetBusinessesByUserIdVariablesBuilder getBusinessesByUserId ({required String userId, }) {
    return GetBusinessesByUserIdVariablesBuilder(dataConnect, userId: userId,);
  }
  
  
  GetBusinessByIdVariablesBuilder getBusinessById ({required String id, }) {
    return GetBusinessByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateShiftRoleVariablesBuilder createShiftRole ({required String shiftId, required String roleId, required int count, }) {
    return CreateShiftRoleVariablesBuilder(dataConnect, shiftId: shiftId,roleId: roleId,count: count,);
  }
  
  
  UpdateShiftRoleVariablesBuilder updateShiftRole ({required String shiftId, required String roleId, }) {
    return UpdateShiftRoleVariablesBuilder(dataConnect, shiftId: shiftId,roleId: roleId,);
  }
  
  
  DeleteShiftRoleVariablesBuilder deleteShiftRole ({required String shiftId, required String roleId, }) {
    return DeleteShiftRoleVariablesBuilder(dataConnect, shiftId: shiftId,roleId: roleId,);
  }
  
  
  CreateTaskVariablesBuilder createTask ({required String taskName, required TaskPriority priority, required TaskStatus status, required String ownerId, }) {
    return CreateTaskVariablesBuilder(dataConnect, taskName: taskName,priority: priority,status: status,ownerId: ownerId,);
  }
  
  
  UpdateTaskVariablesBuilder updateTask ({required String id, }) {
    return UpdateTaskVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteTaskVariablesBuilder deleteTask ({required String id, }) {
    return DeleteTaskVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateTeamHudDepartmentVariablesBuilder createTeamHudDepartment ({required String name, required String teamHubId, }) {
    return CreateTeamHudDepartmentVariablesBuilder(dataConnect, name: name,teamHubId: teamHubId,);
  }
  
  
  UpdateTeamHudDepartmentVariablesBuilder updateTeamHudDepartment ({required String id, }) {
    return UpdateTeamHudDepartmentVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteTeamHudDepartmentVariablesBuilder deleteTeamHudDepartment ({required String id, }) {
    return DeleteTeamHudDepartmentVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateWorkforceVariablesBuilder createWorkforce ({required String vendorId, required String staffId, required String workforceNumber, }) {
    return CreateWorkforceVariablesBuilder(dataConnect, vendorId: vendorId,staffId: staffId,workforceNumber: workforceNumber,);
  }
  
  
  UpdateWorkforceVariablesBuilder updateWorkforce ({required String id, }) {
    return UpdateWorkforceVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeactivateWorkforceVariablesBuilder deactivateWorkforce ({required String id, }) {
    return DeactivateWorkforceVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateAccountVariablesBuilder createAccount ({required String bank, required AccountType type, required String last4, required String ownerId, }) {
    return CreateAccountVariablesBuilder(dataConnect, bank: bank,type: type,last4: last4,ownerId: ownerId,);
  }
  
  
  UpdateAccountVariablesBuilder updateAccount ({required String id, }) {
    return UpdateAccountVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteAccountVariablesBuilder deleteAccount ({required String id, }) {
    return DeleteAccountVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListFaqDatasVariablesBuilder listFaqDatas () {
    return ListFaqDatasVariablesBuilder(dataConnect, );
  }
  
  
  GetFaqDataByIdVariablesBuilder getFaqDataById ({required String id, }) {
    return GetFaqDataByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  FilterFaqDatasVariablesBuilder filterFaqDatas () {
    return FilterFaqDatasVariablesBuilder(dataConnect, );
  }
  
  
  CreateStaffAvailabilityStatsVariablesBuilder createStaffAvailabilityStats ({required String staffId, }) {
    return CreateStaffAvailabilityStatsVariablesBuilder(dataConnect, staffId: staffId,);
  }
  
  
  UpdateStaffAvailabilityStatsVariablesBuilder updateStaffAvailabilityStats ({required String staffId, }) {
    return UpdateStaffAvailabilityStatsVariablesBuilder(dataConnect, staffId: staffId,);
  }
  
  
  DeleteStaffAvailabilityStatsVariablesBuilder deleteStaffAvailabilityStats ({required String staffId, }) {
    return DeleteStaffAvailabilityStatsVariablesBuilder(dataConnect, staffId: staffId,);
  }
  
  
  ListTeamMembersVariablesBuilder listTeamMembers () {
    return ListTeamMembersVariablesBuilder(dataConnect, );
  }
  
  
  GetTeamMemberByIdVariablesBuilder getTeamMemberById ({required String id, }) {
    return GetTeamMemberByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetTeamMembersByTeamIdVariablesBuilder getTeamMembersByTeamId ({required String teamId, }) {
    return GetTeamMembersByTeamIdVariablesBuilder(dataConnect, teamId: teamId,);
  }
  
  
  ListUserConversationsVariablesBuilder listUserConversations () {
    return ListUserConversationsVariablesBuilder(dataConnect, );
  }
  
  
  GetUserConversationByKeyVariablesBuilder getUserConversationByKey ({required String conversationId, required String userId, }) {
    return GetUserConversationByKeyVariablesBuilder(dataConnect, conversationId: conversationId,userId: userId,);
  }
  
  
  ListUserConversationsByUserIdVariablesBuilder listUserConversationsByUserId ({required String userId, }) {
    return ListUserConversationsByUserIdVariablesBuilder(dataConnect, userId: userId,);
  }
  
  
  ListUnreadUserConversationsByUserIdVariablesBuilder listUnreadUserConversationsByUserId ({required String userId, }) {
    return ListUnreadUserConversationsByUserIdVariablesBuilder(dataConnect, userId: userId,);
  }
  
  
  ListUserConversationsByConversationIdVariablesBuilder listUserConversationsByConversationId ({required String conversationId, }) {
    return ListUserConversationsByConversationIdVariablesBuilder(dataConnect, conversationId: conversationId,);
  }
  
  
  FilterUserConversationsVariablesBuilder filterUserConversations () {
    return FilterUserConversationsVariablesBuilder(dataConnect, );
  }
  
  
  GetVendorByIdVariablesBuilder getVendorById ({required String id, }) {
    return GetVendorByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetVendorByUserIdVariablesBuilder getVendorByUserId ({required String userId, }) {
    return GetVendorByUserIdVariablesBuilder(dataConnect, userId: userId,);
  }
  
  
  ListVendorsVariablesBuilder listVendors () {
    return ListVendorsVariablesBuilder(dataConnect, );
  }
  
  
  ListCoursesVariablesBuilder listCourses () {
    return ListCoursesVariablesBuilder(dataConnect, );
  }
  
  
  GetCourseByIdVariablesBuilder getCourseById ({required String id, }) {
    return GetCourseByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  FilterCoursesVariablesBuilder filterCourses () {
    return FilterCoursesVariablesBuilder(dataConnect, );
  }
  
  
  CreateMessageVariablesBuilder createMessage ({required String conversationId, required String senderId, required String content, }) {
    return CreateMessageVariablesBuilder(dataConnect, conversationId: conversationId,senderId: senderId,content: content,);
  }
  
  
  UpdateMessageVariablesBuilder updateMessage ({required String id, }) {
    return UpdateMessageVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteMessageVariablesBuilder deleteMessage ({required String id, }) {
    return DeleteMessageVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListRolesVariablesBuilder listRoles () {
    return ListRolesVariablesBuilder(dataConnect, );
  }
  
  
  GetRoleByIdVariablesBuilder getRoleById ({required String id, }) {
    return GetRoleByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListRolesByVendorIdVariablesBuilder listRolesByVendorId ({required String vendorId, }) {
    return ListRolesByVendorIdVariablesBuilder(dataConnect, vendorId: vendorId,);
  }
  
  
  ListRolesByroleCategoryIdVariablesBuilder listRolesByroleCategoryId ({required String roleCategoryId, }) {
    return ListRolesByroleCategoryIdVariablesBuilder(dataConnect, roleCategoryId: roleCategoryId,);
  }
  
  
  CreateTaxFormVariablesBuilder createTaxForm ({required TaxFormType formType, required String firstName, required String lastName, required int socialSN, required String address, required TaxFormStatus status, required String staffId, }) {
    return CreateTaxFormVariablesBuilder(dataConnect, formType: formType,firstName: firstName,lastName: lastName,socialSN: socialSN,address: address,status: status,staffId: staffId,);
  }
  
  
  UpdateTaxFormVariablesBuilder updateTaxForm ({required String id, }) {
    return UpdateTaxFormVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteTaxFormVariablesBuilder deleteTaxForm ({required String id, }) {
    return DeleteTaxFormVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateApplicationVariablesBuilder createApplication ({required String shiftId, required String staffId, required ApplicationStatus status, required ApplicationOrigin origin, required String roleId, }) {
    return CreateApplicationVariablesBuilder(dataConnect, shiftId: shiftId,staffId: staffId,status: status,origin: origin,roleId: roleId,);
  }
  
  
  UpdateApplicationStatusVariablesBuilder updateApplicationStatus ({required String id, required String roleId, }) {
    return UpdateApplicationStatusVariablesBuilder(dataConnect, id: id,roleId: roleId,);
  }
  
  
  DeleteApplicationVariablesBuilder deleteApplication ({required String id, }) {
    return DeleteApplicationVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListAssignmentsVariablesBuilder listAssignments () {
    return ListAssignmentsVariablesBuilder(dataConnect, );
  }
  
  
  GetAssignmentByIdVariablesBuilder getAssignmentById ({required String id, }) {
    return GetAssignmentByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListAssignmentsByWorkforceIdVariablesBuilder listAssignmentsByWorkforceId ({required String workforceId, }) {
    return ListAssignmentsByWorkforceIdVariablesBuilder(dataConnect, workforceId: workforceId,);
  }
  
  
  ListAssignmentsByWorkforceIdsVariablesBuilder listAssignmentsByWorkforceIds ({required List<String> workforceIds, }) {
    return ListAssignmentsByWorkforceIdsVariablesBuilder(dataConnect, workforceIds: workforceIds,);
  }
  
  
  ListAssignmentsByShiftRoleVariablesBuilder listAssignmentsByShiftRole ({required String shiftId, required String roleId, }) {
    return ListAssignmentsByShiftRoleVariablesBuilder(dataConnect, shiftId: shiftId,roleId: roleId,);
  }
  
  
  FilterAssignmentsVariablesBuilder filterAssignments ({required List<String> shiftIds, required List<String> roleIds, }) {
    return FilterAssignmentsVariablesBuilder(dataConnect, shiftIds: shiftIds,roleIds: roleIds,);
  }
  
  
  CreateCategoryVariablesBuilder createCategory ({required String categoryId, required String label, }) {
    return CreateCategoryVariablesBuilder(dataConnect, categoryId: categoryId,label: label,);
  }
  
  
  UpdateCategoryVariablesBuilder updateCategory ({required String id, }) {
    return UpdateCategoryVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteCategoryVariablesBuilder deleteCategory ({required String id, }) {
    return DeleteCategoryVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListLevelsVariablesBuilder listLevels () {
    return ListLevelsVariablesBuilder(dataConnect, );
  }
  
  
  GetLevelByIdVariablesBuilder getLevelById ({required String id, }) {
    return GetLevelByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  FilterLevelsVariablesBuilder filterLevels () {
    return FilterLevelsVariablesBuilder(dataConnect, );
  }
  
  
  CreateBusinessVariablesBuilder createBusiness ({required String businessName, required String userId, required BusinessRateGroup rateGroup, required BusinessStatus status, }) {
    return CreateBusinessVariablesBuilder(dataConnect, businessName: businessName,userId: userId,rateGroup: rateGroup,status: status,);
  }
  
  
  UpdateBusinessVariablesBuilder updateBusiness ({required String id, }) {
    return UpdateBusinessVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteBusinessVariablesBuilder deleteBusiness ({required String id, }) {
    return DeleteBusinessVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateClientFeedbackVariablesBuilder createClientFeedback ({required String businessId, required String vendorId, }) {
    return CreateClientFeedbackVariablesBuilder(dataConnect, businessId: businessId,vendorId: vendorId,);
  }
  
  
  UpdateClientFeedbackVariablesBuilder updateClientFeedback ({required String id, }) {
    return UpdateClientFeedbackVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteClientFeedbackVariablesBuilder deleteClientFeedback ({required String id, }) {
    return DeleteClientFeedbackVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateHubVariablesBuilder createHub ({required String name, required String ownerId, }) {
    return CreateHubVariablesBuilder(dataConnect, name: name,ownerId: ownerId,);
  }
  
  
  UpdateHubVariablesBuilder updateHub ({required String id, }) {
    return UpdateHubVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteHubVariablesBuilder deleteHub ({required String id, }) {
    return DeleteHubVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListHubsVariablesBuilder listHubs () {
    return ListHubsVariablesBuilder(dataConnect, );
  }
  
  
  GetHubByIdVariablesBuilder getHubById ({required String id, }) {
    return GetHubByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetHubsByOwnerIdVariablesBuilder getHubsByOwnerId ({required String ownerId, }) {
    return GetHubsByOwnerIdVariablesBuilder(dataConnect, ownerId: ownerId,);
  }
  
  
  FilterHubsVariablesBuilder filterHubs () {
    return FilterHubsVariablesBuilder(dataConnect, );
  }
  
  
  ListRecentPaymentsVariablesBuilder listRecentPayments () {
    return ListRecentPaymentsVariablesBuilder(dataConnect, );
  }
  
  
  GetRecentPaymentByIdVariablesBuilder getRecentPaymentById ({required String id, }) {
    return GetRecentPaymentByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListRecentPaymentsByStaffIdVariablesBuilder listRecentPaymentsByStaffId ({required String staffId, }) {
    return ListRecentPaymentsByStaffIdVariablesBuilder(dataConnect, staffId: staffId,);
  }
  
  
  ListRecentPaymentsByApplicationIdVariablesBuilder listRecentPaymentsByApplicationId ({required String applicationId, }) {
    return ListRecentPaymentsByApplicationIdVariablesBuilder(dataConnect, applicationId: applicationId,);
  }
  
  
  ListRecentPaymentsByInvoiceIdVariablesBuilder listRecentPaymentsByInvoiceId ({required String invoiceId, }) {
    return ListRecentPaymentsByInvoiceIdVariablesBuilder(dataConnect, invoiceId: invoiceId,);
  }
  
  
  ListRecentPaymentsByStatusVariablesBuilder listRecentPaymentsByStatus ({required RecentPaymentStatus status, }) {
    return ListRecentPaymentsByStatusVariablesBuilder(dataConnect, status: status,);
  }
  
  
  ListRecentPaymentsByInvoiceIdsVariablesBuilder listRecentPaymentsByInvoiceIds ({required List<String> invoiceIds, }) {
    return ListRecentPaymentsByInvoiceIdsVariablesBuilder(dataConnect, invoiceIds: invoiceIds,);
  }
  
  
  ListRecentPaymentsByBusinessIdVariablesBuilder listRecentPaymentsByBusinessId ({required String businessId, }) {
    return ListRecentPaymentsByBusinessIdVariablesBuilder(dataConnect, businessId: businessId,);
  }
  
  
  CreateRoleCategoryVariablesBuilder createRoleCategory ({required String roleName, required RoleCategoryType category, }) {
    return CreateRoleCategoryVariablesBuilder(dataConnect, roleName: roleName,category: category,);
  }
  
  
  UpdateRoleCategoryVariablesBuilder updateRoleCategory ({required String id, }) {
    return UpdateRoleCategoryVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteRoleCategoryVariablesBuilder deleteRoleCategory ({required String id, }) {
    return DeleteRoleCategoryVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateTeamVariablesBuilder createTeam ({required String teamName, required String ownerId, required String ownerName, required String ownerRole, }) {
    return CreateTeamVariablesBuilder(dataConnect, teamName: teamName,ownerId: ownerId,ownerName: ownerName,ownerRole: ownerRole,);
  }
  
  
  UpdateTeamVariablesBuilder updateTeam ({required String id, }) {
    return UpdateTeamVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteTeamVariablesBuilder deleteTeam ({required String id, }) {
    return DeleteTeamVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListClientFeedbacksVariablesBuilder listClientFeedbacks () {
    return ListClientFeedbacksVariablesBuilder(dataConnect, );
  }
  
  
  GetClientFeedbackByIdVariablesBuilder getClientFeedbackById ({required String id, }) {
    return GetClientFeedbackByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListClientFeedbacksByBusinessIdVariablesBuilder listClientFeedbacksByBusinessId ({required String businessId, }) {
    return ListClientFeedbacksByBusinessIdVariablesBuilder(dataConnect, businessId: businessId,);
  }
  
  
  ListClientFeedbacksByVendorIdVariablesBuilder listClientFeedbacksByVendorId ({required String vendorId, }) {
    return ListClientFeedbacksByVendorIdVariablesBuilder(dataConnect, vendorId: vendorId,);
  }
  
  
  ListClientFeedbacksByBusinessAndVendorVariablesBuilder listClientFeedbacksByBusinessAndVendor ({required String businessId, required String vendorId, }) {
    return ListClientFeedbacksByBusinessAndVendorVariablesBuilder(dataConnect, businessId: businessId,vendorId: vendorId,);
  }
  
  
  FilterClientFeedbacksVariablesBuilder filterClientFeedbacks () {
    return FilterClientFeedbacksVariablesBuilder(dataConnect, );
  }
  
  
  ListClientFeedbackRatingsByVendorIdVariablesBuilder listClientFeedbackRatingsByVendorId ({required String vendorId, }) {
    return ListClientFeedbackRatingsByVendorIdVariablesBuilder(dataConnect, vendorId: vendorId,);
  }
  
  
  CreateConversationVariablesBuilder createConversation () {
    return CreateConversationVariablesBuilder(dataConnect, );
  }
  
  
  UpdateConversationVariablesBuilder updateConversation ({required String id, }) {
    return UpdateConversationVariablesBuilder(dataConnect, id: id,);
  }
  
  
  UpdateConversationLastMessageVariablesBuilder updateConversationLastMessage ({required String id, }) {
    return UpdateConversationLastMessageVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteConversationVariablesBuilder deleteConversation ({required String id, }) {
    return DeleteConversationVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListShiftsForCoverageVariablesBuilder listShiftsForCoverage ({required String businessId, required Timestamp startDate, required Timestamp endDate, }) {
    return ListShiftsForCoverageVariablesBuilder(dataConnect, businessId: businessId,startDate: startDate,endDate: endDate,);
  }
  
  
  ListApplicationsForCoverageVariablesBuilder listApplicationsForCoverage ({required List<String> shiftIds, }) {
    return ListApplicationsForCoverageVariablesBuilder(dataConnect, shiftIds: shiftIds,);
  }
  
  
  ListShiftsForDailyOpsByBusinessVariablesBuilder listShiftsForDailyOpsByBusiness ({required String businessId, required Timestamp date, }) {
    return ListShiftsForDailyOpsByBusinessVariablesBuilder(dataConnect, businessId: businessId,date: date,);
  }
  
  
  ListShiftsForDailyOpsByVendorVariablesBuilder listShiftsForDailyOpsByVendor ({required String vendorId, required Timestamp date, }) {
    return ListShiftsForDailyOpsByVendorVariablesBuilder(dataConnect, vendorId: vendorId,date: date,);
  }
  
  
  ListApplicationsForDailyOpsVariablesBuilder listApplicationsForDailyOps ({required List<String> shiftIds, }) {
    return ListApplicationsForDailyOpsVariablesBuilder(dataConnect, shiftIds: shiftIds,);
  }
  
  
  ListShiftsForForecastByBusinessVariablesBuilder listShiftsForForecastByBusiness ({required String businessId, required Timestamp startDate, required Timestamp endDate, }) {
    return ListShiftsForForecastByBusinessVariablesBuilder(dataConnect, businessId: businessId,startDate: startDate,endDate: endDate,);
  }
  
  
  ListShiftsForForecastByVendorVariablesBuilder listShiftsForForecastByVendor ({required String vendorId, required Timestamp startDate, required Timestamp endDate, }) {
    return ListShiftsForForecastByVendorVariablesBuilder(dataConnect, vendorId: vendorId,startDate: startDate,endDate: endDate,);
  }
  
  
  ListShiftsForNoShowRangeByBusinessVariablesBuilder listShiftsForNoShowRangeByBusiness ({required String businessId, required Timestamp startDate, required Timestamp endDate, }) {
    return ListShiftsForNoShowRangeByBusinessVariablesBuilder(dataConnect, businessId: businessId,startDate: startDate,endDate: endDate,);
  }
  
  
  ListShiftsForNoShowRangeByVendorVariablesBuilder listShiftsForNoShowRangeByVendor ({required String vendorId, required Timestamp startDate, required Timestamp endDate, }) {
    return ListShiftsForNoShowRangeByVendorVariablesBuilder(dataConnect, vendorId: vendorId,startDate: startDate,endDate: endDate,);
  }
  
  
  ListApplicationsForNoShowRangeVariablesBuilder listApplicationsForNoShowRange ({required List<String> shiftIds, }) {
    return ListApplicationsForNoShowRangeVariablesBuilder(dataConnect, shiftIds: shiftIds,);
  }
  
  
  ListStaffForNoShowReportVariablesBuilder listStaffForNoShowReport ({required List<String> staffIds, }) {
    return ListStaffForNoShowReportVariablesBuilder(dataConnect, staffIds: staffIds,);
  }
  
  
  ListInvoicesForSpendByBusinessVariablesBuilder listInvoicesForSpendByBusiness ({required String businessId, required Timestamp startDate, required Timestamp endDate, }) {
    return ListInvoicesForSpendByBusinessVariablesBuilder(dataConnect, businessId: businessId,startDate: startDate,endDate: endDate,);
  }
  
  
  ListInvoicesForSpendByVendorVariablesBuilder listInvoicesForSpendByVendor ({required String vendorId, required Timestamp startDate, required Timestamp endDate, }) {
    return ListInvoicesForSpendByVendorVariablesBuilder(dataConnect, vendorId: vendorId,startDate: startDate,endDate: endDate,);
  }
  
  
  ListInvoicesForSpendByOrderVariablesBuilder listInvoicesForSpendByOrder ({required String orderId, required Timestamp startDate, required Timestamp endDate, }) {
    return ListInvoicesForSpendByOrderVariablesBuilder(dataConnect, orderId: orderId,startDate: startDate,endDate: endDate,);
  }
  
  
  ListTimesheetsForSpendVariablesBuilder listTimesheetsForSpend ({required Timestamp startTime, required Timestamp endTime, }) {
    return ListTimesheetsForSpendVariablesBuilder(dataConnect, startTime: startTime,endTime: endTime,);
  }
  
  
  ListShiftsForPerformanceByBusinessVariablesBuilder listShiftsForPerformanceByBusiness ({required String businessId, required Timestamp startDate, required Timestamp endDate, }) {
    return ListShiftsForPerformanceByBusinessVariablesBuilder(dataConnect, businessId: businessId,startDate: startDate,endDate: endDate,);
  }
  
  
  ListShiftsForPerformanceByVendorVariablesBuilder listShiftsForPerformanceByVendor ({required String vendorId, required Timestamp startDate, required Timestamp endDate, }) {
    return ListShiftsForPerformanceByVendorVariablesBuilder(dataConnect, vendorId: vendorId,startDate: startDate,endDate: endDate,);
  }
  
  
  ListApplicationsForPerformanceVariablesBuilder listApplicationsForPerformance ({required List<String> shiftIds, }) {
    return ListApplicationsForPerformanceVariablesBuilder(dataConnect, shiftIds: shiftIds,);
  }
  
  
  ListStaffForPerformanceVariablesBuilder listStaffForPerformance ({required List<String> staffIds, }) {
    return ListStaffForPerformanceVariablesBuilder(dataConnect, staffIds: staffIds,);
  }
  
  
  CreateStaffAvailabilityVariablesBuilder createStaffAvailability ({required String staffId, required DayOfWeek day, required AvailabilitySlot slot, }) {
    return CreateStaffAvailabilityVariablesBuilder(dataConnect, staffId: staffId,day: day,slot: slot,);
  }
  
  
  UpdateStaffAvailabilityVariablesBuilder updateStaffAvailability ({required String staffId, required DayOfWeek day, required AvailabilitySlot slot, }) {
    return UpdateStaffAvailabilityVariablesBuilder(dataConnect, staffId: staffId,day: day,slot: slot,);
  }
  
  
  DeleteStaffAvailabilityVariablesBuilder deleteStaffAvailability ({required String staffId, required DayOfWeek day, required AvailabilitySlot slot, }) {
    return DeleteStaffAvailabilityVariablesBuilder(dataConnect, staffId: staffId,day: day,slot: slot,);
  }
  
  
  ListTeamHudDepartmentsVariablesBuilder listTeamHudDepartments () {
    return ListTeamHudDepartmentsVariablesBuilder(dataConnect, );
  }
  
  
  GetTeamHudDepartmentByIdVariablesBuilder getTeamHudDepartmentById ({required String id, }) {
    return GetTeamHudDepartmentByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListTeamHudDepartmentsByTeamHubIdVariablesBuilder listTeamHudDepartmentsByTeamHubId ({required String teamHubId, }) {
    return ListTeamHudDepartmentsByTeamHubIdVariablesBuilder(dataConnect, teamHubId: teamHubId,);
  }
  
  
  ListUsersVariablesBuilder listUsers () {
    return ListUsersVariablesBuilder(dataConnect, );
  }
  
  
  GetUserByIdVariablesBuilder getUserById ({required String id, }) {
    return GetUserByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  FilterUsersVariablesBuilder filterUsers () {
    return FilterUsersVariablesBuilder(dataConnect, );
  }
  
  
  ListAccountsVariablesBuilder listAccounts () {
    return ListAccountsVariablesBuilder(dataConnect, );
  }
  
  
  GetAccountByIdVariablesBuilder getAccountById ({required String id, }) {
    return GetAccountByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetAccountsByOwnerIdVariablesBuilder getAccountsByOwnerId ({required String ownerId, }) {
    return GetAccountsByOwnerIdVariablesBuilder(dataConnect, ownerId: ownerId,);
  }
  
  
  FilterAccountsVariablesBuilder filterAccounts () {
    return FilterAccountsVariablesBuilder(dataConnect, );
  }
  
  
  CreateAssignmentVariablesBuilder createAssignment ({required String workforceId, required String roleId, required String shiftId, }) {
    return CreateAssignmentVariablesBuilder(dataConnect, workforceId: workforceId,roleId: roleId,shiftId: shiftId,);
  }
  
  
  UpdateAssignmentVariablesBuilder updateAssignment ({required String id, required String roleId, required String shiftId, }) {
    return UpdateAssignmentVariablesBuilder(dataConnect, id: id,roleId: roleId,shiftId: shiftId,);
  }
  
  
  DeleteAssignmentVariablesBuilder deleteAssignment ({required String id, }) {
    return DeleteAssignmentVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListAttireOptionsVariablesBuilder listAttireOptions () {
    return ListAttireOptionsVariablesBuilder(dataConnect, );
  }
  
  
  GetAttireOptionByIdVariablesBuilder getAttireOptionById ({required String id, }) {
    return GetAttireOptionByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  FilterAttireOptionsVariablesBuilder filterAttireOptions () {
    return FilterAttireOptionsVariablesBuilder(dataConnect, );
  }
  
  
  ListInvoicesVariablesBuilder listInvoices () {
    return ListInvoicesVariablesBuilder(dataConnect, );
  }
  
  
  GetInvoiceByIdVariablesBuilder getInvoiceById ({required String id, }) {
    return GetInvoiceByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListInvoicesByVendorIdVariablesBuilder listInvoicesByVendorId ({required String vendorId, }) {
    return ListInvoicesByVendorIdVariablesBuilder(dataConnect, vendorId: vendorId,);
  }
  
  
  ListInvoicesByBusinessIdVariablesBuilder listInvoicesByBusinessId ({required String businessId, }) {
    return ListInvoicesByBusinessIdVariablesBuilder(dataConnect, businessId: businessId,);
  }
  
  
  ListInvoicesByOrderIdVariablesBuilder listInvoicesByOrderId ({required String orderId, }) {
    return ListInvoicesByOrderIdVariablesBuilder(dataConnect, orderId: orderId,);
  }
  
  
  ListInvoicesByStatusVariablesBuilder listInvoicesByStatus ({required InvoiceStatus status, }) {
    return ListInvoicesByStatusVariablesBuilder(dataConnect, status: status,);
  }
  
  
  FilterInvoicesVariablesBuilder filterInvoices () {
    return FilterInvoicesVariablesBuilder(dataConnect, );
  }
  
  
  ListOverdueInvoicesVariablesBuilder listOverdueInvoices ({required Timestamp now, }) {
    return ListOverdueInvoicesVariablesBuilder(dataConnect, now: now,);
  }
  
  
  ListMessagesVariablesBuilder listMessages () {
    return ListMessagesVariablesBuilder(dataConnect, );
  }
  
  
  GetMessageByIdVariablesBuilder getMessageById ({required String id, }) {
    return GetMessageByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetMessagesByConversationIdVariablesBuilder getMessagesByConversationId ({required String conversationId, }) {
    return GetMessagesByConversationIdVariablesBuilder(dataConnect, conversationId: conversationId,);
  }
  
  
  ListTaskCommentsVariablesBuilder listTaskComments () {
    return ListTaskCommentsVariablesBuilder(dataConnect, );
  }
  
  
  GetTaskCommentByIdVariablesBuilder getTaskCommentById ({required String id, }) {
    return GetTaskCommentByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetTaskCommentsByTaskIdVariablesBuilder getTaskCommentsByTaskId ({required String taskId, }) {
    return GetTaskCommentsByTaskIdVariablesBuilder(dataConnect, taskId: taskId,);
  }
  
  
  CreateUserVariablesBuilder createUser ({required String id, required UserBaseRole role, }) {
    return CreateUserVariablesBuilder(dataConnect, id: id,role: role,);
  }
  
  
  UpdateUserVariablesBuilder updateUser ({required String id, }) {
    return UpdateUserVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteUserVariablesBuilder deleteUser ({required String id, }) {
    return DeleteUserVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListCategoriesVariablesBuilder listCategories () {
    return ListCategoriesVariablesBuilder(dataConnect, );
  }
  
  
  GetCategoryByIdVariablesBuilder getCategoryById ({required String id, }) {
    return GetCategoryByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  FilterCategoriesVariablesBuilder filterCategories () {
    return FilterCategoriesVariablesBuilder(dataConnect, );
  }
  
  
  ListCustomRateCardsVariablesBuilder listCustomRateCards () {
    return ListCustomRateCardsVariablesBuilder(dataConnect, );
  }
  
  
  GetCustomRateCardByIdVariablesBuilder getCustomRateCardById ({required String id, }) {
    return GetCustomRateCardByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListDocumentsVariablesBuilder listDocuments () {
    return ListDocumentsVariablesBuilder(dataConnect, );
  }
  
  
  GetDocumentByIdVariablesBuilder getDocumentById ({required String id, }) {
    return GetDocumentByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  FilterDocumentsVariablesBuilder filterDocuments () {
    return FilterDocumentsVariablesBuilder(dataConnect, );
  }
  
  
  CreateInvoiceTemplateVariablesBuilder createInvoiceTemplate ({required String name, required String ownerId, }) {
    return CreateInvoiceTemplateVariablesBuilder(dataConnect, name: name,ownerId: ownerId,);
  }
  
  
  UpdateInvoiceTemplateVariablesBuilder updateInvoiceTemplate ({required String id, }) {
    return UpdateInvoiceTemplateVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteInvoiceTemplateVariablesBuilder deleteInvoiceTemplate ({required String id, }) {
    return DeleteInvoiceTemplateVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListStaffAvailabilityStatsVariablesBuilder listStaffAvailabilityStats () {
    return ListStaffAvailabilityStatsVariablesBuilder(dataConnect, );
  }
  
  
  GetStaffAvailabilityStatsByStaffIdVariablesBuilder getStaffAvailabilityStatsByStaffId ({required String staffId, }) {
    return GetStaffAvailabilityStatsByStaffIdVariablesBuilder(dataConnect, staffId: staffId,);
  }
  
  
  FilterStaffAvailabilityStatsVariablesBuilder filterStaffAvailabilityStats () {
    return FilterStaffAvailabilityStatsVariablesBuilder(dataConnect, );
  }
  
  
  CreateBenefitsDataVariablesBuilder createBenefitsData ({required String vendorBenefitPlanId, required String staffId, required int current, }) {
    return CreateBenefitsDataVariablesBuilder(dataConnect, vendorBenefitPlanId: vendorBenefitPlanId,staffId: staffId,current: current,);
  }
  
  
  UpdateBenefitsDataVariablesBuilder updateBenefitsData ({required String staffId, required String vendorBenefitPlanId, }) {
    return UpdateBenefitsDataVariablesBuilder(dataConnect, staffId: staffId,vendorBenefitPlanId: vendorBenefitPlanId,);
  }
  
  
  DeleteBenefitsDataVariablesBuilder deleteBenefitsData ({required String staffId, required String vendorBenefitPlanId, }) {
    return DeleteBenefitsDataVariablesBuilder(dataConnect, staffId: staffId,vendorBenefitPlanId: vendorBenefitPlanId,);
  }
  
  
  CreateCustomRateCardVariablesBuilder createCustomRateCard ({required String name, }) {
    return CreateCustomRateCardVariablesBuilder(dataConnect, name: name,);
  }
  
  
  UpdateCustomRateCardVariablesBuilder updateCustomRateCard ({required String id, }) {
    return UpdateCustomRateCardVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteCustomRateCardVariablesBuilder deleteCustomRateCard ({required String id, }) {
    return DeleteCustomRateCardVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateEmergencyContactVariablesBuilder createEmergencyContact ({required String name, required String phone, required RelationshipType relationship, required String staffId, }) {
    return CreateEmergencyContactVariablesBuilder(dataConnect, name: name,phone: phone,relationship: relationship,staffId: staffId,);
  }
  
  
  UpdateEmergencyContactVariablesBuilder updateEmergencyContact ({required String id, }) {
    return UpdateEmergencyContactVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteEmergencyContactVariablesBuilder deleteEmergencyContact ({required String id, }) {
    return DeleteEmergencyContactVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListStaffAvailabilitiesVariablesBuilder listStaffAvailabilities () {
    return ListStaffAvailabilitiesVariablesBuilder(dataConnect, );
  }
  
  
  ListStaffAvailabilitiesByStaffIdVariablesBuilder listStaffAvailabilitiesByStaffId ({required String staffId, }) {
    return ListStaffAvailabilitiesByStaffIdVariablesBuilder(dataConnect, staffId: staffId,);
  }
  
  
  GetStaffAvailabilityByKeyVariablesBuilder getStaffAvailabilityByKey ({required String staffId, required DayOfWeek day, required AvailabilitySlot slot, }) {
    return GetStaffAvailabilityByKeyVariablesBuilder(dataConnect, staffId: staffId,day: day,slot: slot,);
  }
  
  
  ListStaffAvailabilitiesByDayVariablesBuilder listStaffAvailabilitiesByDay ({required DayOfWeek day, }) {
    return ListStaffAvailabilitiesByDayVariablesBuilder(dataConnect, day: day,);
  }
  
  
  GetStaffCourseByIdVariablesBuilder getStaffCourseById ({required String id, }) {
    return GetStaffCourseByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListStaffCoursesByStaffIdVariablesBuilder listStaffCoursesByStaffId ({required String staffId, }) {
    return ListStaffCoursesByStaffIdVariablesBuilder(dataConnect, staffId: staffId,);
  }
  
  
  ListStaffCoursesByCourseIdVariablesBuilder listStaffCoursesByCourseId ({required String courseId, }) {
    return ListStaffCoursesByCourseIdVariablesBuilder(dataConnect, courseId: courseId,);
  }
  
  
  GetStaffCourseByStaffAndCourseVariablesBuilder getStaffCourseByStaffAndCourse ({required String staffId, required String courseId, }) {
    return GetStaffCourseByStaffAndCourseVariablesBuilder(dataConnect, staffId: staffId,courseId: courseId,);
  }
  
  
  ListStaffRolesVariablesBuilder listStaffRoles () {
    return ListStaffRolesVariablesBuilder(dataConnect, );
  }
  
  
  GetStaffRoleByKeyVariablesBuilder getStaffRoleByKey ({required String staffId, required String roleId, }) {
    return GetStaffRoleByKeyVariablesBuilder(dataConnect, staffId: staffId,roleId: roleId,);
  }
  
  
  ListStaffRolesByStaffIdVariablesBuilder listStaffRolesByStaffId ({required String staffId, }) {
    return ListStaffRolesByStaffIdVariablesBuilder(dataConnect, staffId: staffId,);
  }
  
  
  ListStaffRolesByRoleIdVariablesBuilder listStaffRolesByRoleId ({required String roleId, }) {
    return ListStaffRolesByRoleIdVariablesBuilder(dataConnect, roleId: roleId,);
  }
  
  
  FilterStaffRolesVariablesBuilder filterStaffRoles () {
    return FilterStaffRolesVariablesBuilder(dataConnect, );
  }
  
  
  CreateCertificateVariablesBuilder createCertificate ({required String name, required CertificateStatus status, required String staffId, }) {
    return CreateCertificateVariablesBuilder(dataConnect, name: name,status: status,staffId: staffId,);
  }
  
  
  UpdateCertificateVariablesBuilder updateCertificate ({required String id, }) {
    return UpdateCertificateVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteCertificateVariablesBuilder deleteCertificate ({required String id, }) {
    return DeleteCertificateVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListEmergencyContactsVariablesBuilder listEmergencyContacts () {
    return ListEmergencyContactsVariablesBuilder(dataConnect, );
  }
  
  
  GetEmergencyContactByIdVariablesBuilder getEmergencyContactById ({required String id, }) {
    return GetEmergencyContactByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetEmergencyContactsByStaffIdVariablesBuilder getEmergencyContactsByStaffId ({required String staffId, }) {
    return GetEmergencyContactsByStaffIdVariablesBuilder(dataConnect, staffId: staffId,);
  }
  
  
  ListInvoiceTemplatesVariablesBuilder listInvoiceTemplates () {
    return ListInvoiceTemplatesVariablesBuilder(dataConnect, );
  }
  
  
  GetInvoiceTemplateByIdVariablesBuilder getInvoiceTemplateById ({required String id, }) {
    return GetInvoiceTemplateByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  ListInvoiceTemplatesByOwnerIdVariablesBuilder listInvoiceTemplatesByOwnerId ({required String ownerId, }) {
    return ListInvoiceTemplatesByOwnerIdVariablesBuilder(dataConnect, ownerId: ownerId,);
  }
  
  
  ListInvoiceTemplatesByVendorIdVariablesBuilder listInvoiceTemplatesByVendorId ({required String vendorId, }) {
    return ListInvoiceTemplatesByVendorIdVariablesBuilder(dataConnect, vendorId: vendorId,);
  }
  
  
  ListInvoiceTemplatesByBusinessIdVariablesBuilder listInvoiceTemplatesByBusinessId ({required String businessId, }) {
    return ListInvoiceTemplatesByBusinessIdVariablesBuilder(dataConnect, businessId: businessId,);
  }
  
  
  ListInvoiceTemplatesByOrderIdVariablesBuilder listInvoiceTemplatesByOrderId ({required String orderId, }) {
    return ListInvoiceTemplatesByOrderIdVariablesBuilder(dataConnect, orderId: orderId,);
  }
  
  
  SearchInvoiceTemplatesByOwnerAndNameVariablesBuilder searchInvoiceTemplatesByOwnerAndName ({required String ownerId, required String name, }) {
    return SearchInvoiceTemplatesByOwnerAndNameVariablesBuilder(dataConnect, ownerId: ownerId,name: name,);
  }
  
  
  ListOrdersVariablesBuilder listOrders () {
    return ListOrdersVariablesBuilder(dataConnect, );
  }
  
  
  GetOrderByIdVariablesBuilder getOrderById ({required String id, }) {
    return GetOrderByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetOrdersByBusinessIdVariablesBuilder getOrdersByBusinessId ({required String businessId, }) {
    return GetOrdersByBusinessIdVariablesBuilder(dataConnect, businessId: businessId,);
  }
  
  
  GetOrdersByVendorIdVariablesBuilder getOrdersByVendorId ({required String vendorId, }) {
    return GetOrdersByVendorIdVariablesBuilder(dataConnect, vendorId: vendorId,);
  }
  
  
  GetOrdersByStatusVariablesBuilder getOrdersByStatus ({required OrderStatus status, }) {
    return GetOrdersByStatusVariablesBuilder(dataConnect, status: status,);
  }
  
  
  GetOrdersByDateRangeVariablesBuilder getOrdersByDateRange ({required Timestamp start, required Timestamp end, }) {
    return GetOrdersByDateRangeVariablesBuilder(dataConnect, start: start,end: end,);
  }
  
  
  GetRapidOrdersVariablesBuilder getRapidOrders () {
    return GetRapidOrdersVariablesBuilder(dataConnect, );
  }
  
  
  ListOrdersByBusinessAndTeamHubVariablesBuilder listOrdersByBusinessAndTeamHub ({required String businessId, required String teamHubId, }) {
    return ListOrdersByBusinessAndTeamHubVariablesBuilder(dataConnect, businessId: businessId,teamHubId: teamHubId,);
  }
  
  
  ListRoleCategoriesVariablesBuilder listRoleCategories () {
    return ListRoleCategoriesVariablesBuilder(dataConnect, );
  }
  
  
  GetRoleCategoryByIdVariablesBuilder getRoleCategoryById ({required String id, }) {
    return GetRoleCategoryByIdVariablesBuilder(dataConnect, id: id,);
  }
  
  
  GetRoleCategoriesByCategoryVariablesBuilder getRoleCategoriesByCategory ({required RoleCategoryType category, }) {
    return GetRoleCategoriesByCategoryVariablesBuilder(dataConnect, category: category,);
  }
  
  
  CreateTaskCommentVariablesBuilder createTaskComment ({required String taskId, required String teamMemberId, required String comment, }) {
    return CreateTaskCommentVariablesBuilder(dataConnect, taskId: taskId,teamMemberId: teamMemberId,comment: comment,);
  }
  
  
  UpdateTaskCommentVariablesBuilder updateTaskComment ({required String id, }) {
    return UpdateTaskCommentVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteTaskCommentVariablesBuilder deleteTaskComment ({required String id, }) {
    return DeleteTaskCommentVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateTeamHubVariablesBuilder createTeamHub ({required String teamId, required String hubName, required String address, }) {
    return CreateTeamHubVariablesBuilder(dataConnect, teamId: teamId,hubName: hubName,address: address,);
  }
  
  
  UpdateTeamHubVariablesBuilder updateTeamHub ({required String id, }) {
    return UpdateTeamHubVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteTeamHubVariablesBuilder deleteTeamHub ({required String id, }) {
    return DeleteTeamHubVariablesBuilder(dataConnect, id: id,);
  }
  
  
  CreateAttireOptionVariablesBuilder createAttireOption ({required String itemId, required String label, }) {
    return CreateAttireOptionVariablesBuilder(dataConnect, itemId: itemId,label: label,);
  }
  
  
  UpdateAttireOptionVariablesBuilder updateAttireOption ({required String id, }) {
    return UpdateAttireOptionVariablesBuilder(dataConnect, id: id,);
  }
  
  
  DeleteAttireOptionVariablesBuilder deleteAttireOption ({required String id, }) {
    return DeleteAttireOptionVariablesBuilder(dataConnect, id: id,);
  }
  

  static ConnectorConfig connectorConfig = ConnectorConfig(
    'us-central1',
    'example',
    'krow-workforce-db',
  );

  ExampleConnector({required this.dataConnect});
  static ExampleConnector get instance {
    return ExampleConnector(
        dataConnect: FirebaseDataConnect.instanceFor(
            connectorConfig: connectorConfig,
            sdkType: CallerSDKType.generated));
  }

  FirebaseDataConnect dataConnect;
}
