import { ConnectorConfig, DataConnect, QueryRef, QueryPromise, MutationRef, MutationPromise } from 'firebase/data-connect';

export const connectorConfig: ConnectorConfig;

export type TimestampString = string;
export type UUIDString = string;
export type Int64String = string;
export type DateString = string;


export enum OrderDirection {
  ASC = "ASC",
  DESC = "DESC",
};

export enum ActivityType {
  EVENT_CREATED = "EVENT_CREATED",
  EVENT_UPDATED = "EVENT_UPDATED",
  STAFF_ASSIGNED = "STAFF_ASSIGNED",
  INVOICE_PAID = "INVOICE_PAID",
  INVOICE_CREATED = "INVOICE_CREATED",
  VENDOR_APPROVED = "VENDOR_APPROVED",
  MESSAGE_RECEIVED = "MESSAGE_RECEIVED",
};

export enum AssignmentStatus {
  PENDING = "PENDING",
  CONFIRMED = "CONFIRMED",
  CHECKED_IN = "CHECKED_IN",
  IN_PROGRESS = "IN_PROGRESS",
  COMPLETED = "COMPLETED",
  CANCELLED = "CANCELLED",
  NO_SHOW = "NO_SHOW",
};

export enum BackgroundCheckStatus {
  PENDING = "PENDING",
  CLEARED = "CLEARED",
  FAILED = "FAILED",
  EXPIRED = "EXPIRED",
  NOT_REQUIRED = "NOT_REQUIRED",
};

export enum BusinessRateGroup {
  STANDARD = "STANDARD",
  PREMIUM = "PREMIUM",
  ENTERPRISE = "ENTERPRISE",
  CUSTOM = "CUSTOM",
};

export enum BusinessSector {
  BON_APPETIT = "BON_APPETIT",
  EUREST = "EUREST",
  ARAMARK = "ARAMARK",
  EPICUREAN_GROUP = "EPICUREAN_GROUP",
  CHARTWELLS = "CHARTWELLS",
  OTHER = "OTHER",
};

export enum BusinessStatus {
  ACTIVE = "ACTIVE",
  INACTIVE = "INACTIVE",
  PENDING = "PENDING",
};

export enum CertificationStatus {
  CURRENT = "CURRENT",
  EXPIRING_SOON = "EXPIRING_SOON",
  EXPIRED = "EXPIRED",
  PENDING_VALIDATION = "PENDING_VALIDATION",
};

export enum CertificationType {
  LEGAL = "LEGAL",
  OPERATIONAL = "OPERATIONAL",
  SAFETY = "SAFETY",
  TRAINING = "TRAINING",
  LICENSE = "LICENSE",
  OTHER = "OTHER",
};

export enum CertificationValidationStatus {
  APPROVED = "APPROVED",
  PENDING_EXPERT_REVIEW = "PENDING_EXPERT_REVIEW",
  REJECTED = "REJECTED",
  AI_VERIFIED = "AI_VERIFIED",
  AI_FLAGGED = "AI_FLAGGED",
  MANUAL_REVIEW_NEEDED = "MANUAL_REVIEW_NEEDED",
};

export enum ContractType {
  W2 = "W2",
  C1099 = "C1099",
  TEMP = "TEMP",
  CONTRACT = "CONTRACT",
};

export enum ConversationStatus {
  ACTIVE = "ACTIVE",
  ARCHIVED = "ARCHIVED",
  CLOSED = "CLOSED",
};

export enum ConversationType {
  CLIENT_VENDOR = "CLIENT_VENDOR",
  STAFF_CLIENT = "STAFF_CLIENT",
  STAFF_ADMIN = "STAFF_ADMIN",
  VENDOR_ADMIN = "VENDOR_ADMIN",
  CLIENT_ADMIN = "CLIENT_ADMIN",
  GROUP_STAFF = "GROUP_STAFF",
  GROUP_EVENT_STAFF = "GROUP_EVENT_STAFF",
};

export enum EmploymentType {
  FULL_TIME = "FULL_TIME",
  PART_TIME = "PART_TIME",
  ON_CALL = "ON_CALL",
  WEEKENDS = "WEEKENDS",
  SPECIFIC_DAYS = "SPECIFIC_DAYS",
  SEASONAL = "SEASONAL",
  MEDICAL_LEAVE = "MEDICAL_LEAVE",
};

export enum EnglishLevel {
  FLUENT = "FLUENT",
  INTERMEDIATE = "INTERMEDIATE",
  BASIC = "BASIC",
  NONE = "NONE",
};

export enum EventStatus {
  DRAFT = "DRAFT",
  ACTIVE = "ACTIVE",
  PENDING = "PENDING",
  ASSIGNED = "ASSIGNED",
  CONFIRMED = "CONFIRMED",
  COMPLETED = "COMPLETED",
  CANCELED = "CANCELED",
  PARTIAL = "PARTIAL",
  PARTIAL_STAFFED = "PARTIAL_STAFFED",
  FULLY_STAFFED = "FULLY_STAFFED",
  EVENT_CREATED = "EVENT_CREATED",
};

export enum InvoiceStatus {
  DRAFT = "DRAFT",
  PENDING_REVIEW = "PENDING_REVIEW",
  APPROVED = "APPROVED",
  DISPUTED = "DISPUTED",
  UNDER_REVIEW = "UNDER_REVIEW",
  RESOLVED = "RESOLVED",
  OVERDUE = "OVERDUE",
  PAID = "PAID",
  RECONCILED = "RECONCILED",
  CANCELLED = "CANCELLED",
};

export enum OrderStatus {
  DRAFT = "DRAFT",
  SUBMITTED = "SUBMITTED",
  CONFIRMED = "CONFIRMED",
  IN_PROGRESS = "IN_PROGRESS",
  COMPLETED = "COMPLETED",
  CANCELLED = "CANCELLED",
};

export enum OrderType {
  STANDARD = "STANDARD",
  LAST_MINUTE = "LAST_MINUTE",
  EMERGENCY = "EMERGENCY",
  RECURRING = "RECURRING",
};

export enum PartnerType {
  CORPORATE = "CORPORATE",
  EDUCATION = "EDUCATION",
  HEALTHCARE = "HEALTHCARE",
  SPORTS_ENTERTAINMENT = "SPORTS_ENTERTAINMENT",
  GOVERNMENT = "GOVERNMENT",
};

export enum ProfileType {
  SKILLED = "SKILLED",
  BEGINNER = "BEGINNER",
  CROSS_TRAINED = "CROSS_TRAINED",
};

export enum RecurrenceType {
  SINGLE = "SINGLE",
  DATE_RANGE = "DATE_RANGE",
  SCATTER = "SCATTER",
};

export enum SectorType {
  FOOD_SERVICE = "FOOD_SERVICE",
  FACILITIES = "FACILITIES",
  HEALTHCARE = "HEALTHCARE",
  EDUCATION = "EDUCATION",
  CORPORATE = "CORPORATE",
  SPORTS_ENTERTAINMENT = "SPORTS_ENTERTAINMENT",
};

export enum StaffDepartment {
  OPERATIONS = "OPERATIONS",
  SALES = "SALES",
  HR = "HR",
  FINANCE = "FINANCE",
  IT = "IT",
  MARKETING = "MARKETING",
  CUSTOMER_SERVICE = "CUSTOMER_SERVICE",
  LOGISTICS = "LOGISTICS",
};

export enum TeamMemberInviteStatus {
  PENDING = "PENDING",
  ACCEPTED = "ACCEPTED",
  EXPIRED = "EXPIRED",
  CANCELLED = "CANCELLED",
};

export enum TeamMemberRole {
  ADMIN = "ADMIN",
  MANAGER = "MANAGER",
  MEMBER = "MEMBER",
  VIEWER = "VIEWER",
};

export enum TeamOwnerRole {
  ADMIN = "ADMIN",
  PROCUREMENT = "PROCUREMENT",
  OPERATOR = "OPERATOR",
  SECTOR = "SECTOR",
  CLIENT = "CLIENT",
  VENDOR = "VENDOR",
  WORKFORCE = "WORKFORCE",
};

export enum UserBaseRole {
  ADMIN = "ADMIN",
  USER = "USER",
};

export enum VendorApprovalStatus {
  PENDING = "PENDING",
  APPROVED = "APPROVED",
  SUSPENDED = "SUSPENDED",
  TERMINATED = "TERMINATED",
};

export enum VendorPlatformType {
  FULL_PLATFORM = "FULL_PLATFORM",
  BUILDING_PLATFORM = "BUILDING_PLATFORM",
  PARTIAL_TECH = "PARTIAL_TECH",
  TRADITIONAL = "TRADITIONAL",
};

export enum VendorRateCategory {
  KITCHEN_AND_CULINARY = "KITCHEN_AND_CULINARY",
  CONCESSIONS = "CONCESSIONS",
  FACILITIES = "FACILITIES",
  BARTENDING = "BARTENDING",
  SECURITY = "SECURITY",
  EVENT_STAFF = "EVENT_STAFF",
  MANAGEMENT = "MANAGEMENT",
  TECHNICAL = "TECHNICAL",
  OTHER = "OTHER",
};

export enum VendorRegion {
  NATIONAL = "NATIONAL",
  BAY_AREA = "BAY_AREA",
  SOUTHERN_CALIFORNIA = "SOUTHERN_CALIFORNIA",
  NORTHERN_CALIFORNIA = "NORTHERN_CALIFORNIA",
  WEST = "WEST",
  EAST = "EAST",
  MIDWEST = "MIDWEST",
  SOUTH = "SOUTH",
};

export enum WorkforceEmploymentType {
  W2 = "W2",
  W1099 = "W1099",
  TEMPORARY = "TEMPORARY",
  CONTRACT = "CONTRACT",
};



export interface ActivityLog_Key {
  id: UUIDString;
  __typename?: 'ActivityLog_Key';
}

export interface Assignment_Key {
  id: UUIDString;
  __typename?: 'Assignment_Key';
}

export interface Business_Key {
  id: UUIDString;
  __typename?: 'Business_Key';
}

export interface Certification_Key {
  id: UUIDString;
  __typename?: 'Certification_Key';
}

export interface Conversation_Key {
  id: UUIDString;
  __typename?: 'Conversation_Key';
}

export interface CreateActivityLogData {
  activityLog_insert: ActivityLog_Key;
}

export interface CreateActivityLogVariables {
  title: string;
  description: string;
  activityType: ActivityType;
  userId: string;
  isRead?: boolean | null;
  iconType?: string | null;
  iconColor?: string | null;
}

export interface CreateAssignmentData {
  assignment_insert: Assignment_Key;
}

export interface CreateAssignmentVariables {
  assignmentNumber?: string | null;
  orderId: UUIDString;
  workforceId: UUIDString;
  vendorId: UUIDString;
  role: string;
  assignmentStatus: AssignmentStatus;
  scheduledStart: TimestampString;
}

export interface CreateBusinessData {
  business_insert: Business_Key;
}

export interface CreateBusinessVariables {
  businessName: string;
  contactName: string;
  email?: string | null;
  sector?: BusinessSector | null;
  rateGroup: BusinessRateGroup;
  status?: BusinessStatus | null;
}

export interface CreateCertificationData {
  certification_insert: Certification_Key;
}

export interface CreateCertificationVariables {
  employeeName: string;
  certificationName: string;
  certificationType?: CertificationType | null;
  status?: CertificationStatus | null;
  expiryDate: string;
  validationStatus?: CertificationValidationStatus | null;
}

export interface CreateConversationData {
  conversation_insert: Conversation_Key;
}

export interface CreateConversationVariables {
  participants: string;
  conversationType: ConversationType;
  relatedTo: UUIDString;
  status?: ConversationStatus | null;
}

export interface CreateEnterpriseData {
  enterprise_insert: Enterprise_Key;
}

export interface CreateEnterpriseVariables {
  enterpriseNumber: string;
  enterpriseName: string;
  enterpriseCode: string;
}

export interface CreateEventData {
  event_insert: Event_Key;
}

export interface CreateEventVariables {
  eventName: string;
  isRapid?: boolean | null;
  isRecurring?: boolean | null;
  isMultiDay?: boolean | null;
  recurrenceType?: RecurrenceType | null;
  recurrenceStartDate?: TimestampString | null;
  recurrenceEndDate?: TimestampString | null;
  scatterDates?: unknown | null;
  multiDayStartDate?: TimestampString | null;
  multiDayEndDate?: TimestampString | null;
  bufferTimeBefore?: number | null;
  bufferTimeAfter?: number | null;
  conflictDetectionEnabled?: boolean | null;
  detectedConflicts?: unknown | null;
  businessId: UUIDString;
  businessName?: string | null;
  vendorId?: string | null;
  vendorName?: string | null;
  hub?: string | null;
  eventLocation?: string | null;
  contractType?: ContractType | null;
  poReference?: string | null;
  status: EventStatus;
  date: string;
  shifts?: unknown | null;
  addons?: unknown | null;
  total?: number | null;
  clientName?: string | null;
  clientEmail?: string | null;
  clientPhone?: string | null;
  invoiceId?: UUIDString | null;
  notes?: string | null;
  requested?: number | null;
  assignedStaff?: unknown | null;
  department?: string | null;
  createdBy?: string | null;
  orderType?: string | null;
  recurringStartDate?: string | null;
  recurringEndDate?: string | null;
  recurringDays?: unknown | null;
  permanentStartDate?: string | null;
  permanentDays?: unknown | null;
  includeBackup?: boolean | null;
  backupStaffCount?: number | null;
  recurringTime?: string | null;
  permanentTime?: string | null;
}

export interface CreateInvoiceData {
  invoice_insert: Invoice_Key;
}

export interface CreateInvoiceVariables {
  invoiceNumber: string;
  amount: number;
  status: InvoiceStatus;
  issueDate: TimestampString;
  dueDate: TimestampString;
  disputedItems?: string | null;
  isAutoGenerated?: boolean | null;
}

export interface CreateMessageData {
  message_insert: Message_Key;
}

export interface CreateMessageVariables {
  conversationId: UUIDString;
  senderName: string;
  content: string;
  readBy?: string | null;
}

export interface CreateOrderData {
  order_insert: Order_Key;
}

export interface CreateOrderVariables {
  orderNumber: string;
  partnerId: UUIDString;
  orderType?: OrderType | null;
  orderStatus?: OrderStatus | null;
}

export interface CreatePartnerData {
  partner_insert: Partner_Key;
}

export interface CreatePartnerVariables {
  partnerName: string;
  partnerNumber: string;
  partnerType?: PartnerType | null;
}

export interface CreateSectorData {
  sector_insert: Sector_Key;
}

export interface CreateSectorVariables {
  sectorNumber: string;
  sectorName: string;
  sectorType?: SectorType | null;
}

export interface CreateShiftData {
  shift_insert: Shift_Key;
}

export interface CreateShiftVariables {
  shiftName: string;
  startDate: TimestampString;
  endDate?: TimestampString | null;
  assignedStaff?: string | null;
}

export interface CreateStaffData {
  staff_insert: Staff_Key;
}

export interface CreateStaffVariables {
  employeeName: string;
  vendorId?: string | null;
  vendorName?: string | null;
  manager?: string | null;
  contactNumber?: string | null;
  phone?: string | null;
  email?: string | null;
  department?: StaffDepartment | null;
  hubLocation?: string | null;
  eventLocation?: string | null;
  address?: string | null;
  city?: string | null;
  track?: string | null;
  position?: string | null;
  position2?: string | null;
  initial?: string | null;
  profileType?: ProfileType | null;
  employmentType?: EmploymentType | null;
  english?: EnglishLevel | null;
  rate?: number | null;
  rating?: number | null;
  reliabilityScore?: number | null;
  backgroundCheckStatus?: BackgroundCheckStatus | null;
  notes?: string | null;
  accountingComments?: string | null;
  shiftCoveragePercentage?: number | null;
  cancellationCount?: number | null;
  noShowCount?: number | null;
  totalShifts?: number | null;
  invoiced?: boolean | null;
  englishRequired?: boolean | null;
  checkIn?: string | null;
  scheduleDays?: string | null;
  replacedBy?: string | null;
  action?: string | null;
  ro?: string | null;
  mon?: string | null;
}

export interface CreateTeamData {
  team_insert: Team_Key;
}

export interface CreateTeamHubData {
  teamHub_insert: TeamHub_Key;
}

export interface CreateTeamHubVariables {
  teamId: UUIDString;
  hubName: string;
  departments?: string | null;
}

export interface CreateTeamMemberData {
  teamMember_insert: TeamMember_Key;
}

export interface CreateTeamMemberInviteData {
  teamMemberInvite_insert: TeamMemberInvite_Key;
}

export interface CreateTeamMemberInviteVariables {
  teamId: UUIDString;
  email: string;
  inviteStatus: TeamMemberInviteStatus;
}

export interface CreateTeamMemberVariables {
  teamId: UUIDString;
  memberName: string;
  email: string;
  role?: TeamMemberRole | null;
  isActive?: boolean | null;
}

export interface CreateTeamVariables {
  teamName: string;
  ownerId: string;
  ownerName: string;
  ownerRole: TeamOwnerRole;
  favoriteStaff?: string | null;
  blockedStaff?: string | null;
}

export interface CreateUserData {
  user_insert: User_Key;
}

export interface CreateUserVariables {
  id: string;
  email: string;
  fullName: string;
  role: UserBaseRole;
  userRole?: string | null;
}

export interface CreateVendorData {
  vendor_insert: Vendor_Key;
}

export interface CreateVendorDefaultSettingData {
  vendorDefaultSetting_insert: VendorDefaultSetting_Key;
}

export interface CreateVendorDefaultSettingVariables {
  vendorName: string;
  defaultMarkupPercentage: number;
  defaultVendorFeePercentage: number;
}

