import { queryRef, executeQuery, mutationRef, executeMutation, validateArgs } from 'firebase/data-connect';

export const OrderDirection = {
  ASC: "ASC",
  DESC: "DESC",
}

export const 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 const AssignmentStatus = {
  PENDING: "PENDING",
  CONFIRMED: "CONFIRMED",
  CHECKED_IN: "CHECKED_IN",
  IN_PROGRESS: "IN_PROGRESS",
  COMPLETED: "COMPLETED",
  CANCELLED: "CANCELLED",
  NO_SHOW: "NO_SHOW",
}

export const BackgroundCheckStatus = {
  PENDING: "PENDING",
  CLEARED: "CLEARED",
  FAILED: "FAILED",
  EXPIRED: "EXPIRED",
  NOT_REQUIRED: "NOT_REQUIRED",
}

export const BusinessRateGroup = {
  STANDARD: "STANDARD",
  PREMIUM: "PREMIUM",
  ENTERPRISE: "ENTERPRISE",
  CUSTOM: "CUSTOM",
}

export const BusinessSector = {
  BON_APPETIT: "BON_APPETIT",
  EUREST: "EUREST",
  ARAMARK: "ARAMARK",
  EPICUREAN_GROUP: "EPICUREAN_GROUP",
  CHARTWELLS: "CHARTWELLS",
  OTHER: "OTHER",
}

export const BusinessStatus = {
  ACTIVE: "ACTIVE",
  INACTIVE: "INACTIVE",
  PENDING: "PENDING",
}

export const CertificationStatus = {
  CURRENT: "CURRENT",
  EXPIRING_SOON: "EXPIRING_SOON",
  EXPIRED: "EXPIRED",
  PENDING_VALIDATION: "PENDING_VALIDATION",
}

export const CertificationType = {
  LEGAL: "LEGAL",
  OPERATIONAL: "OPERATIONAL",
  SAFETY: "SAFETY",
  TRAINING: "TRAINING",
  LICENSE: "LICENSE",
  OTHER: "OTHER",
}

export const 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 const ContractType = {
  W2: "W2",
  C1099: "C1099",
  TEMP: "TEMP",
  CONTRACT: "CONTRACT",
}

export const ConversationStatus = {
  ACTIVE: "ACTIVE",
  ARCHIVED: "ARCHIVED",
  CLOSED: "CLOSED",
}

export const 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 const 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 const EnglishLevel = {
  FLUENT: "FLUENT",
  INTERMEDIATE: "INTERMEDIATE",
  BASIC: "BASIC",
  NONE: "NONE",
}

export const 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 const 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 const OrderStatus = {
  DRAFT: "DRAFT",
  SUBMITTED: "SUBMITTED",
  CONFIRMED: "CONFIRMED",
  IN_PROGRESS: "IN_PROGRESS",
  COMPLETED: "COMPLETED",
  CANCELLED: "CANCELLED",
}

export const OrderType = {
  STANDARD: "STANDARD",
  LAST_MINUTE: "LAST_MINUTE",
  EMERGENCY: "EMERGENCY",
  RECURRING: "RECURRING",
}

export const PartnerType = {
  CORPORATE: "CORPORATE",
  EDUCATION: "EDUCATION",
  HEALTHCARE: "HEALTHCARE",
  SPORTS_ENTERTAINMENT: "SPORTS_ENTERTAINMENT",
  GOVERNMENT: "GOVERNMENT",
}

export const ProfileType = {
  SKILLED: "SKILLED",
  BEGINNER: "BEGINNER",
  CROSS_TRAINED: "CROSS_TRAINED",
}

export const RecurrenceType = {
  SINGLE: "SINGLE",
  DATE_RANGE: "DATE_RANGE",
  SCATTER: "SCATTER",
}

export const SectorType = {
  FOOD_SERVICE: "FOOD_SERVICE",
  FACILITIES: "FACILITIES",
  HEALTHCARE: "HEALTHCARE",
  EDUCATION: "EDUCATION",
  CORPORATE: "CORPORATE",
  SPORTS_ENTERTAINMENT: "SPORTS_ENTERTAINMENT",
}

export const StaffDepartment = {
  OPERATIONS: "OPERATIONS",
  SALES: "SALES",
  HR: "HR",
  FINANCE: "FINANCE",
  IT: "IT",
  MARKETING: "MARKETING",
  CUSTOMER_SERVICE: "CUSTOMER_SERVICE",
  LOGISTICS: "LOGISTICS",
}

export const TeamMemberInviteStatus = {
  PENDING: "PENDING",
  ACCEPTED: "ACCEPTED",
  EXPIRED: "EXPIRED",
  CANCELLED: "CANCELLED",
}

export const TeamMemberRole = {
  ADMIN: "ADMIN",
  MANAGER: "MANAGER",
  MEMBER: "MEMBER",
  VIEWER: "VIEWER",
}

export const TeamOwnerRole = {
  ADMIN: "ADMIN",
  PROCUREMENT: "PROCUREMENT",
  OPERATOR: "OPERATOR",
  SECTOR: "SECTOR",
  CLIENT: "CLIENT",
  VENDOR: "VENDOR",
  WORKFORCE: "WORKFORCE",
}

