const { queryRef, executeQuery, mutationRef, executeMutation, validateArgs } = require('firebase/data-connect');

const OrderDirection = {
  ASC: "ASC",
  DESC: "DESC",
}
exports.OrderDirection = OrderDirection;

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",
}
exports.ActivityType = ActivityType;

const AssignmentStatus = {
  PENDING: "PENDING",
  CONFIRMED: "CONFIRMED",
  CHECKED_IN: "CHECKED_IN",
  IN_PROGRESS: "IN_PROGRESS",
  COMPLETED: "COMPLETED",
  CANCELLED: "CANCELLED",
  NO_SHOW: "NO_SHOW",
}
exports.AssignmentStatus = AssignmentStatus;

const BackgroundCheckStatus = {
  PENDING: "PENDING",
  CLEARED: "CLEARED",
  FAILED: "FAILED",
  EXPIRED: "EXPIRED",
  NOT_REQUIRED: "NOT_REQUIRED",
}
exports.BackgroundCheckStatus = BackgroundCheckStatus;

const BusinessRateGroup = {
  STANDARD: "STANDARD",
  PREMIUM: "PREMIUM",
  ENTERPRISE: "ENTERPRISE",
  CUSTOM: "CUSTOM",
}
exports.BusinessRateGroup = BusinessRateGroup;

const BusinessSector = {
  BON_APPETIT: "BON_APPETIT",
  EUREST: "EUREST",
  ARAMARK: "ARAMARK",
  EPICUREAN_GROUP: "EPICUREAN_GROUP",
  CHARTWELLS: "CHARTWELLS",
  OTHER: "OTHER",
}
exports.BusinessSector = BusinessSector;

const BusinessStatus = {
  ACTIVE: "ACTIVE",
  INACTIVE: "INACTIVE",
  PENDING: "PENDING",
}
exports.BusinessStatus = BusinessStatus;

const CertificationStatus = {
  CURRENT: "CURRENT",
  EXPIRING_SOON: "EXPIRING_SOON",
  EXPIRED: "EXPIRED",
  PENDING_VALIDATION: "PENDING_VALIDATION",
}
exports.CertificationStatus = CertificationStatus;

const CertificationType = {
  LEGAL: "LEGAL",
  OPERATIONAL: "OPERATIONAL",
  SAFETY: "SAFETY",
  TRAINING: "TRAINING",
  LICENSE: "LICENSE",
  OTHER: "OTHER",
}
exports.CertificationType = CertificationType;

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",
}
exports.CertificationValidationStatus = CertificationValidationStatus;

const ContractType = {
  W2: "W2",
  C1099: "C1099",
  TEMP: "TEMP",
  CONTRACT: "CONTRACT",
}
exports.ContractType = ContractType;

const ConversationStatus = {
  ACTIVE: "ACTIVE",
  ARCHIVED: "ARCHIVED",
  CLOSED: "CLOSED",
}
exports.ConversationStatus = ConversationStatus;

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",
}
exports.ConversationType = ConversationType;

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",
}
exports.EmploymentType = EmploymentType;

const EnglishLevel = {
  FLUENT: "FLUENT",
  INTERMEDIATE: "INTERMEDIATE",
  BASIC: "BASIC",
  NONE: "NONE",
}
exports.EnglishLevel = EnglishLevel;

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",
}
exports.EventStatus = EventStatus;

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",
}
exports.InvoiceStatus = InvoiceStatus;

const OrderStatus = {
  DRAFT: "DRAFT",
  SUBMITTED: "SUBMITTED",
  CONFIRMED: "CONFIRMED",
  IN_PROGRESS: "IN_PROGRESS",
  COMPLETED: "COMPLETED",
  CANCELLED: "CANCELLED",
}
exports.OrderStatus = OrderStatus;

const OrderType = {
  STANDARD: "STANDARD",
  LAST_MINUTE: "LAST_MINUTE",
  EMERGENCY: "EMERGENCY",
  RECURRING: "RECURRING",
}
exports.OrderType = OrderType;