export interface CreateVendorRateData {
  vendorRate_insert: VendorRate_Key;
}

export interface CreateVendorRateVariables {
  vendorName: string;
  category: VendorRateCategory;
  roleName: string;
  employeeWage: number;
  markupPercentage?: number | null;
  vendorFeePercentage?: number | null;
  clientRate: number;
}

export interface CreateVendorVariables {
  vendorNumber: string;
  legalName: string;
  region: VendorRegion;
  platformType: VendorPlatformType;
  primaryContactEmail: string;
  approvalStatus: VendorApprovalStatus;
  isActive?: boolean | null;
}

export interface CreateWorkforceData {
  workforce_insert: Workforce_Key;
}

export interface CreateWorkforceVariables {
  workforceNumber: string;
  vendorId: UUIDString;
  firstName: string;
  lastName: string;
  employmentType?: WorkforceEmploymentType | null;
}

export interface DeleteActivityLogData {
  activityLog_delete?: ActivityLog_Key | null;
}

export interface DeleteActivityLogVariables {
  id: UUIDString;
}

export interface DeleteAssignmentData {
  assignment_delete?: Assignment_Key | null;
}

export interface DeleteAssignmentVariables {
  id: UUIDString;
}

export interface DeleteBusinessData {
  business_delete?: Business_Key | null;
}

export interface DeleteBusinessVariables {
  id: UUIDString;
}

export interface DeleteCertificationData {
  certification_delete?: Certification_Key | null;
}

export interface DeleteCertificationVariables {
  id: UUIDString;
}

export interface DeleteConversationData {
  conversation_delete?: Conversation_Key | null;
}

export interface DeleteConversationVariables {
  id: UUIDString;
}

export interface DeleteEnterpriseData {
  enterprise_delete?: Enterprise_Key | null;
}

export interface DeleteEnterpriseVariables {
  id: UUIDString;
}

export interface DeleteEventData {
  event_delete?: Event_Key | null;
}

export interface DeleteEventVariables {
  id: UUIDString;
}

export interface DeleteInvoiceData {
  invoice_delete?: Invoice_Key | null;
}

export interface DeleteInvoiceVariables {
  id: UUIDString;
}

export interface DeleteMessageData {
  message_delete?: Message_Key | null;
}

export interface DeleteMessageVariables {
  id: UUIDString;
}

export interface DeleteOrderData {
  order_delete?: Order_Key | null;
}

export interface DeleteOrderVariables {
  id: UUIDString;
}

export interface DeletePartnerData {
  partner_delete?: Partner_Key | null;
}

export interface DeletePartnerVariables {
  id: UUIDString;
}

export interface DeleteSectorData {
  sector_delete?: Sector_Key | null;
}

export interface DeleteSectorVariables {
  id: UUIDString;
}

export interface DeleteShiftData {
  shift_delete?: Shift_Key | null;
}

export interface DeleteShiftVariables {
  id: UUIDString;
}

export interface DeleteStaffData {
  staff_delete?: Staff_Key | null;
}

export interface DeleteStaffVariables {
  id: UUIDString;
}

export interface DeleteTeamData {
  team_delete?: Team_Key | null;
}

export interface DeleteTeamHubData {
  teamHub_delete?: TeamHub_Key | null;
}

export interface DeleteTeamHubVariables {
  id: UUIDString;
}

export interface DeleteTeamMemberData {
  teamMember_delete?: TeamMember_Key | null;
}

export interface DeleteTeamMemberInviteData {
  teamMemberInvite_delete?: TeamMemberInvite_Key | null;
}

export interface DeleteTeamMemberInviteVariables {
  id: UUIDString;
}

export interface DeleteTeamMemberVariables {
  id: UUIDString;
}

export interface DeleteTeamVariables {
  id: UUIDString;
}

export interface DeleteUserData {
  user_delete?: User_Key | null;
}

export interface DeleteUserVariables {
  id: string;
}

export interface DeleteVendorData {
  vendor_delete?: Vendor_Key | null;
}

export interface DeleteVendorDefaultSettingData {
  vendorDefaultSetting_delete?: VendorDefaultSetting_Key | null;
}

export interface DeleteVendorDefaultSettingVariables {
  id: UUIDString;
}

export interface DeleteVendorRateData {
  vendorRate_delete?: VendorRate_Key | null;
}

export interface DeleteVendorRateVariables {
  id: UUIDString;
}

export interface DeleteVendorVariables {
  id: UUIDString;
}

export interface DeleteWorkforceData {
  workforce_delete?: Workforce_Key | null;
}

export interface DeleteWorkforceVariables {
  id: UUIDString;
}

export interface Enterprise_Key {
  id: UUIDString;
  __typename?: 'Enterprise_Key';
}

export interface Event_Key {
  id: UUIDString;
  __typename?: 'Event_Key';
}

export interface FilterActivityLogData {
  activityLogs: ({
    id: UUIDString;
    title: string;
    description: string;
    activityType: ActivityType;
    userId: string;
    isRead?: boolean | null;
    iconType?: string | null;
    iconColor?: string | null;
  } & ActivityLog_Key)[];
}

export interface FilterActivityLogVariables {
  userId?: string | null;
  activityType?: ActivityType | null;
  isRead?: boolean | null;
}

export interface FilterAssignmentData {
  assignments: ({
    id: UUIDString;
    assignmentNumber?: string | null;
    orderId: UUIDString;
    workforceId: UUIDString;
    vendorId: UUIDString;
    role: string;
    assignmentStatus: AssignmentStatus;
    scheduledStart: TimestampString;
  } & Assignment_Key)[];
}

export interface FilterAssignmentVariables {
  assignmentNumber?: string | null;
  orderId?: UUIDString | null;
  workforceId?: UUIDString | null;
  vendorId?: UUIDString | null;
  assignmentStatus?: AssignmentStatus | null;
}

export interface FilterBusinessData {
  businesses: ({
    id: UUIDString;
    businessName: string;
    contactName: string;
    email?: string | null;
    sector?: BusinessSector | null;
    rateGroup: BusinessRateGroup;
    status?: BusinessStatus | null;
  } & Business_Key)[];
}

export interface FilterBusinessVariables {
  businessName?: string | null;
  contactName?: string | null;
  sector?: BusinessSector | null;
  rateGroup?: BusinessRateGroup | null;
  status?: BusinessStatus | null;
}

export interface FilterCertificationData {
  certifications: ({
    id: UUIDString;
    employeeName: string;
    certificationName: string;
    certificationType?: CertificationType | null;
    status?: CertificationStatus | null;
    expiryDate: string;
    validationStatus?: CertificationValidationStatus | null;
  } & Certification_Key)[];
}

export interface FilterCertificationVariables {
  employeeName?: string | null;
  certificationName?: string | null;
  certificationType?: CertificationType | null;
  status?: CertificationStatus | null;
  validationStatus?: CertificationValidationStatus | null;
}

export interface FilterConversationData {
  conversations: ({
    id: UUIDString;
    participants: string;
    conversationType: ConversationType;
    relatedTo: UUIDString;
    status?: ConversationStatus | null;
  } & Conversation_Key)[];
}

export interface FilterConversationVariables {
  conversationType?: ConversationType | null;
  status?: ConversationStatus | null;
  relatedTo?: UUIDString | null;
}

export interface FilterEnterpriseData {
  enterprises: ({
    id: UUIDString;
    enterpriseNumber: string;
    enterpriseName: string;
    enterpriseCode: string;
  } & Enterprise_Key)[];
}

export interface FilterEnterpriseVariables {
  enterpriseNumber?: string | null;
  enterpriseName?: string | null;
  enterpriseCode?: string | null;
}

export interface FilterEventsData {
  events: ({
    id: UUIDString;
    eventName: string;
    status: EventStatus;
    date: string;
    isRapid?: boolean | null;
    isRecurring?: boolean | null;
    isMultiDay?: boolean | null;
    recurrenceType?: RecurrenceType | null;
    recurrenceStartDate?: TimestampString | null;
    recurrenceEndDate?: TimestampString | null;
    scatterDates?: unknown | null;
    multiDayStartDate?: TimestampString | null;
    multiDayEndDate?: TimestampString | null;
    bufferTimeBefore?: number | null;
    bufferTimeAfter?: number | null;
    conflictDetectionEnabled?: boolean | null;
    detectedConflicts?: unknown | null;
    businessId: UUIDString;
    businessName?: string | null;
    vendorId?: string | null;
    vendorName?: string | null;
    hub?: string | null;
    eventLocation?: string | null;
    contractType?: ContractType | null;
    poReference?: string | null;
    shifts?: unknown | null;
    addons?: unknown | null;
    total?: number | null;
    clientName?: string | null;
    clientEmail?: string | null;
    clientPhone?: string | null;
    invoiceId?: UUIDString | null;
    notes?: string | null;
    requested?: number | null;
    assignedStaff?: unknown | null;
    orderType?: string | null;
    department?: string | null;
    createdBy?: string | null;
    recurringStartDate?: string | null;
    recurringEndDate?: string | null;
    recurringDays?: unknown | null;
    permanentStartDate?: string | null;
    permanentDays?: unknown | null;
    includeBackup?: boolean | null;
    backupStaffCount?: number | null;
    recurringTime?: string | null;
    permanentTime?: string | null;
  } & Event_Key)[];
}

export interface FilterEventsVariables {
  status?: EventStatus | null;
  businessId?: UUIDString | null;
  vendorId?: string | null;
  isRecurring?: boolean | null;
  isRapid?: boolean | null;
  isMultiDay?: boolean | null;
  recurrenceType?: RecurrenceType | null;
  date?: string | null;
  hub?: string | null;
  eventLocation?: string | null;
  contractType?: ContractType | null;
  clientEmail?: string | null;
}

export interface FilterInvoicesData {
  invoices: ({
    id: UUIDString;
    invoiceNumber: string;
    amount: number;
    status: InvoiceStatus;
    issueDate: TimestampString;
    dueDate: TimestampString;
    isAutoGenerated?: boolean | null;
  } & Invoice_Key)[];
}

export interface FilterInvoicesVariables {
  invoiceNumber?: string | null;
  status?: InvoiceStatus | null;
  isAutoGenerated?: boolean | null;
  amount?: number | null;
}

export interface FilterMessageData {
  messages: ({
    id: UUIDString;
    conversationId: UUIDString;
    senderName: string;
    content: string;
    readBy?: string | null;
  } & Message_Key)[];
}

export interface FilterMessageVariables {
  conversationId?: UUIDString | null;
  senderName?: string | null;
}

export interface FilterOrderData {
  orders: ({
    id: UUIDString;
    orderNumber: string;
    partnerId: UUIDString;
    orderType?: OrderType | null;
    orderStatus?: OrderStatus | null;
  } & Order_Key)[];
}

export interface FilterOrderVariables {
  orderNumber?: string | null;
  partnerId?: UUIDString | null;
  orderType?: OrderType | null;
  orderStatus?: OrderStatus | null;
}

export interface FilterPartnerData {
  partners: ({
    id: UUIDString;
    partnerName: string;
    partnerNumber: string;
    partnerType?: PartnerType | null;
  } & Partner_Key)[];
}

export interface FilterPartnerVariables {
  partnerName?: string | null;
  partnerNumber?: string | null;
  partnerType?: PartnerType | null;
}

export interface FilterSectorData {
  sectors: ({
    id: UUIDString;
    sectorNumber: string;
    sectorName: string;
    sectorType?: SectorType | null;
  } & Sector_Key)[];
}

export interface FilterSectorVariables {
  sectorNumber?: string | null;
  sectorName?: string | null;
  sectorType?: SectorType | null;
}

export interface FilterShiftData {
  shifts: ({
    id: UUIDString;
    shiftName: string;
    startDate: TimestampString;
    endDate?: TimestampString | null;
    assignedStaff?: string | null;
  } & Shift_Key)[];
}

export interface FilterShiftVariables {
  shiftName?: string | null;
  startDate?: TimestampString | null;
  endDate?: TimestampString | null;
}

export interface FilterStaffData {
  staffs: ({
    id: UUIDString;
    employeeName: string;
    vendorId?: string | null;
    vendorName?: string | null;
    department?: StaffDepartment | null;
    hubLocation?: string | null;
    eventLocation?: string | null;
    position?: string | null;
    position2?: string | null;
    employmentType?: EmploymentType | null;
    english?: EnglishLevel | null;
    rate?: number | null;
    rating?: number | null;
    reliabilityScore?: number | null;
    backgroundCheckStatus?: BackgroundCheckStatus | null;
    notes?: string | null;
    invoiced?: boolean | null;
  } & Staff_Key)[];
}

export interface FilterStaffVariables {
  employeeName?: string | null;
  vendorId?: string | null;
  department?: StaffDepartment | null;
  employmentType?: EmploymentType | null;
  english?: EnglishLevel | null;
  backgroundCheckStatus?: BackgroundCheckStatus | null;
}

export interface FilterTeamData {
  teams: ({
    id: UUIDString;
    teamName: string;
    ownerId: string;
    ownerName: string;
    ownerRole: TeamOwnerRole;
    favoriteStaff?: string | null;
    blockedStaff?: string | null;
  } & Team_Key)[];
}

export interface FilterTeamHubData {
  teamHubs: ({
    id: UUIDString;
    teamId: UUIDString;
    hubName: string;
    departments?: string | null;
  } & TeamHub_Key)[];
}

export interface FilterTeamHubVariables {
  teamId?: UUIDString | null;
  hubName?: string | null;
}

export interface FilterTeamMemberData {
  teamMembers: ({
    id: UUIDString;
    teamId: UUIDString;
    memberName: string;
    email: string;
    role?: TeamMemberRole | null;
    isActive?: boolean | null;
  } & TeamMember_Key)[];
}

export interface FilterTeamMemberInviteData {
  teamMemberInvites: ({
    id: UUIDString;
    teamId: UUIDString;
    inviteCode: string;
    email: string;
    inviteStatus: TeamMemberInviteStatus;
  } & TeamMemberInvite_Key)[];
}

export interface FilterTeamMemberInviteVariables {
  teamId?: UUIDString | null;
  email?: string | null;
  inviteStatus?: TeamMemberInviteStatus | null;
}

export interface FilterTeamMemberVariables {
  teamId?: UUIDString | null;
  memberName?: string | null;
  email?: string | null;
  role?: TeamMemberRole | null;
  isActive?: boolean | null;
}

export interface FilterTeamVariables {
  teamName?: string | null;
  ownerId?: string | null;
  ownerRole?: TeamOwnerRole | null;
}

export interface FilterUsersData {
  users: ({
    id: string;
    email: string;
    fullName: string;
    role: UserBaseRole;
    userRole?: string | null;
  } & User_Key)[];
}

export interface FilterUsersVariables {
  id?: string | null;
  email?: string | null;
  role?: UserBaseRole | null;
  userRole?: string | null;
}

export interface FilterVendorDefaultSettingsData {
  vendorDefaultSettings: ({
    id: UUIDString;
    vendorName: string;
    defaultMarkupPercentage: number;
    defaultVendorFeePercentage: number;
  } & VendorDefaultSetting_Key)[];
}

export interface FilterVendorDefaultSettingsVariables {
  vendorName?: string | null;
  defaultMarkupPercentage?: number | null;
  defaultVendorFeePercentage?: number | null;
}

export interface FilterVendorRatesData {
  vendorRates: ({
    id: UUIDString;
    vendorName: string;
    category: VendorRateCategory;
    roleName: string;
    employeeWage: number;
    markupPercentage?: number | null;
    vendorFeePercentage?: number | null;
    clientRate: number;
  } & VendorRate_Key)[];
}

export interface FilterVendorRatesVariables {
  vendorName?: string | null;
  category?: VendorRateCategory | null;
  roleName?: string | null;
  minClientRate?: number | null;
  maxClientRate?: number | null;
}

export interface FilterVendorsData {
  vendors: ({
    id: UUIDString;
    vendorNumber: string;
    legalName: string;
    region: VendorRegion;
    platformType: VendorPlatformType;
    primaryContactEmail: string;
    approvalStatus: VendorApprovalStatus;
    isActive?: boolean | null;
  } & Vendor_Key)[];
}

export interface FilterVendorsVariables {
  region?: VendorRegion | null;
  approvalStatus?: VendorApprovalStatus | null;
  isActive?: boolean | null;
  vendorNumber?: string | null;
  primaryContactEmail?: string | null;
  legalName?: string | null;
  platformType?: VendorPlatformType | null;
}

export interface FilterWorkforceData {
  workforces: ({
    id: UUIDString;
    workforceNumber: string;
    vendorId: UUIDString;
    firstName: string;
    lastName: string;
    employmentType?: WorkforceEmploymentType | null;
  } & Workforce_Key)[];
}

export interface FilterWorkforceVariables {
  workforceNumber?: string | null;
  vendorId?: UUIDString | null;
  firstName?: string | null;
  lastName?: string | null;
  employmentType?: WorkforceEmploymentType | null;
}

export interface GetActivityLogByIdData {
  activityLog?: {
    id: UUIDString;
    title: string;
    description: string;
    activityType: ActivityType;
    userId: string;
    isRead?: boolean | null;
    iconType?: string | null;
    iconColor?: string | null;
  } & ActivityLog_Key;
}

export interface GetActivityLogByIdVariables {
  id: UUIDString;
}

export interface GetAssignmentByIdData {
  assignment?: {
    id: UUIDString;
    assignmentNumber?: string | null;
    orderId: UUIDString;
    workforceId: UUIDString;
    vendorId: UUIDString;
    role: string;
    assignmentStatus: AssignmentStatus;
    scheduledStart: TimestampString;
  } & Assignment_Key;
}