export const UserBaseRole = {
  ADMIN: "ADMIN",
  USER: "USER",
}

export const VendorApprovalStatus = {
  PENDING: "PENDING",
  APPROVED: "APPROVED",
  SUSPENDED: "SUSPENDED",
  TERMINATED: "TERMINATED",
}

export const VendorPlatformType = {
  FULL_PLATFORM: "FULL_PLATFORM",
  BUILDING_PLATFORM: "BUILDING_PLATFORM",
  PARTIAL_TECH: "PARTIAL_TECH",
  TRADITIONAL: "TRADITIONAL",
}

export const 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 const VendorRegion = {
  NATIONAL: "NATIONAL",
  BAY_AREA: "BAY_AREA",
  SOUTHERN_CALIFORNIA: "SOUTHERN_CALIFORNIA",
  NORTHERN_CALIFORNIA: "NORTHERN_CALIFORNIA",
  WEST: "WEST",
  EAST: "EAST",
  MIDWEST: "MIDWEST",
  SOUTH: "SOUTH",
}

export const WorkforceEmploymentType = {
  W2: "W2",
  W1099: "W1099",
  TEMPORARY: "TEMPORARY",
  CONTRACT: "CONTRACT",
}

export const connectorConfig = {
  connector: 'krow-connector',
  service: 'krow-workforce-db',
  location: 'us-central1'
};

export const createMessageRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateMessage', inputVars);
}
createMessageRef.operationName = 'CreateMessage';

export function createMessage(dcOrVars, vars) {
  return executeMutation(createMessageRef(dcOrVars, vars));
}

export const updateMessageRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateMessage', inputVars);
}
updateMessageRef.operationName = 'UpdateMessage';

export function updateMessage(dcOrVars, vars) {
  return executeMutation(updateMessageRef(dcOrVars, vars));
}

export const deleteMessageRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteMessage', inputVars);
}
deleteMessageRef.operationName = 'DeleteMessage';

export function deleteMessage(dcOrVars, vars) {
  return executeMutation(deleteMessageRef(dcOrVars, vars));
}

export const createStaffRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateStaff', inputVars);
}
createStaffRef.operationName = 'CreateStaff';

export function createStaff(dcOrVars, vars) {
  return executeMutation(createStaffRef(dcOrVars, vars));
}

export const updateStaffRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateStaff', inputVars);
}
updateStaffRef.operationName = 'UpdateStaff';

export function updateStaff(dcOrVars, vars) {
  return executeMutation(updateStaffRef(dcOrVars, vars));
}

export const deleteStaffRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteStaff', inputVars);
}
deleteStaffRef.operationName = 'DeleteStaff';

export function deleteStaff(dcOrVars, vars) {
  return executeMutation(deleteStaffRef(dcOrVars, vars));
}

export const listTeamMemberInviteRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listTeamMemberInvite');
}
listTeamMemberInviteRef.operationName = 'listTeamMemberInvite';

export function listTeamMemberInvite(dc) {
  return executeQuery(listTeamMemberInviteRef(dc));
}

export const getTeamMemberInviteByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getTeamMemberInviteById', inputVars);
}
getTeamMemberInviteByIdRef.operationName = 'getTeamMemberInviteById';

export function getTeamMemberInviteById(dcOrVars, vars) {
  return executeQuery(getTeamMemberInviteByIdRef(dcOrVars, vars));
}

export const filterTeamMemberInviteRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterTeamMemberInvite', inputVars);
}
filterTeamMemberInviteRef.operationName = 'filterTeamMemberInvite';

export function filterTeamMemberInvite(dcOrVars, vars) {
  return executeQuery(filterTeamMemberInviteRef(dcOrVars, vars));
}

export const createVendorRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateVendor', inputVars);
}
createVendorRef.operationName = 'CreateVendor';

export function createVendor(dcOrVars, vars) {
  return executeMutation(createVendorRef(dcOrVars, vars));
}

export const updateVendorRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateVendor', inputVars);
}
updateVendorRef.operationName = 'UpdateVendor';

export function updateVendor(dcOrVars, vars) {
  return executeMutation(updateVendorRef(dcOrVars, vars));
}

export const deleteVendorRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteVendor', inputVars);
}
deleteVendorRef.operationName = 'DeleteVendor';

export function deleteVendor(dcOrVars, vars) {
  return executeMutation(deleteVendorRef(dcOrVars, vars));
}

export const createActivityLogRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateActivityLog', inputVars);
}
createActivityLogRef.operationName = 'CreateActivityLog';

export function createActivityLog(dcOrVars, vars) {
  return executeMutation(createActivityLogRef(dcOrVars, vars));
}

export const updateActivityLogRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateActivityLog', inputVars);
}
updateActivityLogRef.operationName = 'UpdateActivityLog';

export function updateActivityLog(dcOrVars, vars) {
  return executeMutation(updateActivityLogRef(dcOrVars, vars));
}