const PartnerType = {
  CORPORATE: "CORPORATE",
  EDUCATION: "EDUCATION",
  HEALTHCARE: "HEALTHCARE",
  SPORTS_ENTERTAINMENT: "SPORTS_ENTERTAINMENT",
  GOVERNMENT: "GOVERNMENT",
}
exports.PartnerType = PartnerType;

const ProfileType = {
  SKILLED: "SKILLED",
  BEGINNER: "BEGINNER",
  CROSS_TRAINED: "CROSS_TRAINED",
}
exports.ProfileType = ProfileType;

const RecurrenceType = {
  SINGLE: "SINGLE",
  DATE_RANGE: "DATE_RANGE",
  SCATTER: "SCATTER",
}
exports.RecurrenceType = RecurrenceType;

const SectorType = {
  FOOD_SERVICE: "FOOD_SERVICE",
  FACILITIES: "FACILITIES",
  HEALTHCARE: "HEALTHCARE",
  EDUCATION: "EDUCATION",
  CORPORATE: "CORPORATE",
  SPORTS_ENTERTAINMENT: "SPORTS_ENTERTAINMENT",
}
exports.SectorType = SectorType;

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

const TeamMemberInviteStatus = {
  PENDING: "PENDING",
  ACCEPTED: "ACCEPTED",
  EXPIRED: "EXPIRED",
  CANCELLED: "CANCELLED",
}
exports.TeamMemberInviteStatus = TeamMemberInviteStatus;

const TeamMemberRole = {
  ADMIN: "ADMIN",
  MANAGER: "MANAGER",
  MEMBER: "MEMBER",
  VIEWER: "VIEWER",
}
exports.TeamMemberRole = TeamMemberRole;

const TeamOwnerRole = {
  ADMIN: "ADMIN",
  PROCUREMENT: "PROCUREMENT",
  OPERATOR: "OPERATOR",
  SECTOR: "SECTOR",
  CLIENT: "CLIENT",
  VENDOR: "VENDOR",
  WORKFORCE: "WORKFORCE",
}
exports.TeamOwnerRole = TeamOwnerRole;

const UserBaseRole = {
  ADMIN: "ADMIN",
  USER: "USER",
}
exports.UserBaseRole = UserBaseRole;

const VendorApprovalStatus = {
  PENDING: "PENDING",
  APPROVED: "APPROVED",
  SUSPENDED: "SUSPENDED",
  TERMINATED: "TERMINATED",
}
exports.VendorApprovalStatus = VendorApprovalStatus;

const VendorPlatformType = {
  FULL_PLATFORM: "FULL_PLATFORM",
  BUILDING_PLATFORM: "BUILDING_PLATFORM",
  PARTIAL_TECH: "PARTIAL_TECH",
  TRADITIONAL: "TRADITIONAL",
}
exports.VendorPlatformType = VendorPlatformType;

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",
}
exports.VendorRateCategory = VendorRateCategory;

const VendorRegion = {
  NATIONAL: "NATIONAL",
  BAY_AREA: "BAY_AREA",
  SOUTHERN_CALIFORNIA: "SOUTHERN_CALIFORNIA",
  NORTHERN_CALIFORNIA: "NORTHERN_CALIFORNIA",
  WEST: "WEST",
  EAST: "EAST",
  MIDWEST: "MIDWEST",
  SOUTH: "SOUTH",
}
exports.VendorRegion = VendorRegion;

const WorkforceEmploymentType = {
  W2: "W2",
  W1099: "W1099",
  TEMPORARY: "TEMPORARY",
  CONTRACT: "CONTRACT",
}
exports.WorkforceEmploymentType = WorkforceEmploymentType;

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

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

exports.createMessage = function createMessage(dcOrVars, vars) {
  return executeMutation(createMessageRef(dcOrVars, vars));
};

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

exports.updateMessage = function updateMessage(dcOrVars, vars) {
  return executeMutation(updateMessageRef(dcOrVars, vars));
};

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

exports.deleteMessage = function deleteMessage(dcOrVars, vars) {
  return executeMutation(deleteMessageRef(dcOrVars, vars));
};

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