export interface GetAssignmentByIdVariables {
  id: UUIDString;
}

export interface GetBusinessByIdData {
  business?: {
    id: UUIDString;
    businessName: string;
    contactName: string;
    email?: string | null;
    sector?: BusinessSector | null;
    rateGroup: BusinessRateGroup;
    status?: BusinessStatus | null;
  } & Business_Key;
}

export interface GetBusinessByIdVariables {
  id: UUIDString;
}

export interface GetCertificationByIdData {
  certification?: {
    id: UUIDString;
    employeeName: string;
    certificationName: string;
    certificationType?: CertificationType | null;
    status?: CertificationStatus | null;
    expiryDate: string;
    validationStatus?: CertificationValidationStatus | null;
    createdDate?: TimestampString | null;
    updatedDate?: TimestampString | null;
    createdBy?: string | null;
  } & Certification_Key;
}

export interface GetCertificationByIdVariables {
  id: UUIDString;
}

export interface GetConversationByIdData {
  conversation?: {
    id: UUIDString;
    participants: string;
    conversationType: ConversationType;
    relatedTo: UUIDString;
    status?: ConversationStatus | null;
  } & Conversation_Key;
}

export interface GetConversationByIdVariables {
  id: UUIDString;
}

export interface GetEnterpriseByIdData {
  enterprise?: {
    id: UUIDString;
    enterpriseNumber: string;
    enterpriseName: string;
    enterpriseCode: string;
  } & Enterprise_Key;
}

export interface GetEnterpriseByIdVariables {
  id: UUIDString;
}

export interface GetEventByIdData {
  event?: {
    id: UUIDString;
    eventName: string;
    status: EventStatus;
    date: string;
    isRapid?: boolean | null;
    isRecurring?: boolean | null;
    isMultiDay?: boolean | null;
    recurrenceType?: RecurrenceType | null;
    recurrenceStartDate?: TimestampString | null;
    recurrenceEndDate?: TimestampString | null;
    scatterDates?: unknown | null;
    multiDayStartDate?: TimestampString | null;
    multiDayEndDate?: TimestampString | null;
    bufferTimeBefore?: number | null;
    bufferTimeAfter?: number | null;
    conflictDetectionEnabled?: boolean | null;
    detectedConflicts?: unknown | null;
    businessId: UUIDString;
    businessName?: string | null;
    vendorId?: string | null;
    vendorName?: string | null;
    hub?: string | null;
    eventLocation?: string | null;
    contractType?: ContractType | null;
    poReference?: string | null;
    shifts?: unknown | null;
    addons?: unknown | null;
    total?: number | null;
    clientName?: string | null;
    clientEmail?: string | null;
    clientPhone?: string | null;
    invoiceId?: UUIDString | null;
    notes?: string | null;
    requested?: number | null;
    orderType?: string | null;
    department?: string | null;
    assignedStaff?: unknown | null;
    recurringStartDate?: string | null;
    recurringEndDate?: string | null;
    recurringDays?: unknown | null;
    permanentStartDate?: string | null;
    permanentDays?: unknown | null;
    includeBackup?: boolean | null;
    backupStaffCount?: number | null;
    recurringTime?: string | null;
    permanentTime?: string | null;
  } & Event_Key;
}

export interface GetEventByIdVariables {
  id: UUIDString;
}

export interface GetInvoiceByIdData {
  invoice?: {
    id: UUIDString;
    invoiceNumber: string;
    amount: number;
    status: InvoiceStatus;
    issueDate: TimestampString;
    dueDate: TimestampString;
    disputedItems?: string | null;
    isAutoGenerated?: boolean | null;
  } & Invoice_Key;
}

export interface GetInvoiceByIdVariables {
  id: UUIDString;
}

export interface GetMessageByIdData {
  message?: {
    id: UUIDString;
    conversationId: UUIDString;
    senderName: string;
    content: string;
    readBy?: string | null;
  } & Message_Key;
}

export interface GetMessageByIdVariables {
  id: UUIDString;
}

export interface GetOrderByIdData {
  order?: {
    id: UUIDString;
    orderNumber: string;
    partnerId: UUIDString;
    orderType?: OrderType | null;
    orderStatus?: OrderStatus | null;
  } & Order_Key;
}

export interface GetOrderByIdVariables {
  id: UUIDString;
}

export interface GetPartnerByIdData {
  partner?: {
    id: UUIDString;
    partnerName: string;
    partnerNumber: string;
    partnerType?: PartnerType | null;
  } & Partner_Key;
}

export interface GetPartnerByIdVariables {
  id: UUIDString;
}

export interface GetSectorByIdData {
  sector?: {
    id: UUIDString;
    sectorNumber: string;
    sectorName: string;
    sectorType?: SectorType | null;
  } & Sector_Key;
}

export interface GetSectorByIdVariables {
  id: UUIDString;
}

export interface GetShiftByIdData {
  shift?: {
    id: UUIDString;
    shiftName: string;
    startDate: TimestampString;
    endDate?: TimestampString | null;
    assignedStaff?: string | null;
    createdDate?: TimestampString | null;
    updatedDate?: TimestampString | null;
    createdBy?: string | null;
  } & Shift_Key;
}

export interface GetShiftByIdVariables {
  id: UUIDString;
}

export interface GetStaffByIdData {
  staff?: {
    id: UUIDString;
    employeeName: string;
    vendorId?: string | null;
    vendorName?: string | null;
    manager?: string | null;
    contactNumber?: string | null;
    phone?: string | null;
    email?: string | null;
    department?: StaffDepartment | null;
    hubLocation?: string | null;
    eventLocation?: string | null;
    address?: string | null;
    city?: string | null;
    track?: string | null;
    position?: string | null;
    position2?: string | null;
    initial?: string | null;
    profileType?: ProfileType | null;
    employmentType?: EmploymentType | null;
    english?: EnglishLevel | null;
    rate?: number | null;
    rating?: number | null;
    reliabilityScore?: number | null;
    backgroundCheckStatus?: BackgroundCheckStatus | null;
    notes?: string | null;
    accountingComments?: string | null;
    shiftCoveragePercentage?: number | null;
    cancellationCount?: number | null;
    noShowCount?: number | null;
    totalShifts?: number | null;
    invoiced?: boolean | null;
    englishRequired?: boolean | null;
    checkIn?: string | null;
    scheduleDays?: string | null;
    replacedBy?: string | null;
    action?: string | null;
    ro?: string | null;
    mon?: string | null;
  } & Staff_Key;
}

export interface GetStaffByIdVariables {
  id: UUIDString;
}

export interface GetTeamByIdData {
  team?: {
    id: UUIDString;
    teamName: string;
    ownerId: string;
    ownerName: string;
    ownerRole: TeamOwnerRole;
    favoriteStaff?: string | null;
    blockedStaff?: string | null;
  } & Team_Key;
}

export interface GetTeamByIdVariables {
  id: UUIDString;
}

export interface GetTeamHubByIdData {
  teamHub?: {
    id: UUIDString;
    teamId: UUIDString;
    hubName: string;
    departments?: string | null;
  } & TeamHub_Key;
}

export interface GetTeamHubByIdVariables {
  id: UUIDString;
}

export interface GetTeamMemberByIdData {
  teamMember?: {
    id: UUIDString;
    teamId: UUIDString;
    memberName: string;
    email: string;
    role?: TeamMemberRole | null;
    isActive?: boolean | null;
  } & TeamMember_Key;
}

export interface GetTeamMemberByIdVariables {
  id: UUIDString;
}

export interface GetTeamMemberInviteByIdData {
  teamMemberInvite?: {
    id: UUIDString;
    teamId: UUIDString;
    inviteCode: string;
    email: string;
    inviteStatus: TeamMemberInviteStatus;
  } & TeamMemberInvite_Key;
}

export interface GetTeamMemberInviteByIdVariables {
  id: UUIDString;
}

export interface GetUserByIdData {
  user?: {
    id: string;
    email: string;
    fullName: string;
    role: UserBaseRole;
    userRole?: string | null;
  } & User_Key;
}

export interface GetUserByIdVariables {
  id: string;
}

export interface GetVendorByIdData {
  vendor?: {
    id: UUIDString;
    vendorNumber: string;
    legalName: string;
    region: VendorRegion;
    platformType: VendorPlatformType;
    primaryContactEmail: string;
    approvalStatus: VendorApprovalStatus;
    isActive?: boolean | null;
  } & Vendor_Key;
}

export interface GetVendorByIdVariables {
  id: UUIDString;
}

export interface GetVendorDefaultSettingByIdData {
  vendorDefaultSetting?: {
    id: UUIDString;
    vendorName: string;
    defaultMarkupPercentage: number;
    defaultVendorFeePercentage: number;
  } & VendorDefaultSetting_Key;
}

export interface GetVendorDefaultSettingByIdVariables {
  id: UUIDString;
}

export interface GetVendorRateByIdData {
  vendorRate?: {
    id: UUIDString;
    vendorName: string;
    category: VendorRateCategory;
    roleName: string;
    employeeWage: number;
    markupPercentage?: number | null;
    vendorFeePercentage?: number | null;
    clientRate: number;
    createdDate?: TimestampString | null;
    updatedDate?: TimestampString | null;
    createdBy?: string | null;
  } & VendorRate_Key;
}

export interface GetVendorRateByIdVariables {
  id: UUIDString;
}

export interface GetWorkforceByIdData {
  workforce?: {
    id: UUIDString;
    workforceNumber: string;
    vendorId: UUIDString;
    firstName: string;
    lastName: string;
    employmentType?: WorkforceEmploymentType | null;
  } & Workforce_Key;
}

export interface GetWorkforceByIdVariables {
  id: UUIDString;
}

export interface Invoice_Key {
  id: UUIDString;
  __typename?: 'Invoice_Key';
}

export interface ListActivityLogData {
  activityLogs: ({
    id: UUIDString;
    title: string;
    description: string;
    activityType: ActivityType;
    userId: string;
    isRead?: boolean | null;
    iconType?: string | null;
    iconColor?: string | null;
  } & ActivityLog_Key)[];
}

export interface ListAssignmentData {
  assignments: ({
    id: UUIDString;
    assignmentNumber?: string | null;
    orderId: UUIDString;
    workforceId: UUIDString;
    vendorId: UUIDString;
    role: string;
    assignmentStatus: AssignmentStatus;
    scheduledStart: TimestampString;
  } & Assignment_Key)[];
}

export interface ListBusinessData {
  businesses: ({
    id: UUIDString;
    businessName: string;
    contactName: string;
    email?: string | null;
    sector?: BusinessSector | null;
    rateGroup: BusinessRateGroup;
    status?: BusinessStatus | null;
  } & Business_Key)[];
}

export interface ListCertificationData {
  certifications: ({
    id: UUIDString;
    employeeName: string;
    certificationName: string;
    certificationType?: CertificationType | null;
    status?: CertificationStatus | null;
    expiryDate: string;
    validationStatus?: CertificationValidationStatus | null;
  } & Certification_Key)[];
}

export interface ListConversationData {
  conversations: ({
    id: UUIDString;
    participants: string;
    conversationType: ConversationType;
    relatedTo: UUIDString;
    status?: ConversationStatus | null;
  } & Conversation_Key)[];
}

export interface ListEnterpriseData {
  enterprises: ({
    id: UUIDString;
    enterpriseNumber: string;
    enterpriseName: string;
    enterpriseCode: string;
  } & Enterprise_Key)[];
}

export interface ListEventsData {
  events: ({
    id: UUIDString;
    eventName: string;
    status: EventStatus;
    date: string;
    isRapid?: boolean | null;
    isRecurring?: boolean | null;
    isMultiDay?: boolean | null;
    recurrenceType?: RecurrenceType | null;
    recurrenceStartDate?: TimestampString | null;
    recurrenceEndDate?: TimestampString | null;
    scatterDates?: unknown | null;
    multiDayStartDate?: TimestampString | null;
    multiDayEndDate?: TimestampString | null;
    bufferTimeBefore?: number | null;
    bufferTimeAfter?: number | null;
    conflictDetectionEnabled?: boolean | null;
    detectedConflicts?: unknown | null;
    businessId: UUIDString;
    businessName?: string | null;
    vendorId?: string | null;
    vendorName?: string | null;
    hub?: string | null;
    eventLocation?: string | null;
    contractType?: ContractType | null;
    poReference?: string | null;
    shifts?: unknown | null;
    addons?: unknown | null;
    total?: number | null;
    clientName?: string | null;
    clientEmail?: string | null;
    clientPhone?: string | null;
    invoiceId?: UUIDString | null;
    notes?: string | null;
    requested?: number | null;
    assignedStaff?: unknown | null;
    orderType?: string | null;
    department?: string | null;
    createdBy?: string | null;
    recurringStartDate?: string | null;
    recurringEndDate?: string | null;
    recurringDays?: unknown | null;
    permanentStartDate?: string | null;
    permanentDays?: unknown | null;
    includeBackup?: boolean | null;
    backupStaffCount?: number | null;
    recurringTime?: string | null;
    permanentTime?: string | null;
  } & Event_Key)[];
}

export interface ListEventsVariables {
  orderByDate?: OrderDirection | null;
  orderByCreatedDate?: OrderDirection | null;
  limit?: number | null;
}

export interface ListInvoiceData {
  invoices: ({
    id: UUIDString;
    invoiceNumber: string;
    amount: number;
    status: InvoiceStatus;
    issueDate: TimestampString;
    dueDate: TimestampString;
    disputedItems?: string | null;
    isAutoGenerated?: boolean | null;
  } & Invoice_Key)[];
}

export interface ListMessageData {
  messages: ({
    id: UUIDString;
    conversationId: UUIDString;
    senderName: string;
    content: string;
    readBy?: string | null;
  } & Message_Key)[];
}

export interface ListOrderData {
  orders: ({
    id: UUIDString;
    orderNumber: string;
    partnerId: UUIDString;
    orderType?: OrderType | null;
    orderStatus?: OrderStatus | null;
  } & Order_Key)[];
}

export interface ListPartnerData {
  partners: ({
    id: UUIDString;
    partnerName: string;
    partnerNumber: string;
    partnerType?: PartnerType | null;
  } & Partner_Key)[];
}

export interface ListSectorData {
  sectors: ({
    id: UUIDString;
    sectorNumber: string;
    sectorName: string;
    sectorType?: SectorType | null;
  } & Sector_Key)[];
}

export interface ListShiftData {
  shifts: ({
    id: UUIDString;
    shiftName: string;
    startDate: TimestampString;
    endDate?: TimestampString | null;
    assignedStaff?: string | null;
  } & Shift_Key)[];
}

export interface ListStaffData {
  staffs: ({
    id: UUIDString;
    employeeName: string;
    vendorId?: string | null;
    vendorName?: string | null;
    manager?: string | null;
    contactNumber?: string | null;
    phone?: string | null;
    email?: string | null;
    department?: StaffDepartment | null;
    hubLocation?: string | null;
    eventLocation?: string | null;
    address?: string | null;
    city?: string | null;
    track?: string | null;
    position?: string | null;
    position2?: string | null;
    initial?: string | null;
    profileType?: ProfileType | null;
    employmentType?: EmploymentType | null;
    english?: EnglishLevel | null;
    englishRequired?: boolean | null;
    rate?: number | null;
    rating?: number | null;
    reliabilityScore?: number | null;
    backgroundCheckStatus?: BackgroundCheckStatus | null;
    notes?: string | null;
    accountingComments?: string | null;
    shiftCoveragePercentage?: number | null;
    cancellationCount?: number | null;
    noShowCount?: number | null;
    totalShifts?: number | null;
    invoiced?: boolean | null;
    checkIn?: string | null;
    scheduleDays?: string | null;
    replacedBy?: string | null;
    action?: string | null;
    ro?: string | null;
    mon?: string | null;
  } & Staff_Key)[];
}

export interface ListTeamData {
  teams: ({
    id: UUIDString;
    teamName: string;
    ownerId: string;
    ownerName: string;
    ownerRole: TeamOwnerRole;
    favoriteStaff?: string | null;
    blockedStaff?: string | null;
  } & Team_Key)[];
}

export interface ListTeamHubData {
  teamHubs: ({
    id: UUIDString;
    teamId: UUIDString;
    hubName: string;
    departments?: string | null;
  } & TeamHub_Key)[];
}

export interface ListTeamMemberData {
  teamMembers: ({
    id: UUIDString;
    teamId: UUIDString;
    memberName: string;
    email: string;
    role?: TeamMemberRole | null;
    isActive?: boolean | null;
  } & TeamMember_Key)[];
}

export interface ListTeamMemberInviteData {
  teamMemberInvites: ({
    id: UUIDString;
    teamId: UUIDString;
    inviteCode: string;
    email: string;
    inviteStatus: TeamMemberInviteStatus;
  } & TeamMemberInvite_Key)[];
}

export interface ListTeamVariables {
  orderByCreatedDate?: OrderDirection | null;
  limit?: number | null;
}

export interface ListUsersData {
  users: ({
    id: string;
    email: string;
    fullName: string;
    role: UserBaseRole;
    userRole?: string | null;
    createdDate?: TimestampString | null;
    updatedDate?: TimestampString | null;
  } & User_Key)[];
}

export interface ListVendorData {
  vendors: ({
    id: UUIDString;
    vendorNumber: string;
    legalName: string;
    region: VendorRegion;
    platformType: VendorPlatformType;
    primaryContactEmail: string;
    approvalStatus: VendorApprovalStatus;
    isActive?: boolean | null;
  } & Vendor_Key)[];
}

export interface ListVendorDefaultSettingsData {
  vendorDefaultSettings: ({
    id: UUIDString;
    vendorName: string;
    defaultMarkupPercentage: number;
    defaultVendorFeePercentage: number;
  } & VendorDefaultSetting_Key)[];
}