export const deleteActivityLogRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteActivityLog', inputVars);
}
deleteActivityLogRef.operationName = 'DeleteActivityLog';

export function deleteActivityLog(dcOrVars, vars) {
  return executeMutation(deleteActivityLogRef(dcOrVars, vars));
}

export const createAssignmentRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateAssignment', inputVars);
}
createAssignmentRef.operationName = 'CreateAssignment';

export function createAssignment(dcOrVars, vars) {
  return executeMutation(createAssignmentRef(dcOrVars, vars));
}

export const updateAssignmentRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateAssignment', inputVars);
}
updateAssignmentRef.operationName = 'UpdateAssignment';

export function updateAssignment(dcOrVars, vars) {
  return executeMutation(updateAssignmentRef(dcOrVars, vars));
}

export const deleteAssignmentRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteAssignment', inputVars);
}
deleteAssignmentRef.operationName = 'DeleteAssignment';

export function deleteAssignment(dcOrVars, vars) {
  return executeMutation(deleteAssignmentRef(dcOrVars, vars));
}

export const createCertificationRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateCertification', inputVars);
}
createCertificationRef.operationName = 'CreateCertification';

export function createCertification(dcOrVars, vars) {
  return executeMutation(createCertificationRef(dcOrVars, vars));
}

export const updateCertificationRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateCertification', inputVars);
}
updateCertificationRef.operationName = 'UpdateCertification';

export function updateCertification(dcOrVars, vars) {
  return executeMutation(updateCertificationRef(dcOrVars, vars));
}

export const deleteCertificationRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteCertification', inputVars);
}
deleteCertificationRef.operationName = 'DeleteCertification';

export function deleteCertification(dcOrVars, vars) {
  return executeMutation(deleteCertificationRef(dcOrVars, vars));
}

export const listCertificationRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listCertification');
}
listCertificationRef.operationName = 'listCertification';

export function listCertification(dc) {
  return executeQuery(listCertificationRef(dc));
}

export const getCertificationByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getCertificationById', inputVars);
}
getCertificationByIdRef.operationName = 'getCertificationById';

export function getCertificationById(dcOrVars, vars) {
  return executeQuery(getCertificationByIdRef(dcOrVars, vars));
}

export const filterCertificationRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterCertification', inputVars);
}
filterCertificationRef.operationName = 'filterCertification';

export function filterCertification(dcOrVars, vars) {
  return executeQuery(filterCertificationRef(dcOrVars, vars));
}

export const listConversationRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listConversation');
}
listConversationRef.operationName = 'listConversation';

export function listConversation(dc) {
  return executeQuery(listConversationRef(dc));
}

export const getConversationByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getConversationById', inputVars);
}
getConversationByIdRef.operationName = 'getConversationById';

export function getConversationById(dcOrVars, vars) {
  return executeQuery(getConversationByIdRef(dcOrVars, vars));
}

export const filterConversationRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterConversation', inputVars);
}
filterConversationRef.operationName = 'filterConversation';

export function filterConversation(dcOrVars, vars) {
  return executeQuery(filterConversationRef(dcOrVars, vars));
}

export const createShiftRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateShift', inputVars);
}
createShiftRef.operationName = 'CreateShift';

export function createShift(dcOrVars, vars) {
  return executeMutation(createShiftRef(dcOrVars, vars));
}

export const updateShiftRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateShift', inputVars);
}
updateShiftRef.operationName = 'UpdateShift';

export function updateShift(dcOrVars, vars) {
  return executeMutation(updateShiftRef(dcOrVars, vars));
}

export const deleteShiftRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteShift', inputVars);
}
deleteShiftRef.operationName = 'DeleteShift';

export function deleteShift(dcOrVars, vars) {
  return executeMutation(deleteShiftRef(dcOrVars, vars));
}

export const listShiftRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listShift');
}
listShiftRef.operationName = 'listShift';

export function listShift(dc) {
  return executeQuery(listShiftRef(dc));
}

export const getShiftByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getShiftById', inputVars);
}
getShiftByIdRef.operationName = 'getShiftById';

export function getShiftById(dcOrVars, vars) {
  return executeQuery(getShiftByIdRef(dcOrVars, vars));
}

export const filterShiftRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterShift', inputVars);
}
filterShiftRef.operationName = 'filterShift';

export function filterShift(dcOrVars, vars) {
  return executeQuery(filterShiftRef(dcOrVars, vars));
}

export const createTeamHubRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateTeamHub', inputVars);
}
createTeamHubRef.operationName = 'CreateTeamHub';

export function createTeamHub(dcOrVars, vars) {
  return executeMutation(createTeamHubRef(dcOrVars, vars));
}

export const updateTeamHubRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateTeamHub', inputVars);
}
updateTeamHubRef.operationName = 'UpdateTeamHub';

export function updateTeamHub(dcOrVars, vars) {
  return executeMutation(updateTeamHubRef(dcOrVars, vars));
}

export const deleteTeamHubRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteTeamHub', inputVars);
}
deleteTeamHubRef.operationName = 'DeleteTeamHub';