exports.createStaff = function createStaff(dcOrVars, vars) {
  return executeMutation(createStaffRef(dcOrVars, vars));
};

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

exports.updateStaff = function updateStaff(dcOrVars, vars) {
  return executeMutation(updateStaffRef(dcOrVars, vars));
};

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

exports.deleteStaff = function deleteStaff(dcOrVars, vars) {
  return executeMutation(deleteStaffRef(dcOrVars, vars));
};

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

exports.listTeamMemberInvite = function listTeamMemberInvite(dc) {
  return executeQuery(listTeamMemberInviteRef(dc));
};

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

exports.getTeamMemberInviteById = function getTeamMemberInviteById(dcOrVars, vars) {
  return executeQuery(getTeamMemberInviteByIdRef(dcOrVars, vars));
};

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

exports.filterTeamMemberInvite = function filterTeamMemberInvite(dcOrVars, vars) {
  return executeQuery(filterTeamMemberInviteRef(dcOrVars, vars));
};

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

exports.createVendor = function createVendor(dcOrVars, vars) {
  return executeMutation(createVendorRef(dcOrVars, vars));
};

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

exports.updateVendor = function updateVendor(dcOrVars, vars) {
  return executeMutation(updateVendorRef(dcOrVars, vars));
};

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

exports.deleteVendor = function deleteVendor(dcOrVars, vars) {
  return executeMutation(deleteVendorRef(dcOrVars, vars));
};

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

exports.createActivityLog = function createActivityLog(dcOrVars, vars) {
  return executeMutation(createActivityLogRef(dcOrVars, vars));
};

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

exports.updateActivityLog = function updateActivityLog(dcOrVars, vars) {
  return executeMutation(updateActivityLogRef(dcOrVars, vars));
};

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

exports.deleteActivityLog = function deleteActivityLog(dcOrVars, vars) {
  return executeMutation(deleteActivityLogRef(dcOrVars, vars));
};

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

exports.createAssignment = function createAssignment(dcOrVars, vars) {
  return executeMutation(createAssignmentRef(dcOrVars, vars));
};

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

exports.updateAssignment = function updateAssignment(dcOrVars, vars) {
  return executeMutation(updateAssignmentRef(dcOrVars, vars));
};

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

exports.deleteAssignment = function deleteAssignment(dcOrVars, vars) {
  return executeMutation(deleteAssignmentRef(dcOrVars, vars));
};

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

exports.createCertification = function createCertification(dcOrVars, vars) {
  return executeMutation(createCertificationRef(dcOrVars, vars));
};

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

exports.updateCertification = function updateCertification(dcOrVars, vars) {
  return executeMutation(updateCertificationRef(dcOrVars, vars));
};

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

exports.deleteCertification = function deleteCertification(dcOrVars, vars) {
  return executeMutation(deleteCertificationRef(dcOrVars, vars));
};

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

exports.listCertification = function listCertification(dc) {
  return executeQuery(listCertificationRef(dc));
};

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

exports.getCertificationById = function getCertificationById(dcOrVars, vars) {
  return executeQuery(getCertificationByIdRef(dcOrVars, vars));
};

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

exports.filterCertification = function filterCertification(dcOrVars, vars) {
  return executeQuery(filterCertificationRef(dcOrVars, vars));
};

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

exports.listConversation = function listConversation(dc) {
  return executeQuery(listConversationRef(dc));
};

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

exports.getConversationById = function getConversationById(dcOrVars, vars) {
  return executeQuery(getConversationByIdRef(dcOrVars, vars));
};

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

exports.filterConversation = function filterConversation(dcOrVars, vars) {
  return executeQuery(filterConversationRef(dcOrVars, vars));
};

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

exports.createShift = function createShift(dcOrVars, vars) {
  return executeMutation(createShiftRef(dcOrVars, vars));
};

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

exports.updateShift = function updateShift(dcOrVars, vars) {
  return executeMutation(updateShiftRef(dcOrVars, vars));
};

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

exports.deleteShift = function deleteShift(dcOrVars, vars) {
  return executeMutation(deleteShiftRef(dcOrVars, vars));
};

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