export interface ListVendorRateData {
  vendorRates: ({
    id: UUIDString;
    vendorName: string;
    category: VendorRateCategory;
    roleName: string;
    employeeWage: number;
    markupPercentage?: number | null;
    vendorFeePercentage?: number | null;
    clientRate: number;
  } & VendorRate_Key)[];
}

export interface ListWorkforceData {
  workforces: ({
    id: UUIDString;
    workforceNumber: string;
    vendorId: UUIDString;
    firstName: string;
    lastName: string;
    employmentType?: WorkforceEmploymentType | null;
  } & Workforce_Key)[];
}

export interface Message_Key {
  id: UUIDString;
  __typename?: 'Message_Key';
}

export interface Order_Key {
  id: UUIDString;
  __typename?: 'Order_Key';
}

export interface Partner_Key {
  id: UUIDString;
  __typename?: 'Partner_Key';
}

export interface Sector_Key {
  id: UUIDString;
  __typename?: 'Sector_Key';
}

export interface Shift_Key {
  id: UUIDString;
  __typename?: 'Shift_Key';
}

export interface Staff_Key {
  id: UUIDString;
  __typename?: 'Staff_Key';
}

export interface TeamHub_Key {
  id: UUIDString;
  __typename?: 'TeamHub_Key';
}

export interface TeamMemberInvite_Key {
  id: UUIDString;
  __typename?: 'TeamMemberInvite_Key';
}

export interface TeamMember_Key {
  id: UUIDString;
  __typename?: 'TeamMember_Key';
}

export interface Team_Key {
  id: UUIDString;
  __typename?: 'Team_Key';
}

export interface UpdateActivityLogData {
  activityLog_update?: ActivityLog_Key | null;
}

export interface UpdateActivityLogVariables {
  id: UUIDString;
  title?: string | null;
  description?: string | null;
  activityType?: ActivityType | null;
  userId?: string | null;
  isRead?: boolean | null;
  iconType?: string | null;
  iconColor?: string | null;
}

export interface UpdateAssignmentData {
  assignment_update?: Assignment_Key | null;
}

export interface UpdateAssignmentVariables {
  id: UUIDString;
  assignmentNumber?: string | null;
  orderId?: UUIDString | null;
  workforceId?: UUIDString | null;
  vendorId?: UUIDString | null;
  role?: string | null;
  assignmentStatus?: AssignmentStatus | null;
  scheduledStart?: TimestampString | null;
}

export interface UpdateBusinessData {
  business_update?: Business_Key | null;
}

export interface UpdateBusinessVariables {
  id: UUIDString;
  businessName?: string | null;
  contactName?: string | null;
  email?: string | null;
  sector?: BusinessSector | null;
  rateGroup?: BusinessRateGroup | null;
  status?: BusinessStatus | null;
}

export interface UpdateCertificationData {
  certification_update?: Certification_Key | null;
}

export interface UpdateCertificationVariables {
  id: UUIDString;
  employeeName?: string | null;
  certificationName?: string | null;
  certificationType?: CertificationType | null;
  status?: CertificationStatus | null;
  expiryDate?: string | null;
  validationStatus?: CertificationValidationStatus | null;
}

export interface UpdateConversationData {
  conversation_update?: Conversation_Key | null;
}

export interface UpdateConversationVariables {
  id: UUIDString;
  participants?: string | null;
  conversationType?: ConversationType | null;
  relatedTo?: UUIDString | null;
  status?: ConversationStatus | null;
}

export interface UpdateEnterpriseData {
  enterprise_update?: Enterprise_Key | null;
}

export interface UpdateEnterpriseVariables {
  id: UUIDString;
  enterpriseNumber?: string | null;
  enterpriseName?: string | null;
  enterpriseCode?: string | null;
}

export interface UpdateEventData {
  event_update?: Event_Key | null;
}

export interface UpdateEventVariables {
  id: UUIDString;
  eventName?: string | null;
  isRapid?: boolean | null;
  isRecurring?: boolean | null;
  isMultiDay?: boolean | null;
  recurrenceType?: RecurrenceType | null;
  recurrenceStartDate?: TimestampString | null;
  recurrenceEndDate?: TimestampString | null;
  scatterDates?: unknown | null;
  multiDayStartDate?: TimestampString | null;
  multiDayEndDate?: TimestampString | null;
  bufferTimeBefore?: number | null;
  bufferTimeAfter?: number | null;
  conflictDetectionEnabled?: boolean | null;
  detectedConflicts?: unknown | null;
  businessId?: UUIDString | null;
  businessName?: string | null;
  vendorId?: string | null;
  vendorName?: string | null;
  hub?: string | null;
  eventLocation?: string | null;
  contractType?: ContractType | null;
  poReference?: string | null;
  status?: EventStatus | null;
  date?: string | null;
  shifts?: unknown | null;
  addons?: unknown | null;
  total?: number | null;
  clientName?: string | null;
  clientEmail?: string | null;
  clientPhone?: string | null;
  invoiceId?: UUIDString | null;
  notes?: string | null;
  requested?: number | null;
  orderType?: string | null;
  department?: string | null;
  assignedStaff?: unknown | null;
  createdBy?: string | null;
  recurringStartDate?: string | null;
  recurringEndDate?: string | null;
  recurringDays?: unknown | null;
  permanentStartDate?: string | null;
  permanentDays?: unknown | null;
  includeBackup?: boolean | null;
  backupStaffCount?: number | null;
  recurringTime?: string | null;
  permanentTime?: string | null;
}

export interface UpdateInvoiceData {
  invoice_update?: Invoice_Key | null;
}

export interface UpdateInvoiceVariables {
  id: UUIDString;
  invoiceNumber?: string | null;
  amount?: number | null;
  status?: InvoiceStatus | null;
  issueDate?: TimestampString | null;
  dueDate?: TimestampString | null;
  disputedItems?: string | null;
  isAutoGenerated?: boolean | null;
}

export interface UpdateMessageData {
  message_update?: Message_Key | null;
}

export interface UpdateMessageVariables {
  id: UUIDString;
  conversationId?: UUIDString | null;
  senderName?: string | null;
  content?: string | null;
  readBy?: string | null;
}

export interface UpdateOrderData {
  order_update?: Order_Key | null;
}

export interface UpdateOrderVariables {
  id: UUIDString;
  orderNumber?: string | null;
  partnerId?: UUIDString | null;
  orderType?: OrderType | null;
  orderStatus?: OrderStatus | null;
}

export interface UpdatePartnerData {
  partner_update?: Partner_Key | null;
}

export interface UpdatePartnerVariables {
  id: UUIDString;
  partnerName?: string | null;
  partnerNumber?: string | null;
  partnerType?: PartnerType | null;
}

export interface UpdateSectorData {
  sector_update?: Sector_Key | null;
}

export interface UpdateSectorVariables {
  id: UUIDString;
  sectorNumber?: string | null;
  sectorName?: string | null;
  sectorType?: SectorType | null;
}

export interface UpdateShiftData {
  shift_update?: Shift_Key | null;
}

export interface UpdateShiftVariables {
  id: UUIDString;
  shiftName?: string | null;
  startDate?: TimestampString | null;
  endDate?: TimestampString | null;
  assignedStaff?: string | null;
}

export interface UpdateStaffData {
  staff_update?: Staff_Key | null;
}

export interface UpdateStaffVariables {
  id: UUIDString;
  employeeName?: string | null;
  vendorId?: string | null;
  vendorName?: string | null;
  manager?: string | null;
  contactNumber?: string | null;
  phone?: string | null;
  email?: string | null;
  department?: StaffDepartment | null;
  hubLocation?: string | null;
  eventLocation?: string | null;
  address?: string | null;
  city?: string | null;
  track?: string | null;
  position?: string | null;
  position2?: string | null;
  initial?: string | null;
  profileType?: ProfileType | null;
  employmentType?: EmploymentType | null;
  english?: EnglishLevel | null;
  englishRequired?: boolean | null;
  rate?: number | null;
  rating?: number | null;
  reliabilityScore?: number | null;
  backgroundCheckStatus?: BackgroundCheckStatus | null;
  notes?: string | null;
  accountingComments?: string | null;
  shiftCoveragePercentage?: number | null;
  cancellationCount?: number | null;
  noShowCount?: number | null;
  totalShifts?: number | null;
  invoiced?: boolean | null;
  checkIn?: string | null;
  scheduleDays?: string | null;
  replacedBy?: string | null;
  action?: string | null;
  ro?: string | null;
  mon?: string | null;
}

export interface UpdateTeamData {
  team_update?: Team_Key | null;
}

export interface UpdateTeamHubData {
  teamHub_update?: TeamHub_Key | null;
}

export interface UpdateTeamHubVariables {
  id: UUIDString;
  teamId?: UUIDString | null;
  hubName?: string | null;
  departments?: string | null;
}

export interface UpdateTeamMemberData {
  teamMember_update?: TeamMember_Key | null;
}

export interface UpdateTeamMemberInviteData {
  teamMemberInvite_update?: TeamMemberInvite_Key | null;
}

export interface UpdateTeamMemberInviteVariables {
  id: UUIDString;
  teamId?: UUIDString | null;
  email?: string | null;
  inviteStatus?: TeamMemberInviteStatus | null;
}

export interface UpdateTeamMemberVariables {
  id: UUIDString;
  teamId?: UUIDString | null;
  memberName?: string | null;
  email?: string | null;
  role?: TeamMemberRole | null;
  isActive?: boolean | null;
}

export interface UpdateTeamVariables {
  id: UUIDString;
  teamName?: string | null;
  ownerId?: string | null;
  ownerName?: string | null;
  ownerRole?: TeamOwnerRole | null;
  favoriteStaff?: string | null;
  blockedStaff?: string | null;
}

export interface UpdateUserData {
  user_update?: User_Key | null;
}

export interface UpdateUserVariables {
  id: string;
  email?: string | null;
  fullName?: string | null;
  role?: UserBaseRole | null;
  userRole?: string | null;
}

export interface UpdateVendorData {
  vendor_update?: Vendor_Key | null;
}

export interface UpdateVendorDefaultSettingData {
  vendorDefaultSetting_update?: VendorDefaultSetting_Key | null;
}

export interface UpdateVendorDefaultSettingVariables {
  id: UUIDString;
  vendorName?: string | null;
  defaultMarkupPercentage?: number | null;
  defaultVendorFeePercentage?: number | null;
}

export interface UpdateVendorRateData {
  vendorRate_update?: VendorRate_Key | null;
}

export interface UpdateVendorRateVariables {
  id: UUIDString;
  vendorName?: string | null;
  category?: VendorRateCategory | null;
  roleName?: string | null;
  employeeWage?: number | null;
  markupPercentage?: number | null;
  vendorFeePercentage?: number | null;
  clientRate?: number | null;
}

export interface UpdateVendorVariables {
  id: UUIDString;
  vendorNumber?: string | null;
  legalName?: string | null;
  region?: VendorRegion | null;
  platformType?: VendorPlatformType | null;
  primaryContactEmail?: string | null;
  approvalStatus?: VendorApprovalStatus | null;
  isActive?: boolean | null;
}

export interface UpdateWorkforceData {
  workforce_update?: Workforce_Key | null;
}

export interface UpdateWorkforceVariables {
  id: UUIDString;
  workforceNumber?: string | null;
  vendorId?: UUIDString | null;
  firstName?: string | null;
  lastName?: string | null;
  employmentType?: WorkforceEmploymentType | null;
}

export interface User_Key {
  id: string;
  __typename?: 'User_Key';
}

export interface VendorDefaultSetting_Key {
  id: UUIDString;
  __typename?: 'VendorDefaultSetting_Key';
}

export interface VendorRate_Key {
  id: UUIDString;
  __typename?: 'VendorRate_Key';
}

export interface Vendor_Key {
  id: UUIDString;
  __typename?: 'Vendor_Key';
}

export interface Workforce_Key {
  id: UUIDString;
  __typename?: 'Workforce_Key';
}

interface CreateMessageRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateMessageVariables): MutationRef<CreateMessageData, CreateMessageVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateMessageVariables): MutationRef<CreateMessageData, CreateMessageVariables>;
  operationName: string;
}
export const createMessageRef: CreateMessageRef;

export function createMessage(vars: CreateMessageVariables): MutationPromise<CreateMessageData, CreateMessageVariables>;
export function createMessage(dc: DataConnect, vars: CreateMessageVariables): MutationPromise<CreateMessageData, CreateMessageVariables>;

interface UpdateMessageRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateMessageVariables): MutationRef<UpdateMessageData, UpdateMessageVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateMessageVariables): MutationRef<UpdateMessageData, UpdateMessageVariables>;
  operationName: string;
}
export const updateMessageRef: UpdateMessageRef;

export function updateMessage(vars: UpdateMessageVariables): MutationPromise<UpdateMessageData, UpdateMessageVariables>;
export function updateMessage(dc: DataConnect, vars: UpdateMessageVariables): MutationPromise<UpdateMessageData, UpdateMessageVariables>;

interface DeleteMessageRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteMessageVariables): MutationRef<DeleteMessageData, DeleteMessageVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteMessageVariables): MutationRef<DeleteMessageData, DeleteMessageVariables>;
  operationName: string;
}
export const deleteMessageRef: DeleteMessageRef;

export function deleteMessage(vars: DeleteMessageVariables): MutationPromise<DeleteMessageData, DeleteMessageVariables>;
export function deleteMessage(dc: DataConnect, vars: DeleteMessageVariables): MutationPromise<DeleteMessageData, DeleteMessageVariables>;

interface CreateStaffRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateStaffVariables): MutationRef<CreateStaffData, CreateStaffVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateStaffVariables): MutationRef<CreateStaffData, CreateStaffVariables>;
  operationName: string;
}
export const createStaffRef: CreateStaffRef;

export function createStaff(vars: CreateStaffVariables): MutationPromise<CreateStaffData, CreateStaffVariables>;
export function createStaff(dc: DataConnect, vars: CreateStaffVariables): MutationPromise<CreateStaffData, CreateStaffVariables>;

interface UpdateStaffRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateStaffVariables): MutationRef<UpdateStaffData, UpdateStaffVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateStaffVariables): MutationRef<UpdateStaffData, UpdateStaffVariables>;
  operationName: string;
}
export const updateStaffRef: UpdateStaffRef;

export function updateStaff(vars: UpdateStaffVariables): MutationPromise<UpdateStaffData, UpdateStaffVariables>;
export function updateStaff(dc: DataConnect, vars: UpdateStaffVariables): MutationPromise<UpdateStaffData, UpdateStaffVariables>;

interface DeleteStaffRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteStaffVariables): MutationRef<DeleteStaffData, DeleteStaffVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteStaffVariables): MutationRef<DeleteStaffData, DeleteStaffVariables>;
  operationName: string;
}
export const deleteStaffRef: DeleteStaffRef;

export function deleteStaff(vars: DeleteStaffVariables): MutationPromise<DeleteStaffData, DeleteStaffVariables>;
export function deleteStaff(dc: DataConnect, vars: DeleteStaffVariables): MutationPromise<DeleteStaffData, DeleteStaffVariables>;

interface ListTeamMemberInviteRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListTeamMemberInviteData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListTeamMemberInviteData, undefined>;
  operationName: string;
}
export const listTeamMemberInviteRef: ListTeamMemberInviteRef;

export function listTeamMemberInvite(): QueryPromise<ListTeamMemberInviteData, undefined>;
export function listTeamMemberInvite(dc: DataConnect): QueryPromise<ListTeamMemberInviteData, undefined>;

interface GetTeamMemberInviteByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetTeamMemberInviteByIdVariables): QueryRef<GetTeamMemberInviteByIdData, GetTeamMemberInviteByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetTeamMemberInviteByIdVariables): QueryRef<GetTeamMemberInviteByIdData, GetTeamMemberInviteByIdVariables>;
  operationName: string;
}
export const getTeamMemberInviteByIdRef: GetTeamMemberInviteByIdRef;

export function getTeamMemberInviteById(vars: GetTeamMemberInviteByIdVariables): QueryPromise<GetTeamMemberInviteByIdData, GetTeamMemberInviteByIdVariables>;
export function getTeamMemberInviteById(dc: DataConnect, vars: GetTeamMemberInviteByIdVariables): QueryPromise<GetTeamMemberInviteByIdData, GetTeamMemberInviteByIdVariables>;

interface FilterTeamMemberInviteRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterTeamMemberInviteVariables): QueryRef<FilterTeamMemberInviteData, FilterTeamMemberInviteVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterTeamMemberInviteVariables): QueryRef<FilterTeamMemberInviteData, FilterTeamMemberInviteVariables>;
  operationName: string;
}
export const filterTeamMemberInviteRef: FilterTeamMemberInviteRef;

export function filterTeamMemberInvite(vars?: FilterTeamMemberInviteVariables): QueryPromise<FilterTeamMemberInviteData, FilterTeamMemberInviteVariables>;
export function filterTeamMemberInvite(dc: DataConnect, vars?: FilterTeamMemberInviteVariables): QueryPromise<FilterTeamMemberInviteData, FilterTeamMemberInviteVariables>;

interface CreateVendorRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateVendorVariables): MutationRef<CreateVendorData, CreateVendorVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateVendorVariables): MutationRef<CreateVendorData, CreateVendorVariables>;
  operationName: string;
}
export const createVendorRef: CreateVendorRef;

export function createVendor(vars: CreateVendorVariables): MutationPromise<CreateVendorData, CreateVendorVariables>;
export function createVendor(dc: DataConnect, vars: CreateVendorVariables): MutationPromise<CreateVendorData, CreateVendorVariables>;