export function deleteTeamHub(dcOrVars, vars) {
  return executeMutation(deleteTeamHubRef(dcOrVars, vars));
}

export const listEnterpriseRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listEnterprise');
}
listEnterpriseRef.operationName = 'listEnterprise';

export function listEnterprise(dc) {
  return executeQuery(listEnterpriseRef(dc));
}

export const getEnterpriseByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getEnterpriseById', inputVars);
}
getEnterpriseByIdRef.operationName = 'getEnterpriseById';

export function getEnterpriseById(dcOrVars, vars) {
  return executeQuery(getEnterpriseByIdRef(dcOrVars, vars));
}

export const filterEnterpriseRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterEnterprise', inputVars);
}
filterEnterpriseRef.operationName = 'filterEnterprise';

export function filterEnterprise(dcOrVars, vars) {
  return executeQuery(filterEnterpriseRef(dcOrVars, vars));
}

export const listInvoiceRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listInvoice');
}
listInvoiceRef.operationName = 'listInvoice';

export function listInvoice(dc) {
  return executeQuery(listInvoiceRef(dc));
}

export const getInvoiceByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getInvoiceById', inputVars);
}
getInvoiceByIdRef.operationName = 'getInvoiceById';

export function getInvoiceById(dcOrVars, vars) {
  return executeQuery(getInvoiceByIdRef(dcOrVars, vars));
}

export const filterInvoicesRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterInvoices', inputVars);
}
filterInvoicesRef.operationName = 'filterInvoices';

export function filterInvoices(dcOrVars, vars) {
  return executeQuery(filterInvoicesRef(dcOrVars, vars));
}

export const createOrderRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateOrder', inputVars);
}
createOrderRef.operationName = 'CreateOrder';

export function createOrder(dcOrVars, vars) {
  return executeMutation(createOrderRef(dcOrVars, vars));
}

export const updateOrderRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateOrder', inputVars);
}
updateOrderRef.operationName = 'UpdateOrder';

export function updateOrder(dcOrVars, vars) {
  return executeMutation(updateOrderRef(dcOrVars, vars));
}

export const deleteOrderRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteOrder', inputVars);
}
deleteOrderRef.operationName = 'DeleteOrder';

export function deleteOrder(dcOrVars, vars) {
  return executeMutation(deleteOrderRef(dcOrVars, vars));
}

export const createSectorRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateSector', inputVars);
}
createSectorRef.operationName = 'CreateSector';

export function createSector(dcOrVars, vars) {
  return executeMutation(createSectorRef(dcOrVars, vars));
}

export const updateSectorRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateSector', inputVars);
}
updateSectorRef.operationName = 'UpdateSector';

export function updateSector(dcOrVars, vars) {
  return executeMutation(updateSectorRef(dcOrVars, vars));
}

export const deleteSectorRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteSector', inputVars);
}
deleteSectorRef.operationName = 'DeleteSector';

export function deleteSector(dcOrVars, vars) {
  return executeMutation(deleteSectorRef(dcOrVars, vars));
}

export const listTeamMemberRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listTeamMember');
}
listTeamMemberRef.operationName = 'listTeamMember';

export function listTeamMember(dc) {
  return executeQuery(listTeamMemberRef(dc));
}

export const getTeamMemberByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getTeamMemberById', inputVars);
}
getTeamMemberByIdRef.operationName = 'getTeamMemberById';

export function getTeamMemberById(dcOrVars, vars) {
  return executeQuery(getTeamMemberByIdRef(dcOrVars, vars));
}

export const filterTeamMemberRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterTeamMember', inputVars);
}
filterTeamMemberRef.operationName = 'filterTeamMember';

export function filterTeamMember(dcOrVars, vars) {
  return executeQuery(filterTeamMemberRef(dcOrVars, vars));
}

export const createUserRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateUser', inputVars);
}
createUserRef.operationName = 'CreateUser';

export function createUser(dcOrVars, vars) {
  return executeMutation(createUserRef(dcOrVars, vars));
}

export const updateUserRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateUser', inputVars);
}
updateUserRef.operationName = 'UpdateUser';

export function updateUser(dcOrVars, vars) {
  return executeMutation(updateUserRef(dcOrVars, vars));
}

export const deleteUserRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteUser', inputVars);
}
deleteUserRef.operationName = 'DeleteUser';

export function deleteUser(dcOrVars, vars) {
  return executeMutation(deleteUserRef(dcOrVars, vars));
}

export const listUsersRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listUsers');
}
listUsersRef.operationName = 'listUsers';

export function listUsers(dc) {
  return executeQuery(listUsersRef(dc));
}

export const getUserByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getUserById', inputVars);
}
getUserByIdRef.operationName = 'getUserById';

export function getUserById(dcOrVars, vars) {
  return executeQuery(getUserByIdRef(dcOrVars, vars));
}

export const filterUsersRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterUsers', inputVars);
}
filterUsersRef.operationName = 'filterUsers';

export function filterUsers(dcOrVars, vars) {
  return executeQuery(filterUsersRef(dcOrVars, vars));
}

export const listVendorDefaultSettingsRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listVendorDefaultSettings');
}
listVendorDefaultSettingsRef.operationName = 'listVendorDefaultSettings';

export function listVendorDefaultSettings(dc) {
  return executeQuery(listVendorDefaultSettingsRef(dc));
}

export const getVendorDefaultSettingByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getVendorDefaultSettingById', inputVars);
}
getVendorDefaultSettingByIdRef.operationName = 'getVendorDefaultSettingById';

export function getVendorDefaultSettingById(dcOrVars, vars) {
  return executeQuery(getVendorDefaultSettingByIdRef(dcOrVars, vars));
}

export const filterVendorDefaultSettingsRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterVendorDefaultSettings', inputVars);
}
filterVendorDefaultSettingsRef.operationName = 'filterVendorDefaultSettings';

export function filterVendorDefaultSettings(dcOrVars, vars) {
  return executeQuery(filterVendorDefaultSettingsRef(dcOrVars, vars));
}

export const listAssignmentRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listAssignment');
}
listAssignmentRef.operationName = 'listAssignment';

export function listAssignment(dc) {
  return executeQuery(listAssignmentRef(dc));
}

export const getAssignmentByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getAssignmentById', inputVars);
}
getAssignmentByIdRef.operationName = 'getAssignmentById';

export function getAssignmentById(dcOrVars, vars) {
  return executeQuery(getAssignmentByIdRef(dcOrVars, vars));
}

export const filterAssignmentRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterAssignment', inputVars);
}
filterAssignmentRef.operationName = 'filterAssignment';

export function filterAssignment(dcOrVars, vars) {
  return executeQuery(filterAssignmentRef(dcOrVars, vars));
}

export const listEventsRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listEvents', inputVars);
}
listEventsRef.operationName = 'listEvents';

export function listEvents(dcOrVars, vars) {
  return executeQuery(listEventsRef(dcOrVars, vars));
}

export const getEventByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getEventById', inputVars);
}
getEventByIdRef.operationName = 'getEventById';

export function getEventById(dcOrVars, vars) {
  return executeQuery(getEventByIdRef(dcOrVars, vars));
}

export const filterEventsRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterEvents', inputVars);
}
filterEventsRef.operationName = 'filterEvents';

export function filterEvents(dcOrVars, vars) {
  return executeQuery(filterEventsRef(dcOrVars, vars));
}

export const listMessageRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listMessage');
}
listMessageRef.operationName = 'listMessage';

export function listMessage(dc) {
  return executeQuery(listMessageRef(dc));
}

export const getMessageByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getMessageById', inputVars);
}
getMessageByIdRef.operationName = 'getMessageById';

export function getMessageById(dcOrVars, vars) {
  return executeQuery(getMessageByIdRef(dcOrVars, vars));
}

export const filterMessageRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterMessage', inputVars);
}
filterMessageRef.operationName = 'filterMessage';

export function filterMessage(dcOrVars, vars) {
  return executeQuery(filterMessageRef(dcOrVars, vars));
}

export const listSectorRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listSector');
}
listSectorRef.operationName = 'listSector';

export function listSector(dc) {
  return executeQuery(listSectorRef(dc));
}

export const getSectorByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getSectorById', inputVars);
}
getSectorByIdRef.operationName = 'getSectorById';

export function getSectorById(dcOrVars, vars) {
  return executeQuery(getSectorByIdRef(dcOrVars, vars));
}

export const filterSectorRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterSector', inputVars);
}
filterSectorRef.operationName = 'filterSector';

export function filterSector(dcOrVars, vars) {
  return executeQuery(filterSectorRef(dcOrVars, vars));
}

export const listStaffRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listStaff');
}
listStaffRef.operationName = 'listStaff';

export function listStaff(dc) {
  return executeQuery(listStaffRef(dc));
}

export const getStaffByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getStaffById', inputVars);
}
getStaffByIdRef.operationName = 'getStaffById';

export function getStaffById(dcOrVars, vars) {
  return executeQuery(getStaffByIdRef(dcOrVars, vars));
}

export const filterStaffRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterStaff', inputVars);
}
filterStaffRef.operationName = 'filterStaff';

export function filterStaff(dcOrVars, vars) {
  return executeQuery(filterStaffRef(dcOrVars, vars));
}

export const createTeamMemberInviteRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateTeamMemberInvite', inputVars);
}
createTeamMemberInviteRef.operationName = 'CreateTeamMemberInvite';

export function createTeamMemberInvite(dcOrVars, vars) {
  return executeMutation(createTeamMemberInviteRef(dcOrVars, vars));
}

export const updateTeamMemberInviteRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateTeamMemberInvite', inputVars);
}
updateTeamMemberInviteRef.operationName = 'UpdateTeamMemberInvite';

export function updateTeamMemberInvite(dcOrVars, vars) {
  return executeMutation(updateTeamMemberInviteRef(dcOrVars, vars));
}

export const deleteTeamMemberInviteRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteTeamMemberInvite', inputVars);
}
deleteTeamMemberInviteRef.operationName = 'DeleteTeamMemberInvite';