exports.listShift = function listShift(dc) {
  return executeQuery(listShiftRef(dc));
};

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

exports.getShiftById = function getShiftById(dcOrVars, vars) {
  return executeQuery(getShiftByIdRef(dcOrVars, vars));
};

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

exports.filterShift = function filterShift(dcOrVars, vars) {
  return executeQuery(filterShiftRef(dcOrVars, vars));
};

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

exports.createTeamHub = function createTeamHub(dcOrVars, vars) {
  return executeMutation(createTeamHubRef(dcOrVars, vars));
};

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

exports.updateTeamHub = function updateTeamHub(dcOrVars, vars) {
  return executeMutation(updateTeamHubRef(dcOrVars, vars));
};

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

exports.deleteTeamHub = function deleteTeamHub(dcOrVars, vars) {
  return executeMutation(deleteTeamHubRef(dcOrVars, vars));
};

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

exports.listEnterprise = function listEnterprise(dc) {
  return executeQuery(listEnterpriseRef(dc));
};

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

exports.getEnterpriseById = function getEnterpriseById(dcOrVars, vars) {
  return executeQuery(getEnterpriseByIdRef(dcOrVars, vars));
};

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

exports.filterEnterprise = function filterEnterprise(dcOrVars, vars) {
  return executeQuery(filterEnterpriseRef(dcOrVars, vars));
};

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

exports.listInvoice = function listInvoice(dc) {
  return executeQuery(listInvoiceRef(dc));
};

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

exports.getInvoiceById = function getInvoiceById(dcOrVars, vars) {
  return executeQuery(getInvoiceByIdRef(dcOrVars, vars));
};

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

exports.filterInvoices = function filterInvoices(dcOrVars, vars) {
  return executeQuery(filterInvoicesRef(dcOrVars, vars));
};

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

exports.createOrder = function createOrder(dcOrVars, vars) {
  return executeMutation(createOrderRef(dcOrVars, vars));
};

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

exports.updateOrder = function updateOrder(dcOrVars, vars) {
  return executeMutation(updateOrderRef(dcOrVars, vars));
};

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

exports.deleteOrder = function deleteOrder(dcOrVars, vars) {
  return executeMutation(deleteOrderRef(dcOrVars, vars));
};

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

exports.createSector = function createSector(dcOrVars, vars) {
  return executeMutation(createSectorRef(dcOrVars, vars));
};

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

exports.updateSector = function updateSector(dcOrVars, vars) {
  return executeMutation(updateSectorRef(dcOrVars, vars));
};

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

exports.deleteSector = function deleteSector(dcOrVars, vars) {
  return executeMutation(deleteSectorRef(dcOrVars, vars));
};

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

exports.listTeamMember = function listTeamMember(dc) {
  return executeQuery(listTeamMemberRef(dc));
};

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

exports.getTeamMemberById = function getTeamMemberById(dcOrVars, vars) {
  return executeQuery(getTeamMemberByIdRef(dcOrVars, vars));
};

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

exports.filterTeamMember = function filterTeamMember(dcOrVars, vars) {
  return executeQuery(filterTeamMemberRef(dcOrVars, vars));
};

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

exports.createUser = function createUser(dcOrVars, vars) {
  return executeMutation(createUserRef(dcOrVars, vars));
};

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

exports.updateUser = function updateUser(dcOrVars, vars) {
  return executeMutation(updateUserRef(dcOrVars, vars));
};

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

exports.deleteUser = function deleteUser(dcOrVars, vars) {
  return executeMutation(deleteUserRef(dcOrVars, vars));
};

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

exports.listUsers = function listUsers(dc) {
  return executeQuery(listUsersRef(dc));
};

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

exports.getUserById = function getUserById(dcOrVars, vars) {
  return executeQuery(getUserByIdRef(dcOrVars, vars));
};

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

exports.filterUsers = function filterUsers(dcOrVars, vars) {
  return executeQuery(filterUsersRef(dcOrVars, vars));
};

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

exports.listVendorDefaultSettings = function listVendorDefaultSettings(dc) {
  return executeQuery(listVendorDefaultSettingsRef(dc));
};

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