interface UpdateVendorRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateVendorVariables): MutationRef<UpdateVendorData, UpdateVendorVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateVendorVariables): MutationRef<UpdateVendorData, UpdateVendorVariables>;
  operationName: string;
}
export const updateVendorRef: UpdateVendorRef;

export function updateVendor(vars: UpdateVendorVariables): MutationPromise<UpdateVendorData, UpdateVendorVariables>;
export function updateVendor(dc: DataConnect, vars: UpdateVendorVariables): MutationPromise<UpdateVendorData, UpdateVendorVariables>;

interface DeleteVendorRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteVendorVariables): MutationRef<DeleteVendorData, DeleteVendorVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteVendorVariables): MutationRef<DeleteVendorData, DeleteVendorVariables>;
  operationName: string;
}
export const deleteVendorRef: DeleteVendorRef;

export function deleteVendor(vars: DeleteVendorVariables): MutationPromise<DeleteVendorData, DeleteVendorVariables>;
export function deleteVendor(dc: DataConnect, vars: DeleteVendorVariables): MutationPromise<DeleteVendorData, DeleteVendorVariables>;

interface CreateActivityLogRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateActivityLogVariables): MutationRef<CreateActivityLogData, CreateActivityLogVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateActivityLogVariables): MutationRef<CreateActivityLogData, CreateActivityLogVariables>;
  operationName: string;
}
export const createActivityLogRef: CreateActivityLogRef;

export function createActivityLog(vars: CreateActivityLogVariables): MutationPromise<CreateActivityLogData, CreateActivityLogVariables>;
export function createActivityLog(dc: DataConnect, vars: CreateActivityLogVariables): MutationPromise<CreateActivityLogData, CreateActivityLogVariables>;

interface UpdateActivityLogRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateActivityLogVariables): MutationRef<UpdateActivityLogData, UpdateActivityLogVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateActivityLogVariables): MutationRef<UpdateActivityLogData, UpdateActivityLogVariables>;
  operationName: string;
}
export const updateActivityLogRef: UpdateActivityLogRef;

export function updateActivityLog(vars: UpdateActivityLogVariables): MutationPromise<UpdateActivityLogData, UpdateActivityLogVariables>;
export function updateActivityLog(dc: DataConnect, vars: UpdateActivityLogVariables): MutationPromise<UpdateActivityLogData, UpdateActivityLogVariables>;

interface DeleteActivityLogRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteActivityLogVariables): MutationRef<DeleteActivityLogData, DeleteActivityLogVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteActivityLogVariables): MutationRef<DeleteActivityLogData, DeleteActivityLogVariables>;
  operationName: string;
}
export const deleteActivityLogRef: DeleteActivityLogRef;

export function deleteActivityLog(vars: DeleteActivityLogVariables): MutationPromise<DeleteActivityLogData, DeleteActivityLogVariables>;
export function deleteActivityLog(dc: DataConnect, vars: DeleteActivityLogVariables): MutationPromise<DeleteActivityLogData, DeleteActivityLogVariables>;

interface CreateAssignmentRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateAssignmentVariables): MutationRef<CreateAssignmentData, CreateAssignmentVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateAssignmentVariables): MutationRef<CreateAssignmentData, CreateAssignmentVariables>;
  operationName: string;
}
export const createAssignmentRef: CreateAssignmentRef;

export function createAssignment(vars: CreateAssignmentVariables): MutationPromise<CreateAssignmentData, CreateAssignmentVariables>;
export function createAssignment(dc: DataConnect, vars: CreateAssignmentVariables): MutationPromise<CreateAssignmentData, CreateAssignmentVariables>;

interface UpdateAssignmentRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateAssignmentVariables): MutationRef<UpdateAssignmentData, UpdateAssignmentVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateAssignmentVariables): MutationRef<UpdateAssignmentData, UpdateAssignmentVariables>;
  operationName: string;
}
export const updateAssignmentRef: UpdateAssignmentRef;

export function updateAssignment(vars: UpdateAssignmentVariables): MutationPromise<UpdateAssignmentData, UpdateAssignmentVariables>;
export function updateAssignment(dc: DataConnect, vars: UpdateAssignmentVariables): MutationPromise<UpdateAssignmentData, UpdateAssignmentVariables>;

interface DeleteAssignmentRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteAssignmentVariables): MutationRef<DeleteAssignmentData, DeleteAssignmentVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteAssignmentVariables): MutationRef<DeleteAssignmentData, DeleteAssignmentVariables>;
  operationName: string;
}
export const deleteAssignmentRef: DeleteAssignmentRef;

export function deleteAssignment(vars: DeleteAssignmentVariables): MutationPromise<DeleteAssignmentData, DeleteAssignmentVariables>;
export function deleteAssignment(dc: DataConnect, vars: DeleteAssignmentVariables): MutationPromise<DeleteAssignmentData, DeleteAssignmentVariables>;

interface CreateCertificationRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateCertificationVariables): MutationRef<CreateCertificationData, CreateCertificationVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateCertificationVariables): MutationRef<CreateCertificationData, CreateCertificationVariables>;
  operationName: string;
}
export const createCertificationRef: CreateCertificationRef;

export function createCertification(vars: CreateCertificationVariables): MutationPromise<CreateCertificationData, CreateCertificationVariables>;
export function createCertification(dc: DataConnect, vars: CreateCertificationVariables): MutationPromise<CreateCertificationData, CreateCertificationVariables>;

interface UpdateCertificationRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateCertificationVariables): MutationRef<UpdateCertificationData, UpdateCertificationVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateCertificationVariables): MutationRef<UpdateCertificationData, UpdateCertificationVariables>;
  operationName: string;
}
export const updateCertificationRef: UpdateCertificationRef;

export function updateCertification(vars: UpdateCertificationVariables): MutationPromise<UpdateCertificationData, UpdateCertificationVariables>;
export function updateCertification(dc: DataConnect, vars: UpdateCertificationVariables): MutationPromise<UpdateCertificationData, UpdateCertificationVariables>;

interface DeleteCertificationRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteCertificationVariables): MutationRef<DeleteCertificationData, DeleteCertificationVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteCertificationVariables): MutationRef<DeleteCertificationData, DeleteCertificationVariables>;
  operationName: string;
}
export const deleteCertificationRef: DeleteCertificationRef;

export function deleteCertification(vars: DeleteCertificationVariables): MutationPromise<DeleteCertificationData, DeleteCertificationVariables>;
export function deleteCertification(dc: DataConnect, vars: DeleteCertificationVariables): MutationPromise<DeleteCertificationData, DeleteCertificationVariables>;

interface ListCertificationRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListCertificationData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListCertificationData, undefined>;
  operationName: string;
}
export const listCertificationRef: ListCertificationRef;

export function listCertification(): QueryPromise<ListCertificationData, undefined>;
export function listCertification(dc: DataConnect): QueryPromise<ListCertificationData, undefined>;

interface GetCertificationByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetCertificationByIdVariables): QueryRef<GetCertificationByIdData, GetCertificationByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetCertificationByIdVariables): QueryRef<GetCertificationByIdData, GetCertificationByIdVariables>;
  operationName: string;
}
export const getCertificationByIdRef: GetCertificationByIdRef;

export function getCertificationById(vars: GetCertificationByIdVariables): QueryPromise<GetCertificationByIdData, GetCertificationByIdVariables>;
export function getCertificationById(dc: DataConnect, vars: GetCertificationByIdVariables): QueryPromise<GetCertificationByIdData, GetCertificationByIdVariables>;

interface FilterCertificationRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterCertificationVariables): QueryRef<FilterCertificationData, FilterCertificationVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterCertificationVariables): QueryRef<FilterCertificationData, FilterCertificationVariables>;
  operationName: string;
}
export const filterCertificationRef: FilterCertificationRef;

export function filterCertification(vars?: FilterCertificationVariables): QueryPromise<FilterCertificationData, FilterCertificationVariables>;
export function filterCertification(dc: DataConnect, vars?: FilterCertificationVariables): QueryPromise<FilterCertificationData, FilterCertificationVariables>;

interface ListConversationRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListConversationData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListConversationData, undefined>;
  operationName: string;
}
export const listConversationRef: ListConversationRef;

export function listConversation(): QueryPromise<ListConversationData, undefined>;
export function listConversation(dc: DataConnect): QueryPromise<ListConversationData, undefined>;

interface GetConversationByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetConversationByIdVariables): QueryRef<GetConversationByIdData, GetConversationByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetConversationByIdVariables): QueryRef<GetConversationByIdData, GetConversationByIdVariables>;
  operationName: string;
}
export const getConversationByIdRef: GetConversationByIdRef;

export function getConversationById(vars: GetConversationByIdVariables): QueryPromise<GetConversationByIdData, GetConversationByIdVariables>;
export function getConversationById(dc: DataConnect, vars: GetConversationByIdVariables): QueryPromise<GetConversationByIdData, GetConversationByIdVariables>;

interface FilterConversationRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterConversationVariables): QueryRef<FilterConversationData, FilterConversationVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterConversationVariables): QueryRef<FilterConversationData, FilterConversationVariables>;
  operationName: string;
}
export const filterConversationRef: FilterConversationRef;

export function filterConversation(vars?: FilterConversationVariables): QueryPromise<FilterConversationData, FilterConversationVariables>;
export function filterConversation(dc: DataConnect, vars?: FilterConversationVariables): QueryPromise<FilterConversationData, FilterConversationVariables>;

interface CreateShiftRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateShiftVariables): MutationRef<CreateShiftData, CreateShiftVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateShiftVariables): MutationRef<CreateShiftData, CreateShiftVariables>;
  operationName: string;
}
export const createShiftRef: CreateShiftRef;

export function createShift(vars: CreateShiftVariables): MutationPromise<CreateShiftData, CreateShiftVariables>;
export function createShift(dc: DataConnect, vars: CreateShiftVariables): MutationPromise<CreateShiftData, CreateShiftVariables>;

interface UpdateShiftRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateShiftVariables): MutationRef<UpdateShiftData, UpdateShiftVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateShiftVariables): MutationRef<UpdateShiftData, UpdateShiftVariables>;
  operationName: string;
}
export const updateShiftRef: UpdateShiftRef;

export function updateShift(vars: UpdateShiftVariables): MutationPromise<UpdateShiftData, UpdateShiftVariables>;
export function updateShift(dc: DataConnect, vars: UpdateShiftVariables): MutationPromise<UpdateShiftData, UpdateShiftVariables>;

interface DeleteShiftRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteShiftVariables): MutationRef<DeleteShiftData, DeleteShiftVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteShiftVariables): MutationRef<DeleteShiftData, DeleteShiftVariables>;
  operationName: string;
}
export const deleteShiftRef: DeleteShiftRef;

export function deleteShift(vars: DeleteShiftVariables): MutationPromise<DeleteShiftData, DeleteShiftVariables>;
export function deleteShift(dc: DataConnect, vars: DeleteShiftVariables): MutationPromise<DeleteShiftData, DeleteShiftVariables>;

interface ListShiftRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListShiftData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListShiftData, undefined>;
  operationName: string;
}
export const listShiftRef: ListShiftRef;

export function listShift(): QueryPromise<ListShiftData, undefined>;
export function listShift(dc: DataConnect): QueryPromise<ListShiftData, undefined>;

interface GetShiftByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetShiftByIdVariables): QueryRef<GetShiftByIdData, GetShiftByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetShiftByIdVariables): QueryRef<GetShiftByIdData, GetShiftByIdVariables>;
  operationName: string;
}
export const getShiftByIdRef: GetShiftByIdRef;

export function getShiftById(vars: GetShiftByIdVariables): QueryPromise<GetShiftByIdData, GetShiftByIdVariables>;
export function getShiftById(dc: DataConnect, vars: GetShiftByIdVariables): QueryPromise<GetShiftByIdData, GetShiftByIdVariables>;

interface FilterShiftRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterShiftVariables): QueryRef<FilterShiftData, FilterShiftVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterShiftVariables): QueryRef<FilterShiftData, FilterShiftVariables>;
  operationName: string;
}
export const filterShiftRef: FilterShiftRef;

export function filterShift(vars?: FilterShiftVariables): QueryPromise<FilterShiftData, FilterShiftVariables>;
export function filterShift(dc: DataConnect, vars?: FilterShiftVariables): QueryPromise<FilterShiftData, FilterShiftVariables>;

interface CreateTeamHubRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateTeamHubVariables): MutationRef<CreateTeamHubData, CreateTeamHubVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateTeamHubVariables): MutationRef<CreateTeamHubData, CreateTeamHubVariables>;
  operationName: string;
}
export const createTeamHubRef: CreateTeamHubRef;

export function createTeamHub(vars: CreateTeamHubVariables): MutationPromise<CreateTeamHubData, CreateTeamHubVariables>;
export function createTeamHub(dc: DataConnect, vars: CreateTeamHubVariables): MutationPromise<CreateTeamHubData, CreateTeamHubVariables>;

interface UpdateTeamHubRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateTeamHubVariables): MutationRef<UpdateTeamHubData, UpdateTeamHubVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateTeamHubVariables): MutationRef<UpdateTeamHubData, UpdateTeamHubVariables>;
  operationName: string;
}
export const updateTeamHubRef: UpdateTeamHubRef;

export function updateTeamHub(vars: UpdateTeamHubVariables): MutationPromise<UpdateTeamHubData, UpdateTeamHubVariables>;
export function updateTeamHub(dc: DataConnect, vars: UpdateTeamHubVariables): MutationPromise<UpdateTeamHubData, UpdateTeamHubVariables>;

interface DeleteTeamHubRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteTeamHubVariables): MutationRef<DeleteTeamHubData, DeleteTeamHubVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteTeamHubVariables): MutationRef<DeleteTeamHubData, DeleteTeamHubVariables>;
  operationName: string;
}
export const deleteTeamHubRef: DeleteTeamHubRef;

export function deleteTeamHub(vars: DeleteTeamHubVariables): MutationPromise<DeleteTeamHubData, DeleteTeamHubVariables>;
export function deleteTeamHub(dc: DataConnect, vars: DeleteTeamHubVariables): MutationPromise<DeleteTeamHubData, DeleteTeamHubVariables>;

interface ListEnterpriseRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListEnterpriseData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListEnterpriseData, undefined>;
  operationName: string;
}
export const listEnterpriseRef: ListEnterpriseRef;

export function listEnterprise(): QueryPromise<ListEnterpriseData, undefined>;
export function listEnterprise(dc: DataConnect): QueryPromise<ListEnterpriseData, undefined>;

interface GetEnterpriseByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetEnterpriseByIdVariables): QueryRef<GetEnterpriseByIdData, GetEnterpriseByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetEnterpriseByIdVariables): QueryRef<GetEnterpriseByIdData, GetEnterpriseByIdVariables>;
  operationName: string;
}
export const getEnterpriseByIdRef: GetEnterpriseByIdRef;

export function getEnterpriseById(vars: GetEnterpriseByIdVariables): QueryPromise<GetEnterpriseByIdData, GetEnterpriseByIdVariables>;
export function getEnterpriseById(dc: DataConnect, vars: GetEnterpriseByIdVariables): QueryPromise<GetEnterpriseByIdData, GetEnterpriseByIdVariables>;

interface FilterEnterpriseRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterEnterpriseVariables): QueryRef<FilterEnterpriseData, FilterEnterpriseVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterEnterpriseVariables): QueryRef<FilterEnterpriseData, FilterEnterpriseVariables>;
  operationName: string;
}
export const filterEnterpriseRef: FilterEnterpriseRef;

export function filterEnterprise(vars?: FilterEnterpriseVariables): QueryPromise<FilterEnterpriseData, FilterEnterpriseVariables>;
export function filterEnterprise(dc: DataConnect, vars?: FilterEnterpriseVariables): QueryPromise<FilterEnterpriseData, FilterEnterpriseVariables>;

interface ListInvoiceRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListInvoiceData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListInvoiceData, undefined>;
  operationName: string;
}
export const listInvoiceRef: ListInvoiceRef;

export function listInvoice(): QueryPromise<ListInvoiceData, undefined>;
export function listInvoice(dc: DataConnect): QueryPromise<ListInvoiceData, undefined>;

interface GetInvoiceByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetInvoiceByIdVariables): QueryRef<GetInvoiceByIdData, GetInvoiceByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetInvoiceByIdVariables): QueryRef<GetInvoiceByIdData, GetInvoiceByIdVariables>;
  operationName: string;
}
export const getInvoiceByIdRef: GetInvoiceByIdRef;

export function getInvoiceById(vars: GetInvoiceByIdVariables): QueryPromise<GetInvoiceByIdData, GetInvoiceByIdVariables>;
export function getInvoiceById(dc: DataConnect, vars: GetInvoiceByIdVariables): QueryPromise<GetInvoiceByIdData, GetInvoiceByIdVariables>;

interface FilterInvoicesRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterInvoicesVariables): QueryRef<FilterInvoicesData, FilterInvoicesVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterInvoicesVariables): QueryRef<FilterInvoicesData, FilterInvoicesVariables>;
  operationName: string;
}
export const filterInvoicesRef: FilterInvoicesRef;

export function filterInvoices(vars?: FilterInvoicesVariables): QueryPromise<FilterInvoicesData, FilterInvoicesVariables>;
export function filterInvoices(dc: DataConnect, vars?: FilterInvoicesVariables): QueryPromise<FilterInvoicesData, FilterInvoicesVariables>;

interface CreateOrderRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateOrderVariables): MutationRef<CreateOrderData, CreateOrderVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateOrderVariables): MutationRef<CreateOrderData, CreateOrderVariables>;
  operationName: string;
}
export const createOrderRef: CreateOrderRef;