export function deleteTeamMemberInvite(dcOrVars, vars) {
  return executeMutation(deleteTeamMemberInviteRef(dcOrVars, vars));
}

export const createVendorDefaultSettingRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateVendorDefaultSetting', inputVars);
}
createVendorDefaultSettingRef.operationName = 'CreateVendorDefaultSetting';

export function createVendorDefaultSetting(dcOrVars, vars) {
  return executeMutation(createVendorDefaultSettingRef(dcOrVars, vars));
}

export const updateVendorDefaultSettingRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateVendorDefaultSetting', inputVars);
}
updateVendorDefaultSettingRef.operationName = 'UpdateVendorDefaultSetting';

export function updateVendorDefaultSetting(dcOrVars, vars) {
  return executeMutation(updateVendorDefaultSettingRef(dcOrVars, vars));
}

export const deleteVendorDefaultSettingRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteVendorDefaultSetting', inputVars);
}
deleteVendorDefaultSettingRef.operationName = 'DeleteVendorDefaultSetting';

export function deleteVendorDefaultSetting(dcOrVars, vars) {
  return executeMutation(deleteVendorDefaultSettingRef(dcOrVars, vars));
}

export const createVendorRateRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateVendorRate', inputVars);
}
createVendorRateRef.operationName = 'CreateVendorRate';

export function createVendorRate(dcOrVars, vars) {
  return executeMutation(createVendorRateRef(dcOrVars, vars));
}

export const updateVendorRateRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateVendorRate', inputVars);
}
updateVendorRateRef.operationName = 'UpdateVendorRate';

export function updateVendorRate(dcOrVars, vars) {
  return executeMutation(updateVendorRateRef(dcOrVars, vars));
}

export const deleteVendorRateRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteVendorRate', inputVars);
}
deleteVendorRateRef.operationName = 'DeleteVendorRate';

export function deleteVendorRate(dcOrVars, vars) {
  return executeMutation(deleteVendorRateRef(dcOrVars, vars));
}

export const createEnterpriseRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateEnterprise', inputVars);
}
createEnterpriseRef.operationName = 'CreateEnterprise';

export function createEnterprise(dcOrVars, vars) {
  return executeMutation(createEnterpriseRef(dcOrVars, vars));
}

export const updateEnterpriseRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateEnterprise', inputVars);
}
updateEnterpriseRef.operationName = 'UpdateEnterprise';

export function updateEnterprise(dcOrVars, vars) {
  return executeMutation(updateEnterpriseRef(dcOrVars, vars));
}

export const deleteEnterpriseRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteEnterprise', inputVars);
}
deleteEnterpriseRef.operationName = 'DeleteEnterprise';

export function deleteEnterprise(dcOrVars, vars) {
  return executeMutation(deleteEnterpriseRef(dcOrVars, vars));
}

export const listOrderRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listOrder');
}
listOrderRef.operationName = 'listOrder';

export function listOrder(dc) {
  return executeQuery(listOrderRef(dc));
}

export const getOrderByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getOrderById', inputVars);
}
getOrderByIdRef.operationName = 'getOrderById';

export function getOrderById(dcOrVars, vars) {
  return executeQuery(getOrderByIdRef(dcOrVars, vars));
}

export const filterOrderRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterOrder', inputVars);
}
filterOrderRef.operationName = 'filterOrder';

export function filterOrder(dcOrVars, vars) {
  return executeQuery(filterOrderRef(dcOrVars, vars));
}

export const createPartnerRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreatePartner', inputVars);
}
createPartnerRef.operationName = 'CreatePartner';

export function createPartner(dcOrVars, vars) {
  return executeMutation(createPartnerRef(dcOrVars, vars));
}

export const updatePartnerRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdatePartner', inputVars);
}
updatePartnerRef.operationName = 'UpdatePartner';

export function updatePartner(dcOrVars, vars) {
  return executeMutation(updatePartnerRef(dcOrVars, vars));
}

export const deletePartnerRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeletePartner', inputVars);
}
deletePartnerRef.operationName = 'DeletePartner';

export function deletePartner(dcOrVars, vars) {
  return executeMutation(deletePartnerRef(dcOrVars, vars));
}

export const listPartnerRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listPartner');
}
listPartnerRef.operationName = 'listPartner';

export function listPartner(dc) {
  return executeQuery(listPartnerRef(dc));
}

export const getPartnerByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getPartnerById', inputVars);
}
getPartnerByIdRef.operationName = 'getPartnerById';

export function getPartnerById(dcOrVars, vars) {
  return executeQuery(getPartnerByIdRef(dcOrVars, vars));
}

export const filterPartnerRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterPartner', inputVars);
}
filterPartnerRef.operationName = 'filterPartner';

export function filterPartner(dcOrVars, vars) {
  return executeQuery(filterPartnerRef(dcOrVars, vars));
}

export const createTeamMemberRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateTeamMember', inputVars);
}
createTeamMemberRef.operationName = 'CreateTeamMember';

export function createTeamMember(dcOrVars, vars) {
  return executeMutation(createTeamMemberRef(dcOrVars, vars));
}