exports.getVendorDefaultSettingById = function getVendorDefaultSettingById(dcOrVars, vars) {
  return executeQuery(getVendorDefaultSettingByIdRef(dcOrVars, vars));
};

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

exports.filterVendorDefaultSettings = function filterVendorDefaultSettings(dcOrVars, vars) {
  return executeQuery(filterVendorDefaultSettingsRef(dcOrVars, vars));
};

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

exports.listAssignment = function listAssignment(dc) {
  return executeQuery(listAssignmentRef(dc));
};

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

exports.getAssignmentById = function getAssignmentById(dcOrVars, vars) {
  return executeQuery(getAssignmentByIdRef(dcOrVars, vars));
};

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

exports.filterAssignment = function filterAssignment(dcOrVars, vars) {
  return executeQuery(filterAssignmentRef(dcOrVars, vars));
};

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

exports.listEvents = function listEvents(dcOrVars, vars) {
  return executeQuery(listEventsRef(dcOrVars, vars));
};

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

exports.getEventById = function getEventById(dcOrVars, vars) {
  return executeQuery(getEventByIdRef(dcOrVars, vars));
};

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

exports.filterEvents = function filterEvents(dcOrVars, vars) {
  return executeQuery(filterEventsRef(dcOrVars, vars));
};

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

exports.listMessage = function listMessage(dc) {
  return executeQuery(listMessageRef(dc));
};

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

exports.getMessageById = function getMessageById(dcOrVars, vars) {
  return executeQuery(getMessageByIdRef(dcOrVars, vars));
};

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

exports.filterMessage = function filterMessage(dcOrVars, vars) {
  return executeQuery(filterMessageRef(dcOrVars, vars));
};

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

exports.listSector = function listSector(dc) {
  return executeQuery(listSectorRef(dc));
};

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

exports.getSectorById = function getSectorById(dcOrVars, vars) {
  return executeQuery(getSectorByIdRef(dcOrVars, vars));
};

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

exports.filterSector = function filterSector(dcOrVars, vars) {
  return executeQuery(filterSectorRef(dcOrVars, vars));
};

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

exports.listStaff = function listStaff(dc) {
  return executeQuery(listStaffRef(dc));
};

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

exports.getStaffById = function getStaffById(dcOrVars, vars) {
  return executeQuery(getStaffByIdRef(dcOrVars, vars));
};

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

exports.filterStaff = function filterStaff(dcOrVars, vars) {
  return executeQuery(filterStaffRef(dcOrVars, vars));
};

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

exports.createTeamMemberInvite = function createTeamMemberInvite(dcOrVars, vars) {
  return executeMutation(createTeamMemberInviteRef(dcOrVars, vars));
};

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

exports.updateTeamMemberInvite = function updateTeamMemberInvite(dcOrVars, vars) {
  return executeMutation(updateTeamMemberInviteRef(dcOrVars, vars));
};

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

exports.deleteTeamMemberInvite = function deleteTeamMemberInvite(dcOrVars, vars) {
  return executeMutation(deleteTeamMemberInviteRef(dcOrVars, vars));
};

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

exports.createVendorDefaultSetting = function createVendorDefaultSetting(dcOrVars, vars) {
  return executeMutation(createVendorDefaultSettingRef(dcOrVars, vars));
};

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

exports.updateVendorDefaultSetting = function updateVendorDefaultSetting(dcOrVars, vars) {
  return executeMutation(updateVendorDefaultSettingRef(dcOrVars, vars));
};

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

exports.deleteVendorDefaultSetting = function deleteVendorDefaultSetting(dcOrVars, vars) {
  return executeMutation(deleteVendorDefaultSettingRef(dcOrVars, vars));
};

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

exports.createVendorRate = function createVendorRate(dcOrVars, vars) {
  return executeMutation(createVendorRateRef(dcOrVars, vars));
};

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

exports.updateVendorRate = function updateVendorRate(dcOrVars, vars) {
  return executeMutation(updateVendorRateRef(dcOrVars, vars));
};

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

exports.deleteVendorRate = function deleteVendorRate(dcOrVars, vars) {
  return executeMutation(deleteVendorRateRef(dcOrVars, vars));
};

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