export function createOrder(vars: CreateOrderVariables): MutationPromise<CreateOrderData, CreateOrderVariables>;
export function createOrder(dc: DataConnect, vars: CreateOrderVariables): MutationPromise<CreateOrderData, CreateOrderVariables>;

interface UpdateOrderRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateOrderVariables): MutationRef<UpdateOrderData, UpdateOrderVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateOrderVariables): MutationRef<UpdateOrderData, UpdateOrderVariables>;
  operationName: string;
}
export const updateOrderRef: UpdateOrderRef;

export function updateOrder(vars: UpdateOrderVariables): MutationPromise<UpdateOrderData, UpdateOrderVariables>;
export function updateOrder(dc: DataConnect, vars: UpdateOrderVariables): MutationPromise<UpdateOrderData, UpdateOrderVariables>;

interface DeleteOrderRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteOrderVariables): MutationRef<DeleteOrderData, DeleteOrderVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteOrderVariables): MutationRef<DeleteOrderData, DeleteOrderVariables>;
  operationName: string;
}
export const deleteOrderRef: DeleteOrderRef;

export function deleteOrder(vars: DeleteOrderVariables): MutationPromise<DeleteOrderData, DeleteOrderVariables>;
export function deleteOrder(dc: DataConnect, vars: DeleteOrderVariables): MutationPromise<DeleteOrderData, DeleteOrderVariables>;

interface CreateSectorRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateSectorVariables): MutationRef<CreateSectorData, CreateSectorVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateSectorVariables): MutationRef<CreateSectorData, CreateSectorVariables>;
  operationName: string;
}
export const createSectorRef: CreateSectorRef;

export function createSector(vars: CreateSectorVariables): MutationPromise<CreateSectorData, CreateSectorVariables>;
export function createSector(dc: DataConnect, vars: CreateSectorVariables): MutationPromise<CreateSectorData, CreateSectorVariables>;

interface UpdateSectorRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateSectorVariables): MutationRef<UpdateSectorData, UpdateSectorVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateSectorVariables): MutationRef<UpdateSectorData, UpdateSectorVariables>;
  operationName: string;
}
export const updateSectorRef: UpdateSectorRef;

export function updateSector(vars: UpdateSectorVariables): MutationPromise<UpdateSectorData, UpdateSectorVariables>;
export function updateSector(dc: DataConnect, vars: UpdateSectorVariables): MutationPromise<UpdateSectorData, UpdateSectorVariables>;

interface DeleteSectorRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteSectorVariables): MutationRef<DeleteSectorData, DeleteSectorVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteSectorVariables): MutationRef<DeleteSectorData, DeleteSectorVariables>;
  operationName: string;
}
export const deleteSectorRef: DeleteSectorRef;

export function deleteSector(vars: DeleteSectorVariables): MutationPromise<DeleteSectorData, DeleteSectorVariables>;
export function deleteSector(dc: DataConnect, vars: DeleteSectorVariables): MutationPromise<DeleteSectorData, DeleteSectorVariables>;

interface ListTeamMemberRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListTeamMemberData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListTeamMemberData, undefined>;
  operationName: string;
}
export const listTeamMemberRef: ListTeamMemberRef;

export function listTeamMember(): QueryPromise<ListTeamMemberData, undefined>;
export function listTeamMember(dc: DataConnect): QueryPromise<ListTeamMemberData, undefined>;

interface GetTeamMemberByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetTeamMemberByIdVariables): QueryRef<GetTeamMemberByIdData, GetTeamMemberByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetTeamMemberByIdVariables): QueryRef<GetTeamMemberByIdData, GetTeamMemberByIdVariables>;
  operationName: string;
}
export const getTeamMemberByIdRef: GetTeamMemberByIdRef;

export function getTeamMemberById(vars: GetTeamMemberByIdVariables): QueryPromise<GetTeamMemberByIdData, GetTeamMemberByIdVariables>;
export function getTeamMemberById(dc: DataConnect, vars: GetTeamMemberByIdVariables): QueryPromise<GetTeamMemberByIdData, GetTeamMemberByIdVariables>;

interface FilterTeamMemberRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterTeamMemberVariables): QueryRef<FilterTeamMemberData, FilterTeamMemberVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterTeamMemberVariables): QueryRef<FilterTeamMemberData, FilterTeamMemberVariables>;
  operationName: string;
}
export const filterTeamMemberRef: FilterTeamMemberRef;

export function filterTeamMember(vars?: FilterTeamMemberVariables): QueryPromise<FilterTeamMemberData, FilterTeamMemberVariables>;
export function filterTeamMember(dc: DataConnect, vars?: FilterTeamMemberVariables): QueryPromise<FilterTeamMemberData, FilterTeamMemberVariables>;

interface CreateUserRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateUserVariables): MutationRef<CreateUserData, CreateUserVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateUserVariables): MutationRef<CreateUserData, CreateUserVariables>;
  operationName: string;
}
export const createUserRef: CreateUserRef;

export function createUser(vars: CreateUserVariables): MutationPromise<CreateUserData, CreateUserVariables>;
export function createUser(dc: DataConnect, vars: CreateUserVariables): MutationPromise<CreateUserData, CreateUserVariables>;

interface UpdateUserRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateUserVariables): MutationRef<UpdateUserData, UpdateUserVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateUserVariables): MutationRef<UpdateUserData, UpdateUserVariables>;
  operationName: string;
}
export const updateUserRef: UpdateUserRef;

export function updateUser(vars: UpdateUserVariables): MutationPromise<UpdateUserData, UpdateUserVariables>;
export function updateUser(dc: DataConnect, vars: UpdateUserVariables): MutationPromise<UpdateUserData, UpdateUserVariables>;

interface DeleteUserRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteUserVariables): MutationRef<DeleteUserData, DeleteUserVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteUserVariables): MutationRef<DeleteUserData, DeleteUserVariables>;
  operationName: string;
}
export const deleteUserRef: DeleteUserRef;

export function deleteUser(vars: DeleteUserVariables): MutationPromise<DeleteUserData, DeleteUserVariables>;
export function deleteUser(dc: DataConnect, vars: DeleteUserVariables): MutationPromise<DeleteUserData, DeleteUserVariables>;

interface ListUsersRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListUsersData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListUsersData, undefined>;
  operationName: string;
}
export const listUsersRef: ListUsersRef;

export function listUsers(): QueryPromise<ListUsersData, undefined>;
export function listUsers(dc: DataConnect): QueryPromise<ListUsersData, undefined>;

interface GetUserByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetUserByIdVariables): QueryRef<GetUserByIdData, GetUserByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetUserByIdVariables): QueryRef<GetUserByIdData, GetUserByIdVariables>;
  operationName: string;
}
export const getUserByIdRef: GetUserByIdRef;

export function getUserById(vars: GetUserByIdVariables): QueryPromise<GetUserByIdData, GetUserByIdVariables>;
export function getUserById(dc: DataConnect, vars: GetUserByIdVariables): QueryPromise<GetUserByIdData, GetUserByIdVariables>;

interface FilterUsersRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterUsersVariables): QueryRef<FilterUsersData, FilterUsersVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterUsersVariables): QueryRef<FilterUsersData, FilterUsersVariables>;
  operationName: string;
}
export const filterUsersRef: FilterUsersRef;

export function filterUsers(vars?: FilterUsersVariables): QueryPromise<FilterUsersData, FilterUsersVariables>;
export function filterUsers(dc: DataConnect, vars?: FilterUsersVariables): QueryPromise<FilterUsersData, FilterUsersVariables>;

interface ListVendorDefaultSettingsRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListVendorDefaultSettingsData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListVendorDefaultSettingsData, undefined>;
  operationName: string;
}
export const listVendorDefaultSettingsRef: ListVendorDefaultSettingsRef;

export function listVendorDefaultSettings(): QueryPromise<ListVendorDefaultSettingsData, undefined>;
export function listVendorDefaultSettings(dc: DataConnect): QueryPromise<ListVendorDefaultSettingsData, undefined>;

interface GetVendorDefaultSettingByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetVendorDefaultSettingByIdVariables): QueryRef<GetVendorDefaultSettingByIdData, GetVendorDefaultSettingByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetVendorDefaultSettingByIdVariables): QueryRef<GetVendorDefaultSettingByIdData, GetVendorDefaultSettingByIdVariables>;
  operationName: string;
}
export const getVendorDefaultSettingByIdRef: GetVendorDefaultSettingByIdRef;

export function getVendorDefaultSettingById(vars: GetVendorDefaultSettingByIdVariables): QueryPromise<GetVendorDefaultSettingByIdData, GetVendorDefaultSettingByIdVariables>;
export function getVendorDefaultSettingById(dc: DataConnect, vars: GetVendorDefaultSettingByIdVariables): QueryPromise<GetVendorDefaultSettingByIdData, GetVendorDefaultSettingByIdVariables>;

interface FilterVendorDefaultSettingsRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterVendorDefaultSettingsVariables): QueryRef<FilterVendorDefaultSettingsData, FilterVendorDefaultSettingsVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterVendorDefaultSettingsVariables): QueryRef<FilterVendorDefaultSettingsData, FilterVendorDefaultSettingsVariables>;
  operationName: string;
}
export const filterVendorDefaultSettingsRef: FilterVendorDefaultSettingsRef;

export function filterVendorDefaultSettings(vars?: FilterVendorDefaultSettingsVariables): QueryPromise<FilterVendorDefaultSettingsData, FilterVendorDefaultSettingsVariables>;
export function filterVendorDefaultSettings(dc: DataConnect, vars?: FilterVendorDefaultSettingsVariables): QueryPromise<FilterVendorDefaultSettingsData, FilterVendorDefaultSettingsVariables>;

interface ListAssignmentRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListAssignmentData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListAssignmentData, undefined>;
  operationName: string;
}
export const listAssignmentRef: ListAssignmentRef;

export function listAssignment(): QueryPromise<ListAssignmentData, undefined>;
export function listAssignment(dc: DataConnect): QueryPromise<ListAssignmentData, undefined>;

interface GetAssignmentByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetAssignmentByIdVariables): QueryRef<GetAssignmentByIdData, GetAssignmentByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetAssignmentByIdVariables): QueryRef<GetAssignmentByIdData, GetAssignmentByIdVariables>;
  operationName: string;
}
export const getAssignmentByIdRef: GetAssignmentByIdRef;

export function getAssignmentById(vars: GetAssignmentByIdVariables): QueryPromise<GetAssignmentByIdData, GetAssignmentByIdVariables>;
export function getAssignmentById(dc: DataConnect, vars: GetAssignmentByIdVariables): QueryPromise<GetAssignmentByIdData, GetAssignmentByIdVariables>;

interface FilterAssignmentRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterAssignmentVariables): QueryRef<FilterAssignmentData, FilterAssignmentVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterAssignmentVariables): QueryRef<FilterAssignmentData, FilterAssignmentVariables>;
  operationName: string;
}
export const filterAssignmentRef: FilterAssignmentRef;

export function filterAssignment(vars?: FilterAssignmentVariables): QueryPromise<FilterAssignmentData, FilterAssignmentVariables>;
export function filterAssignment(dc: DataConnect, vars?: FilterAssignmentVariables): QueryPromise<FilterAssignmentData, FilterAssignmentVariables>;

interface ListEventsRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: ListEventsVariables): QueryRef<ListEventsData, ListEventsVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: ListEventsVariables): QueryRef<ListEventsData, ListEventsVariables>;
  operationName: string;
}
export const listEventsRef: ListEventsRef;

export function listEvents(vars?: ListEventsVariables): QueryPromise<ListEventsData, ListEventsVariables>;
export function listEvents(dc: DataConnect, vars?: ListEventsVariables): QueryPromise<ListEventsData, ListEventsVariables>;

interface GetEventByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetEventByIdVariables): QueryRef<GetEventByIdData, GetEventByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetEventByIdVariables): QueryRef<GetEventByIdData, GetEventByIdVariables>;
  operationName: string;
}
export const getEventByIdRef: GetEventByIdRef;

export function getEventById(vars: GetEventByIdVariables): QueryPromise<GetEventByIdData, GetEventByIdVariables>;
export function getEventById(dc: DataConnect, vars: GetEventByIdVariables): QueryPromise<GetEventByIdData, GetEventByIdVariables>;

interface FilterEventsRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterEventsVariables): QueryRef<FilterEventsData, FilterEventsVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterEventsVariables): QueryRef<FilterEventsData, FilterEventsVariables>;
  operationName: string;
}
export const filterEventsRef: FilterEventsRef;

export function filterEvents(vars?: FilterEventsVariables): QueryPromise<FilterEventsData, FilterEventsVariables>;
export function filterEvents(dc: DataConnect, vars?: FilterEventsVariables): QueryPromise<FilterEventsData, FilterEventsVariables>;

interface ListMessageRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListMessageData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListMessageData, undefined>;
  operationName: string;
}
export const listMessageRef: ListMessageRef;

export function listMessage(): QueryPromise<ListMessageData, undefined>;
export function listMessage(dc: DataConnect): QueryPromise<ListMessageData, undefined>;

interface GetMessageByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetMessageByIdVariables): QueryRef<GetMessageByIdData, GetMessageByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetMessageByIdVariables): QueryRef<GetMessageByIdData, GetMessageByIdVariables>;
  operationName: string;
}
export const getMessageByIdRef: GetMessageByIdRef;

export function getMessageById(vars: GetMessageByIdVariables): QueryPromise<GetMessageByIdData, GetMessageByIdVariables>;
export function getMessageById(dc: DataConnect, vars: GetMessageByIdVariables): QueryPromise<GetMessageByIdData, GetMessageByIdVariables>;

interface FilterMessageRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterMessageVariables): QueryRef<FilterMessageData, FilterMessageVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterMessageVariables): QueryRef<FilterMessageData, FilterMessageVariables>;
  operationName: string;
}
export const filterMessageRef: FilterMessageRef;

export function filterMessage(vars?: FilterMessageVariables): QueryPromise<FilterMessageData, FilterMessageVariables>;
export function filterMessage(dc: DataConnect, vars?: FilterMessageVariables): QueryPromise<FilterMessageData, FilterMessageVariables>;

interface ListSectorRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListSectorData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListSectorData, undefined>;
  operationName: string;
}
export const listSectorRef: ListSectorRef;

export function listSector(): QueryPromise<ListSectorData, undefined>;
export function listSector(dc: DataConnect): QueryPromise<ListSectorData, undefined>;

interface GetSectorByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetSectorByIdVariables): QueryRef<GetSectorByIdData, GetSectorByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetSectorByIdVariables): QueryRef<GetSectorByIdData, GetSectorByIdVariables>;
  operationName: string;
}
export const getSectorByIdRef: GetSectorByIdRef;

export function getSectorById(vars: GetSectorByIdVariables): QueryPromise<GetSectorByIdData, GetSectorByIdVariables>;
export function getSectorById(dc: DataConnect, vars: GetSectorByIdVariables): QueryPromise<GetSectorByIdData, GetSectorByIdVariables>;

interface FilterSectorRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterSectorVariables): QueryRef<FilterSectorData, FilterSectorVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterSectorVariables): QueryRef<FilterSectorData, FilterSectorVariables>;
  operationName: string;
}
export const filterSectorRef: FilterSectorRef;

export function filterSector(vars?: FilterSectorVariables): QueryPromise<FilterSectorData, FilterSectorVariables>;
export function filterSector(dc: DataConnect, vars?: FilterSectorVariables): QueryPromise<FilterSectorData, FilterSectorVariables>;

interface ListStaffRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListStaffData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListStaffData, undefined>;
  operationName: string;
}
export const listStaffRef: ListStaffRef;

export function listStaff(): QueryPromise<ListStaffData, undefined>;
export function listStaff(dc: DataConnect): QueryPromise<ListStaffData, undefined>;

interface GetStaffByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetStaffByIdVariables): QueryRef<GetStaffByIdData, GetStaffByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetStaffByIdVariables): QueryRef<GetStaffByIdData, GetStaffByIdVariables>;
  operationName: string;
}
export const getStaffByIdRef: GetStaffByIdRef;

export function getStaffById(vars: GetStaffByIdVariables): QueryPromise<GetStaffByIdData, GetStaffByIdVariables>;
export function getStaffById(dc: DataConnect, vars: GetStaffByIdVariables): QueryPromise<GetStaffByIdData, GetStaffByIdVariables>;

interface FilterStaffRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterStaffVariables): QueryRef<FilterStaffData, FilterStaffVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterStaffVariables): QueryRef<FilterStaffData, FilterStaffVariables>;
  operationName: string;
}
export const filterStaffRef: FilterStaffRef;

export function filterStaff(vars?: FilterStaffVariables): QueryPromise<FilterStaffData, FilterStaffVariables>;
export function filterStaff(dc: DataConnect, vars?: FilterStaffVariables): QueryPromise<FilterStaffData, FilterStaffVariables>;

interface CreateTeamMemberInviteRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateTeamMemberInviteVariables): MutationRef<CreateTeamMemberInviteData, CreateTeamMemberInviteVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateTeamMemberInviteVariables): MutationRef<CreateTeamMemberInviteData, CreateTeamMemberInviteVariables>;
  operationName: string;
}
export const createTeamMemberInviteRef: CreateTeamMemberInviteRef;

export function createTeamMemberInvite(vars: CreateTeamMemberInviteVariables): MutationPromise<CreateTeamMemberInviteData, CreateTeamMemberInviteVariables>;
export function createTeamMemberInvite(dc: DataConnect, vars: CreateTeamMemberInviteVariables): MutationPromise<CreateTeamMemberInviteData, CreateTeamMemberInviteVariables>;

interface UpdateTeamMemberInviteRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateTeamMemberInviteVariables): MutationRef<UpdateTeamMemberInviteData, UpdateTeamMemberInviteVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateTeamMemberInviteVariables): MutationRef<UpdateTeamMemberInviteData, UpdateTeamMemberInviteVariables>;
  operationName: string;
}
export const updateTeamMemberInviteRef: UpdateTeamMemberInviteRef;

export function updateTeamMemberInvite(vars: UpdateTeamMemberInviteVariables): MutationPromise<UpdateTeamMemberInviteData, UpdateTeamMemberInviteVariables>;
export function updateTeamMemberInvite(dc: DataConnect, vars: UpdateTeamMemberInviteVariables): MutationPromise<UpdateTeamMemberInviteData, UpdateTeamMemberInviteVariables>;

interface DeleteTeamMemberInviteRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteTeamMemberInviteVariables): MutationRef<DeleteTeamMemberInviteData, DeleteTeamMemberInviteVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteTeamMemberInviteVariables): MutationRef<DeleteTeamMemberInviteData, DeleteTeamMemberInviteVariables>;
  operationName: string;
}
export const deleteTeamMemberInviteRef: DeleteTeamMemberInviteRef;

export function deleteTeamMemberInvite(vars: DeleteTeamMemberInviteVariables): MutationPromise<DeleteTeamMemberInviteData, DeleteTeamMemberInviteVariables>;
export function deleteTeamMemberInvite(dc: DataConnect, vars: DeleteTeamMemberInviteVariables): MutationPromise<DeleteTeamMemberInviteData, DeleteTeamMemberInviteVariables>;

interface CreateVendorDefaultSettingRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateVendorDefaultSettingVariables): MutationRef<CreateVendorDefaultSettingData, CreateVendorDefaultSettingVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationRef<CreateVendorDefaultSettingData, CreateVendorDefaultSettingVariables>;
  operationName: string;
}
export const createVendorDefaultSettingRef: CreateVendorDefaultSettingRef;

export function createVendorDefaultSetting(vars: CreateVendorDefaultSettingVariables): MutationPromise<CreateVendorDefaultSettingData, CreateVendorDefaultSettingVariables>;
export function createVendorDefaultSetting(dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationPromise<CreateVendorDefaultSettingData, CreateVendorDefaultSettingVariables>;

interface UpdateVendorDefaultSettingRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateVendorDefaultSettingVariables): MutationRef<UpdateVendorDefaultSettingData, UpdateVendorDefaultSettingVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationRef<UpdateVendorDefaultSettingData, UpdateVendorDefaultSettingVariables>;
  operationName: string;
}
export const updateVendorDefaultSettingRef: UpdateVendorDefaultSettingRef;

export function updateVendorDefaultSetting(vars: UpdateVendorDefaultSettingVariables): MutationPromise<UpdateVendorDefaultSettingData, UpdateVendorDefaultSettingVariables>;
export function updateVendorDefaultSetting(dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationPromise<UpdateVendorDefaultSettingData, UpdateVendorDefaultSettingVariables>;

interface DeleteVendorDefaultSettingRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteVendorDefaultSettingVariables): MutationRef<DeleteVendorDefaultSettingData, DeleteVendorDefaultSettingVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationRef<DeleteVendorDefaultSettingData, DeleteVendorDefaultSettingVariables>;
  operationName: string;
}
export const deleteVendorDefaultSettingRef: DeleteVendorDefaultSettingRef;

export function deleteVendorDefaultSetting(vars: DeleteVendorDefaultSettingVariables): MutationPromise<DeleteVendorDefaultSettingData, DeleteVendorDefaultSettingVariables>;
export function deleteVendorDefaultSetting(dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationPromise<DeleteVendorDefaultSettingData, DeleteVendorDefaultSettingVariables>;

interface CreateVendorRateRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateVendorRateVariables): MutationRef<CreateVendorRateData, CreateVendorRateVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateVendorRateVariables): MutationRef<CreateVendorRateData, CreateVendorRateVariables>;
  operationName: string;
}
export const createVendorRateRef: CreateVendorRateRef;

export function createVendorRate(vars: CreateVendorRateVariables): MutationPromise<CreateVendorRateData, CreateVendorRateVariables>;
export function createVendorRate(dc: DataConnect, vars: CreateVendorRateVariables): MutationPromise<CreateVendorRateData, CreateVendorRateVariables>;

interface UpdateVendorRateRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateVendorRateVariables): MutationRef<UpdateVendorRateData, UpdateVendorRateVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateVendorRateVariables): MutationRef<UpdateVendorRateData, UpdateVendorRateVariables>;
  operationName: string;
}
export const updateVendorRateRef: UpdateVendorRateRef;

export function updateVendorRate(vars: UpdateVendorRateVariables): MutationPromise<UpdateVendorRateData, UpdateVendorRateVariables>;
export function updateVendorRate(dc: DataConnect, vars: UpdateVendorRateVariables): MutationPromise<UpdateVendorRateData, UpdateVendorRateVariables>;

interface DeleteVendorRateRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteVendorRateVariables): MutationRef<DeleteVendorRateData, DeleteVendorRateVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteVendorRateVariables): MutationRef<DeleteVendorRateData, DeleteVendorRateVariables>;
  operationName: string;
}
export const deleteVendorRateRef: DeleteVendorRateRef;

export function deleteVendorRate(vars: DeleteVendorRateVariables): MutationPromise<DeleteVendorRateData, DeleteVendorRateVariables>;
export function deleteVendorRate(dc: DataConnect, vars: DeleteVendorRateVariables): MutationPromise<DeleteVendorRateData, DeleteVendorRateVariables>;

interface CreateEnterpriseRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateEnterpriseVariables): MutationRef<CreateEnterpriseData, CreateEnterpriseVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateEnterpriseVariables): MutationRef<CreateEnterpriseData, CreateEnterpriseVariables>;
  operationName: string;
}
export const createEnterpriseRef: CreateEnterpriseRef;

export function createEnterprise(vars: CreateEnterpriseVariables): MutationPromise<CreateEnterpriseData, CreateEnterpriseVariables>;
export function createEnterprise(dc: DataConnect, vars: CreateEnterpriseVariables): MutationPromise<CreateEnterpriseData, CreateEnterpriseVariables>;

interface UpdateEnterpriseRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateEnterpriseVariables): MutationRef<UpdateEnterpriseData, UpdateEnterpriseVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateEnterpriseVariables): MutationRef<UpdateEnterpriseData, UpdateEnterpriseVariables>;
  operationName: string;
}
export const updateEnterpriseRef: UpdateEnterpriseRef;

export function updateEnterprise(vars: UpdateEnterpriseVariables): MutationPromise<UpdateEnterpriseData, UpdateEnterpriseVariables>;
export function updateEnterprise(dc: DataConnect, vars: UpdateEnterpriseVariables): MutationPromise<UpdateEnterpriseData, UpdateEnterpriseVariables>;

interface DeleteEnterpriseRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteEnterpriseVariables): MutationRef<DeleteEnterpriseData, DeleteEnterpriseVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteEnterpriseVariables): MutationRef<DeleteEnterpriseData, DeleteEnterpriseVariables>;
  operationName: string;
}
export const deleteEnterpriseRef: DeleteEnterpriseRef;

export function deleteEnterprise(vars: DeleteEnterpriseVariables): MutationPromise<DeleteEnterpriseData, DeleteEnterpriseVariables>;
export function deleteEnterprise(dc: DataConnect, vars: DeleteEnterpriseVariables): MutationPromise<DeleteEnterpriseData, DeleteEnterpriseVariables>;

interface ListOrderRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListOrderData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListOrderData, undefined>;
  operationName: string;
}
export const listOrderRef: ListOrderRef;

export function listOrder(): QueryPromise<ListOrderData, undefined>;
export function listOrder(dc: DataConnect): QueryPromise<ListOrderData, undefined>;

interface GetOrderByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetOrderByIdVariables): QueryRef<GetOrderByIdData, GetOrderByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetOrderByIdVariables): QueryRef<GetOrderByIdData, GetOrderByIdVariables>;
  operationName: string;
}
export const getOrderByIdRef: GetOrderByIdRef;

export function getOrderById(vars: GetOrderByIdVariables): QueryPromise<GetOrderByIdData, GetOrderByIdVariables>;
export function getOrderById(dc: DataConnect, vars: GetOrderByIdVariables): QueryPromise<GetOrderByIdData, GetOrderByIdVariables>;

interface FilterOrderRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterOrderVariables): QueryRef<FilterOrderData, FilterOrderVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterOrderVariables): QueryRef<FilterOrderData, FilterOrderVariables>;
  operationName: string;
}
export const filterOrderRef: FilterOrderRef;

export function filterOrder(vars?: FilterOrderVariables): QueryPromise<FilterOrderData, FilterOrderVariables>;
export function filterOrder(dc: DataConnect, vars?: FilterOrderVariables): QueryPromise<FilterOrderData, FilterOrderVariables>;

interface CreatePartnerRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreatePartnerVariables): MutationRef<CreatePartnerData, CreatePartnerVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreatePartnerVariables): MutationRef<CreatePartnerData, CreatePartnerVariables>;
  operationName: string;
}
export const createPartnerRef: CreatePartnerRef;

export function createPartner(vars: CreatePartnerVariables): MutationPromise<CreatePartnerData, CreatePartnerVariables>;
export function createPartner(dc: DataConnect, vars: CreatePartnerVariables): MutationPromise<CreatePartnerData, CreatePartnerVariables>;

interface UpdatePartnerRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdatePartnerVariables): MutationRef<UpdatePartnerData, UpdatePartnerVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdatePartnerVariables): MutationRef<UpdatePartnerData, UpdatePartnerVariables>;
  operationName: string;
}
export const updatePartnerRef: UpdatePartnerRef;

export function updatePartner(vars: UpdatePartnerVariables): MutationPromise<UpdatePartnerData, UpdatePartnerVariables>;
export function updatePartner(dc: DataConnect, vars: UpdatePartnerVariables): MutationPromise<UpdatePartnerData, UpdatePartnerVariables>;

interface DeletePartnerRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeletePartnerVariables): MutationRef<DeletePartnerData, DeletePartnerVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeletePartnerVariables): MutationRef<DeletePartnerData, DeletePartnerVariables>;
  operationName: string;
}
export const deletePartnerRef: DeletePartnerRef;

export function deletePartner(vars: DeletePartnerVariables): MutationPromise<DeletePartnerData, DeletePartnerVariables>;
export function deletePartner(dc: DataConnect, vars: DeletePartnerVariables): MutationPromise<DeletePartnerData, DeletePartnerVariables>;

interface ListPartnerRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListPartnerData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListPartnerData, undefined>;
  operationName: string;
}
export const listPartnerRef: ListPartnerRef;

export function listPartner(): QueryPromise<ListPartnerData, undefined>;
export function listPartner(dc: DataConnect): QueryPromise<ListPartnerData, undefined>;

interface GetPartnerByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetPartnerByIdVariables): QueryRef<GetPartnerByIdData, GetPartnerByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetPartnerByIdVariables): QueryRef<GetPartnerByIdData, GetPartnerByIdVariables>;
  operationName: string;
}
export const getPartnerByIdRef: GetPartnerByIdRef;

export function getPartnerById(vars: GetPartnerByIdVariables): QueryPromise<GetPartnerByIdData, GetPartnerByIdVariables>;
export function getPartnerById(dc: DataConnect, vars: GetPartnerByIdVariables): QueryPromise<GetPartnerByIdData, GetPartnerByIdVariables>;

interface FilterPartnerRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterPartnerVariables): QueryRef<FilterPartnerData, FilterPartnerVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterPartnerVariables): QueryRef<FilterPartnerData, FilterPartnerVariables>;
  operationName: string;
}
export const filterPartnerRef: FilterPartnerRef;

export function filterPartner(vars?: FilterPartnerVariables): QueryPromise<FilterPartnerData, FilterPartnerVariables>;
export function filterPartner(dc: DataConnect, vars?: FilterPartnerVariables): QueryPromise<FilterPartnerData, FilterPartnerVariables>;

interface CreateTeamMemberRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateTeamMemberVariables): MutationRef<CreateTeamMemberData, CreateTeamMemberVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateTeamMemberVariables): MutationRef<CreateTeamMemberData, CreateTeamMemberVariables>;
  operationName: string;
}
export const createTeamMemberRef: CreateTeamMemberRef;

export function createTeamMember(vars: CreateTeamMemberVariables): MutationPromise<CreateTeamMemberData, CreateTeamMemberVariables>;
export function createTeamMember(dc: DataConnect, vars: CreateTeamMemberVariables): MutationPromise<CreateTeamMemberData, CreateTeamMemberVariables>;

interface UpdateTeamMemberRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateTeamMemberVariables): MutationRef<UpdateTeamMemberData, UpdateTeamMemberVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateTeamMemberVariables): MutationRef<UpdateTeamMemberData, UpdateTeamMemberVariables>;
  operationName: string;
}
export const updateTeamMemberRef: UpdateTeamMemberRef;

export function updateTeamMember(vars: UpdateTeamMemberVariables): MutationPromise<UpdateTeamMemberData, UpdateTeamMemberVariables>;
export function updateTeamMember(dc: DataConnect, vars: UpdateTeamMemberVariables): MutationPromise<UpdateTeamMemberData, UpdateTeamMemberVariables>;

interface DeleteTeamMemberRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteTeamMemberVariables): MutationRef<DeleteTeamMemberData, DeleteTeamMemberVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteTeamMemberVariables): MutationRef<DeleteTeamMemberData, DeleteTeamMemberVariables>;
  operationName: string;
}
export const deleteTeamMemberRef: DeleteTeamMemberRef;

export function deleteTeamMember(vars: DeleteTeamMemberVariables): MutationPromise<DeleteTeamMemberData, DeleteTeamMemberVariables>;
export function deleteTeamMember(dc: DataConnect, vars: DeleteTeamMemberVariables): MutationPromise<DeleteTeamMemberData, DeleteTeamMemberVariables>;

interface ListVendorRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListVendorData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListVendorData, undefined>;
  operationName: string;
}
export const listVendorRef: ListVendorRef;

export function listVendor(): QueryPromise<ListVendorData, undefined>;
export function listVendor(dc: DataConnect): QueryPromise<ListVendorData, undefined>;

interface GetVendorByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetVendorByIdVariables): QueryRef<GetVendorByIdData, GetVendorByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetVendorByIdVariables): QueryRef<GetVendorByIdData, GetVendorByIdVariables>;
  operationName: string;
}
export const getVendorByIdRef: GetVendorByIdRef;

export function getVendorById(vars: GetVendorByIdVariables): QueryPromise<GetVendorByIdData, GetVendorByIdVariables>;
export function getVendorById(dc: DataConnect, vars: GetVendorByIdVariables): QueryPromise<GetVendorByIdData, GetVendorByIdVariables>;

interface FilterVendorsRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterVendorsVariables): QueryRef<FilterVendorsData, FilterVendorsVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterVendorsVariables): QueryRef<FilterVendorsData, FilterVendorsVariables>;
  operationName: string;
}
export const filterVendorsRef: FilterVendorsRef;

export function filterVendors(vars?: FilterVendorsVariables): QueryPromise<FilterVendorsData, FilterVendorsVariables>;
export function filterVendors(dc: DataConnect, vars?: FilterVendorsVariables): QueryPromise<FilterVendorsData, FilterVendorsVariables>;

interface ListWorkforceRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListWorkforceData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListWorkforceData, undefined>;
  operationName: string;
}
export const listWorkforceRef: ListWorkforceRef;

export function listWorkforce(): QueryPromise<ListWorkforceData, undefined>;
export function listWorkforce(dc: DataConnect): QueryPromise<ListWorkforceData, undefined>;

interface GetWorkforceByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetWorkforceByIdVariables): QueryRef<GetWorkforceByIdData, GetWorkforceByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetWorkforceByIdVariables): QueryRef<GetWorkforceByIdData, GetWorkforceByIdVariables>;
  operationName: string;
}
export const getWorkforceByIdRef: GetWorkforceByIdRef;

export function getWorkforceById(vars: GetWorkforceByIdVariables): QueryPromise<GetWorkforceByIdData, GetWorkforceByIdVariables>;
export function getWorkforceById(dc: DataConnect, vars: GetWorkforceByIdVariables): QueryPromise<GetWorkforceByIdData, GetWorkforceByIdVariables>;

interface FilterWorkforceRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterWorkforceVariables): QueryRef<FilterWorkforceData, FilterWorkforceVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterWorkforceVariables): QueryRef<FilterWorkforceData, FilterWorkforceVariables>;
  operationName: string;
}
export const filterWorkforceRef: FilterWorkforceRef;

export function filterWorkforce(vars?: FilterWorkforceVariables): QueryPromise<FilterWorkforceData, FilterWorkforceVariables>;
export function filterWorkforce(dc: DataConnect, vars?: FilterWorkforceVariables): QueryPromise<FilterWorkforceData, FilterWorkforceVariables>;

interface ListActivityLogRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListActivityLogData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListActivityLogData, undefined>;
  operationName: string;
}
export const listActivityLogRef: ListActivityLogRef;

export function listActivityLog(): QueryPromise<ListActivityLogData, undefined>;
export function listActivityLog(dc: DataConnect): QueryPromise<ListActivityLogData, undefined>;

interface GetActivityLogByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetActivityLogByIdVariables): QueryRef<GetActivityLogByIdData, GetActivityLogByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetActivityLogByIdVariables): QueryRef<GetActivityLogByIdData, GetActivityLogByIdVariables>;
  operationName: string;
}
export const getActivityLogByIdRef: GetActivityLogByIdRef;