export const updateTeamMemberRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateTeamMember', inputVars);
}
updateTeamMemberRef.operationName = 'UpdateTeamMember';

export function updateTeamMember(dcOrVars, vars) {
  return executeMutation(updateTeamMemberRef(dcOrVars, vars));
}

export const deleteTeamMemberRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteTeamMember', inputVars);
}
deleteTeamMemberRef.operationName = 'DeleteTeamMember';

export function deleteTeamMember(dcOrVars, vars) {
  return executeMutation(deleteTeamMemberRef(dcOrVars, vars));
}

export const listVendorRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listVendor');
}
listVendorRef.operationName = 'listVendor';

export function listVendor(dc) {
  return executeQuery(listVendorRef(dc));
}

export const getVendorByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getVendorById', inputVars);
}
getVendorByIdRef.operationName = 'getVendorById';

export function getVendorById(dcOrVars, vars) {
  return executeQuery(getVendorByIdRef(dcOrVars, vars));
}

export const filterVendorsRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterVendors', inputVars);
}
filterVendorsRef.operationName = 'filterVendors';

export function filterVendors(dcOrVars, vars) {
  return executeQuery(filterVendorsRef(dcOrVars, vars));
}

export const listWorkforceRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listWorkforce');
}
listWorkforceRef.operationName = 'listWorkforce';

export function listWorkforce(dc) {
  return executeQuery(listWorkforceRef(dc));
}

export const getWorkforceByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getWorkforceById', inputVars);
}
getWorkforceByIdRef.operationName = 'getWorkforceById';

export function getWorkforceById(dcOrVars, vars) {
  return executeQuery(getWorkforceByIdRef(dcOrVars, vars));
}

export const filterWorkforceRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterWorkforce', inputVars);
}
filterWorkforceRef.operationName = 'filterWorkforce';

export function filterWorkforce(dcOrVars, vars) {
  return executeQuery(filterWorkforceRef(dcOrVars, vars));
}

export const listActivityLogRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listActivityLog');
}
listActivityLogRef.operationName = 'listActivityLog';

export function listActivityLog(dc) {
  return executeQuery(listActivityLogRef(dc));
}

export const getActivityLogByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getActivityLogById', inputVars);
}
getActivityLogByIdRef.operationName = 'getActivityLogById';

export function getActivityLogById(dcOrVars, vars) {
  return executeQuery(getActivityLogByIdRef(dcOrVars, vars));
}

export const filterActivityLogRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterActivityLog', inputVars);
}
filterActivityLogRef.operationName = 'filterActivityLog';

export function filterActivityLog(dcOrVars, vars) {
  return executeQuery(filterActivityLogRef(dcOrVars, vars));
}

export const createConversationRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateConversation', inputVars);
}
createConversationRef.operationName = 'CreateConversation';

export function createConversation(dcOrVars, vars) {
  return executeMutation(createConversationRef(dcOrVars, vars));
}

export const updateConversationRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateConversation', inputVars);
}
updateConversationRef.operationName = 'UpdateConversation';

export function updateConversation(dcOrVars, vars) {
  return executeMutation(updateConversationRef(dcOrVars, vars));
}

export const deleteConversationRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteConversation', inputVars);
}
deleteConversationRef.operationName = 'DeleteConversation';

export function deleteConversation(dcOrVars, vars) {
  return executeMutation(deleteConversationRef(dcOrVars, vars));
}

export const createInvoiceRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateInvoice', inputVars);
}
createInvoiceRef.operationName = 'CreateInvoice';

export function createInvoice(dcOrVars, vars) {
  return executeMutation(createInvoiceRef(dcOrVars, vars));
}

export const updateInvoiceRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateInvoice', inputVars);
}
updateInvoiceRef.operationName = 'UpdateInvoice';

export function updateInvoice(dcOrVars, vars) {
  return executeMutation(updateInvoiceRef(dcOrVars, vars));
}

export const deleteInvoiceRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteInvoice', inputVars);
}
deleteInvoiceRef.operationName = 'DeleteInvoice';

export function deleteInvoice(dcOrVars, vars) {
  return executeMutation(deleteInvoiceRef(dcOrVars, vars));
}

export const listTeamRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listTeam', inputVars);
}
listTeamRef.operationName = 'listTeam';

export function listTeam(dcOrVars, vars) {
  return executeQuery(listTeamRef(dcOrVars, vars));
}

export const getTeamByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getTeamById', inputVars);
}
getTeamByIdRef.operationName = 'getTeamById';

export function getTeamById(dcOrVars, vars) {
  return executeQuery(getTeamByIdRef(dcOrVars, vars));
}

export const filterTeamRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterTeam', inputVars);
}
filterTeamRef.operationName = 'filterTeam';

export function filterTeam(dcOrVars, vars) {
  return executeQuery(filterTeamRef(dcOrVars, vars));
}

export const listVendorRateRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listVendorRate');
}
listVendorRateRef.operationName = 'listVendorRate';

export function listVendorRate(dc) {
  return executeQuery(listVendorRateRef(dc));
}