exports.createEnterprise = function createEnterprise(dcOrVars, vars) {
  return executeMutation(createEnterpriseRef(dcOrVars, vars));
};

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

exports.updateEnterprise = function updateEnterprise(dcOrVars, vars) {
  return executeMutation(updateEnterpriseRef(dcOrVars, vars));
};

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

exports.deleteEnterprise = function deleteEnterprise(dcOrVars, vars) {
  return executeMutation(deleteEnterpriseRef(dcOrVars, vars));
};

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

exports.listOrder = function listOrder(dc) {
  return executeQuery(listOrderRef(dc));
};

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

exports.getOrderById = function getOrderById(dcOrVars, vars) {
  return executeQuery(getOrderByIdRef(dcOrVars, vars));
};

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

exports.filterOrder = function filterOrder(dcOrVars, vars) {
  return executeQuery(filterOrderRef(dcOrVars, vars));
};

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

exports.createPartner = function createPartner(dcOrVars, vars) {
  return executeMutation(createPartnerRef(dcOrVars, vars));
};

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

exports.updatePartner = function updatePartner(dcOrVars, vars) {
  return executeMutation(updatePartnerRef(dcOrVars, vars));
};

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

exports.deletePartner = function deletePartner(dcOrVars, vars) {
  return executeMutation(deletePartnerRef(dcOrVars, vars));
};

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

exports.listPartner = function listPartner(dc) {
  return executeQuery(listPartnerRef(dc));
};

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

exports.getPartnerById = function getPartnerById(dcOrVars, vars) {
  return executeQuery(getPartnerByIdRef(dcOrVars, vars));
};

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

exports.filterPartner = function filterPartner(dcOrVars, vars) {
  return executeQuery(filterPartnerRef(dcOrVars, vars));
};

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

exports.createTeamMember = function createTeamMember(dcOrVars, vars) {
  return executeMutation(createTeamMemberRef(dcOrVars, vars));
};

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

exports.updateTeamMember = function updateTeamMember(dcOrVars, vars) {
  return executeMutation(updateTeamMemberRef(dcOrVars, vars));
};

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

exports.deleteTeamMember = function deleteTeamMember(dcOrVars, vars) {
  return executeMutation(deleteTeamMemberRef(dcOrVars, vars));
};

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

exports.listVendor = function listVendor(dc) {
  return executeQuery(listVendorRef(dc));
};

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

exports.getVendorById = function getVendorById(dcOrVars, vars) {
  return executeQuery(getVendorByIdRef(dcOrVars, vars));
};

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

exports.filterVendors = function filterVendors(dcOrVars, vars) {
  return executeQuery(filterVendorsRef(dcOrVars, vars));
};

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

exports.listWorkforce = function listWorkforce(dc) {
  return executeQuery(listWorkforceRef(dc));
};

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

exports.getWorkforceById = function getWorkforceById(dcOrVars, vars) {
  return executeQuery(getWorkforceByIdRef(dcOrVars, vars));
};

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

exports.filterWorkforce = function filterWorkforce(dcOrVars, vars) {
  return executeQuery(filterWorkforceRef(dcOrVars, vars));
};

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

exports.listActivityLog = function listActivityLog(dc) {
  return executeQuery(listActivityLogRef(dc));
};

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

exports.getActivityLogById = function getActivityLogById(dcOrVars, vars) {
  return executeQuery(getActivityLogByIdRef(dcOrVars, vars));
};

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

exports.filterActivityLog = function filterActivityLog(dcOrVars, vars) {
  return executeQuery(filterActivityLogRef(dcOrVars, vars));
};

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

exports.createConversation = function createConversation(dcOrVars, vars) {
  return executeMutation(createConversationRef(dcOrVars, vars));
};

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

exports.updateConversation = function updateConversation(dcOrVars, vars) {
  return executeMutation(updateConversationRef(dcOrVars, vars));
};

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

exports.deleteConversation = function deleteConversation(dcOrVars, vars) {
  return executeMutation(deleteConversationRef(dcOrVars, vars));
};

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