export function getActivityLogById(vars: GetActivityLogByIdVariables): QueryPromise<GetActivityLogByIdData, GetActivityLogByIdVariables>;
export function getActivityLogById(dc: DataConnect, vars: GetActivityLogByIdVariables): QueryPromise<GetActivityLogByIdData, GetActivityLogByIdVariables>;

interface FilterActivityLogRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterActivityLogVariables): QueryRef<FilterActivityLogData, FilterActivityLogVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterActivityLogVariables): QueryRef<FilterActivityLogData, FilterActivityLogVariables>;
  operationName: string;
}
export const filterActivityLogRef: FilterActivityLogRef;

export function filterActivityLog(vars?: FilterActivityLogVariables): QueryPromise<FilterActivityLogData, FilterActivityLogVariables>;
export function filterActivityLog(dc: DataConnect, vars?: FilterActivityLogVariables): QueryPromise<FilterActivityLogData, FilterActivityLogVariables>;

interface CreateConversationRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateConversationVariables): MutationRef<CreateConversationData, CreateConversationVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateConversationVariables): MutationRef<CreateConversationData, CreateConversationVariables>;
  operationName: string;
}
export const createConversationRef: CreateConversationRef;

export function createConversation(vars: CreateConversationVariables): MutationPromise<CreateConversationData, CreateConversationVariables>;
export function createConversation(dc: DataConnect, vars: CreateConversationVariables): MutationPromise<CreateConversationData, CreateConversationVariables>;

interface UpdateConversationRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateConversationVariables): MutationRef<UpdateConversationData, UpdateConversationVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateConversationVariables): MutationRef<UpdateConversationData, UpdateConversationVariables>;
  operationName: string;
}
export const updateConversationRef: UpdateConversationRef;

export function updateConversation(vars: UpdateConversationVariables): MutationPromise<UpdateConversationData, UpdateConversationVariables>;
export function updateConversation(dc: DataConnect, vars: UpdateConversationVariables): MutationPromise<UpdateConversationData, UpdateConversationVariables>;

interface DeleteConversationRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteConversationVariables): MutationRef<DeleteConversationData, DeleteConversationVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteConversationVariables): MutationRef<DeleteConversationData, DeleteConversationVariables>;
  operationName: string;
}
export const deleteConversationRef: DeleteConversationRef;

export function deleteConversation(vars: DeleteConversationVariables): MutationPromise<DeleteConversationData, DeleteConversationVariables>;
export function deleteConversation(dc: DataConnect, vars: DeleteConversationVariables): MutationPromise<DeleteConversationData, DeleteConversationVariables>;

interface CreateInvoiceRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateInvoiceVariables): MutationRef<CreateInvoiceData, CreateInvoiceVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateInvoiceVariables): MutationRef<CreateInvoiceData, CreateInvoiceVariables>;
  operationName: string;
}
export const createInvoiceRef: CreateInvoiceRef;

export function createInvoice(vars: CreateInvoiceVariables): MutationPromise<CreateInvoiceData, CreateInvoiceVariables>;
export function createInvoice(dc: DataConnect, vars: CreateInvoiceVariables): MutationPromise<CreateInvoiceData, CreateInvoiceVariables>;

interface UpdateInvoiceRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateInvoiceVariables): MutationRef<UpdateInvoiceData, UpdateInvoiceVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateInvoiceVariables): MutationRef<UpdateInvoiceData, UpdateInvoiceVariables>;
  operationName: string;
}
export const updateInvoiceRef: UpdateInvoiceRef;

export function updateInvoice(vars: UpdateInvoiceVariables): MutationPromise<UpdateInvoiceData, UpdateInvoiceVariables>;
export function updateInvoice(dc: DataConnect, vars: UpdateInvoiceVariables): MutationPromise<UpdateInvoiceData, UpdateInvoiceVariables>;

interface DeleteInvoiceRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteInvoiceVariables): MutationRef<DeleteInvoiceData, DeleteInvoiceVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteInvoiceVariables): MutationRef<DeleteInvoiceData, DeleteInvoiceVariables>;
  operationName: string;
}
export const deleteInvoiceRef: DeleteInvoiceRef;

export function deleteInvoice(vars: DeleteInvoiceVariables): MutationPromise<DeleteInvoiceData, DeleteInvoiceVariables>;
export function deleteInvoice(dc: DataConnect, vars: DeleteInvoiceVariables): MutationPromise<DeleteInvoiceData, DeleteInvoiceVariables>;

interface ListTeamRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: ListTeamVariables): QueryRef<ListTeamData, ListTeamVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: ListTeamVariables): QueryRef<ListTeamData, ListTeamVariables>;
  operationName: string;
}
export const listTeamRef: ListTeamRef;

export function listTeam(vars?: ListTeamVariables): QueryPromise<ListTeamData, ListTeamVariables>;
export function listTeam(dc: DataConnect, vars?: ListTeamVariables): QueryPromise<ListTeamData, ListTeamVariables>;

interface GetTeamByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetTeamByIdVariables): QueryRef<GetTeamByIdData, GetTeamByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetTeamByIdVariables): QueryRef<GetTeamByIdData, GetTeamByIdVariables>;
  operationName: string;
}
export const getTeamByIdRef: GetTeamByIdRef;

export function getTeamById(vars: GetTeamByIdVariables): QueryPromise<GetTeamByIdData, GetTeamByIdVariables>;
export function getTeamById(dc: DataConnect, vars: GetTeamByIdVariables): QueryPromise<GetTeamByIdData, GetTeamByIdVariables>;

interface FilterTeamRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterTeamVariables): QueryRef<FilterTeamData, FilterTeamVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterTeamVariables): QueryRef<FilterTeamData, FilterTeamVariables>;
  operationName: string;
}
export const filterTeamRef: FilterTeamRef;

export function filterTeam(vars?: FilterTeamVariables): QueryPromise<FilterTeamData, FilterTeamVariables>;
export function filterTeam(dc: DataConnect, vars?: FilterTeamVariables): QueryPromise<FilterTeamData, FilterTeamVariables>;

interface ListVendorRateRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListVendorRateData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListVendorRateData, undefined>;
  operationName: string;
}
export const listVendorRateRef: ListVendorRateRef;

export function listVendorRate(): QueryPromise<ListVendorRateData, undefined>;
export function listVendorRate(dc: DataConnect): QueryPromise<ListVendorRateData, undefined>;

interface GetVendorRateByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetVendorRateByIdVariables): QueryRef<GetVendorRateByIdData, GetVendorRateByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetVendorRateByIdVariables): QueryRef<GetVendorRateByIdData, GetVendorRateByIdVariables>;
  operationName: string;
}
export const getVendorRateByIdRef: GetVendorRateByIdRef;

export function getVendorRateById(vars: GetVendorRateByIdVariables): QueryPromise<GetVendorRateByIdData, GetVendorRateByIdVariables>;
export function getVendorRateById(dc: DataConnect, vars: GetVendorRateByIdVariables): QueryPromise<GetVendorRateByIdData, GetVendorRateByIdVariables>;

interface FilterVendorRatesRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterVendorRatesVariables): QueryRef<FilterVendorRatesData, FilterVendorRatesVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterVendorRatesVariables): QueryRef<FilterVendorRatesData, FilterVendorRatesVariables>;
  operationName: string;
}
export const filterVendorRatesRef: FilterVendorRatesRef;

export function filterVendorRates(vars?: FilterVendorRatesVariables): QueryPromise<FilterVendorRatesData, FilterVendorRatesVariables>;
export function filterVendorRates(dc: DataConnect, vars?: FilterVendorRatesVariables): QueryPromise<FilterVendorRatesData, FilterVendorRatesVariables>;

interface CreateBusinessRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateBusinessVariables): MutationRef<CreateBusinessData, CreateBusinessVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateBusinessVariables): MutationRef<CreateBusinessData, CreateBusinessVariables>;
  operationName: string;
}
export const createBusinessRef: CreateBusinessRef;

export function createBusiness(vars: CreateBusinessVariables): MutationPromise<CreateBusinessData, CreateBusinessVariables>;
export function createBusiness(dc: DataConnect, vars: CreateBusinessVariables): MutationPromise<CreateBusinessData, CreateBusinessVariables>;

interface UpdateBusinessRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateBusinessVariables): MutationRef<UpdateBusinessData, UpdateBusinessVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateBusinessVariables): MutationRef<UpdateBusinessData, UpdateBusinessVariables>;
  operationName: string;
}
export const updateBusinessRef: UpdateBusinessRef;

export function updateBusiness(vars: UpdateBusinessVariables): MutationPromise<UpdateBusinessData, UpdateBusinessVariables>;
export function updateBusiness(dc: DataConnect, vars: UpdateBusinessVariables): MutationPromise<UpdateBusinessData, UpdateBusinessVariables>;

interface DeleteBusinessRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteBusinessVariables): MutationRef<DeleteBusinessData, DeleteBusinessVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteBusinessVariables): MutationRef<DeleteBusinessData, DeleteBusinessVariables>;
  operationName: string;
}
export const deleteBusinessRef: DeleteBusinessRef;

export function deleteBusiness(vars: DeleteBusinessVariables): MutationPromise<DeleteBusinessData, DeleteBusinessVariables>;
export function deleteBusiness(dc: DataConnect, vars: DeleteBusinessVariables): MutationPromise<DeleteBusinessData, DeleteBusinessVariables>;

interface ListTeamHubRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListTeamHubData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListTeamHubData, undefined>;
  operationName: string;
}
export const listTeamHubRef: ListTeamHubRef;

export function listTeamHub(): QueryPromise<ListTeamHubData, undefined>;
export function listTeamHub(dc: DataConnect): QueryPromise<ListTeamHubData, undefined>;

interface GetTeamHubByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetTeamHubByIdVariables): QueryRef<GetTeamHubByIdData, GetTeamHubByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetTeamHubByIdVariables): QueryRef<GetTeamHubByIdData, GetTeamHubByIdVariables>;
  operationName: string;
}
export const getTeamHubByIdRef: GetTeamHubByIdRef;

export function getTeamHubById(vars: GetTeamHubByIdVariables): QueryPromise<GetTeamHubByIdData, GetTeamHubByIdVariables>;
export function getTeamHubById(dc: DataConnect, vars: GetTeamHubByIdVariables): QueryPromise<GetTeamHubByIdData, GetTeamHubByIdVariables>;

interface FilterTeamHubRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterTeamHubVariables): QueryRef<FilterTeamHubData, FilterTeamHubVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterTeamHubVariables): QueryRef<FilterTeamHubData, FilterTeamHubVariables>;
  operationName: string;
}
export const filterTeamHubRef: FilterTeamHubRef;

export function filterTeamHub(vars?: FilterTeamHubVariables): QueryPromise<FilterTeamHubData, FilterTeamHubVariables>;
export function filterTeamHub(dc: DataConnect, vars?: FilterTeamHubVariables): QueryPromise<FilterTeamHubData, FilterTeamHubVariables>;

interface CreateEventRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateEventVariables): MutationRef<CreateEventData, CreateEventVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateEventVariables): MutationRef<CreateEventData, CreateEventVariables>;
  operationName: string;
}
export const createEventRef: CreateEventRef;

export function createEvent(vars: CreateEventVariables): MutationPromise<CreateEventData, CreateEventVariables>;
export function createEvent(dc: DataConnect, vars: CreateEventVariables): MutationPromise<CreateEventData, CreateEventVariables>;

interface UpdateEventRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateEventVariables): MutationRef<UpdateEventData, UpdateEventVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateEventVariables): MutationRef<UpdateEventData, UpdateEventVariables>;
  operationName: string;
}
export const updateEventRef: UpdateEventRef;

export function updateEvent(vars: UpdateEventVariables): MutationPromise<UpdateEventData, UpdateEventVariables>;
export function updateEvent(dc: DataConnect, vars: UpdateEventVariables): MutationPromise<UpdateEventData, UpdateEventVariables>;

interface DeleteEventRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteEventVariables): MutationRef<DeleteEventData, DeleteEventVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteEventVariables): MutationRef<DeleteEventData, DeleteEventVariables>;
  operationName: string;
}
export const deleteEventRef: DeleteEventRef;

export function deleteEvent(vars: DeleteEventVariables): MutationPromise<DeleteEventData, DeleteEventVariables>;
export function deleteEvent(dc: DataConnect, vars: DeleteEventVariables): MutationPromise<DeleteEventData, DeleteEventVariables>;

interface CreateTeamRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateTeamVariables): MutationRef<CreateTeamData, CreateTeamVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateTeamVariables): MutationRef<CreateTeamData, CreateTeamVariables>;
  operationName: string;
}
export const createTeamRef: CreateTeamRef;

export function createTeam(vars: CreateTeamVariables): MutationPromise<CreateTeamData, CreateTeamVariables>;
export function createTeam(dc: DataConnect, vars: CreateTeamVariables): MutationPromise<CreateTeamData, CreateTeamVariables>;

interface UpdateTeamRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateTeamVariables): MutationRef<UpdateTeamData, UpdateTeamVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateTeamVariables): MutationRef<UpdateTeamData, UpdateTeamVariables>;
  operationName: string;
}
export const updateTeamRef: UpdateTeamRef;

export function updateTeam(vars: UpdateTeamVariables): MutationPromise<UpdateTeamData, UpdateTeamVariables>;
export function updateTeam(dc: DataConnect, vars: UpdateTeamVariables): MutationPromise<UpdateTeamData, UpdateTeamVariables>;

interface DeleteTeamRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteTeamVariables): MutationRef<DeleteTeamData, DeleteTeamVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteTeamVariables): MutationRef<DeleteTeamData, DeleteTeamVariables>;
  operationName: string;
}
export const deleteTeamRef: DeleteTeamRef;

export function deleteTeam(vars: DeleteTeamVariables): MutationPromise<DeleteTeamData, DeleteTeamVariables>;
export function deleteTeam(dc: DataConnect, vars: DeleteTeamVariables): MutationPromise<DeleteTeamData, DeleteTeamVariables>;

interface CreateWorkforceRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateWorkforceVariables): MutationRef<CreateWorkforceData, CreateWorkforceVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: CreateWorkforceVariables): MutationRef<CreateWorkforceData, CreateWorkforceVariables>;
  operationName: string;
}
export const createWorkforceRef: CreateWorkforceRef;

export function createWorkforce(vars: CreateWorkforceVariables): MutationPromise<CreateWorkforceData, CreateWorkforceVariables>;
export function createWorkforce(dc: DataConnect, vars: CreateWorkforceVariables): MutationPromise<CreateWorkforceData, CreateWorkforceVariables>;

interface UpdateWorkforceRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateWorkforceVariables): MutationRef<UpdateWorkforceData, UpdateWorkforceVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: UpdateWorkforceVariables): MutationRef<UpdateWorkforceData, UpdateWorkforceVariables>;
  operationName: string;
}
export const updateWorkforceRef: UpdateWorkforceRef;

export function updateWorkforce(vars: UpdateWorkforceVariables): MutationPromise<UpdateWorkforceData, UpdateWorkforceVariables>;
export function updateWorkforce(dc: DataConnect, vars: UpdateWorkforceVariables): MutationPromise<UpdateWorkforceData, UpdateWorkforceVariables>;

interface DeleteWorkforceRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteWorkforceVariables): MutationRef<DeleteWorkforceData, DeleteWorkforceVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: DeleteWorkforceVariables): MutationRef<DeleteWorkforceData, DeleteWorkforceVariables>;
  operationName: string;
}
export const deleteWorkforceRef: DeleteWorkforceRef;

export function deleteWorkforce(vars: DeleteWorkforceVariables): MutationPromise<DeleteWorkforceData, DeleteWorkforceVariables>;
export function deleteWorkforce(dc: DataConnect, vars: DeleteWorkforceVariables): MutationPromise<DeleteWorkforceData, DeleteWorkforceVariables>;

interface ListBusinessRef {
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListBusinessData, undefined>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect): QueryRef<ListBusinessData, undefined>;
  operationName: string;
}
export const listBusinessRef: ListBusinessRef;

export function listBusiness(): QueryPromise<ListBusinessData, undefined>;
export function listBusiness(dc: DataConnect): QueryPromise<ListBusinessData, undefined>;

interface GetBusinessByIdRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetBusinessByIdVariables): QueryRef<GetBusinessByIdData, GetBusinessByIdVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars: GetBusinessByIdVariables): QueryRef<GetBusinessByIdData, GetBusinessByIdVariables>;
  operationName: string;
}
export const getBusinessByIdRef: GetBusinessByIdRef;

export function getBusinessById(vars: GetBusinessByIdVariables): QueryPromise<GetBusinessByIdData, GetBusinessByIdVariables>;
export function getBusinessById(dc: DataConnect, vars: GetBusinessByIdVariables): QueryPromise<GetBusinessByIdData, GetBusinessByIdVariables>;

interface FilterBusinessRef {
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterBusinessVariables): QueryRef<FilterBusinessData, FilterBusinessVariables>;
  /* Allow users to pass in custom DataConnect instances */
  (dc: DataConnect, vars?: FilterBusinessVariables): QueryRef<FilterBusinessData, FilterBusinessVariables>;
  operationName: string;
}
export const filterBusinessRef: FilterBusinessRef;

export function filterBusiness(vars?: FilterBusinessVariables): QueryPromise<FilterBusinessData, FilterBusinessVariables>;
export function filterBusiness(dc: DataConnect, vars?: FilterBusinessVariables): QueryPromise<FilterBusinessData, FilterBusinessVariables>;