export const getVendorRateByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getVendorRateById', inputVars);
}
getVendorRateByIdRef.operationName = 'getVendorRateById';

export function getVendorRateById(dcOrVars, vars) {
  return executeQuery(getVendorRateByIdRef(dcOrVars, vars));
}

export const filterVendorRatesRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterVendorRates', inputVars);
}
filterVendorRatesRef.operationName = 'filterVendorRates';

export function filterVendorRates(dcOrVars, vars) {
  return executeQuery(filterVendorRatesRef(dcOrVars, vars));
}

export const createBusinessRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateBusiness', inputVars);
}
createBusinessRef.operationName = 'CreateBusiness';

export function createBusiness(dcOrVars, vars) {
  return executeMutation(createBusinessRef(dcOrVars, vars));
}

export const updateBusinessRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateBusiness', inputVars);
}
updateBusinessRef.operationName = 'UpdateBusiness';

export function updateBusiness(dcOrVars, vars) {
  return executeMutation(updateBusinessRef(dcOrVars, vars));
}

export const deleteBusinessRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteBusiness', inputVars);
}
deleteBusinessRef.operationName = 'DeleteBusiness';

export function deleteBusiness(dcOrVars, vars) {
  return executeMutation(deleteBusinessRef(dcOrVars, vars));
}

export const listTeamHubRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listTeamHub');
}
listTeamHubRef.operationName = 'listTeamHub';

export function listTeamHub(dc) {
  return executeQuery(listTeamHubRef(dc));
}

export const getTeamHubByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getTeamHubById', inputVars);
}
getTeamHubByIdRef.operationName = 'getTeamHubById';

export function getTeamHubById(dcOrVars, vars) {
  return executeQuery(getTeamHubByIdRef(dcOrVars, vars));
}

export const filterTeamHubRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterTeamHub', inputVars);
}
filterTeamHubRef.operationName = 'filterTeamHub';

export function filterTeamHub(dcOrVars, vars) {
  return executeQuery(filterTeamHubRef(dcOrVars, vars));
}

export const createEventRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateEvent', inputVars);
}
createEventRef.operationName = 'CreateEvent';

export function createEvent(dcOrVars, vars) {
  return executeMutation(createEventRef(dcOrVars, vars));
}

export const updateEventRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateEvent', inputVars);
}
updateEventRef.operationName = 'UpdateEvent';

export function updateEvent(dcOrVars, vars) {
  return executeMutation(updateEventRef(dcOrVars, vars));
}

export const deleteEventRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteEvent', inputVars);
}
deleteEventRef.operationName = 'DeleteEvent';

export function deleteEvent(dcOrVars, vars) {
  return executeMutation(deleteEventRef(dcOrVars, vars));
}

export const createTeamRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateTeam', inputVars);
}
createTeamRef.operationName = 'CreateTeam';

export function createTeam(dcOrVars, vars) {
  return executeMutation(createTeamRef(dcOrVars, vars));
}

export const updateTeamRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateTeam', inputVars);
}
updateTeamRef.operationName = 'UpdateTeam';

export function updateTeam(dcOrVars, vars) {
  return executeMutation(updateTeamRef(dcOrVars, vars));
}

export const deleteTeamRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteTeam', inputVars);
}
deleteTeamRef.operationName = 'DeleteTeam';

export function deleteTeam(dcOrVars, vars) {
  return executeMutation(deleteTeamRef(dcOrVars, vars));
}

export const createWorkforceRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'CreateWorkforce', inputVars);
}
createWorkforceRef.operationName = 'CreateWorkforce';

export function createWorkforce(dcOrVars, vars) {
  return executeMutation(createWorkforceRef(dcOrVars, vars));
}

export const updateWorkforceRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'UpdateWorkforce', inputVars);
}
updateWorkforceRef.operationName = 'UpdateWorkforce';

export function updateWorkforce(dcOrVars, vars) {
  return executeMutation(updateWorkforceRef(dcOrVars, vars));
}

export const deleteWorkforceRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return mutationRef(dcInstance, 'DeleteWorkforce', inputVars);
}
deleteWorkforceRef.operationName = 'DeleteWorkforce';

export function deleteWorkforce(dcOrVars, vars) {
  return executeMutation(deleteWorkforceRef(dcOrVars, vars));
}

export const listBusinessRef = (dc) => {
  const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'listBusiness');
}
listBusinessRef.operationName = 'listBusiness';

export function listBusiness(dc) {
  return executeQuery(listBusinessRef(dc));
}

export const getBusinessByIdRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'getBusinessById', inputVars);
}
getBusinessByIdRef.operationName = 'getBusinessById';

export function getBusinessById(dcOrVars, vars) {
  return executeQuery(getBusinessByIdRef(dcOrVars, vars));
}

export const filterBusinessRef = (dcOrVars, vars) => {
  const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars);
  dcInstance._useGeneratedSdk();
  return queryRef(dcInstance, 'filterBusiness', inputVars);
}
filterBusinessRef.operationName = 'filterBusiness';

export function filterBusiness(dcOrVars, vars) {
  return executeQuery(filterBusinessRef(dcOrVars, vars));
}