exports.createInvoice = function createInvoice(dcOrVars, vars) {
  return executeMutation(createInvoiceRef(dcOrVars, vars));
};

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

exports.updateInvoice = function updateInvoice(dcOrVars, vars) {
  return executeMutation(updateInvoiceRef(dcOrVars, vars));
};

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

exports.deleteInvoice = function deleteInvoice(dcOrVars, vars) {
  return executeMutation(deleteInvoiceRef(dcOrVars, vars));
};

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

exports.listTeam = function listTeam(dcOrVars, vars) {
  return executeQuery(listTeamRef(dcOrVars, vars));
};

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

exports.getTeamById = function getTeamById(dcOrVars, vars) {
  return executeQuery(getTeamByIdRef(dcOrVars, vars));
};

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

exports.filterTeam = function filterTeam(dcOrVars, vars) {
  return executeQuery(filterTeamRef(dcOrVars, vars));
};

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

exports.listVendorRate = function listVendorRate(dc) {
  return executeQuery(listVendorRateRef(dc));
};

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

exports.getVendorRateById = function getVendorRateById(dcOrVars, vars) {
  return executeQuery(getVendorRateByIdRef(dcOrVars, vars));
};

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

exports.filterVendorRates = function filterVendorRates(dcOrVars, vars) {
  return executeQuery(filterVendorRatesRef(dcOrVars, vars));
};

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

exports.createBusiness = function createBusiness(dcOrVars, vars) {
  return executeMutation(createBusinessRef(dcOrVars, vars));
};

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

exports.updateBusiness = function updateBusiness(dcOrVars, vars) {
  return executeMutation(updateBusinessRef(dcOrVars, vars));
};

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

exports.deleteBusiness = function deleteBusiness(dcOrVars, vars) {
  return executeMutation(deleteBusinessRef(dcOrVars, vars));
};

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

exports.listTeamHub = function listTeamHub(dc) {
  return executeQuery(listTeamHubRef(dc));
};

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

exports.getTeamHubById = function getTeamHubById(dcOrVars, vars) {
  return executeQuery(getTeamHubByIdRef(dcOrVars, vars));
};

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

exports.filterTeamHub = function filterTeamHub(dcOrVars, vars) {
  return executeQuery(filterTeamHubRef(dcOrVars, vars));
};

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

exports.createEvent = function createEvent(dcOrVars, vars) {
  return executeMutation(createEventRef(dcOrVars, vars));
};

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

exports.updateEvent = function updateEvent(dcOrVars, vars) {
  return executeMutation(updateEventRef(dcOrVars, vars));
};

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

exports.deleteEvent = function deleteEvent(dcOrVars, vars) {
  return executeMutation(deleteEventRef(dcOrVars, vars));
};

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

exports.createTeam = function createTeam(dcOrVars, vars) {
  return executeMutation(createTeamRef(dcOrVars, vars));
};

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

exports.updateTeam = function updateTeam(dcOrVars, vars) {
  return executeMutation(updateTeamRef(dcOrVars, vars));
};

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

exports.deleteTeam = function deleteTeam(dcOrVars, vars) {
  return executeMutation(deleteTeamRef(dcOrVars, vars));
};

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

exports.createWorkforce = function createWorkforce(dcOrVars, vars) {
  return executeMutation(createWorkforceRef(dcOrVars, vars));
};

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

exports.updateWorkforce = function updateWorkforce(dcOrVars, vars) {
  return executeMutation(updateWorkforceRef(dcOrVars, vars));
};

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

exports.deleteWorkforce = function deleteWorkforce(dcOrVars, vars) {
  return executeMutation(deleteWorkforceRef(dcOrVars, vars));
};

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

exports.listBusiness = function listBusiness(dc) {
  return executeQuery(listBusinessRef(dc));
};

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

exports.getBusinessById = function getBusinessById(dcOrVars, vars) {
  return executeQuery(getBusinessByIdRef(dcOrVars, vars));
};

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

exports.filterBusiness = function filterBusiness(dcOrVars, vars) {
  return executeQuery(filterBusinessRef(dcOrVars, vars));
};
