# Generated TypeScript README
This README will guide you through the process of using the generated JavaScript SDK package for the connector `krow-connector`. It will also provide examples on how to use your generated SDK to call your Data Connect queries and mutations.

**If you're looking for the `React README`, you can find it at [`dataconnect-generated/react/README.md`](./react/README.md)**

***NOTE:** This README is generated alongside the generated SDK. If you make changes to this file, they will be overwritten when the SDK is regenerated.*

# Table of Contents
- [**Overview**](#generated-javascript-readme)
- [**Accessing the connector**](#accessing-the-connector)
  - [*Connecting to the local Emulator*](#connecting-to-the-local-emulator)
- [**Queries**](#queries)
  - [*listTeamMemberInvite*](#listteammemberinvite)
  - [*getTeamMemberInviteById*](#getteammemberinvitebyid)
  - [*filterTeamMemberInvite*](#filterteammemberinvite)
  - [*listCertification*](#listcertification)
  - [*getCertificationById*](#getcertificationbyid)
  - [*filterCertification*](#filtercertification)
  - [*listConversation*](#listconversation)
  - [*getConversationById*](#getconversationbyid)
  - [*filterConversation*](#filterconversation)
  - [*listShift*](#listshift)
  - [*getShiftById*](#getshiftbyid)
  - [*filterShift*](#filtershift)
  - [*listEnterprise*](#listenterprise)
  - [*getEnterpriseById*](#getenterprisebyid)
  - [*filterEnterprise*](#filterenterprise)
  - [*listInvoice*](#listinvoice)
  - [*getInvoiceById*](#getinvoicebyid)
  - [*filterInvoices*](#filterinvoices)
  - [*listTeamMember*](#listteammember)
  - [*getTeamMemberById*](#getteammemberbyid)
  - [*filterTeamMember*](#filterteammember)
  - [*listUsers*](#listusers)
  - [*getUserById*](#getuserbyid)
  - [*filterUsers*](#filterusers)
  - [*listVendorDefaultSettings*](#listvendordefaultsettings)
  - [*getVendorDefaultSettingById*](#getvendordefaultsettingbyid)
  - [*filterVendorDefaultSettings*](#filtervendordefaultsettings)
  - [*listAssignment*](#listassignment)
  - [*getAssignmentById*](#getassignmentbyid)
  - [*filterAssignment*](#filterassignment)
  - [*listEvents*](#listevents)
  - [*getEventById*](#geteventbyid)
  - [*filterEvents*](#filterevents)
  - [*listMessage*](#listmessage)
  - [*getMessageById*](#getmessagebyid)
  - [*filterMessage*](#filtermessage)
  - [*listSector*](#listsector)
  - [*getSectorById*](#getsectorbyid)
  - [*filterSector*](#filtersector)
  - [*listStaff*](#liststaff)
  - [*getStaffById*](#getstaffbyid)
  - [*filterStaff*](#filterstaff)
  - [*listOrder*](#listorder)
  - [*getOrderById*](#getorderbyid)
  - [*filterOrder*](#filterorder)
  - [*listPartner*](#listpartner)
  - [*getPartnerById*](#getpartnerbyid)
  - [*filterPartner*](#filterpartner)
  - [*listVendor*](#listvendor)
  - [*getVendorById*](#getvendorbyid)
  - [*filterVendors*](#filtervendors)
  - [*listWorkforce*](#listworkforce)
  - [*getWorkforceById*](#getworkforcebyid)
  - [*filterWorkforce*](#filterworkforce)
  - [*listActivityLog*](#listactivitylog)
  - [*getActivityLogById*](#getactivitylogbyid)
  - [*filterActivityLog*](#filteractivitylog)
  - [*listTeam*](#listteam)
  - [*getTeamById*](#getteambyid)
  - [*filterTeam*](#filterteam)
  - [*listVendorRate*](#listvendorrate)
  - [*getVendorRateById*](#getvendorratebyid)
  - [*filterVendorRates*](#filtervendorrates)
  - [*listTeamHub*](#listteamhub)
  - [*getTeamHubById*](#getteamhubbyid)
  - [*filterTeamHub*](#filterteamhub)
  - [*listBusiness*](#listbusiness)
  - [*getBusinessById*](#getbusinessbyid)
  - [*filterBusiness*](#filterbusiness)
- [**Mutations**](#mutations)
  - [*CreateMessage*](#createmessage)
  - [*UpdateMessage*](#updatemessage)
  - [*DeleteMessage*](#deletemessage)
  - [*CreateStaff*](#createstaff)
  - [*UpdateStaff*](#updatestaff)
  - [*DeleteStaff*](#deletestaff)
  - [*CreateVendor*](#createvendor)
  - [*UpdateVendor*](#updatevendor)
  - [*DeleteVendor*](#deletevendor)
  - [*CreateActivityLog*](#createactivitylog)
  - [*UpdateActivityLog*](#updateactivitylog)
  - [*DeleteActivityLog*](#deleteactivitylog)
  - [*CreateAssignment*](#createassignment)
  - [*UpdateAssignment*](#updateassignment)
  - [*DeleteAssignment*](#deleteassignment)
  - [*CreateCertification*](#createcertification)
  - [*UpdateCertification*](#updatecertification)
  - [*DeleteCertification*](#deletecertification)
  - [*CreateShift*](#createshift)
  - [*UpdateShift*](#updateshift)
  - [*DeleteShift*](#deleteshift)
  - [*CreateTeamHub*](#createteamhub)
  - [*UpdateTeamHub*](#updateteamhub)
  - [*DeleteTeamHub*](#deleteteamhub)
  - [*CreateOrder*](#createorder)
  - [*UpdateOrder*](#updateorder)
  - [*DeleteOrder*](#deleteorder)
  - [*CreateSector*](#createsector)
  - [*UpdateSector*](#updatesector)
  - [*DeleteSector*](#deletesector)
  - [*CreateUser*](#createuser)
  - [*UpdateUser*](#updateuser)
  - [*DeleteUser*](#deleteuser)
  - [*CreateTeamMemberInvite*](#createteammemberinvite)
  - [*UpdateTeamMemberInvite*](#updateteammemberinvite)
  - [*DeleteTeamMemberInvite*](#deleteteammemberinvite)
  - [*CreateVendorDefaultSetting*](#createvendordefaultsetting)
  - [*UpdateVendorDefaultSetting*](#updatevendordefaultsetting)
  - [*DeleteVendorDefaultSetting*](#deletevendordefaultsetting)
  - [*CreateVendorRate*](#createvendorrate)
  - [*UpdateVendorRate*](#updatevendorrate)
  - [*DeleteVendorRate*](#deletevendorrate)
  - [*CreateEnterprise*](#createenterprise)
  - [*UpdateEnterprise*](#updateenterprise)
  - [*DeleteEnterprise*](#deleteenterprise)
  - [*CreatePartner*](#createpartner)
  - [*UpdatePartner*](#updatepartner)
  - [*DeletePartner*](#deletepartner)
  - [*CreateTeamMember*](#createteammember)
  - [*UpdateTeamMember*](#updateteammember)
  - [*DeleteTeamMember*](#deleteteammember)
  - [*CreateConversation*](#createconversation)
  - [*UpdateConversation*](#updateconversation)
  - [*DeleteConversation*](#deleteconversation)
  - [*CreateInvoice*](#createinvoice)
  - [*UpdateInvoice*](#updateinvoice)
  - [*DeleteInvoice*](#deleteinvoice)
  - [*CreateBusiness*](#createbusiness)
  - [*UpdateBusiness*](#updatebusiness)
  - [*DeleteBusiness*](#deletebusiness)
  - [*CreateEvent*](#createevent)
  - [*UpdateEvent*](#updateevent)
  - [*DeleteEvent*](#deleteevent)
  - [*CreateTeam*](#createteam)
  - [*UpdateTeam*](#updateteam)
  - [*DeleteTeam*](#deleteteam)
  - [*CreateWorkforce*](#createworkforce)
  - [*UpdateWorkforce*](#updateworkforce)
  - [*DeleteWorkforce*](#deleteworkforce)

# Accessing the connector
A connector is a collection of Queries and Mutations. One SDK is generated for each connector - this SDK is generated for the connector `krow-connector`. You can find more information about connectors in the [Data Connect documentation](https://firebase.google.com/docs/data-connect#how-does).

You can use this generated SDK by importing from the package `@dataconnect/generated` as shown below. Both CommonJS and ESM imports are supported.

You can also follow the instructions from the [Data Connect documentation](https://firebase.google.com/docs/data-connect/web-sdk#set-client).

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig } from '@dataconnect/generated';

const dataConnect = getDataConnect(connectorConfig);
```

## Connecting to the local Emulator
By default, the connector will connect to the production service.

To connect to the emulator, you can use the following code.
You can also follow the emulator instructions from the [Data Connect documentation](https://firebase.google.com/docs/data-connect/web-sdk#instrument-clients).

```typescript
import { connectDataConnectEmulator, getDataConnect } from 'firebase/data-connect';
import { connectorConfig } from '@dataconnect/generated';

const dataConnect = getDataConnect(connectorConfig);
connectDataConnectEmulator(dataConnect, 'localhost', 9399);
```

After it's initialized, you can call your Data Connect [queries](#queries) and [mutations](#mutations) from your generated SDK.

# Queries

There are two ways to execute a Data Connect Query using the generated Web SDK:
- Using a Query Reference function, which returns a `QueryRef`
  - The `QueryRef` can be used as an argument to `executeQuery()`, which will execute the Query and return a `QueryPromise`
- Using an action shortcut function, which returns a `QueryPromise`
  - Calling the action shortcut function will execute the Query and return a `QueryPromise`

The following is true for both the action shortcut function and the `QueryRef` function:
- The `QueryPromise` returned will resolve to the result of the Query once it has finished executing
- If the Query accepts arguments, both the action shortcut function and the `QueryRef` function accept a single argument: an object that contains all the required variables (and the optional variables) for the Query
- Both functions can be called with or without passing in a `DataConnect` instance as an argument. If no `DataConnect` argument is passed in, then the generated SDK will call `getDataConnect(connectorConfig)` behind the scenes for you.

Below are examples of how to use the `krow-connector` connector's generated functions to execute each query. You can also follow the examples from the [Data Connect documentation](https://firebase.google.com/docs/data-connect/web-sdk#using-queries).

## listTeamMemberInvite
You can execute the `listTeamMemberInvite` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listTeamMemberInvite(): QueryPromise<ListTeamMemberInviteData, undefined>;

interface ListTeamMemberInviteRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListTeamMemberInviteData, undefined>;
}
export const listTeamMemberInviteRef: ListTeamMemberInviteRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listTeamMemberInvite(dc: DataConnect): QueryPromise<ListTeamMemberInviteData, undefined>;

interface ListTeamMemberInviteRef {
  ...
  (dc: DataConnect): QueryRef<ListTeamMemberInviteData, undefined>;
}
export const listTeamMemberInviteRef: ListTeamMemberInviteRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listTeamMemberInviteRef:
```typescript
const name = listTeamMemberInviteRef.operationName;
console.log(name);
```

### Variables
The `listTeamMemberInvite` query has no variables.
### Return Type
Recall that executing the `listTeamMemberInvite` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListTeamMemberInviteData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListTeamMemberInviteData {
  teamMemberInvites: ({
    id: UUIDString;
    teamId: UUIDString;
    inviteCode: string;
    email: string;
    inviteStatus: TeamMemberInviteStatus;
  } & TeamMemberInvite_Key)[];
}
```
### Using `listTeamMemberInvite`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listTeamMemberInvite } from '@dataconnect/generated';


// Call the `listTeamMemberInvite()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listTeamMemberInvite();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listTeamMemberInvite(dataConnect);

console.log(data.teamMemberInvites);

// Or, you can use the `Promise` API.
listTeamMemberInvite().then((response) => {
  const data = response.data;
  console.log(data.teamMemberInvites);
});
```

### Using `listTeamMemberInvite`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listTeamMemberInviteRef } from '@dataconnect/generated';


// Call the `listTeamMemberInviteRef()` function to get a reference to the query.
const ref = listTeamMemberInviteRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listTeamMemberInviteRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.teamMemberInvites);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.teamMemberInvites);
});
```

## getTeamMemberInviteById
You can execute the `getTeamMemberInviteById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getTeamMemberInviteById(vars: GetTeamMemberInviteByIdVariables): QueryPromise<GetTeamMemberInviteByIdData, GetTeamMemberInviteByIdVariables>;

interface GetTeamMemberInviteByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetTeamMemberInviteByIdVariables): QueryRef<GetTeamMemberInviteByIdData, GetTeamMemberInviteByIdVariables>;
}
export const getTeamMemberInviteByIdRef: GetTeamMemberInviteByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getTeamMemberInviteById(dc: DataConnect, vars: GetTeamMemberInviteByIdVariables): QueryPromise<GetTeamMemberInviteByIdData, GetTeamMemberInviteByIdVariables>;

interface GetTeamMemberInviteByIdRef {
  ...
  (dc: DataConnect, vars: GetTeamMemberInviteByIdVariables): QueryRef<GetTeamMemberInviteByIdData, GetTeamMemberInviteByIdVariables>;
}
export const getTeamMemberInviteByIdRef: GetTeamMemberInviteByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getTeamMemberInviteByIdRef:
```typescript
const name = getTeamMemberInviteByIdRef.operationName;
console.log(name);
```

### Variables
The `getTeamMemberInviteById` query requires an argument of type `GetTeamMemberInviteByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetTeamMemberInviteByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getTeamMemberInviteById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetTeamMemberInviteByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetTeamMemberInviteByIdData {
  teamMemberInvite?: {
    id: UUIDString;
    teamId: UUIDString;
    inviteCode: string;
    email: string;
    inviteStatus: TeamMemberInviteStatus;
  } & TeamMemberInvite_Key;
}
```
### Using `getTeamMemberInviteById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getTeamMemberInviteById, GetTeamMemberInviteByIdVariables } from '@dataconnect/generated';

// The `getTeamMemberInviteById` query requires an argument of type `GetTeamMemberInviteByIdVariables`:
const getTeamMemberInviteByIdVars: GetTeamMemberInviteByIdVariables = {
  id: ..., 
};

// Call the `getTeamMemberInviteById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getTeamMemberInviteById(getTeamMemberInviteByIdVars);
// Variables can be defined inline as well.
const { data } = await getTeamMemberInviteById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getTeamMemberInviteById(dataConnect, getTeamMemberInviteByIdVars);

console.log(data.teamMemberInvite);

// Or, you can use the `Promise` API.
getTeamMemberInviteById(getTeamMemberInviteByIdVars).then((response) => {
  const data = response.data;
  console.log(data.teamMemberInvite);
});
```

### Using `getTeamMemberInviteById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getTeamMemberInviteByIdRef, GetTeamMemberInviteByIdVariables } from '@dataconnect/generated';

// The `getTeamMemberInviteById` query requires an argument of type `GetTeamMemberInviteByIdVariables`:
const getTeamMemberInviteByIdVars: GetTeamMemberInviteByIdVariables = {
  id: ..., 
};

// Call the `getTeamMemberInviteByIdRef()` function to get a reference to the query.
const ref = getTeamMemberInviteByIdRef(getTeamMemberInviteByIdVars);
// Variables can be defined inline as well.
const ref = getTeamMemberInviteByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getTeamMemberInviteByIdRef(dataConnect, getTeamMemberInviteByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.teamMemberInvite);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.teamMemberInvite);
});
```

## filterTeamMemberInvite
You can execute the `filterTeamMemberInvite` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterTeamMemberInvite(vars?: FilterTeamMemberInviteVariables): QueryPromise<FilterTeamMemberInviteData, FilterTeamMemberInviteVariables>;

interface FilterTeamMemberInviteRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterTeamMemberInviteVariables): QueryRef<FilterTeamMemberInviteData, FilterTeamMemberInviteVariables>;
}
export const filterTeamMemberInviteRef: FilterTeamMemberInviteRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterTeamMemberInvite(dc: DataConnect, vars?: FilterTeamMemberInviteVariables): QueryPromise<FilterTeamMemberInviteData, FilterTeamMemberInviteVariables>;

interface FilterTeamMemberInviteRef {
  ...
  (dc: DataConnect, vars?: FilterTeamMemberInviteVariables): QueryRef<FilterTeamMemberInviteData, FilterTeamMemberInviteVariables>;
}
export const filterTeamMemberInviteRef: FilterTeamMemberInviteRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterTeamMemberInviteRef:
```typescript
const name = filterTeamMemberInviteRef.operationName;
console.log(name);
```

### Variables
The `filterTeamMemberInvite` query has an optional argument of type `FilterTeamMemberInviteVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterTeamMemberInviteVariables {
  teamId?: UUIDString | null;
  email?: string | null;
  inviteStatus?: TeamMemberInviteStatus | null;
}
```
### Return Type
Recall that executing the `filterTeamMemberInvite` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterTeamMemberInviteData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterTeamMemberInviteData {
  teamMemberInvites: ({
    id: UUIDString;
    teamId: UUIDString;
    inviteCode: string;
    email: string;
    inviteStatus: TeamMemberInviteStatus;
  } & TeamMemberInvite_Key)[];
}
```
### Using `filterTeamMemberInvite`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterTeamMemberInvite, FilterTeamMemberInviteVariables } from '@dataconnect/generated';

// The `filterTeamMemberInvite` query has an optional argument of type `FilterTeamMemberInviteVariables`:
const filterTeamMemberInviteVars: FilterTeamMemberInviteVariables = {
  teamId: ..., // optional
  email: ..., // optional
  inviteStatus: ..., // optional
};

// Call the `filterTeamMemberInvite()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterTeamMemberInvite(filterTeamMemberInviteVars);
// Variables can be defined inline as well.
const { data } = await filterTeamMemberInvite({ teamId: ..., email: ..., inviteStatus: ..., });
// Since all variables are optional for this query, you can omit the `FilterTeamMemberInviteVariables` argument.
const { data } = await filterTeamMemberInvite();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterTeamMemberInvite(dataConnect, filterTeamMemberInviteVars);

console.log(data.teamMemberInvites);

// Or, you can use the `Promise` API.
filterTeamMemberInvite(filterTeamMemberInviteVars).then((response) => {
  const data = response.data;
  console.log(data.teamMemberInvites);
});
```

### Using `filterTeamMemberInvite`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterTeamMemberInviteRef, FilterTeamMemberInviteVariables } from '@dataconnect/generated';

// The `filterTeamMemberInvite` query has an optional argument of type `FilterTeamMemberInviteVariables`:
const filterTeamMemberInviteVars: FilterTeamMemberInviteVariables = {
  teamId: ..., // optional
  email: ..., // optional
  inviteStatus: ..., // optional
};

// Call the `filterTeamMemberInviteRef()` function to get a reference to the query.
const ref = filterTeamMemberInviteRef(filterTeamMemberInviteVars);
// Variables can be defined inline as well.
const ref = filterTeamMemberInviteRef({ teamId: ..., email: ..., inviteStatus: ..., });
// Since all variables are optional for this query, you can omit the `FilterTeamMemberInviteVariables` argument.
const ref = filterTeamMemberInviteRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterTeamMemberInviteRef(dataConnect, filterTeamMemberInviteVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.teamMemberInvites);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.teamMemberInvites);
});
```

## listCertification
You can execute the `listCertification` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listCertification(): QueryPromise<ListCertificationData, undefined>;

interface ListCertificationRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListCertificationData, undefined>;
}
export const listCertificationRef: ListCertificationRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listCertification(dc: DataConnect): QueryPromise<ListCertificationData, undefined>;

interface ListCertificationRef {
  ...
  (dc: DataConnect): QueryRef<ListCertificationData, undefined>;
}
export const listCertificationRef: ListCertificationRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listCertificationRef:
```typescript
const name = listCertificationRef.operationName;
console.log(name);
```

### Variables
The `listCertification` query has no variables.
### Return Type
Recall that executing the `listCertification` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListCertificationData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListCertificationData {
  certifications: ({
    id: UUIDString;
    employeeName: string;
    certificationName: string;
    certificationType?: CertificationType | null;
    status?: CertificationStatus | null;
    expiryDate: string;
    validationStatus?: CertificationValidationStatus | null;
  } & Certification_Key)[];
}
```
### Using `listCertification`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listCertification } from '@dataconnect/generated';


// Call the `listCertification()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listCertification();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listCertification(dataConnect);

console.log(data.certifications);

// Or, you can use the `Promise` API.
listCertification().then((response) => {
  const data = response.data;
  console.log(data.certifications);
});
```

### Using `listCertification`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listCertificationRef } from '@dataconnect/generated';


// Call the `listCertificationRef()` function to get a reference to the query.
const ref = listCertificationRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listCertificationRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.certifications);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.certifications);
});
```

## getCertificationById
You can execute the `getCertificationById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getCertificationById(vars: GetCertificationByIdVariables): QueryPromise<GetCertificationByIdData, GetCertificationByIdVariables>;

interface GetCertificationByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetCertificationByIdVariables): QueryRef<GetCertificationByIdData, GetCertificationByIdVariables>;
}
export const getCertificationByIdRef: GetCertificationByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getCertificationById(dc: DataConnect, vars: GetCertificationByIdVariables): QueryPromise<GetCertificationByIdData, GetCertificationByIdVariables>;

interface GetCertificationByIdRef {
  ...
  (dc: DataConnect, vars: GetCertificationByIdVariables): QueryRef<GetCertificationByIdData, GetCertificationByIdVariables>;
}
export const getCertificationByIdRef: GetCertificationByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getCertificationByIdRef:
```typescript
const name = getCertificationByIdRef.operationName;
console.log(name);
```

### Variables
The `getCertificationById` query requires an argument of type `GetCertificationByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetCertificationByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getCertificationById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetCertificationByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetCertificationByIdData {
  certification?: {
    id: UUIDString;
    employeeName: string;
    certificationName: string;
    certificationType?: CertificationType | null;
    status?: CertificationStatus | null;
    expiryDate: string;
    validationStatus?: CertificationValidationStatus | null;
    createdDate?: TimestampString | null;
    updatedDate?: TimestampString | null;
    createdBy?: string | null;
  } & Certification_Key;
}
```
### Using `getCertificationById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getCertificationById, GetCertificationByIdVariables } from '@dataconnect/generated';

// The `getCertificationById` query requires an argument of type `GetCertificationByIdVariables`:
const getCertificationByIdVars: GetCertificationByIdVariables = {
  id: ..., 
};

// Call the `getCertificationById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getCertificationById(getCertificationByIdVars);
// Variables can be defined inline as well.
const { data } = await getCertificationById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getCertificationById(dataConnect, getCertificationByIdVars);

console.log(data.certification);

// Or, you can use the `Promise` API.
getCertificationById(getCertificationByIdVars).then((response) => {
  const data = response.data;
  console.log(data.certification);
});
```

### Using `getCertificationById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getCertificationByIdRef, GetCertificationByIdVariables } from '@dataconnect/generated';

// The `getCertificationById` query requires an argument of type `GetCertificationByIdVariables`:
const getCertificationByIdVars: GetCertificationByIdVariables = {
  id: ..., 
};

// Call the `getCertificationByIdRef()` function to get a reference to the query.
const ref = getCertificationByIdRef(getCertificationByIdVars);
// Variables can be defined inline as well.
const ref = getCertificationByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getCertificationByIdRef(dataConnect, getCertificationByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.certification);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.certification);
});
```

## filterCertification
You can execute the `filterCertification` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterCertification(vars?: FilterCertificationVariables): QueryPromise<FilterCertificationData, FilterCertificationVariables>;

interface FilterCertificationRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterCertificationVariables): QueryRef<FilterCertificationData, FilterCertificationVariables>;
}
export const filterCertificationRef: FilterCertificationRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterCertification(dc: DataConnect, vars?: FilterCertificationVariables): QueryPromise<FilterCertificationData, FilterCertificationVariables>;

interface FilterCertificationRef {
  ...
  (dc: DataConnect, vars?: FilterCertificationVariables): QueryRef<FilterCertificationData, FilterCertificationVariables>;
}
export const filterCertificationRef: FilterCertificationRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterCertificationRef:
```typescript
const name = filterCertificationRef.operationName;
console.log(name);
```

### Variables
The `filterCertification` query has an optional argument of type `FilterCertificationVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterCertificationVariables {
  employeeName?: string | null;
  certificationName?: string | null;
  certificationType?: CertificationType | null;
  status?: CertificationStatus | null;
  validationStatus?: CertificationValidationStatus | null;
}
```
### Return Type
Recall that executing the `filterCertification` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterCertificationData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterCertificationData {
  certifications: ({
    id: UUIDString;
    employeeName: string;
    certificationName: string;
    certificationType?: CertificationType | null;
    status?: CertificationStatus | null;
    expiryDate: string;
    validationStatus?: CertificationValidationStatus | null;
  } & Certification_Key)[];
}
```
### Using `filterCertification`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterCertification, FilterCertificationVariables } from '@dataconnect/generated';

// The `filterCertification` query has an optional argument of type `FilterCertificationVariables`:
const filterCertificationVars: FilterCertificationVariables = {
  employeeName: ..., // optional
  certificationName: ..., // optional
  certificationType: ..., // optional
  status: ..., // optional
  validationStatus: ..., // optional
};

// Call the `filterCertification()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterCertification(filterCertificationVars);
// Variables can be defined inline as well.
const { data } = await filterCertification({ employeeName: ..., certificationName: ..., certificationType: ..., status: ..., validationStatus: ..., });
// Since all variables are optional for this query, you can omit the `FilterCertificationVariables` argument.
const { data } = await filterCertification();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterCertification(dataConnect, filterCertificationVars);

console.log(data.certifications);

// Or, you can use the `Promise` API.
filterCertification(filterCertificationVars).then((response) => {
  const data = response.data;
  console.log(data.certifications);
});
```

### Using `filterCertification`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterCertificationRef, FilterCertificationVariables } from '@dataconnect/generated';

// The `filterCertification` query has an optional argument of type `FilterCertificationVariables`:
const filterCertificationVars: FilterCertificationVariables = {
  employeeName: ..., // optional
  certificationName: ..., // optional
  certificationType: ..., // optional
  status: ..., // optional
  validationStatus: ..., // optional
};

// Call the `filterCertificationRef()` function to get a reference to the query.
const ref = filterCertificationRef(filterCertificationVars);
// Variables can be defined inline as well.
const ref = filterCertificationRef({ employeeName: ..., certificationName: ..., certificationType: ..., status: ..., validationStatus: ..., });
// Since all variables are optional for this query, you can omit the `FilterCertificationVariables` argument.
const ref = filterCertificationRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterCertificationRef(dataConnect, filterCertificationVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.certifications);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.certifications);
});
```

## listConversation
You can execute the `listConversation` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listConversation(): QueryPromise<ListConversationData, undefined>;

interface ListConversationRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListConversationData, undefined>;
}
export const listConversationRef: ListConversationRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listConversation(dc: DataConnect): QueryPromise<ListConversationData, undefined>;

interface ListConversationRef {
  ...
  (dc: DataConnect): QueryRef<ListConversationData, undefined>;
}
export const listConversationRef: ListConversationRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listConversationRef:
```typescript
const name = listConversationRef.operationName;
console.log(name);
```

### Variables
The `listConversation` query has no variables.
### Return Type
Recall that executing the `listConversation` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListConversationData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListConversationData {
  conversations: ({
    id: UUIDString;
    participants: string;
    conversationType: ConversationType;
    relatedTo: UUIDString;
    status?: ConversationStatus | null;
  } & Conversation_Key)[];
}
```
### Using `listConversation`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listConversation } from '@dataconnect/generated';


// Call the `listConversation()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listConversation();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listConversation(dataConnect);

console.log(data.conversations);

// Or, you can use the `Promise` API.
listConversation().then((response) => {
  const data = response.data;
  console.log(data.conversations);
});
```

### Using `listConversation`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listConversationRef } from '@dataconnect/generated';


// Call the `listConversationRef()` function to get a reference to the query.
const ref = listConversationRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listConversationRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.conversations);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.conversations);
});
```

## getConversationById
You can execute the `getConversationById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getConversationById(vars: GetConversationByIdVariables): QueryPromise<GetConversationByIdData, GetConversationByIdVariables>;

interface GetConversationByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetConversationByIdVariables): QueryRef<GetConversationByIdData, GetConversationByIdVariables>;
}
export const getConversationByIdRef: GetConversationByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getConversationById(dc: DataConnect, vars: GetConversationByIdVariables): QueryPromise<GetConversationByIdData, GetConversationByIdVariables>;

interface GetConversationByIdRef {
  ...
  (dc: DataConnect, vars: GetConversationByIdVariables): QueryRef<GetConversationByIdData, GetConversationByIdVariables>;
}
export const getConversationByIdRef: GetConversationByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getConversationByIdRef:
```typescript
const name = getConversationByIdRef.operationName;
console.log(name);
```

### Variables
The `getConversationById` query requires an argument of type `GetConversationByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetConversationByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getConversationById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetConversationByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetConversationByIdData {
  conversation?: {
    id: UUIDString;
    participants: string;
    conversationType: ConversationType;
    relatedTo: UUIDString;
    status?: ConversationStatus | null;
  } & Conversation_Key;
}
```
### Using `getConversationById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getConversationById, GetConversationByIdVariables } from '@dataconnect/generated';

// The `getConversationById` query requires an argument of type `GetConversationByIdVariables`:
const getConversationByIdVars: GetConversationByIdVariables = {
  id: ..., 
};

// Call the `getConversationById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getConversationById(getConversationByIdVars);
// Variables can be defined inline as well.
const { data } = await getConversationById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getConversationById(dataConnect, getConversationByIdVars);

console.log(data.conversation);

// Or, you can use the `Promise` API.
getConversationById(getConversationByIdVars).then((response) => {
  const data = response.data;
  console.log(data.conversation);
});
```

### Using `getConversationById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getConversationByIdRef, GetConversationByIdVariables } from '@dataconnect/generated';

// The `getConversationById` query requires an argument of type `GetConversationByIdVariables`:
const getConversationByIdVars: GetConversationByIdVariables = {
  id: ..., 
};

// Call the `getConversationByIdRef()` function to get a reference to the query.
const ref = getConversationByIdRef(getConversationByIdVars);
// Variables can be defined inline as well.
const ref = getConversationByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getConversationByIdRef(dataConnect, getConversationByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.conversation);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.conversation);
});
```

## filterConversation
You can execute the `filterConversation` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterConversation(vars?: FilterConversationVariables): QueryPromise<FilterConversationData, FilterConversationVariables>;

interface FilterConversationRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterConversationVariables): QueryRef<FilterConversationData, FilterConversationVariables>;
}
export const filterConversationRef: FilterConversationRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterConversation(dc: DataConnect, vars?: FilterConversationVariables): QueryPromise<FilterConversationData, FilterConversationVariables>;

interface FilterConversationRef {
  ...
  (dc: DataConnect, vars?: FilterConversationVariables): QueryRef<FilterConversationData, FilterConversationVariables>;
}
export const filterConversationRef: FilterConversationRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterConversationRef:
```typescript
const name = filterConversationRef.operationName;
console.log(name);
```

### Variables
The `filterConversation` query has an optional argument of type `FilterConversationVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterConversationVariables {
  conversationType?: ConversationType | null;
  status?: ConversationStatus | null;
  relatedTo?: UUIDString | null;
}
```
### Return Type
Recall that executing the `filterConversation` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterConversationData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterConversationData {
  conversations: ({
    id: UUIDString;
    participants: string;
    conversationType: ConversationType;
    relatedTo: UUIDString;
    status?: ConversationStatus | null;
  } & Conversation_Key)[];
}
```
### Using `filterConversation`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterConversation, FilterConversationVariables } from '@dataconnect/generated';

// The `filterConversation` query has an optional argument of type `FilterConversationVariables`:
const filterConversationVars: FilterConversationVariables = {
  conversationType: ..., // optional
  status: ..., // optional
  relatedTo: ..., // optional
};

// Call the `filterConversation()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterConversation(filterConversationVars);
// Variables can be defined inline as well.
const { data } = await filterConversation({ conversationType: ..., status: ..., relatedTo: ..., });
// Since all variables are optional for this query, you can omit the `FilterConversationVariables` argument.
const { data } = await filterConversation();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterConversation(dataConnect, filterConversationVars);

console.log(data.conversations);

// Or, you can use the `Promise` API.
filterConversation(filterConversationVars).then((response) => {
  const data = response.data;
  console.log(data.conversations);
});
```

### Using `filterConversation`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterConversationRef, FilterConversationVariables } from '@dataconnect/generated';

// The `filterConversation` query has an optional argument of type `FilterConversationVariables`:
const filterConversationVars: FilterConversationVariables = {
  conversationType: ..., // optional
  status: ..., // optional
  relatedTo: ..., // optional
};

// Call the `filterConversationRef()` function to get a reference to the query.
const ref = filterConversationRef(filterConversationVars);
// Variables can be defined inline as well.
const ref = filterConversationRef({ conversationType: ..., status: ..., relatedTo: ..., });
// Since all variables are optional for this query, you can omit the `FilterConversationVariables` argument.
const ref = filterConversationRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterConversationRef(dataConnect, filterConversationVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.conversations);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.conversations);
});
```

## listShift
You can execute the `listShift` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listShift(): QueryPromise<ListShiftData, undefined>;

interface ListShiftRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListShiftData, undefined>;
}
export const listShiftRef: ListShiftRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listShift(dc: DataConnect): QueryPromise<ListShiftData, undefined>;

interface ListShiftRef {
  ...
  (dc: DataConnect): QueryRef<ListShiftData, undefined>;
}
export const listShiftRef: ListShiftRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listShiftRef:
```typescript
const name = listShiftRef.operationName;
console.log(name);
```

### Variables
The `listShift` query has no variables.
### Return Type
Recall that executing the `listShift` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListShiftData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListShiftData {
  shifts: ({
    id: UUIDString;
    shiftName: string;
    startDate: TimestampString;
    endDate?: TimestampString | null;
    assignedStaff?: string | null;
  } & Shift_Key)[];
}
```
### Using `listShift`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listShift } from '@dataconnect/generated';


// Call the `listShift()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listShift();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listShift(dataConnect);

console.log(data.shifts);

// Or, you can use the `Promise` API.
listShift().then((response) => {
  const data = response.data;
  console.log(data.shifts);
});
```

### Using `listShift`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listShiftRef } from '@dataconnect/generated';


// Call the `listShiftRef()` function to get a reference to the query.
const ref = listShiftRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listShiftRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.shifts);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.shifts);
});
```

## getShiftById
You can execute the `getShiftById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getShiftById(vars: GetShiftByIdVariables): QueryPromise<GetShiftByIdData, GetShiftByIdVariables>;

interface GetShiftByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetShiftByIdVariables): QueryRef<GetShiftByIdData, GetShiftByIdVariables>;
}
export const getShiftByIdRef: GetShiftByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getShiftById(dc: DataConnect, vars: GetShiftByIdVariables): QueryPromise<GetShiftByIdData, GetShiftByIdVariables>;

interface GetShiftByIdRef {
  ...
  (dc: DataConnect, vars: GetShiftByIdVariables): QueryRef<GetShiftByIdData, GetShiftByIdVariables>;
}
export const getShiftByIdRef: GetShiftByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getShiftByIdRef:
```typescript
const name = getShiftByIdRef.operationName;
console.log(name);
```

### Variables
The `getShiftById` query requires an argument of type `GetShiftByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetShiftByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getShiftById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetShiftByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetShiftByIdData {
  shift?: {
    id: UUIDString;
    shiftName: string;
    startDate: TimestampString;
    endDate?: TimestampString | null;
    assignedStaff?: string | null;
    createdDate?: TimestampString | null;
    updatedDate?: TimestampString | null;
    createdBy?: string | null;
  } & Shift_Key;
}
```
### Using `getShiftById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getShiftById, GetShiftByIdVariables } from '@dataconnect/generated';

// The `getShiftById` query requires an argument of type `GetShiftByIdVariables`:
const getShiftByIdVars: GetShiftByIdVariables = {
  id: ..., 
};

// Call the `getShiftById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getShiftById(getShiftByIdVars);
// Variables can be defined inline as well.
const { data } = await getShiftById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getShiftById(dataConnect, getShiftByIdVars);

console.log(data.shift);

// Or, you can use the `Promise` API.
getShiftById(getShiftByIdVars).then((response) => {
  const data = response.data;
  console.log(data.shift);
});
```

### Using `getShiftById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getShiftByIdRef, GetShiftByIdVariables } from '@dataconnect/generated';

// The `getShiftById` query requires an argument of type `GetShiftByIdVariables`:
const getShiftByIdVars: GetShiftByIdVariables = {
  id: ..., 
};

// Call the `getShiftByIdRef()` function to get a reference to the query.
const ref = getShiftByIdRef(getShiftByIdVars);
// Variables can be defined inline as well.
const ref = getShiftByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getShiftByIdRef(dataConnect, getShiftByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.shift);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.shift);
});
```

## filterShift
You can execute the `filterShift` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterShift(vars?: FilterShiftVariables): QueryPromise<FilterShiftData, FilterShiftVariables>;

interface FilterShiftRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterShiftVariables): QueryRef<FilterShiftData, FilterShiftVariables>;
}
export const filterShiftRef: FilterShiftRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterShift(dc: DataConnect, vars?: FilterShiftVariables): QueryPromise<FilterShiftData, FilterShiftVariables>;

interface FilterShiftRef {
  ...
  (dc: DataConnect, vars?: FilterShiftVariables): QueryRef<FilterShiftData, FilterShiftVariables>;
}
export const filterShiftRef: FilterShiftRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterShiftRef:
```typescript
const name = filterShiftRef.operationName;
console.log(name);
```

### Variables
The `filterShift` query has an optional argument of type `FilterShiftVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterShiftVariables {
  shiftName?: string | null;
  startDate?: TimestampString | null;
  endDate?: TimestampString | null;
}
```
### Return Type
Recall that executing the `filterShift` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterShiftData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterShiftData {
  shifts: ({
    id: UUIDString;
    shiftName: string;
    startDate: TimestampString;
    endDate?: TimestampString | null;
    assignedStaff?: string | null;
  } & Shift_Key)[];
}
```
### Using `filterShift`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterShift, FilterShiftVariables } from '@dataconnect/generated';

// The `filterShift` query has an optional argument of type `FilterShiftVariables`:
const filterShiftVars: FilterShiftVariables = {
  shiftName: ..., // optional
  startDate: ..., // optional
  endDate: ..., // optional
};

// Call the `filterShift()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterShift(filterShiftVars);
// Variables can be defined inline as well.
const { data } = await filterShift({ shiftName: ..., startDate: ..., endDate: ..., });
// Since all variables are optional for this query, you can omit the `FilterShiftVariables` argument.
const { data } = await filterShift();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterShift(dataConnect, filterShiftVars);

console.log(data.shifts);

// Or, you can use the `Promise` API.
filterShift(filterShiftVars).then((response) => {
  const data = response.data;
  console.log(data.shifts);
});
```

### Using `filterShift`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterShiftRef, FilterShiftVariables } from '@dataconnect/generated';

// The `filterShift` query has an optional argument of type `FilterShiftVariables`:
const filterShiftVars: FilterShiftVariables = {
  shiftName: ..., // optional
  startDate: ..., // optional
  endDate: ..., // optional
};

// Call the `filterShiftRef()` function to get a reference to the query.
const ref = filterShiftRef(filterShiftVars);
// Variables can be defined inline as well.
const ref = filterShiftRef({ shiftName: ..., startDate: ..., endDate: ..., });
// Since all variables are optional for this query, you can omit the `FilterShiftVariables` argument.
const ref = filterShiftRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterShiftRef(dataConnect, filterShiftVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.shifts);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.shifts);
});
```

## listEnterprise
You can execute the `listEnterprise` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listEnterprise(): QueryPromise<ListEnterpriseData, undefined>;

interface ListEnterpriseRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListEnterpriseData, undefined>;
}
export const listEnterpriseRef: ListEnterpriseRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listEnterprise(dc: DataConnect): QueryPromise<ListEnterpriseData, undefined>;

interface ListEnterpriseRef {
  ...
  (dc: DataConnect): QueryRef<ListEnterpriseData, undefined>;
}
export const listEnterpriseRef: ListEnterpriseRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listEnterpriseRef:
```typescript
const name = listEnterpriseRef.operationName;
console.log(name);
```

### Variables
The `listEnterprise` query has no variables.
### Return Type
Recall that executing the `listEnterprise` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListEnterpriseData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListEnterpriseData {
  enterprises: ({
    id: UUIDString;
    enterpriseNumber: string;
    enterpriseName: string;
    enterpriseCode: string;
  } & Enterprise_Key)[];
}
```
### Using `listEnterprise`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listEnterprise } from '@dataconnect/generated';


// Call the `listEnterprise()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listEnterprise();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listEnterprise(dataConnect);

console.log(data.enterprises);

// Or, you can use the `Promise` API.
listEnterprise().then((response) => {
  const data = response.data;
  console.log(data.enterprises);
});
```

### Using `listEnterprise`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listEnterpriseRef } from '@dataconnect/generated';


// Call the `listEnterpriseRef()` function to get a reference to the query.
const ref = listEnterpriseRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listEnterpriseRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.enterprises);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.enterprises);
});
```

## getEnterpriseById
You can execute the `getEnterpriseById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getEnterpriseById(vars: GetEnterpriseByIdVariables): QueryPromise<GetEnterpriseByIdData, GetEnterpriseByIdVariables>;

interface GetEnterpriseByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetEnterpriseByIdVariables): QueryRef<GetEnterpriseByIdData, GetEnterpriseByIdVariables>;
}
export const getEnterpriseByIdRef: GetEnterpriseByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getEnterpriseById(dc: DataConnect, vars: GetEnterpriseByIdVariables): QueryPromise<GetEnterpriseByIdData, GetEnterpriseByIdVariables>;

interface GetEnterpriseByIdRef {
  ...
  (dc: DataConnect, vars: GetEnterpriseByIdVariables): QueryRef<GetEnterpriseByIdData, GetEnterpriseByIdVariables>;
}
export const getEnterpriseByIdRef: GetEnterpriseByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getEnterpriseByIdRef:
```typescript
const name = getEnterpriseByIdRef.operationName;
console.log(name);
```

### Variables
The `getEnterpriseById` query requires an argument of type `GetEnterpriseByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetEnterpriseByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getEnterpriseById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetEnterpriseByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetEnterpriseByIdData {
  enterprise?: {
    id: UUIDString;
    enterpriseNumber: string;
    enterpriseName: string;
    enterpriseCode: string;
  } & Enterprise_Key;
}
```
### Using `getEnterpriseById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getEnterpriseById, GetEnterpriseByIdVariables } from '@dataconnect/generated';

// The `getEnterpriseById` query requires an argument of type `GetEnterpriseByIdVariables`:
const getEnterpriseByIdVars: GetEnterpriseByIdVariables = {
  id: ..., 
};

// Call the `getEnterpriseById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getEnterpriseById(getEnterpriseByIdVars);
// Variables can be defined inline as well.
const { data } = await getEnterpriseById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getEnterpriseById(dataConnect, getEnterpriseByIdVars);

console.log(data.enterprise);

// Or, you can use the `Promise` API.
getEnterpriseById(getEnterpriseByIdVars).then((response) => {
  const data = response.data;
  console.log(data.enterprise);
});
```

### Using `getEnterpriseById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getEnterpriseByIdRef, GetEnterpriseByIdVariables } from '@dataconnect/generated';

// The `getEnterpriseById` query requires an argument of type `GetEnterpriseByIdVariables`:
const getEnterpriseByIdVars: GetEnterpriseByIdVariables = {
  id: ..., 
};

// Call the `getEnterpriseByIdRef()` function to get a reference to the query.
const ref = getEnterpriseByIdRef(getEnterpriseByIdVars);
// Variables can be defined inline as well.
const ref = getEnterpriseByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getEnterpriseByIdRef(dataConnect, getEnterpriseByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.enterprise);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.enterprise);
});
```

## filterEnterprise
You can execute the `filterEnterprise` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterEnterprise(vars?: FilterEnterpriseVariables): QueryPromise<FilterEnterpriseData, FilterEnterpriseVariables>;

interface FilterEnterpriseRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterEnterpriseVariables): QueryRef<FilterEnterpriseData, FilterEnterpriseVariables>;
}
export const filterEnterpriseRef: FilterEnterpriseRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterEnterprise(dc: DataConnect, vars?: FilterEnterpriseVariables): QueryPromise<FilterEnterpriseData, FilterEnterpriseVariables>;

interface FilterEnterpriseRef {
  ...
  (dc: DataConnect, vars?: FilterEnterpriseVariables): QueryRef<FilterEnterpriseData, FilterEnterpriseVariables>;
}
export const filterEnterpriseRef: FilterEnterpriseRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterEnterpriseRef:
```typescript
const name = filterEnterpriseRef.operationName;
console.log(name);
```

### Variables
The `filterEnterprise` query has an optional argument of type `FilterEnterpriseVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterEnterpriseVariables {
  enterpriseNumber?: string | null;
  enterpriseName?: string | null;
  enterpriseCode?: string | null;
}
```
### Return Type
Recall that executing the `filterEnterprise` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterEnterpriseData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterEnterpriseData {
  enterprises: ({
    id: UUIDString;
    enterpriseNumber: string;
    enterpriseName: string;
    enterpriseCode: string;
  } & Enterprise_Key)[];
}
```
### Using `filterEnterprise`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterEnterprise, FilterEnterpriseVariables } from '@dataconnect/generated';

// The `filterEnterprise` query has an optional argument of type `FilterEnterpriseVariables`:
const filterEnterpriseVars: FilterEnterpriseVariables = {
  enterpriseNumber: ..., // optional
  enterpriseName: ..., // optional
  enterpriseCode: ..., // optional
};

// Call the `filterEnterprise()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterEnterprise(filterEnterpriseVars);
// Variables can be defined inline as well.
const { data } = await filterEnterprise({ enterpriseNumber: ..., enterpriseName: ..., enterpriseCode: ..., });
// Since all variables are optional for this query, you can omit the `FilterEnterpriseVariables` argument.
const { data } = await filterEnterprise();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterEnterprise(dataConnect, filterEnterpriseVars);

console.log(data.enterprises);

// Or, you can use the `Promise` API.
filterEnterprise(filterEnterpriseVars).then((response) => {
  const data = response.data;
  console.log(data.enterprises);
});
```

### Using `filterEnterprise`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterEnterpriseRef, FilterEnterpriseVariables } from '@dataconnect/generated';

// The `filterEnterprise` query has an optional argument of type `FilterEnterpriseVariables`:
const filterEnterpriseVars: FilterEnterpriseVariables = {
  enterpriseNumber: ..., // optional
  enterpriseName: ..., // optional
  enterpriseCode: ..., // optional
};

// Call the `filterEnterpriseRef()` function to get a reference to the query.
const ref = filterEnterpriseRef(filterEnterpriseVars);
// Variables can be defined inline as well.
const ref = filterEnterpriseRef({ enterpriseNumber: ..., enterpriseName: ..., enterpriseCode: ..., });
// Since all variables are optional for this query, you can omit the `FilterEnterpriseVariables` argument.
const ref = filterEnterpriseRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterEnterpriseRef(dataConnect, filterEnterpriseVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.enterprises);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.enterprises);
});
```

## listInvoice
You can execute the `listInvoice` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listInvoice(): QueryPromise<ListInvoiceData, undefined>;

interface ListInvoiceRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListInvoiceData, undefined>;
}
export const listInvoiceRef: ListInvoiceRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listInvoice(dc: DataConnect): QueryPromise<ListInvoiceData, undefined>;

interface ListInvoiceRef {
  ...
  (dc: DataConnect): QueryRef<ListInvoiceData, undefined>;
}
export const listInvoiceRef: ListInvoiceRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listInvoiceRef:
```typescript
const name = listInvoiceRef.operationName;
console.log(name);
```

### Variables
The `listInvoice` query has no variables.
### Return Type
Recall that executing the `listInvoice` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListInvoiceData {
  invoices: ({
    id: UUIDString;
    invoiceNumber: string;
    amount: number;
    status: InvoiceStatus;
    issueDate: TimestampString;
    dueDate: TimestampString;
    disputedItems?: string | null;
    isAutoGenerated?: boolean | null;
  } & Invoice_Key)[];
}
```
### Using `listInvoice`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listInvoice } from '@dataconnect/generated';


// Call the `listInvoice()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listInvoice();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listInvoice(dataConnect);

console.log(data.invoices);

// Or, you can use the `Promise` API.
listInvoice().then((response) => {
  const data = response.data;
  console.log(data.invoices);
});
```

### Using `listInvoice`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listInvoiceRef } from '@dataconnect/generated';


// Call the `listInvoiceRef()` function to get a reference to the query.
const ref = listInvoiceRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listInvoiceRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.invoices);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.invoices);
});
```

## getInvoiceById
You can execute the `getInvoiceById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getInvoiceById(vars: GetInvoiceByIdVariables): QueryPromise<GetInvoiceByIdData, GetInvoiceByIdVariables>;

interface GetInvoiceByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetInvoiceByIdVariables): QueryRef<GetInvoiceByIdData, GetInvoiceByIdVariables>;
}
export const getInvoiceByIdRef: GetInvoiceByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getInvoiceById(dc: DataConnect, vars: GetInvoiceByIdVariables): QueryPromise<GetInvoiceByIdData, GetInvoiceByIdVariables>;

interface GetInvoiceByIdRef {
  ...
  (dc: DataConnect, vars: GetInvoiceByIdVariables): QueryRef<GetInvoiceByIdData, GetInvoiceByIdVariables>;
}
export const getInvoiceByIdRef: GetInvoiceByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getInvoiceByIdRef:
```typescript
const name = getInvoiceByIdRef.operationName;
console.log(name);
```

### Variables
The `getInvoiceById` query requires an argument of type `GetInvoiceByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetInvoiceByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getInvoiceById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetInvoiceByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetInvoiceByIdData {
  invoice?: {
    id: UUIDString;
    invoiceNumber: string;
    amount: number;
    status: InvoiceStatus;
    issueDate: TimestampString;
    dueDate: TimestampString;
    disputedItems?: string | null;
    isAutoGenerated?: boolean | null;
  } & Invoice_Key;
}
```
### Using `getInvoiceById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getInvoiceById, GetInvoiceByIdVariables } from '@dataconnect/generated';

// The `getInvoiceById` query requires an argument of type `GetInvoiceByIdVariables`:
const getInvoiceByIdVars: GetInvoiceByIdVariables = {
  id: ..., 
};

// Call the `getInvoiceById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getInvoiceById(getInvoiceByIdVars);
// Variables can be defined inline as well.
const { data } = await getInvoiceById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getInvoiceById(dataConnect, getInvoiceByIdVars);

console.log(data.invoice);

// Or, you can use the `Promise` API.
getInvoiceById(getInvoiceByIdVars).then((response) => {
  const data = response.data;
  console.log(data.invoice);
});
```

### Using `getInvoiceById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getInvoiceByIdRef, GetInvoiceByIdVariables } from '@dataconnect/generated';

// The `getInvoiceById` query requires an argument of type `GetInvoiceByIdVariables`:
const getInvoiceByIdVars: GetInvoiceByIdVariables = {
  id: ..., 
};

// Call the `getInvoiceByIdRef()` function to get a reference to the query.
const ref = getInvoiceByIdRef(getInvoiceByIdVars);
// Variables can be defined inline as well.
const ref = getInvoiceByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getInvoiceByIdRef(dataConnect, getInvoiceByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.invoice);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.invoice);
});
```

## filterInvoices
You can execute the `filterInvoices` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterInvoices(vars?: FilterInvoicesVariables): QueryPromise<FilterInvoicesData, FilterInvoicesVariables>;

interface FilterInvoicesRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterInvoicesVariables): QueryRef<FilterInvoicesData, FilterInvoicesVariables>;
}
export const filterInvoicesRef: FilterInvoicesRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterInvoices(dc: DataConnect, vars?: FilterInvoicesVariables): QueryPromise<FilterInvoicesData, FilterInvoicesVariables>;

interface FilterInvoicesRef {
  ...
  (dc: DataConnect, vars?: FilterInvoicesVariables): QueryRef<FilterInvoicesData, FilterInvoicesVariables>;
}
export const filterInvoicesRef: FilterInvoicesRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterInvoicesRef:
```typescript
const name = filterInvoicesRef.operationName;
console.log(name);
```

### Variables
The `filterInvoices` query has an optional argument of type `FilterInvoicesVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterInvoicesVariables {
  invoiceNumber?: string | null;
  status?: InvoiceStatus | null;
  isAutoGenerated?: boolean | null;
  amount?: number | null;
}
```
### Return Type
Recall that executing the `filterInvoices` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterInvoicesData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterInvoicesData {
  invoices: ({
    id: UUIDString;
    invoiceNumber: string;
    amount: number;
    status: InvoiceStatus;
    issueDate: TimestampString;
    dueDate: TimestampString;
    isAutoGenerated?: boolean | null;
  } & Invoice_Key)[];
}
```
### Using `filterInvoices`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterInvoices, FilterInvoicesVariables } from '@dataconnect/generated';

// The `filterInvoices` query has an optional argument of type `FilterInvoicesVariables`:
const filterInvoicesVars: FilterInvoicesVariables = {
  invoiceNumber: ..., // optional
  status: ..., // optional
  isAutoGenerated: ..., // optional
  amount: ..., // optional
};

// Call the `filterInvoices()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterInvoices(filterInvoicesVars);
// Variables can be defined inline as well.
const { data } = await filterInvoices({ invoiceNumber: ..., status: ..., isAutoGenerated: ..., amount: ..., });
// Since all variables are optional for this query, you can omit the `FilterInvoicesVariables` argument.
const { data } = await filterInvoices();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterInvoices(dataConnect, filterInvoicesVars);

console.log(data.invoices);

// Or, you can use the `Promise` API.
filterInvoices(filterInvoicesVars).then((response) => {
  const data = response.data;
  console.log(data.invoices);
});
```

### Using `filterInvoices`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterInvoicesRef, FilterInvoicesVariables } from '@dataconnect/generated';

// The `filterInvoices` query has an optional argument of type `FilterInvoicesVariables`:
const filterInvoicesVars: FilterInvoicesVariables = {
  invoiceNumber: ..., // optional
  status: ..., // optional
  isAutoGenerated: ..., // optional
  amount: ..., // optional
};

// Call the `filterInvoicesRef()` function to get a reference to the query.
const ref = filterInvoicesRef(filterInvoicesVars);
// Variables can be defined inline as well.
const ref = filterInvoicesRef({ invoiceNumber: ..., status: ..., isAutoGenerated: ..., amount: ..., });
// Since all variables are optional for this query, you can omit the `FilterInvoicesVariables` argument.
const ref = filterInvoicesRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterInvoicesRef(dataConnect, filterInvoicesVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.invoices);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.invoices);
});
```

## listTeamMember
You can execute the `listTeamMember` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listTeamMember(): QueryPromise<ListTeamMemberData, undefined>;

interface ListTeamMemberRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListTeamMemberData, undefined>;
}
export const listTeamMemberRef: ListTeamMemberRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listTeamMember(dc: DataConnect): QueryPromise<ListTeamMemberData, undefined>;

interface ListTeamMemberRef {
  ...
  (dc: DataConnect): QueryRef<ListTeamMemberData, undefined>;
}
export const listTeamMemberRef: ListTeamMemberRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listTeamMemberRef:
```typescript
const name = listTeamMemberRef.operationName;
console.log(name);
```

### Variables
The `listTeamMember` query has no variables.
### Return Type
Recall that executing the `listTeamMember` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListTeamMemberData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListTeamMemberData {
  teamMembers: ({
    id: UUIDString;
    teamId: UUIDString;
    memberName: string;
    email: string;
    role?: TeamMemberRole | null;
    isActive?: boolean | null;
  } & TeamMember_Key)[];
}
```
### Using `listTeamMember`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listTeamMember } from '@dataconnect/generated';


// Call the `listTeamMember()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listTeamMember();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listTeamMember(dataConnect);

console.log(data.teamMembers);

// Or, you can use the `Promise` API.
listTeamMember().then((response) => {
  const data = response.data;
  console.log(data.teamMembers);
});
```

### Using `listTeamMember`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listTeamMemberRef } from '@dataconnect/generated';


// Call the `listTeamMemberRef()` function to get a reference to the query.
const ref = listTeamMemberRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listTeamMemberRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.teamMembers);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.teamMembers);
});
```

## getTeamMemberById
You can execute the `getTeamMemberById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getTeamMemberById(vars: GetTeamMemberByIdVariables): QueryPromise<GetTeamMemberByIdData, GetTeamMemberByIdVariables>;

interface GetTeamMemberByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetTeamMemberByIdVariables): QueryRef<GetTeamMemberByIdData, GetTeamMemberByIdVariables>;
}
export const getTeamMemberByIdRef: GetTeamMemberByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getTeamMemberById(dc: DataConnect, vars: GetTeamMemberByIdVariables): QueryPromise<GetTeamMemberByIdData, GetTeamMemberByIdVariables>;

interface GetTeamMemberByIdRef {
  ...
  (dc: DataConnect, vars: GetTeamMemberByIdVariables): QueryRef<GetTeamMemberByIdData, GetTeamMemberByIdVariables>;
}
export const getTeamMemberByIdRef: GetTeamMemberByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getTeamMemberByIdRef:
```typescript
const name = getTeamMemberByIdRef.operationName;
console.log(name);
```

### Variables
The `getTeamMemberById` query requires an argument of type `GetTeamMemberByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetTeamMemberByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getTeamMemberById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetTeamMemberByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetTeamMemberByIdData {
  teamMember?: {
    id: UUIDString;
    teamId: UUIDString;
    memberName: string;
    email: string;
    role?: TeamMemberRole | null;
    isActive?: boolean | null;
  } & TeamMember_Key;
}
```
### Using `getTeamMemberById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getTeamMemberById, GetTeamMemberByIdVariables } from '@dataconnect/generated';

// The `getTeamMemberById` query requires an argument of type `GetTeamMemberByIdVariables`:
const getTeamMemberByIdVars: GetTeamMemberByIdVariables = {
  id: ..., 
};

// Call the `getTeamMemberById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getTeamMemberById(getTeamMemberByIdVars);
// Variables can be defined inline as well.
const { data } = await getTeamMemberById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getTeamMemberById(dataConnect, getTeamMemberByIdVars);

console.log(data.teamMember);

// Or, you can use the `Promise` API.
getTeamMemberById(getTeamMemberByIdVars).then((response) => {
  const data = response.data;
  console.log(data.teamMember);
});
```

### Using `getTeamMemberById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getTeamMemberByIdRef, GetTeamMemberByIdVariables } from '@dataconnect/generated';

// The `getTeamMemberById` query requires an argument of type `GetTeamMemberByIdVariables`:
const getTeamMemberByIdVars: GetTeamMemberByIdVariables = {
  id: ..., 
};

// Call the `getTeamMemberByIdRef()` function to get a reference to the query.
const ref = getTeamMemberByIdRef(getTeamMemberByIdVars);
// Variables can be defined inline as well.
const ref = getTeamMemberByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getTeamMemberByIdRef(dataConnect, getTeamMemberByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.teamMember);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.teamMember);
});
```

## filterTeamMember
You can execute the `filterTeamMember` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterTeamMember(vars?: FilterTeamMemberVariables): QueryPromise<FilterTeamMemberData, FilterTeamMemberVariables>;

interface FilterTeamMemberRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterTeamMemberVariables): QueryRef<FilterTeamMemberData, FilterTeamMemberVariables>;
}
export const filterTeamMemberRef: FilterTeamMemberRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterTeamMember(dc: DataConnect, vars?: FilterTeamMemberVariables): QueryPromise<FilterTeamMemberData, FilterTeamMemberVariables>;

interface FilterTeamMemberRef {
  ...
  (dc: DataConnect, vars?: FilterTeamMemberVariables): QueryRef<FilterTeamMemberData, FilterTeamMemberVariables>;
}
export const filterTeamMemberRef: FilterTeamMemberRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterTeamMemberRef:
```typescript
const name = filterTeamMemberRef.operationName;
console.log(name);
```

### Variables
The `filterTeamMember` query has an optional argument of type `FilterTeamMemberVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterTeamMemberVariables {
  teamId?: UUIDString | null;
  memberName?: string | null;
  email?: string | null;
  role?: TeamMemberRole | null;
  isActive?: boolean | null;
}
```
### Return Type
Recall that executing the `filterTeamMember` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterTeamMemberData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterTeamMemberData {
  teamMembers: ({
    id: UUIDString;
    teamId: UUIDString;
    memberName: string;
    email: string;
    role?: TeamMemberRole | null;
    isActive?: boolean | null;
  } & TeamMember_Key)[];
}
```
### Using `filterTeamMember`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterTeamMember, FilterTeamMemberVariables } from '@dataconnect/generated';

// The `filterTeamMember` query has an optional argument of type `FilterTeamMemberVariables`:
const filterTeamMemberVars: FilterTeamMemberVariables = {
  teamId: ..., // optional
  memberName: ..., // optional
  email: ..., // optional
  role: ..., // optional
  isActive: ..., // optional
};

// Call the `filterTeamMember()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterTeamMember(filterTeamMemberVars);
// Variables can be defined inline as well.
const { data } = await filterTeamMember({ teamId: ..., memberName: ..., email: ..., role: ..., isActive: ..., });
// Since all variables are optional for this query, you can omit the `FilterTeamMemberVariables` argument.
const { data } = await filterTeamMember();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterTeamMember(dataConnect, filterTeamMemberVars);

console.log(data.teamMembers);

// Or, you can use the `Promise` API.
filterTeamMember(filterTeamMemberVars).then((response) => {
  const data = response.data;
  console.log(data.teamMembers);
});
```

### Using `filterTeamMember`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterTeamMemberRef, FilterTeamMemberVariables } from '@dataconnect/generated';

// The `filterTeamMember` query has an optional argument of type `FilterTeamMemberVariables`:
const filterTeamMemberVars: FilterTeamMemberVariables = {
  teamId: ..., // optional
  memberName: ..., // optional
  email: ..., // optional
  role: ..., // optional
  isActive: ..., // optional
};

// Call the `filterTeamMemberRef()` function to get a reference to the query.
const ref = filterTeamMemberRef(filterTeamMemberVars);
// Variables can be defined inline as well.
const ref = filterTeamMemberRef({ teamId: ..., memberName: ..., email: ..., role: ..., isActive: ..., });
// Since all variables are optional for this query, you can omit the `FilterTeamMemberVariables` argument.
const ref = filterTeamMemberRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterTeamMemberRef(dataConnect, filterTeamMemberVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.teamMembers);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.teamMembers);
});
```

## listUsers
You can execute the `listUsers` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listUsers(): QueryPromise<ListUsersData, undefined>;

interface ListUsersRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListUsersData, undefined>;
}
export const listUsersRef: ListUsersRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listUsers(dc: DataConnect): QueryPromise<ListUsersData, undefined>;

interface ListUsersRef {
  ...
  (dc: DataConnect): QueryRef<ListUsersData, undefined>;
}
export const listUsersRef: ListUsersRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listUsersRef:
```typescript
const name = listUsersRef.operationName;
console.log(name);
```

### Variables
The `listUsers` query has no variables.
### Return Type
Recall that executing the `listUsers` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListUsersData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListUsersData {
  users: ({
    id: string;
    email: string;
    fullName: string;
    role: UserBaseRole;
    userRole?: string | null;
    createdDate?: TimestampString | null;
    updatedDate?: TimestampString | null;
  } & User_Key)[];
}
```
### Using `listUsers`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listUsers } from '@dataconnect/generated';


// Call the `listUsers()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listUsers();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listUsers(dataConnect);

console.log(data.users);

// Or, you can use the `Promise` API.
listUsers().then((response) => {
  const data = response.data;
  console.log(data.users);
});
```

### Using `listUsers`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listUsersRef } from '@dataconnect/generated';


// Call the `listUsersRef()` function to get a reference to the query.
const ref = listUsersRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listUsersRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.users);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.users);
});
```

## getUserById
You can execute the `getUserById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getUserById(vars: GetUserByIdVariables): QueryPromise<GetUserByIdData, GetUserByIdVariables>;

interface GetUserByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetUserByIdVariables): QueryRef<GetUserByIdData, GetUserByIdVariables>;
}
export const getUserByIdRef: GetUserByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getUserById(dc: DataConnect, vars: GetUserByIdVariables): QueryPromise<GetUserByIdData, GetUserByIdVariables>;

interface GetUserByIdRef {
  ...
  (dc: DataConnect, vars: GetUserByIdVariables): QueryRef<GetUserByIdData, GetUserByIdVariables>;
}
export const getUserByIdRef: GetUserByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getUserByIdRef:
```typescript
const name = getUserByIdRef.operationName;
console.log(name);
```

### Variables
The `getUserById` query requires an argument of type `GetUserByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetUserByIdVariables {
  id: string;
}
```
### Return Type
Recall that executing the `getUserById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetUserByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetUserByIdData {
  user?: {
    id: string;
    email: string;
    fullName: string;
    role: UserBaseRole;
    userRole?: string | null;
  } & User_Key;
}
```
### Using `getUserById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getUserById, GetUserByIdVariables } from '@dataconnect/generated';

// The `getUserById` query requires an argument of type `GetUserByIdVariables`:
const getUserByIdVars: GetUserByIdVariables = {
  id: ..., 
};

// Call the `getUserById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getUserById(getUserByIdVars);
// Variables can be defined inline as well.
const { data } = await getUserById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getUserById(dataConnect, getUserByIdVars);

console.log(data.user);

// Or, you can use the `Promise` API.
getUserById(getUserByIdVars).then((response) => {
  const data = response.data;
  console.log(data.user);
});
```

### Using `getUserById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getUserByIdRef, GetUserByIdVariables } from '@dataconnect/generated';

// The `getUserById` query requires an argument of type `GetUserByIdVariables`:
const getUserByIdVars: GetUserByIdVariables = {
  id: ..., 
};

// Call the `getUserByIdRef()` function to get a reference to the query.
const ref = getUserByIdRef(getUserByIdVars);
// Variables can be defined inline as well.
const ref = getUserByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getUserByIdRef(dataConnect, getUserByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.user);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.user);
});
```

## filterUsers
You can execute the `filterUsers` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterUsers(vars?: FilterUsersVariables): QueryPromise<FilterUsersData, FilterUsersVariables>;

interface FilterUsersRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterUsersVariables): QueryRef<FilterUsersData, FilterUsersVariables>;
}
export const filterUsersRef: FilterUsersRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterUsers(dc: DataConnect, vars?: FilterUsersVariables): QueryPromise<FilterUsersData, FilterUsersVariables>;

interface FilterUsersRef {
  ...
  (dc: DataConnect, vars?: FilterUsersVariables): QueryRef<FilterUsersData, FilterUsersVariables>;
}
export const filterUsersRef: FilterUsersRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterUsersRef:
```typescript
const name = filterUsersRef.operationName;
console.log(name);
```

### Variables
The `filterUsers` query has an optional argument of type `FilterUsersVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterUsersVariables {
  id?: string | null;
  email?: string | null;
  role?: UserBaseRole | null;
  userRole?: string | null;
}
```
### Return Type
Recall that executing the `filterUsers` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterUsersData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterUsersData {
  users: ({
    id: string;
    email: string;
    fullName: string;
    role: UserBaseRole;
    userRole?: string | null;
  } & User_Key)[];
}
```
### Using `filterUsers`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterUsers, FilterUsersVariables } from '@dataconnect/generated';

// The `filterUsers` query has an optional argument of type `FilterUsersVariables`:
const filterUsersVars: FilterUsersVariables = {
  id: ..., // optional
  email: ..., // optional
  role: ..., // optional
  userRole: ..., // optional
};

// Call the `filterUsers()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterUsers(filterUsersVars);
// Variables can be defined inline as well.
const { data } = await filterUsers({ id: ..., email: ..., role: ..., userRole: ..., });
// Since all variables are optional for this query, you can omit the `FilterUsersVariables` argument.
const { data } = await filterUsers();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterUsers(dataConnect, filterUsersVars);

console.log(data.users);

// Or, you can use the `Promise` API.
filterUsers(filterUsersVars).then((response) => {
  const data = response.data;
  console.log(data.users);
});
```

### Using `filterUsers`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterUsersRef, FilterUsersVariables } from '@dataconnect/generated';

// The `filterUsers` query has an optional argument of type `FilterUsersVariables`:
const filterUsersVars: FilterUsersVariables = {
  id: ..., // optional
  email: ..., // optional
  role: ..., // optional
  userRole: ..., // optional
};

// Call the `filterUsersRef()` function to get a reference to the query.
const ref = filterUsersRef(filterUsersVars);
// Variables can be defined inline as well.
const ref = filterUsersRef({ id: ..., email: ..., role: ..., userRole: ..., });
// Since all variables are optional for this query, you can omit the `FilterUsersVariables` argument.
const ref = filterUsersRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterUsersRef(dataConnect, filterUsersVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.users);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.users);
});
```

## listVendorDefaultSettings
You can execute the `listVendorDefaultSettings` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listVendorDefaultSettings(): QueryPromise<ListVendorDefaultSettingsData, undefined>;

interface ListVendorDefaultSettingsRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListVendorDefaultSettingsData, undefined>;
}
export const listVendorDefaultSettingsRef: ListVendorDefaultSettingsRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listVendorDefaultSettings(dc: DataConnect): QueryPromise<ListVendorDefaultSettingsData, undefined>;

interface ListVendorDefaultSettingsRef {
  ...
  (dc: DataConnect): QueryRef<ListVendorDefaultSettingsData, undefined>;
}
export const listVendorDefaultSettingsRef: ListVendorDefaultSettingsRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listVendorDefaultSettingsRef:
```typescript
const name = listVendorDefaultSettingsRef.operationName;
console.log(name);
```

### Variables
The `listVendorDefaultSettings` query has no variables.
### Return Type
Recall that executing the `listVendorDefaultSettings` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListVendorDefaultSettingsData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListVendorDefaultSettingsData {
  vendorDefaultSettings: ({
    id: UUIDString;
    vendorName: string;
    defaultMarkupPercentage: number;
    defaultVendorFeePercentage: number;
  } & VendorDefaultSetting_Key)[];
}
```
### Using `listVendorDefaultSettings`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listVendorDefaultSettings } from '@dataconnect/generated';


// Call the `listVendorDefaultSettings()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listVendorDefaultSettings();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listVendorDefaultSettings(dataConnect);

console.log(data.vendorDefaultSettings);

// Or, you can use the `Promise` API.
listVendorDefaultSettings().then((response) => {
  const data = response.data;
  console.log(data.vendorDefaultSettings);
});
```

### Using `listVendorDefaultSettings`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listVendorDefaultSettingsRef } from '@dataconnect/generated';


// Call the `listVendorDefaultSettingsRef()` function to get a reference to the query.
const ref = listVendorDefaultSettingsRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listVendorDefaultSettingsRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.vendorDefaultSettings);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.vendorDefaultSettings);
});
```

## getVendorDefaultSettingById
You can execute the `getVendorDefaultSettingById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getVendorDefaultSettingById(vars: GetVendorDefaultSettingByIdVariables): QueryPromise<GetVendorDefaultSettingByIdData, GetVendorDefaultSettingByIdVariables>;

interface GetVendorDefaultSettingByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetVendorDefaultSettingByIdVariables): QueryRef<GetVendorDefaultSettingByIdData, GetVendorDefaultSettingByIdVariables>;
}
export const getVendorDefaultSettingByIdRef: GetVendorDefaultSettingByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getVendorDefaultSettingById(dc: DataConnect, vars: GetVendorDefaultSettingByIdVariables): QueryPromise<GetVendorDefaultSettingByIdData, GetVendorDefaultSettingByIdVariables>;

interface GetVendorDefaultSettingByIdRef {
  ...
  (dc: DataConnect, vars: GetVendorDefaultSettingByIdVariables): QueryRef<GetVendorDefaultSettingByIdData, GetVendorDefaultSettingByIdVariables>;
}
export const getVendorDefaultSettingByIdRef: GetVendorDefaultSettingByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getVendorDefaultSettingByIdRef:
```typescript
const name = getVendorDefaultSettingByIdRef.operationName;
console.log(name);
```

### Variables
The `getVendorDefaultSettingById` query requires an argument of type `GetVendorDefaultSettingByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetVendorDefaultSettingByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getVendorDefaultSettingById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetVendorDefaultSettingByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetVendorDefaultSettingByIdData {
  vendorDefaultSetting?: {
    id: UUIDString;
    vendorName: string;
    defaultMarkupPercentage: number;
    defaultVendorFeePercentage: number;
  } & VendorDefaultSetting_Key;
}
```
### Using `getVendorDefaultSettingById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getVendorDefaultSettingById, GetVendorDefaultSettingByIdVariables } from '@dataconnect/generated';

// The `getVendorDefaultSettingById` query requires an argument of type `GetVendorDefaultSettingByIdVariables`:
const getVendorDefaultSettingByIdVars: GetVendorDefaultSettingByIdVariables = {
  id: ..., 
};

// Call the `getVendorDefaultSettingById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getVendorDefaultSettingById(getVendorDefaultSettingByIdVars);
// Variables can be defined inline as well.
const { data } = await getVendorDefaultSettingById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getVendorDefaultSettingById(dataConnect, getVendorDefaultSettingByIdVars);

console.log(data.vendorDefaultSetting);

// Or, you can use the `Promise` API.
getVendorDefaultSettingById(getVendorDefaultSettingByIdVars).then((response) => {
  const data = response.data;
  console.log(data.vendorDefaultSetting);
});
```

### Using `getVendorDefaultSettingById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getVendorDefaultSettingByIdRef, GetVendorDefaultSettingByIdVariables } from '@dataconnect/generated';

// The `getVendorDefaultSettingById` query requires an argument of type `GetVendorDefaultSettingByIdVariables`:
const getVendorDefaultSettingByIdVars: GetVendorDefaultSettingByIdVariables = {
  id: ..., 
};

// Call the `getVendorDefaultSettingByIdRef()` function to get a reference to the query.
const ref = getVendorDefaultSettingByIdRef(getVendorDefaultSettingByIdVars);
// Variables can be defined inline as well.
const ref = getVendorDefaultSettingByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getVendorDefaultSettingByIdRef(dataConnect, getVendorDefaultSettingByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.vendorDefaultSetting);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.vendorDefaultSetting);
});
```

## filterVendorDefaultSettings
You can execute the `filterVendorDefaultSettings` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterVendorDefaultSettings(vars?: FilterVendorDefaultSettingsVariables): QueryPromise<FilterVendorDefaultSettingsData, FilterVendorDefaultSettingsVariables>;

interface FilterVendorDefaultSettingsRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterVendorDefaultSettingsVariables): QueryRef<FilterVendorDefaultSettingsData, FilterVendorDefaultSettingsVariables>;
}
export const filterVendorDefaultSettingsRef: FilterVendorDefaultSettingsRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterVendorDefaultSettings(dc: DataConnect, vars?: FilterVendorDefaultSettingsVariables): QueryPromise<FilterVendorDefaultSettingsData, FilterVendorDefaultSettingsVariables>;

interface FilterVendorDefaultSettingsRef {
  ...
  (dc: DataConnect, vars?: FilterVendorDefaultSettingsVariables): QueryRef<FilterVendorDefaultSettingsData, FilterVendorDefaultSettingsVariables>;
}
export const filterVendorDefaultSettingsRef: FilterVendorDefaultSettingsRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterVendorDefaultSettingsRef:
```typescript
const name = filterVendorDefaultSettingsRef.operationName;
console.log(name);
```

### Variables
The `filterVendorDefaultSettings` query has an optional argument of type `FilterVendorDefaultSettingsVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterVendorDefaultSettingsVariables {
  vendorName?: string | null;
  defaultMarkupPercentage?: number | null;
  defaultVendorFeePercentage?: number | null;
}
```
### Return Type
Recall that executing the `filterVendorDefaultSettings` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterVendorDefaultSettingsData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterVendorDefaultSettingsData {
  vendorDefaultSettings: ({
    id: UUIDString;
    vendorName: string;
    defaultMarkupPercentage: number;
    defaultVendorFeePercentage: number;
  } & VendorDefaultSetting_Key)[];
}
```
### Using `filterVendorDefaultSettings`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterVendorDefaultSettings, FilterVendorDefaultSettingsVariables } from '@dataconnect/generated';

// The `filterVendorDefaultSettings` query has an optional argument of type `FilterVendorDefaultSettingsVariables`:
const filterVendorDefaultSettingsVars: FilterVendorDefaultSettingsVariables = {
  vendorName: ..., // optional
  defaultMarkupPercentage: ..., // optional
  defaultVendorFeePercentage: ..., // optional
};

// Call the `filterVendorDefaultSettings()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterVendorDefaultSettings(filterVendorDefaultSettingsVars);
// Variables can be defined inline as well.
const { data } = await filterVendorDefaultSettings({ vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., });
// Since all variables are optional for this query, you can omit the `FilterVendorDefaultSettingsVariables` argument.
const { data } = await filterVendorDefaultSettings();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterVendorDefaultSettings(dataConnect, filterVendorDefaultSettingsVars);

console.log(data.vendorDefaultSettings);

// Or, you can use the `Promise` API.
filterVendorDefaultSettings(filterVendorDefaultSettingsVars).then((response) => {
  const data = response.data;
  console.log(data.vendorDefaultSettings);
});
```

### Using `filterVendorDefaultSettings`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterVendorDefaultSettingsRef, FilterVendorDefaultSettingsVariables } from '@dataconnect/generated';

// The `filterVendorDefaultSettings` query has an optional argument of type `FilterVendorDefaultSettingsVariables`:
const filterVendorDefaultSettingsVars: FilterVendorDefaultSettingsVariables = {
  vendorName: ..., // optional
  defaultMarkupPercentage: ..., // optional
  defaultVendorFeePercentage: ..., // optional
};

// Call the `filterVendorDefaultSettingsRef()` function to get a reference to the query.
const ref = filterVendorDefaultSettingsRef(filterVendorDefaultSettingsVars);
// Variables can be defined inline as well.
const ref = filterVendorDefaultSettingsRef({ vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., });
// Since all variables are optional for this query, you can omit the `FilterVendorDefaultSettingsVariables` argument.
const ref = filterVendorDefaultSettingsRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterVendorDefaultSettingsRef(dataConnect, filterVendorDefaultSettingsVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.vendorDefaultSettings);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.vendorDefaultSettings);
});
```

## listAssignment
You can execute the `listAssignment` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listAssignment(): QueryPromise<ListAssignmentData, undefined>;

interface ListAssignmentRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListAssignmentData, undefined>;
}
export const listAssignmentRef: ListAssignmentRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listAssignment(dc: DataConnect): QueryPromise<ListAssignmentData, undefined>;

interface ListAssignmentRef {
  ...
  (dc: DataConnect): QueryRef<ListAssignmentData, undefined>;
}
export const listAssignmentRef: ListAssignmentRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listAssignmentRef:
```typescript
const name = listAssignmentRef.operationName;
console.log(name);
```

### Variables
The `listAssignment` query has no variables.
### Return Type
Recall that executing the `listAssignment` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListAssignmentData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListAssignmentData {
  assignments: ({
    id: UUIDString;
    assignmentNumber?: string | null;
    orderId: UUIDString;
    workforceId: UUIDString;
    vendorId: UUIDString;
    role: string;
    assignmentStatus: AssignmentStatus;
    scheduledStart: TimestampString;
  } & Assignment_Key)[];
}
```
### Using `listAssignment`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listAssignment } from '@dataconnect/generated';


// Call the `listAssignment()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listAssignment();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listAssignment(dataConnect);

console.log(data.assignments);

// Or, you can use the `Promise` API.
listAssignment().then((response) => {
  const data = response.data;
  console.log(data.assignments);
});
```

### Using `listAssignment`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listAssignmentRef } from '@dataconnect/generated';


// Call the `listAssignmentRef()` function to get a reference to the query.
const ref = listAssignmentRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listAssignmentRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.assignments);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.assignments);
});
```

## getAssignmentById
You can execute the `getAssignmentById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getAssignmentById(vars: GetAssignmentByIdVariables): QueryPromise<GetAssignmentByIdData, GetAssignmentByIdVariables>;

interface GetAssignmentByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetAssignmentByIdVariables): QueryRef<GetAssignmentByIdData, GetAssignmentByIdVariables>;
}
export const getAssignmentByIdRef: GetAssignmentByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getAssignmentById(dc: DataConnect, vars: GetAssignmentByIdVariables): QueryPromise<GetAssignmentByIdData, GetAssignmentByIdVariables>;

interface GetAssignmentByIdRef {
  ...
  (dc: DataConnect, vars: GetAssignmentByIdVariables): QueryRef<GetAssignmentByIdData, GetAssignmentByIdVariables>;
}
export const getAssignmentByIdRef: GetAssignmentByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getAssignmentByIdRef:
```typescript
const name = getAssignmentByIdRef.operationName;
console.log(name);
```

### Variables
The `getAssignmentById` query requires an argument of type `GetAssignmentByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetAssignmentByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getAssignmentById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetAssignmentByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetAssignmentByIdData {
  assignment?: {
    id: UUIDString;
    assignmentNumber?: string | null;
    orderId: UUIDString;
    workforceId: UUIDString;
    vendorId: UUIDString;
    role: string;
    assignmentStatus: AssignmentStatus;
    scheduledStart: TimestampString;
  } & Assignment_Key;
}
```
### Using `getAssignmentById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getAssignmentById, GetAssignmentByIdVariables } from '@dataconnect/generated';

// The `getAssignmentById` query requires an argument of type `GetAssignmentByIdVariables`:
const getAssignmentByIdVars: GetAssignmentByIdVariables = {
  id: ..., 
};

// Call the `getAssignmentById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getAssignmentById(getAssignmentByIdVars);
// Variables can be defined inline as well.
const { data } = await getAssignmentById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getAssignmentById(dataConnect, getAssignmentByIdVars);

console.log(data.assignment);

// Or, you can use the `Promise` API.
getAssignmentById(getAssignmentByIdVars).then((response) => {
  const data = response.data;
  console.log(data.assignment);
});
```

### Using `getAssignmentById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getAssignmentByIdRef, GetAssignmentByIdVariables } from '@dataconnect/generated';

// The `getAssignmentById` query requires an argument of type `GetAssignmentByIdVariables`:
const getAssignmentByIdVars: GetAssignmentByIdVariables = {
  id: ..., 
};

// Call the `getAssignmentByIdRef()` function to get a reference to the query.
const ref = getAssignmentByIdRef(getAssignmentByIdVars);
// Variables can be defined inline as well.
const ref = getAssignmentByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getAssignmentByIdRef(dataConnect, getAssignmentByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.assignment);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.assignment);
});
```

## filterAssignment
You can execute the `filterAssignment` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterAssignment(vars?: FilterAssignmentVariables): QueryPromise<FilterAssignmentData, FilterAssignmentVariables>;

interface FilterAssignmentRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterAssignmentVariables): QueryRef<FilterAssignmentData, FilterAssignmentVariables>;
}
export const filterAssignmentRef: FilterAssignmentRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterAssignment(dc: DataConnect, vars?: FilterAssignmentVariables): QueryPromise<FilterAssignmentData, FilterAssignmentVariables>;

interface FilterAssignmentRef {
  ...
  (dc: DataConnect, vars?: FilterAssignmentVariables): QueryRef<FilterAssignmentData, FilterAssignmentVariables>;
}
export const filterAssignmentRef: FilterAssignmentRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterAssignmentRef:
```typescript
const name = filterAssignmentRef.operationName;
console.log(name);
```

### Variables
The `filterAssignment` query has an optional argument of type `FilterAssignmentVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterAssignmentVariables {
  assignmentNumber?: string | null;
  orderId?: UUIDString | null;
  workforceId?: UUIDString | null;
  vendorId?: UUIDString | null;
  assignmentStatus?: AssignmentStatus | null;
}
```
### Return Type
Recall that executing the `filterAssignment` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterAssignmentData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterAssignmentData {
  assignments: ({
    id: UUIDString;
    assignmentNumber?: string | null;
    orderId: UUIDString;
    workforceId: UUIDString;
    vendorId: UUIDString;
    role: string;
    assignmentStatus: AssignmentStatus;
    scheduledStart: TimestampString;
  } & Assignment_Key)[];
}
```
### Using `filterAssignment`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterAssignment, FilterAssignmentVariables } from '@dataconnect/generated';

// The `filterAssignment` query has an optional argument of type `FilterAssignmentVariables`:
const filterAssignmentVars: FilterAssignmentVariables = {
  assignmentNumber: ..., // optional
  orderId: ..., // optional
  workforceId: ..., // optional
  vendorId: ..., // optional
  assignmentStatus: ..., // optional
};

// Call the `filterAssignment()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterAssignment(filterAssignmentVars);
// Variables can be defined inline as well.
const { data } = await filterAssignment({ assignmentNumber: ..., orderId: ..., workforceId: ..., vendorId: ..., assignmentStatus: ..., });
// Since all variables are optional for this query, you can omit the `FilterAssignmentVariables` argument.
const { data } = await filterAssignment();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterAssignment(dataConnect, filterAssignmentVars);

console.log(data.assignments);

// Or, you can use the `Promise` API.
filterAssignment(filterAssignmentVars).then((response) => {
  const data = response.data;
  console.log(data.assignments);
});
```

### Using `filterAssignment`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterAssignmentRef, FilterAssignmentVariables } from '@dataconnect/generated';

// The `filterAssignment` query has an optional argument of type `FilterAssignmentVariables`:
const filterAssignmentVars: FilterAssignmentVariables = {
  assignmentNumber: ..., // optional
  orderId: ..., // optional
  workforceId: ..., // optional
  vendorId: ..., // optional
  assignmentStatus: ..., // optional
};

// Call the `filterAssignmentRef()` function to get a reference to the query.
const ref = filterAssignmentRef(filterAssignmentVars);
// Variables can be defined inline as well.
const ref = filterAssignmentRef({ assignmentNumber: ..., orderId: ..., workforceId: ..., vendorId: ..., assignmentStatus: ..., });
// Since all variables are optional for this query, you can omit the `FilterAssignmentVariables` argument.
const ref = filterAssignmentRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterAssignmentRef(dataConnect, filterAssignmentVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.assignments);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.assignments);
});
```

## listEvents
You can execute the `listEvents` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listEvents(vars?: ListEventsVariables): QueryPromise<ListEventsData, ListEventsVariables>;

interface ListEventsRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: ListEventsVariables): QueryRef<ListEventsData, ListEventsVariables>;
}
export const listEventsRef: ListEventsRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listEvents(dc: DataConnect, vars?: ListEventsVariables): QueryPromise<ListEventsData, ListEventsVariables>;

interface ListEventsRef {
  ...
  (dc: DataConnect, vars?: ListEventsVariables): QueryRef<ListEventsData, ListEventsVariables>;
}
export const listEventsRef: ListEventsRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listEventsRef:
```typescript
const name = listEventsRef.operationName;
console.log(name);
```

### Variables
The `listEvents` query has an optional argument of type `ListEventsVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface ListEventsVariables {
  orderByDate?: OrderDirection | null;
  orderByCreatedDate?: OrderDirection | null;
  limit?: number | null;
}
```
### Return Type
Recall that executing the `listEvents` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListEventsData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListEventsData {
  events: ({
    id: UUIDString;
    eventName: string;
    status: EventStatus;
    date: string;
    isRapid?: boolean | null;
    isRecurring?: boolean | null;
    isMultiDay?: boolean | null;
    recurrenceType?: RecurrenceType | null;
    recurrenceStartDate?: TimestampString | null;
    recurrenceEndDate?: TimestampString | null;
    scatterDates?: unknown | null;
    multiDayStartDate?: TimestampString | null;
    multiDayEndDate?: TimestampString | null;
    bufferTimeBefore?: number | null;
    bufferTimeAfter?: number | null;
    conflictDetectionEnabled?: boolean | null;
    detectedConflicts?: unknown | null;
    businessId: UUIDString;
    businessName?: string | null;
    vendorId?: string | null;
    vendorName?: string | null;
    hub?: string | null;
    eventLocation?: string | null;
    contractType?: ContractType | null;
    poReference?: string | null;
    shifts?: unknown | null;
    addons?: unknown | null;
    total?: number | null;
    clientName?: string | null;
    clientEmail?: string | null;
    clientPhone?: string | null;
    invoiceId?: UUIDString | null;
    notes?: string | null;
    requested?: number | null;
    assignedStaff?: unknown | null;
    orderType?: string | null;
    department?: string | null;
    createdBy?: string | null;
    recurringStartDate?: string | null;
    recurringEndDate?: string | null;
    recurringDays?: unknown | null;
    permanentStartDate?: string | null;
    permanentDays?: unknown | null;
    includeBackup?: boolean | null;
    backupStaffCount?: number | null;
    recurringTime?: string | null;
    permanentTime?: string | null;
  } & Event_Key)[];
}
```
### Using `listEvents`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listEvents, ListEventsVariables } from '@dataconnect/generated';

// The `listEvents` query has an optional argument of type `ListEventsVariables`:
const listEventsVars: ListEventsVariables = {
  orderByDate: ..., // optional
  orderByCreatedDate: ..., // optional
  limit: ..., // optional
};

// Call the `listEvents()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listEvents(listEventsVars);
// Variables can be defined inline as well.
const { data } = await listEvents({ orderByDate: ..., orderByCreatedDate: ..., limit: ..., });
// Since all variables are optional for this query, you can omit the `ListEventsVariables` argument.
const { data } = await listEvents();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listEvents(dataConnect, listEventsVars);

console.log(data.events);

// Or, you can use the `Promise` API.
listEvents(listEventsVars).then((response) => {
  const data = response.data;
  console.log(data.events);
});
```

### Using `listEvents`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listEventsRef, ListEventsVariables } from '@dataconnect/generated';

// The `listEvents` query has an optional argument of type `ListEventsVariables`:
const listEventsVars: ListEventsVariables = {
  orderByDate: ..., // optional
  orderByCreatedDate: ..., // optional
  limit: ..., // optional
};

// Call the `listEventsRef()` function to get a reference to the query.
const ref = listEventsRef(listEventsVars);
// Variables can be defined inline as well.
const ref = listEventsRef({ orderByDate: ..., orderByCreatedDate: ..., limit: ..., });
// Since all variables are optional for this query, you can omit the `ListEventsVariables` argument.
const ref = listEventsRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listEventsRef(dataConnect, listEventsVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.events);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.events);
});
```

## getEventById
You can execute the `getEventById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getEventById(vars: GetEventByIdVariables): QueryPromise<GetEventByIdData, GetEventByIdVariables>;

interface GetEventByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetEventByIdVariables): QueryRef<GetEventByIdData, GetEventByIdVariables>;
}
export const getEventByIdRef: GetEventByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getEventById(dc: DataConnect, vars: GetEventByIdVariables): QueryPromise<GetEventByIdData, GetEventByIdVariables>;

interface GetEventByIdRef {
  ...
  (dc: DataConnect, vars: GetEventByIdVariables): QueryRef<GetEventByIdData, GetEventByIdVariables>;
}
export const getEventByIdRef: GetEventByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getEventByIdRef:
```typescript
const name = getEventByIdRef.operationName;
console.log(name);
```

### Variables
The `getEventById` query requires an argument of type `GetEventByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetEventByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getEventById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetEventByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetEventByIdData {
  event?: {
    id: UUIDString;
    eventName: string;
    status: EventStatus;
    date: string;
    isRapid?: boolean | null;
    isRecurring?: boolean | null;
    isMultiDay?: boolean | null;
    recurrenceType?: RecurrenceType | null;
    recurrenceStartDate?: TimestampString | null;
    recurrenceEndDate?: TimestampString | null;
    scatterDates?: unknown | null;
    multiDayStartDate?: TimestampString | null;
    multiDayEndDate?: TimestampString | null;
    bufferTimeBefore?: number | null;
    bufferTimeAfter?: number | null;
    conflictDetectionEnabled?: boolean | null;
    detectedConflicts?: unknown | null;
    businessId: UUIDString;
    businessName?: string | null;
    vendorId?: string | null;
    vendorName?: string | null;
    hub?: string | null;
    eventLocation?: string | null;
    contractType?: ContractType | null;
    poReference?: string | null;
    shifts?: unknown | null;
    addons?: unknown | null;
    total?: number | null;
    clientName?: string | null;
    clientEmail?: string | null;
    clientPhone?: string | null;
    invoiceId?: UUIDString | null;
    notes?: string | null;
    requested?: number | null;
    orderType?: string | null;
    department?: string | null;
    assignedStaff?: unknown | null;
    recurringStartDate?: string | null;
    recurringEndDate?: string | null;
    recurringDays?: unknown | null;
    permanentStartDate?: string | null;
    permanentDays?: unknown | null;
    includeBackup?: boolean | null;
    backupStaffCount?: number | null;
    recurringTime?: string | null;
    permanentTime?: string | null;
  } & Event_Key;
}
```
### Using `getEventById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getEventById, GetEventByIdVariables } from '@dataconnect/generated';

// The `getEventById` query requires an argument of type `GetEventByIdVariables`:
const getEventByIdVars: GetEventByIdVariables = {
  id: ..., 
};

// Call the `getEventById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getEventById(getEventByIdVars);
// Variables can be defined inline as well.
const { data } = await getEventById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getEventById(dataConnect, getEventByIdVars);

console.log(data.event);

// Or, you can use the `Promise` API.
getEventById(getEventByIdVars).then((response) => {
  const data = response.data;
  console.log(data.event);
});
```

### Using `getEventById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getEventByIdRef, GetEventByIdVariables } from '@dataconnect/generated';

// The `getEventById` query requires an argument of type `GetEventByIdVariables`:
const getEventByIdVars: GetEventByIdVariables = {
  id: ..., 
};

// Call the `getEventByIdRef()` function to get a reference to the query.
const ref = getEventByIdRef(getEventByIdVars);
// Variables can be defined inline as well.
const ref = getEventByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getEventByIdRef(dataConnect, getEventByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.event);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.event);
});
```

## filterEvents
You can execute the `filterEvents` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterEvents(vars?: FilterEventsVariables): QueryPromise<FilterEventsData, FilterEventsVariables>;

interface FilterEventsRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterEventsVariables): QueryRef<FilterEventsData, FilterEventsVariables>;
}
export const filterEventsRef: FilterEventsRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterEvents(dc: DataConnect, vars?: FilterEventsVariables): QueryPromise<FilterEventsData, FilterEventsVariables>;

interface FilterEventsRef {
  ...
  (dc: DataConnect, vars?: FilterEventsVariables): QueryRef<FilterEventsData, FilterEventsVariables>;
}
export const filterEventsRef: FilterEventsRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterEventsRef:
```typescript
const name = filterEventsRef.operationName;
console.log(name);
```

### Variables
The `filterEvents` query has an optional argument of type `FilterEventsVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterEventsVariables {
  status?: EventStatus | null;
  businessId?: UUIDString | null;
  vendorId?: string | null;
  isRecurring?: boolean | null;
  isRapid?: boolean | null;
  isMultiDay?: boolean | null;
  recurrenceType?: RecurrenceType | null;
  date?: string | null;
  hub?: string | null;
  eventLocation?: string | null;
  contractType?: ContractType | null;
  clientEmail?: string | null;
}
```
### Return Type
Recall that executing the `filterEvents` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterEventsData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterEventsData {
  events: ({
    id: UUIDString;
    eventName: string;
    status: EventStatus;
    date: string;
    isRapid?: boolean | null;
    isRecurring?: boolean | null;
    isMultiDay?: boolean | null;
    recurrenceType?: RecurrenceType | null;
    recurrenceStartDate?: TimestampString | null;
    recurrenceEndDate?: TimestampString | null;
    scatterDates?: unknown | null;
    multiDayStartDate?: TimestampString | null;
    multiDayEndDate?: TimestampString | null;
    bufferTimeBefore?: number | null;
    bufferTimeAfter?: number | null;
    conflictDetectionEnabled?: boolean | null;
    detectedConflicts?: unknown | null;
    businessId: UUIDString;
    businessName?: string | null;
    vendorId?: string | null;
    vendorName?: string | null;
    hub?: string | null;
    eventLocation?: string | null;
    contractType?: ContractType | null;
    poReference?: string | null;
    shifts?: unknown | null;
    addons?: unknown | null;
    total?: number | null;
    clientName?: string | null;
    clientEmail?: string | null;
    clientPhone?: string | null;
    invoiceId?: UUIDString | null;
    notes?: string | null;
    requested?: number | null;
    assignedStaff?: unknown | null;
    orderType?: string | null;
    department?: string | null;
    createdBy?: string | null;
    recurringStartDate?: string | null;
    recurringEndDate?: string | null;
    recurringDays?: unknown | null;
    permanentStartDate?: string | null;
    permanentDays?: unknown | null;
    includeBackup?: boolean | null;
    backupStaffCount?: number | null;
    recurringTime?: string | null;
    permanentTime?: string | null;
  } & Event_Key)[];
}
```
### Using `filterEvents`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterEvents, FilterEventsVariables } from '@dataconnect/generated';

// The `filterEvents` query has an optional argument of type `FilterEventsVariables`:
const filterEventsVars: FilterEventsVariables = {
  status: ..., // optional
  businessId: ..., // optional
  vendorId: ..., // optional
  isRecurring: ..., // optional
  isRapid: ..., // optional
  isMultiDay: ..., // optional
  recurrenceType: ..., // optional
  date: ..., // optional
  hub: ..., // optional
  eventLocation: ..., // optional
  contractType: ..., // optional
  clientEmail: ..., // optional
};

// Call the `filterEvents()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterEvents(filterEventsVars);
// Variables can be defined inline as well.
const { data } = await filterEvents({ status: ..., businessId: ..., vendorId: ..., isRecurring: ..., isRapid: ..., isMultiDay: ..., recurrenceType: ..., date: ..., hub: ..., eventLocation: ..., contractType: ..., clientEmail: ..., });
// Since all variables are optional for this query, you can omit the `FilterEventsVariables` argument.
const { data } = await filterEvents();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterEvents(dataConnect, filterEventsVars);

console.log(data.events);

// Or, you can use the `Promise` API.
filterEvents(filterEventsVars).then((response) => {
  const data = response.data;
  console.log(data.events);
});
```

### Using `filterEvents`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterEventsRef, FilterEventsVariables } from '@dataconnect/generated';

// The `filterEvents` query has an optional argument of type `FilterEventsVariables`:
const filterEventsVars: FilterEventsVariables = {
  status: ..., // optional
  businessId: ..., // optional
  vendorId: ..., // optional
  isRecurring: ..., // optional
  isRapid: ..., // optional
  isMultiDay: ..., // optional
  recurrenceType: ..., // optional
  date: ..., // optional
  hub: ..., // optional
  eventLocation: ..., // optional
  contractType: ..., // optional
  clientEmail: ..., // optional
};

// Call the `filterEventsRef()` function to get a reference to the query.
const ref = filterEventsRef(filterEventsVars);
// Variables can be defined inline as well.
const ref = filterEventsRef({ status: ..., businessId: ..., vendorId: ..., isRecurring: ..., isRapid: ..., isMultiDay: ..., recurrenceType: ..., date: ..., hub: ..., eventLocation: ..., contractType: ..., clientEmail: ..., });
// Since all variables are optional for this query, you can omit the `FilterEventsVariables` argument.
const ref = filterEventsRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterEventsRef(dataConnect, filterEventsVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.events);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.events);
});
```

## listMessage
You can execute the `listMessage` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listMessage(): QueryPromise<ListMessageData, undefined>;

interface ListMessageRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListMessageData, undefined>;
}
export const listMessageRef: ListMessageRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listMessage(dc: DataConnect): QueryPromise<ListMessageData, undefined>;

interface ListMessageRef {
  ...
  (dc: DataConnect): QueryRef<ListMessageData, undefined>;
}
export const listMessageRef: ListMessageRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listMessageRef:
```typescript
const name = listMessageRef.operationName;
console.log(name);
```

### Variables
The `listMessage` query has no variables.
### Return Type
Recall that executing the `listMessage` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListMessageData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListMessageData {
  messages: ({
    id: UUIDString;
    conversationId: UUIDString;
    senderName: string;
    content: string;
    readBy?: string | null;
  } & Message_Key)[];
}
```
### Using `listMessage`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listMessage } from '@dataconnect/generated';


// Call the `listMessage()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listMessage();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listMessage(dataConnect);

console.log(data.messages);

// Or, you can use the `Promise` API.
listMessage().then((response) => {
  const data = response.data;
  console.log(data.messages);
});
```

### Using `listMessage`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listMessageRef } from '@dataconnect/generated';


// Call the `listMessageRef()` function to get a reference to the query.
const ref = listMessageRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listMessageRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.messages);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.messages);
});
```

## getMessageById
You can execute the `getMessageById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getMessageById(vars: GetMessageByIdVariables): QueryPromise<GetMessageByIdData, GetMessageByIdVariables>;

interface GetMessageByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetMessageByIdVariables): QueryRef<GetMessageByIdData, GetMessageByIdVariables>;
}
export const getMessageByIdRef: GetMessageByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getMessageById(dc: DataConnect, vars: GetMessageByIdVariables): QueryPromise<GetMessageByIdData, GetMessageByIdVariables>;

interface GetMessageByIdRef {
  ...
  (dc: DataConnect, vars: GetMessageByIdVariables): QueryRef<GetMessageByIdData, GetMessageByIdVariables>;
}
export const getMessageByIdRef: GetMessageByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getMessageByIdRef:
```typescript
const name = getMessageByIdRef.operationName;
console.log(name);
```

### Variables
The `getMessageById` query requires an argument of type `GetMessageByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetMessageByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getMessageById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetMessageByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetMessageByIdData {
  message?: {
    id: UUIDString;
    conversationId: UUIDString;
    senderName: string;
    content: string;
    readBy?: string | null;
  } & Message_Key;
}
```
### Using `getMessageById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getMessageById, GetMessageByIdVariables } from '@dataconnect/generated';

// The `getMessageById` query requires an argument of type `GetMessageByIdVariables`:
const getMessageByIdVars: GetMessageByIdVariables = {
  id: ..., 
};

// Call the `getMessageById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getMessageById(getMessageByIdVars);
// Variables can be defined inline as well.
const { data } = await getMessageById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getMessageById(dataConnect, getMessageByIdVars);

console.log(data.message);

// Or, you can use the `Promise` API.
getMessageById(getMessageByIdVars).then((response) => {
  const data = response.data;
  console.log(data.message);
});
```

### Using `getMessageById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getMessageByIdRef, GetMessageByIdVariables } from '@dataconnect/generated';

// The `getMessageById` query requires an argument of type `GetMessageByIdVariables`:
const getMessageByIdVars: GetMessageByIdVariables = {
  id: ..., 
};

// Call the `getMessageByIdRef()` function to get a reference to the query.
const ref = getMessageByIdRef(getMessageByIdVars);
// Variables can be defined inline as well.
const ref = getMessageByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getMessageByIdRef(dataConnect, getMessageByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.message);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.message);
});
```

## filterMessage
You can execute the `filterMessage` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterMessage(vars?: FilterMessageVariables): QueryPromise<FilterMessageData, FilterMessageVariables>;

interface FilterMessageRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterMessageVariables): QueryRef<FilterMessageData, FilterMessageVariables>;
}
export const filterMessageRef: FilterMessageRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterMessage(dc: DataConnect, vars?: FilterMessageVariables): QueryPromise<FilterMessageData, FilterMessageVariables>;

interface FilterMessageRef {
  ...
  (dc: DataConnect, vars?: FilterMessageVariables): QueryRef<FilterMessageData, FilterMessageVariables>;
}
export const filterMessageRef: FilterMessageRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterMessageRef:
```typescript
const name = filterMessageRef.operationName;
console.log(name);
```

### Variables
The `filterMessage` query has an optional argument of type `FilterMessageVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterMessageVariables {
  conversationId?: UUIDString | null;
  senderName?: string | null;
}
```
### Return Type
Recall that executing the `filterMessage` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterMessageData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterMessageData {
  messages: ({
    id: UUIDString;
    conversationId: UUIDString;
    senderName: string;
    content: string;
    readBy?: string | null;
  } & Message_Key)[];
}
```
### Using `filterMessage`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterMessage, FilterMessageVariables } from '@dataconnect/generated';

// The `filterMessage` query has an optional argument of type `FilterMessageVariables`:
const filterMessageVars: FilterMessageVariables = {
  conversationId: ..., // optional
  senderName: ..., // optional
};

// Call the `filterMessage()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterMessage(filterMessageVars);
// Variables can be defined inline as well.
const { data } = await filterMessage({ conversationId: ..., senderName: ..., });
// Since all variables are optional for this query, you can omit the `FilterMessageVariables` argument.
const { data } = await filterMessage();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterMessage(dataConnect, filterMessageVars);

console.log(data.messages);

// Or, you can use the `Promise` API.
filterMessage(filterMessageVars).then((response) => {
  const data = response.data;
  console.log(data.messages);
});
```

### Using `filterMessage`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterMessageRef, FilterMessageVariables } from '@dataconnect/generated';

// The `filterMessage` query has an optional argument of type `FilterMessageVariables`:
const filterMessageVars: FilterMessageVariables = {
  conversationId: ..., // optional
  senderName: ..., // optional
};

// Call the `filterMessageRef()` function to get a reference to the query.
const ref = filterMessageRef(filterMessageVars);
// Variables can be defined inline as well.
const ref = filterMessageRef({ conversationId: ..., senderName: ..., });
// Since all variables are optional for this query, you can omit the `FilterMessageVariables` argument.
const ref = filterMessageRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterMessageRef(dataConnect, filterMessageVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.messages);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.messages);
});
```

## listSector
You can execute the `listSector` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listSector(): QueryPromise<ListSectorData, undefined>;

interface ListSectorRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListSectorData, undefined>;
}
export const listSectorRef: ListSectorRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listSector(dc: DataConnect): QueryPromise<ListSectorData, undefined>;

interface ListSectorRef {
  ...
  (dc: DataConnect): QueryRef<ListSectorData, undefined>;
}
export const listSectorRef: ListSectorRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listSectorRef:
```typescript
const name = listSectorRef.operationName;
console.log(name);
```

### Variables
The `listSector` query has no variables.
### Return Type
Recall that executing the `listSector` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListSectorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListSectorData {
  sectors: ({
    id: UUIDString;
    sectorNumber: string;
    sectorName: string;
    sectorType?: SectorType | null;
  } & Sector_Key)[];
}
```
### Using `listSector`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listSector } from '@dataconnect/generated';


// Call the `listSector()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listSector();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listSector(dataConnect);

console.log(data.sectors);

// Or, you can use the `Promise` API.
listSector().then((response) => {
  const data = response.data;
  console.log(data.sectors);
});
```

### Using `listSector`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listSectorRef } from '@dataconnect/generated';


// Call the `listSectorRef()` function to get a reference to the query.
const ref = listSectorRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listSectorRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.sectors);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.sectors);
});
```

## getSectorById
You can execute the `getSectorById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getSectorById(vars: GetSectorByIdVariables): QueryPromise<GetSectorByIdData, GetSectorByIdVariables>;

interface GetSectorByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetSectorByIdVariables): QueryRef<GetSectorByIdData, GetSectorByIdVariables>;
}
export const getSectorByIdRef: GetSectorByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getSectorById(dc: DataConnect, vars: GetSectorByIdVariables): QueryPromise<GetSectorByIdData, GetSectorByIdVariables>;

interface GetSectorByIdRef {
  ...
  (dc: DataConnect, vars: GetSectorByIdVariables): QueryRef<GetSectorByIdData, GetSectorByIdVariables>;
}
export const getSectorByIdRef: GetSectorByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getSectorByIdRef:
```typescript
const name = getSectorByIdRef.operationName;
console.log(name);
```

### Variables
The `getSectorById` query requires an argument of type `GetSectorByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetSectorByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getSectorById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetSectorByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetSectorByIdData {
  sector?: {
    id: UUIDString;
    sectorNumber: string;
    sectorName: string;
    sectorType?: SectorType | null;
  } & Sector_Key;
}
```
### Using `getSectorById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getSectorById, GetSectorByIdVariables } from '@dataconnect/generated';

// The `getSectorById` query requires an argument of type `GetSectorByIdVariables`:
const getSectorByIdVars: GetSectorByIdVariables = {
  id: ..., 
};

// Call the `getSectorById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getSectorById(getSectorByIdVars);
// Variables can be defined inline as well.
const { data } = await getSectorById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getSectorById(dataConnect, getSectorByIdVars);

console.log(data.sector);

// Or, you can use the `Promise` API.
getSectorById(getSectorByIdVars).then((response) => {
  const data = response.data;
  console.log(data.sector);
});
```

### Using `getSectorById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getSectorByIdRef, GetSectorByIdVariables } from '@dataconnect/generated';

// The `getSectorById` query requires an argument of type `GetSectorByIdVariables`:
const getSectorByIdVars: GetSectorByIdVariables = {
  id: ..., 
};

// Call the `getSectorByIdRef()` function to get a reference to the query.
const ref = getSectorByIdRef(getSectorByIdVars);
// Variables can be defined inline as well.
const ref = getSectorByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getSectorByIdRef(dataConnect, getSectorByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.sector);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.sector);
});
```

## filterSector
You can execute the `filterSector` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterSector(vars?: FilterSectorVariables): QueryPromise<FilterSectorData, FilterSectorVariables>;

interface FilterSectorRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterSectorVariables): QueryRef<FilterSectorData, FilterSectorVariables>;
}
export const filterSectorRef: FilterSectorRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterSector(dc: DataConnect, vars?: FilterSectorVariables): QueryPromise<FilterSectorData, FilterSectorVariables>;

interface FilterSectorRef {
  ...
  (dc: DataConnect, vars?: FilterSectorVariables): QueryRef<FilterSectorData, FilterSectorVariables>;
}
export const filterSectorRef: FilterSectorRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterSectorRef:
```typescript
const name = filterSectorRef.operationName;
console.log(name);
```

### Variables
The `filterSector` query has an optional argument of type `FilterSectorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterSectorVariables {
  sectorNumber?: string | null;
  sectorName?: string | null;
  sectorType?: SectorType | null;
}
```
### Return Type
Recall that executing the `filterSector` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterSectorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterSectorData {
  sectors: ({
    id: UUIDString;
    sectorNumber: string;
    sectorName: string;
    sectorType?: SectorType | null;
  } & Sector_Key)[];
}
```
### Using `filterSector`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterSector, FilterSectorVariables } from '@dataconnect/generated';

// The `filterSector` query has an optional argument of type `FilterSectorVariables`:
const filterSectorVars: FilterSectorVariables = {
  sectorNumber: ..., // optional
  sectorName: ..., // optional
  sectorType: ..., // optional
};

// Call the `filterSector()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterSector(filterSectorVars);
// Variables can be defined inline as well.
const { data } = await filterSector({ sectorNumber: ..., sectorName: ..., sectorType: ..., });
// Since all variables are optional for this query, you can omit the `FilterSectorVariables` argument.
const { data } = await filterSector();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterSector(dataConnect, filterSectorVars);

console.log(data.sectors);

// Or, you can use the `Promise` API.
filterSector(filterSectorVars).then((response) => {
  const data = response.data;
  console.log(data.sectors);
});
```

### Using `filterSector`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterSectorRef, FilterSectorVariables } from '@dataconnect/generated';

// The `filterSector` query has an optional argument of type `FilterSectorVariables`:
const filterSectorVars: FilterSectorVariables = {
  sectorNumber: ..., // optional
  sectorName: ..., // optional
  sectorType: ..., // optional
};

// Call the `filterSectorRef()` function to get a reference to the query.
const ref = filterSectorRef(filterSectorVars);
// Variables can be defined inline as well.
const ref = filterSectorRef({ sectorNumber: ..., sectorName: ..., sectorType: ..., });
// Since all variables are optional for this query, you can omit the `FilterSectorVariables` argument.
const ref = filterSectorRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterSectorRef(dataConnect, filterSectorVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.sectors);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.sectors);
});
```

## listStaff
You can execute the `listStaff` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listStaff(): QueryPromise<ListStaffData, undefined>;

interface ListStaffRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListStaffData, undefined>;
}
export const listStaffRef: ListStaffRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listStaff(dc: DataConnect): QueryPromise<ListStaffData, undefined>;

interface ListStaffRef {
  ...
  (dc: DataConnect): QueryRef<ListStaffData, undefined>;
}
export const listStaffRef: ListStaffRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listStaffRef:
```typescript
const name = listStaffRef.operationName;
console.log(name);
```

### Variables
The `listStaff` query has no variables.
### Return Type
Recall that executing the `listStaff` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListStaffData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListStaffData {
  staffs: ({
    id: UUIDString;
    employeeName: string;
    vendorId?: string | null;
    vendorName?: string | null;
    manager?: string | null;
    contactNumber?: string | null;
    phone?: string | null;
    email?: string | null;
    department?: StaffDepartment | null;
    hubLocation?: string | null;
    eventLocation?: string | null;
    address?: string | null;
    city?: string | null;
    track?: string | null;
    position?: string | null;
    position2?: string | null;
    initial?: string | null;
    profileType?: ProfileType | null;
    employmentType?: EmploymentType | null;
    english?: EnglishLevel | null;
    englishRequired?: boolean | null;
    rate?: number | null;
    rating?: number | null;
    reliabilityScore?: number | null;
    backgroundCheckStatus?: BackgroundCheckStatus | null;
    notes?: string | null;
    accountingComments?: string | null;
    shiftCoveragePercentage?: number | null;
    cancellationCount?: number | null;
    noShowCount?: number | null;
    totalShifts?: number | null;
    invoiced?: boolean | null;
    checkIn?: string | null;
    scheduleDays?: string | null;
    replacedBy?: string | null;
    action?: string | null;
    ro?: string | null;
    mon?: string | null;
  } & Staff_Key)[];
}
```
### Using `listStaff`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listStaff } from '@dataconnect/generated';


// Call the `listStaff()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listStaff();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listStaff(dataConnect);

console.log(data.staffs);

// Or, you can use the `Promise` API.
listStaff().then((response) => {
  const data = response.data;
  console.log(data.staffs);
});
```

### Using `listStaff`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listStaffRef } from '@dataconnect/generated';


// Call the `listStaffRef()` function to get a reference to the query.
const ref = listStaffRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listStaffRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.staffs);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.staffs);
});
```

## getStaffById
You can execute the `getStaffById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getStaffById(vars: GetStaffByIdVariables): QueryPromise<GetStaffByIdData, GetStaffByIdVariables>;

interface GetStaffByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetStaffByIdVariables): QueryRef<GetStaffByIdData, GetStaffByIdVariables>;
}
export const getStaffByIdRef: GetStaffByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getStaffById(dc: DataConnect, vars: GetStaffByIdVariables): QueryPromise<GetStaffByIdData, GetStaffByIdVariables>;

interface GetStaffByIdRef {
  ...
  (dc: DataConnect, vars: GetStaffByIdVariables): QueryRef<GetStaffByIdData, GetStaffByIdVariables>;
}
export const getStaffByIdRef: GetStaffByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getStaffByIdRef:
```typescript
const name = getStaffByIdRef.operationName;
console.log(name);
```

### Variables
The `getStaffById` query requires an argument of type `GetStaffByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetStaffByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getStaffById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetStaffByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetStaffByIdData {
  staff?: {
    id: UUIDString;
    employeeName: string;
    vendorId?: string | null;
    vendorName?: string | null;
    manager?: string | null;
    contactNumber?: string | null;
    phone?: string | null;
    email?: string | null;
    department?: StaffDepartment | null;
    hubLocation?: string | null;
    eventLocation?: string | null;
    address?: string | null;
    city?: string | null;
    track?: string | null;
    position?: string | null;
    position2?: string | null;
    initial?: string | null;
    profileType?: ProfileType | null;
    employmentType?: EmploymentType | null;
    english?: EnglishLevel | null;
    rate?: number | null;
    rating?: number | null;
    reliabilityScore?: number | null;
    backgroundCheckStatus?: BackgroundCheckStatus | null;
    notes?: string | null;
    accountingComments?: string | null;
    shiftCoveragePercentage?: number | null;
    cancellationCount?: number | null;
    noShowCount?: number | null;
    totalShifts?: number | null;
    invoiced?: boolean | null;
    englishRequired?: boolean | null;
    checkIn?: string | null;
    scheduleDays?: string | null;
    replacedBy?: string | null;
    action?: string | null;
    ro?: string | null;
    mon?: string | null;
  } & Staff_Key;
}
```
### Using `getStaffById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getStaffById, GetStaffByIdVariables } from '@dataconnect/generated';

// The `getStaffById` query requires an argument of type `GetStaffByIdVariables`:
const getStaffByIdVars: GetStaffByIdVariables = {
  id: ..., 
};

// Call the `getStaffById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getStaffById(getStaffByIdVars);
// Variables can be defined inline as well.
const { data } = await getStaffById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getStaffById(dataConnect, getStaffByIdVars);

console.log(data.staff);

// Or, you can use the `Promise` API.
getStaffById(getStaffByIdVars).then((response) => {
  const data = response.data;
  console.log(data.staff);
});
```

### Using `getStaffById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getStaffByIdRef, GetStaffByIdVariables } from '@dataconnect/generated';

// The `getStaffById` query requires an argument of type `GetStaffByIdVariables`:
const getStaffByIdVars: GetStaffByIdVariables = {
  id: ..., 
};

// Call the `getStaffByIdRef()` function to get a reference to the query.
const ref = getStaffByIdRef(getStaffByIdVars);
// Variables can be defined inline as well.
const ref = getStaffByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getStaffByIdRef(dataConnect, getStaffByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.staff);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.staff);
});
```

## filterStaff
You can execute the `filterStaff` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterStaff(vars?: FilterStaffVariables): QueryPromise<FilterStaffData, FilterStaffVariables>;

interface FilterStaffRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterStaffVariables): QueryRef<FilterStaffData, FilterStaffVariables>;
}
export const filterStaffRef: FilterStaffRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterStaff(dc: DataConnect, vars?: FilterStaffVariables): QueryPromise<FilterStaffData, FilterStaffVariables>;

interface FilterStaffRef {
  ...
  (dc: DataConnect, vars?: FilterStaffVariables): QueryRef<FilterStaffData, FilterStaffVariables>;
}
export const filterStaffRef: FilterStaffRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterStaffRef:
```typescript
const name = filterStaffRef.operationName;
console.log(name);
```

### Variables
The `filterStaff` query has an optional argument of type `FilterStaffVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterStaffVariables {
  employeeName?: string | null;
  vendorId?: string | null;
  department?: StaffDepartment | null;
  employmentType?: EmploymentType | null;
  english?: EnglishLevel | null;
  backgroundCheckStatus?: BackgroundCheckStatus | null;
}
```
### Return Type
Recall that executing the `filterStaff` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterStaffData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterStaffData {
  staffs: ({
    id: UUIDString;
    employeeName: string;
    vendorId?: string | null;
    vendorName?: string | null;
    department?: StaffDepartment | null;
    hubLocation?: string | null;
    eventLocation?: string | null;
    position?: string | null;
    position2?: string | null;
    employmentType?: EmploymentType | null;
    english?: EnglishLevel | null;
    rate?: number | null;
    rating?: number | null;
    reliabilityScore?: number | null;
    backgroundCheckStatus?: BackgroundCheckStatus | null;
    notes?: string | null;
    invoiced?: boolean | null;
  } & Staff_Key)[];
}
```
### Using `filterStaff`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterStaff, FilterStaffVariables } from '@dataconnect/generated';

// The `filterStaff` query has an optional argument of type `FilterStaffVariables`:
const filterStaffVars: FilterStaffVariables = {
  employeeName: ..., // optional
  vendorId: ..., // optional
  department: ..., // optional
  employmentType: ..., // optional
  english: ..., // optional
  backgroundCheckStatus: ..., // optional
};

// Call the `filterStaff()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterStaff(filterStaffVars);
// Variables can be defined inline as well.
const { data } = await filterStaff({ employeeName: ..., vendorId: ..., department: ..., employmentType: ..., english: ..., backgroundCheckStatus: ..., });
// Since all variables are optional for this query, you can omit the `FilterStaffVariables` argument.
const { data } = await filterStaff();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterStaff(dataConnect, filterStaffVars);

console.log(data.staffs);

// Or, you can use the `Promise` API.
filterStaff(filterStaffVars).then((response) => {
  const data = response.data;
  console.log(data.staffs);
});
```

### Using `filterStaff`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterStaffRef, FilterStaffVariables } from '@dataconnect/generated';

// The `filterStaff` query has an optional argument of type `FilterStaffVariables`:
const filterStaffVars: FilterStaffVariables = {
  employeeName: ..., // optional
  vendorId: ..., // optional
  department: ..., // optional
  employmentType: ..., // optional
  english: ..., // optional
  backgroundCheckStatus: ..., // optional
};

// Call the `filterStaffRef()` function to get a reference to the query.
const ref = filterStaffRef(filterStaffVars);
// Variables can be defined inline as well.
const ref = filterStaffRef({ employeeName: ..., vendorId: ..., department: ..., employmentType: ..., english: ..., backgroundCheckStatus: ..., });
// Since all variables are optional for this query, you can omit the `FilterStaffVariables` argument.
const ref = filterStaffRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterStaffRef(dataConnect, filterStaffVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.staffs);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.staffs);
});
```

## listOrder
You can execute the `listOrder` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listOrder(): QueryPromise<ListOrderData, undefined>;

interface ListOrderRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListOrderData, undefined>;
}
export const listOrderRef: ListOrderRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listOrder(dc: DataConnect): QueryPromise<ListOrderData, undefined>;

interface ListOrderRef {
  ...
  (dc: DataConnect): QueryRef<ListOrderData, undefined>;
}
export const listOrderRef: ListOrderRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listOrderRef:
```typescript
const name = listOrderRef.operationName;
console.log(name);
```

### Variables
The `listOrder` query has no variables.
### Return Type
Recall that executing the `listOrder` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListOrderData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListOrderData {
  orders: ({
    id: UUIDString;
    orderNumber: string;
    partnerId: UUIDString;
    orderType?: OrderType | null;
    orderStatus?: OrderStatus | null;
  } & Order_Key)[];
}
```
### Using `listOrder`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listOrder } from '@dataconnect/generated';


// Call the `listOrder()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listOrder();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listOrder(dataConnect);

console.log(data.orders);

// Or, you can use the `Promise` API.
listOrder().then((response) => {
  const data = response.data;
  console.log(data.orders);
});
```

### Using `listOrder`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listOrderRef } from '@dataconnect/generated';


// Call the `listOrderRef()` function to get a reference to the query.
const ref = listOrderRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listOrderRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.orders);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.orders);
});
```

## getOrderById
You can execute the `getOrderById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getOrderById(vars: GetOrderByIdVariables): QueryPromise<GetOrderByIdData, GetOrderByIdVariables>;

interface GetOrderByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetOrderByIdVariables): QueryRef<GetOrderByIdData, GetOrderByIdVariables>;
}
export const getOrderByIdRef: GetOrderByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getOrderById(dc: DataConnect, vars: GetOrderByIdVariables): QueryPromise<GetOrderByIdData, GetOrderByIdVariables>;

interface GetOrderByIdRef {
  ...
  (dc: DataConnect, vars: GetOrderByIdVariables): QueryRef<GetOrderByIdData, GetOrderByIdVariables>;
}
export const getOrderByIdRef: GetOrderByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getOrderByIdRef:
```typescript
const name = getOrderByIdRef.operationName;
console.log(name);
```

### Variables
The `getOrderById` query requires an argument of type `GetOrderByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetOrderByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getOrderById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetOrderByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetOrderByIdData {
  order?: {
    id: UUIDString;
    orderNumber: string;
    partnerId: UUIDString;
    orderType?: OrderType | null;
    orderStatus?: OrderStatus | null;
  } & Order_Key;
}
```
### Using `getOrderById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getOrderById, GetOrderByIdVariables } from '@dataconnect/generated';

// The `getOrderById` query requires an argument of type `GetOrderByIdVariables`:
const getOrderByIdVars: GetOrderByIdVariables = {
  id: ..., 
};

// Call the `getOrderById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getOrderById(getOrderByIdVars);
// Variables can be defined inline as well.
const { data } = await getOrderById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getOrderById(dataConnect, getOrderByIdVars);

console.log(data.order);

// Or, you can use the `Promise` API.
getOrderById(getOrderByIdVars).then((response) => {
  const data = response.data;
  console.log(data.order);
});
```

### Using `getOrderById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getOrderByIdRef, GetOrderByIdVariables } from '@dataconnect/generated';

// The `getOrderById` query requires an argument of type `GetOrderByIdVariables`:
const getOrderByIdVars: GetOrderByIdVariables = {
  id: ..., 
};

// Call the `getOrderByIdRef()` function to get a reference to the query.
const ref = getOrderByIdRef(getOrderByIdVars);
// Variables can be defined inline as well.
const ref = getOrderByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getOrderByIdRef(dataConnect, getOrderByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.order);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.order);
});
```

## filterOrder
You can execute the `filterOrder` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterOrder(vars?: FilterOrderVariables): QueryPromise<FilterOrderData, FilterOrderVariables>;

interface FilterOrderRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterOrderVariables): QueryRef<FilterOrderData, FilterOrderVariables>;
}
export const filterOrderRef: FilterOrderRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterOrder(dc: DataConnect, vars?: FilterOrderVariables): QueryPromise<FilterOrderData, FilterOrderVariables>;

interface FilterOrderRef {
  ...
  (dc: DataConnect, vars?: FilterOrderVariables): QueryRef<FilterOrderData, FilterOrderVariables>;
}
export const filterOrderRef: FilterOrderRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterOrderRef:
```typescript
const name = filterOrderRef.operationName;
console.log(name);
```

### Variables
The `filterOrder` query has an optional argument of type `FilterOrderVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterOrderVariables {
  orderNumber?: string | null;
  partnerId?: UUIDString | null;
  orderType?: OrderType | null;
  orderStatus?: OrderStatus | null;
}
```
### Return Type
Recall that executing the `filterOrder` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterOrderData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterOrderData {
  orders: ({
    id: UUIDString;
    orderNumber: string;
    partnerId: UUIDString;
    orderType?: OrderType | null;
    orderStatus?: OrderStatus | null;
  } & Order_Key)[];
}
```
### Using `filterOrder`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterOrder, FilterOrderVariables } from '@dataconnect/generated';

// The `filterOrder` query has an optional argument of type `FilterOrderVariables`:
const filterOrderVars: FilterOrderVariables = {
  orderNumber: ..., // optional
  partnerId: ..., // optional
  orderType: ..., // optional
  orderStatus: ..., // optional
};

// Call the `filterOrder()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterOrder(filterOrderVars);
// Variables can be defined inline as well.
const { data } = await filterOrder({ orderNumber: ..., partnerId: ..., orderType: ..., orderStatus: ..., });
// Since all variables are optional for this query, you can omit the `FilterOrderVariables` argument.
const { data } = await filterOrder();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterOrder(dataConnect, filterOrderVars);

console.log(data.orders);

// Or, you can use the `Promise` API.
filterOrder(filterOrderVars).then((response) => {
  const data = response.data;
  console.log(data.orders);
});
```

### Using `filterOrder`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterOrderRef, FilterOrderVariables } from '@dataconnect/generated';

// The `filterOrder` query has an optional argument of type `FilterOrderVariables`:
const filterOrderVars: FilterOrderVariables = {
  orderNumber: ..., // optional
  partnerId: ..., // optional
  orderType: ..., // optional
  orderStatus: ..., // optional
};

// Call the `filterOrderRef()` function to get a reference to the query.
const ref = filterOrderRef(filterOrderVars);
// Variables can be defined inline as well.
const ref = filterOrderRef({ orderNumber: ..., partnerId: ..., orderType: ..., orderStatus: ..., });
// Since all variables are optional for this query, you can omit the `FilterOrderVariables` argument.
const ref = filterOrderRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterOrderRef(dataConnect, filterOrderVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.orders);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.orders);
});
```

## listPartner
You can execute the `listPartner` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listPartner(): QueryPromise<ListPartnerData, undefined>;

interface ListPartnerRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListPartnerData, undefined>;
}
export const listPartnerRef: ListPartnerRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listPartner(dc: DataConnect): QueryPromise<ListPartnerData, undefined>;

interface ListPartnerRef {
  ...
  (dc: DataConnect): QueryRef<ListPartnerData, undefined>;
}
export const listPartnerRef: ListPartnerRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listPartnerRef:
```typescript
const name = listPartnerRef.operationName;
console.log(name);
```

### Variables
The `listPartner` query has no variables.
### Return Type
Recall that executing the `listPartner` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListPartnerData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListPartnerData {
  partners: ({
    id: UUIDString;
    partnerName: string;
    partnerNumber: string;
    partnerType?: PartnerType | null;
  } & Partner_Key)[];
}
```
### Using `listPartner`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listPartner } from '@dataconnect/generated';


// Call the `listPartner()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listPartner();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listPartner(dataConnect);

console.log(data.partners);

// Or, you can use the `Promise` API.
listPartner().then((response) => {
  const data = response.data;
  console.log(data.partners);
});
```

### Using `listPartner`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listPartnerRef } from '@dataconnect/generated';


// Call the `listPartnerRef()` function to get a reference to the query.
const ref = listPartnerRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listPartnerRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.partners);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.partners);
});
```

## getPartnerById
You can execute the `getPartnerById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getPartnerById(vars: GetPartnerByIdVariables): QueryPromise<GetPartnerByIdData, GetPartnerByIdVariables>;

interface GetPartnerByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetPartnerByIdVariables): QueryRef<GetPartnerByIdData, GetPartnerByIdVariables>;
}
export const getPartnerByIdRef: GetPartnerByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getPartnerById(dc: DataConnect, vars: GetPartnerByIdVariables): QueryPromise<GetPartnerByIdData, GetPartnerByIdVariables>;

interface GetPartnerByIdRef {
  ...
  (dc: DataConnect, vars: GetPartnerByIdVariables): QueryRef<GetPartnerByIdData, GetPartnerByIdVariables>;
}
export const getPartnerByIdRef: GetPartnerByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getPartnerByIdRef:
```typescript
const name = getPartnerByIdRef.operationName;
console.log(name);
```

### Variables
The `getPartnerById` query requires an argument of type `GetPartnerByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetPartnerByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getPartnerById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetPartnerByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetPartnerByIdData {
  partner?: {
    id: UUIDString;
    partnerName: string;
    partnerNumber: string;
    partnerType?: PartnerType | null;
  } & Partner_Key;
}
```
### Using `getPartnerById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getPartnerById, GetPartnerByIdVariables } from '@dataconnect/generated';

// The `getPartnerById` query requires an argument of type `GetPartnerByIdVariables`:
const getPartnerByIdVars: GetPartnerByIdVariables = {
  id: ..., 
};

// Call the `getPartnerById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getPartnerById(getPartnerByIdVars);
// Variables can be defined inline as well.
const { data } = await getPartnerById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getPartnerById(dataConnect, getPartnerByIdVars);

console.log(data.partner);

// Or, you can use the `Promise` API.
getPartnerById(getPartnerByIdVars).then((response) => {
  const data = response.data;
  console.log(data.partner);
});
```

### Using `getPartnerById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getPartnerByIdRef, GetPartnerByIdVariables } from '@dataconnect/generated';

// The `getPartnerById` query requires an argument of type `GetPartnerByIdVariables`:
const getPartnerByIdVars: GetPartnerByIdVariables = {
  id: ..., 
};

// Call the `getPartnerByIdRef()` function to get a reference to the query.
const ref = getPartnerByIdRef(getPartnerByIdVars);
// Variables can be defined inline as well.
const ref = getPartnerByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getPartnerByIdRef(dataConnect, getPartnerByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.partner);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.partner);
});
```

## filterPartner
You can execute the `filterPartner` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterPartner(vars?: FilterPartnerVariables): QueryPromise<FilterPartnerData, FilterPartnerVariables>;

interface FilterPartnerRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterPartnerVariables): QueryRef<FilterPartnerData, FilterPartnerVariables>;
}
export const filterPartnerRef: FilterPartnerRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterPartner(dc: DataConnect, vars?: FilterPartnerVariables): QueryPromise<FilterPartnerData, FilterPartnerVariables>;

interface FilterPartnerRef {
  ...
  (dc: DataConnect, vars?: FilterPartnerVariables): QueryRef<FilterPartnerData, FilterPartnerVariables>;
}
export const filterPartnerRef: FilterPartnerRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterPartnerRef:
```typescript
const name = filterPartnerRef.operationName;
console.log(name);
```

### Variables
The `filterPartner` query has an optional argument of type `FilterPartnerVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterPartnerVariables {
  partnerName?: string | null;
  partnerNumber?: string | null;
  partnerType?: PartnerType | null;
}
```
### Return Type
Recall that executing the `filterPartner` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterPartnerData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterPartnerData {
  partners: ({
    id: UUIDString;
    partnerName: string;
    partnerNumber: string;
    partnerType?: PartnerType | null;
  } & Partner_Key)[];
}
```
### Using `filterPartner`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterPartner, FilterPartnerVariables } from '@dataconnect/generated';

// The `filterPartner` query has an optional argument of type `FilterPartnerVariables`:
const filterPartnerVars: FilterPartnerVariables = {
  partnerName: ..., // optional
  partnerNumber: ..., // optional
  partnerType: ..., // optional
};

// Call the `filterPartner()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterPartner(filterPartnerVars);
// Variables can be defined inline as well.
const { data } = await filterPartner({ partnerName: ..., partnerNumber: ..., partnerType: ..., });
// Since all variables are optional for this query, you can omit the `FilterPartnerVariables` argument.
const { data } = await filterPartner();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterPartner(dataConnect, filterPartnerVars);

console.log(data.partners);

// Or, you can use the `Promise` API.
filterPartner(filterPartnerVars).then((response) => {
  const data = response.data;
  console.log(data.partners);
});
```

### Using `filterPartner`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterPartnerRef, FilterPartnerVariables } from '@dataconnect/generated';

// The `filterPartner` query has an optional argument of type `FilterPartnerVariables`:
const filterPartnerVars: FilterPartnerVariables = {
  partnerName: ..., // optional
  partnerNumber: ..., // optional
  partnerType: ..., // optional
};

// Call the `filterPartnerRef()` function to get a reference to the query.
const ref = filterPartnerRef(filterPartnerVars);
// Variables can be defined inline as well.
const ref = filterPartnerRef({ partnerName: ..., partnerNumber: ..., partnerType: ..., });
// Since all variables are optional for this query, you can omit the `FilterPartnerVariables` argument.
const ref = filterPartnerRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterPartnerRef(dataConnect, filterPartnerVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.partners);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.partners);
});
```

## listVendor
You can execute the `listVendor` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listVendor(): QueryPromise<ListVendorData, undefined>;

interface ListVendorRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListVendorData, undefined>;
}
export const listVendorRef: ListVendorRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listVendor(dc: DataConnect): QueryPromise<ListVendorData, undefined>;

interface ListVendorRef {
  ...
  (dc: DataConnect): QueryRef<ListVendorData, undefined>;
}
export const listVendorRef: ListVendorRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listVendorRef:
```typescript
const name = listVendorRef.operationName;
console.log(name);
```

### Variables
The `listVendor` query has no variables.
### Return Type
Recall that executing the `listVendor` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListVendorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListVendorData {
  vendors: ({
    id: UUIDString;
    vendorNumber: string;
    legalName: string;
    region: VendorRegion;
    platformType: VendorPlatformType;
    primaryContactEmail: string;
    approvalStatus: VendorApprovalStatus;
    isActive?: boolean | null;
  } & Vendor_Key)[];
}
```
### Using `listVendor`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listVendor } from '@dataconnect/generated';


// Call the `listVendor()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listVendor();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listVendor(dataConnect);

console.log(data.vendors);

// Or, you can use the `Promise` API.
listVendor().then((response) => {
  const data = response.data;
  console.log(data.vendors);
});
```

### Using `listVendor`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listVendorRef } from '@dataconnect/generated';


// Call the `listVendorRef()` function to get a reference to the query.
const ref = listVendorRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listVendorRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.vendors);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.vendors);
});
```

## getVendorById
You can execute the `getVendorById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getVendorById(vars: GetVendorByIdVariables): QueryPromise<GetVendorByIdData, GetVendorByIdVariables>;

interface GetVendorByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetVendorByIdVariables): QueryRef<GetVendorByIdData, GetVendorByIdVariables>;
}
export const getVendorByIdRef: GetVendorByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getVendorById(dc: DataConnect, vars: GetVendorByIdVariables): QueryPromise<GetVendorByIdData, GetVendorByIdVariables>;

interface GetVendorByIdRef {
  ...
  (dc: DataConnect, vars: GetVendorByIdVariables): QueryRef<GetVendorByIdData, GetVendorByIdVariables>;
}
export const getVendorByIdRef: GetVendorByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getVendorByIdRef:
```typescript
const name = getVendorByIdRef.operationName;
console.log(name);
```

### Variables
The `getVendorById` query requires an argument of type `GetVendorByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetVendorByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getVendorById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetVendorByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetVendorByIdData {
  vendor?: {
    id: UUIDString;
    vendorNumber: string;
    legalName: string;
    region: VendorRegion;
    platformType: VendorPlatformType;
    primaryContactEmail: string;
    approvalStatus: VendorApprovalStatus;
    isActive?: boolean | null;
  } & Vendor_Key;
}
```
### Using `getVendorById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getVendorById, GetVendorByIdVariables } from '@dataconnect/generated';

// The `getVendorById` query requires an argument of type `GetVendorByIdVariables`:
const getVendorByIdVars: GetVendorByIdVariables = {
  id: ..., 
};

// Call the `getVendorById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getVendorById(getVendorByIdVars);
// Variables can be defined inline as well.
const { data } = await getVendorById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getVendorById(dataConnect, getVendorByIdVars);

console.log(data.vendor);

// Or, you can use the `Promise` API.
getVendorById(getVendorByIdVars).then((response) => {
  const data = response.data;
  console.log(data.vendor);
});
```

### Using `getVendorById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getVendorByIdRef, GetVendorByIdVariables } from '@dataconnect/generated';

// The `getVendorById` query requires an argument of type `GetVendorByIdVariables`:
const getVendorByIdVars: GetVendorByIdVariables = {
  id: ..., 
};

// Call the `getVendorByIdRef()` function to get a reference to the query.
const ref = getVendorByIdRef(getVendorByIdVars);
// Variables can be defined inline as well.
const ref = getVendorByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getVendorByIdRef(dataConnect, getVendorByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.vendor);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.vendor);
});
```

## filterVendors
You can execute the `filterVendors` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterVendors(vars?: FilterVendorsVariables): QueryPromise<FilterVendorsData, FilterVendorsVariables>;

interface FilterVendorsRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterVendorsVariables): QueryRef<FilterVendorsData, FilterVendorsVariables>;
}
export const filterVendorsRef: FilterVendorsRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterVendors(dc: DataConnect, vars?: FilterVendorsVariables): QueryPromise<FilterVendorsData, FilterVendorsVariables>;

interface FilterVendorsRef {
  ...
  (dc: DataConnect, vars?: FilterVendorsVariables): QueryRef<FilterVendorsData, FilterVendorsVariables>;
}
export const filterVendorsRef: FilterVendorsRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterVendorsRef:
```typescript
const name = filterVendorsRef.operationName;
console.log(name);
```

### Variables
The `filterVendors` query has an optional argument of type `FilterVendorsVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterVendorsVariables {
  region?: VendorRegion | null;
  approvalStatus?: VendorApprovalStatus | null;
  isActive?: boolean | null;
  vendorNumber?: string | null;
  primaryContactEmail?: string | null;
  legalName?: string | null;
  platformType?: VendorPlatformType | null;
}
```
### Return Type
Recall that executing the `filterVendors` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterVendorsData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterVendorsData {
  vendors: ({
    id: UUIDString;
    vendorNumber: string;
    legalName: string;
    region: VendorRegion;
    platformType: VendorPlatformType;
    primaryContactEmail: string;
    approvalStatus: VendorApprovalStatus;
    isActive?: boolean | null;
  } & Vendor_Key)[];
}
```
### Using `filterVendors`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterVendors, FilterVendorsVariables } from '@dataconnect/generated';

// The `filterVendors` query has an optional argument of type `FilterVendorsVariables`:
const filterVendorsVars: FilterVendorsVariables = {
  region: ..., // optional
  approvalStatus: ..., // optional
  isActive: ..., // optional
  vendorNumber: ..., // optional
  primaryContactEmail: ..., // optional
  legalName: ..., // optional
  platformType: ..., // optional
};

// Call the `filterVendors()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterVendors(filterVendorsVars);
// Variables can be defined inline as well.
const { data } = await filterVendors({ region: ..., approvalStatus: ..., isActive: ..., vendorNumber: ..., primaryContactEmail: ..., legalName: ..., platformType: ..., });
// Since all variables are optional for this query, you can omit the `FilterVendorsVariables` argument.
const { data } = await filterVendors();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterVendors(dataConnect, filterVendorsVars);

console.log(data.vendors);

// Or, you can use the `Promise` API.
filterVendors(filterVendorsVars).then((response) => {
  const data = response.data;
  console.log(data.vendors);
});
```

### Using `filterVendors`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterVendorsRef, FilterVendorsVariables } from '@dataconnect/generated';

// The `filterVendors` query has an optional argument of type `FilterVendorsVariables`:
const filterVendorsVars: FilterVendorsVariables = {
  region: ..., // optional
  approvalStatus: ..., // optional
  isActive: ..., // optional
  vendorNumber: ..., // optional
  primaryContactEmail: ..., // optional
  legalName: ..., // optional
  platformType: ..., // optional
};

// Call the `filterVendorsRef()` function to get a reference to the query.
const ref = filterVendorsRef(filterVendorsVars);
// Variables can be defined inline as well.
const ref = filterVendorsRef({ region: ..., approvalStatus: ..., isActive: ..., vendorNumber: ..., primaryContactEmail: ..., legalName: ..., platformType: ..., });
// Since all variables are optional for this query, you can omit the `FilterVendorsVariables` argument.
const ref = filterVendorsRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterVendorsRef(dataConnect, filterVendorsVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.vendors);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.vendors);
});
```

## listWorkforce
You can execute the `listWorkforce` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listWorkforce(): QueryPromise<ListWorkforceData, undefined>;

interface ListWorkforceRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListWorkforceData, undefined>;
}
export const listWorkforceRef: ListWorkforceRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listWorkforce(dc: DataConnect): QueryPromise<ListWorkforceData, undefined>;

interface ListWorkforceRef {
  ...
  (dc: DataConnect): QueryRef<ListWorkforceData, undefined>;
}
export const listWorkforceRef: ListWorkforceRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listWorkforceRef:
```typescript
const name = listWorkforceRef.operationName;
console.log(name);
```

### Variables
The `listWorkforce` query has no variables.
### Return Type
Recall that executing the `listWorkforce` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListWorkforceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListWorkforceData {
  workforces: ({
    id: UUIDString;
    workforceNumber: string;
    vendorId: UUIDString;
    firstName: string;
    lastName: string;
    employmentType?: WorkforceEmploymentType | null;
  } & Workforce_Key)[];
}
```
### Using `listWorkforce`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listWorkforce } from '@dataconnect/generated';


// Call the `listWorkforce()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listWorkforce();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listWorkforce(dataConnect);

console.log(data.workforces);

// Or, you can use the `Promise` API.
listWorkforce().then((response) => {
  const data = response.data;
  console.log(data.workforces);
});
```

### Using `listWorkforce`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listWorkforceRef } from '@dataconnect/generated';


// Call the `listWorkforceRef()` function to get a reference to the query.
const ref = listWorkforceRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listWorkforceRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.workforces);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.workforces);
});
```

## getWorkforceById
You can execute the `getWorkforceById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getWorkforceById(vars: GetWorkforceByIdVariables): QueryPromise<GetWorkforceByIdData, GetWorkforceByIdVariables>;

interface GetWorkforceByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetWorkforceByIdVariables): QueryRef<GetWorkforceByIdData, GetWorkforceByIdVariables>;
}
export const getWorkforceByIdRef: GetWorkforceByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getWorkforceById(dc: DataConnect, vars: GetWorkforceByIdVariables): QueryPromise<GetWorkforceByIdData, GetWorkforceByIdVariables>;

interface GetWorkforceByIdRef {
  ...
  (dc: DataConnect, vars: GetWorkforceByIdVariables): QueryRef<GetWorkforceByIdData, GetWorkforceByIdVariables>;
}
export const getWorkforceByIdRef: GetWorkforceByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getWorkforceByIdRef:
```typescript
const name = getWorkforceByIdRef.operationName;
console.log(name);
```

### Variables
The `getWorkforceById` query requires an argument of type `GetWorkforceByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetWorkforceByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getWorkforceById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetWorkforceByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetWorkforceByIdData {
  workforce?: {
    id: UUIDString;
    workforceNumber: string;
    vendorId: UUIDString;
    firstName: string;
    lastName: string;
    employmentType?: WorkforceEmploymentType | null;
  } & Workforce_Key;
}
```
### Using `getWorkforceById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getWorkforceById, GetWorkforceByIdVariables } from '@dataconnect/generated';

// The `getWorkforceById` query requires an argument of type `GetWorkforceByIdVariables`:
const getWorkforceByIdVars: GetWorkforceByIdVariables = {
  id: ..., 
};

// Call the `getWorkforceById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getWorkforceById(getWorkforceByIdVars);
// Variables can be defined inline as well.
const { data } = await getWorkforceById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getWorkforceById(dataConnect, getWorkforceByIdVars);

console.log(data.workforce);

// Or, you can use the `Promise` API.
getWorkforceById(getWorkforceByIdVars).then((response) => {
  const data = response.data;
  console.log(data.workforce);
});
```

### Using `getWorkforceById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getWorkforceByIdRef, GetWorkforceByIdVariables } from '@dataconnect/generated';

// The `getWorkforceById` query requires an argument of type `GetWorkforceByIdVariables`:
const getWorkforceByIdVars: GetWorkforceByIdVariables = {
  id: ..., 
};

// Call the `getWorkforceByIdRef()` function to get a reference to the query.
const ref = getWorkforceByIdRef(getWorkforceByIdVars);
// Variables can be defined inline as well.
const ref = getWorkforceByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getWorkforceByIdRef(dataConnect, getWorkforceByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.workforce);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.workforce);
});
```

## filterWorkforce
You can execute the `filterWorkforce` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterWorkforce(vars?: FilterWorkforceVariables): QueryPromise<FilterWorkforceData, FilterWorkforceVariables>;

interface FilterWorkforceRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterWorkforceVariables): QueryRef<FilterWorkforceData, FilterWorkforceVariables>;
}
export const filterWorkforceRef: FilterWorkforceRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterWorkforce(dc: DataConnect, vars?: FilterWorkforceVariables): QueryPromise<FilterWorkforceData, FilterWorkforceVariables>;

interface FilterWorkforceRef {
  ...
  (dc: DataConnect, vars?: FilterWorkforceVariables): QueryRef<FilterWorkforceData, FilterWorkforceVariables>;
}
export const filterWorkforceRef: FilterWorkforceRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterWorkforceRef:
```typescript
const name = filterWorkforceRef.operationName;
console.log(name);
```

### Variables
The `filterWorkforce` query has an optional argument of type `FilterWorkforceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterWorkforceVariables {
  workforceNumber?: string | null;
  vendorId?: UUIDString | null;
  firstName?: string | null;
  lastName?: string | null;
  employmentType?: WorkforceEmploymentType | null;
}
```
### Return Type
Recall that executing the `filterWorkforce` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterWorkforceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterWorkforceData {
  workforces: ({
    id: UUIDString;
    workforceNumber: string;
    vendorId: UUIDString;
    firstName: string;
    lastName: string;
    employmentType?: WorkforceEmploymentType | null;
  } & Workforce_Key)[];
}
```
### Using `filterWorkforce`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterWorkforce, FilterWorkforceVariables } from '@dataconnect/generated';

// The `filterWorkforce` query has an optional argument of type `FilterWorkforceVariables`:
const filterWorkforceVars: FilterWorkforceVariables = {
  workforceNumber: ..., // optional
  vendorId: ..., // optional
  firstName: ..., // optional
  lastName: ..., // optional
  employmentType: ..., // optional
};

// Call the `filterWorkforce()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterWorkforce(filterWorkforceVars);
// Variables can be defined inline as well.
const { data } = await filterWorkforce({ workforceNumber: ..., vendorId: ..., firstName: ..., lastName: ..., employmentType: ..., });
// Since all variables are optional for this query, you can omit the `FilterWorkforceVariables` argument.
const { data } = await filterWorkforce();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterWorkforce(dataConnect, filterWorkforceVars);

console.log(data.workforces);

// Or, you can use the `Promise` API.
filterWorkforce(filterWorkforceVars).then((response) => {
  const data = response.data;
  console.log(data.workforces);
});
```

### Using `filterWorkforce`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterWorkforceRef, FilterWorkforceVariables } from '@dataconnect/generated';

// The `filterWorkforce` query has an optional argument of type `FilterWorkforceVariables`:
const filterWorkforceVars: FilterWorkforceVariables = {
  workforceNumber: ..., // optional
  vendorId: ..., // optional
  firstName: ..., // optional
  lastName: ..., // optional
  employmentType: ..., // optional
};

// Call the `filterWorkforceRef()` function to get a reference to the query.
const ref = filterWorkforceRef(filterWorkforceVars);
// Variables can be defined inline as well.
const ref = filterWorkforceRef({ workforceNumber: ..., vendorId: ..., firstName: ..., lastName: ..., employmentType: ..., });
// Since all variables are optional for this query, you can omit the `FilterWorkforceVariables` argument.
const ref = filterWorkforceRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterWorkforceRef(dataConnect, filterWorkforceVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.workforces);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.workforces);
});
```

## listActivityLog
You can execute the `listActivityLog` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listActivityLog(): QueryPromise<ListActivityLogData, undefined>;

interface ListActivityLogRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListActivityLogData, undefined>;
}
export const listActivityLogRef: ListActivityLogRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listActivityLog(dc: DataConnect): QueryPromise<ListActivityLogData, undefined>;

interface ListActivityLogRef {
  ...
  (dc: DataConnect): QueryRef<ListActivityLogData, undefined>;
}
export const listActivityLogRef: ListActivityLogRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listActivityLogRef:
```typescript
const name = listActivityLogRef.operationName;
console.log(name);
```

### Variables
The `listActivityLog` query has no variables.
### Return Type
Recall that executing the `listActivityLog` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListActivityLogData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListActivityLogData {
  activityLogs: ({
    id: UUIDString;
    title: string;
    description: string;
    activityType: ActivityType;
    userId: string;
    isRead?: boolean | null;
    iconType?: string | null;
    iconColor?: string | null;
  } & ActivityLog_Key)[];
}
```
### Using `listActivityLog`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listActivityLog } from '@dataconnect/generated';


// Call the `listActivityLog()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listActivityLog();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listActivityLog(dataConnect);

console.log(data.activityLogs);

// Or, you can use the `Promise` API.
listActivityLog().then((response) => {
  const data = response.data;
  console.log(data.activityLogs);
});
```

### Using `listActivityLog`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listActivityLogRef } from '@dataconnect/generated';


// Call the `listActivityLogRef()` function to get a reference to the query.
const ref = listActivityLogRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listActivityLogRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.activityLogs);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.activityLogs);
});
```

## getActivityLogById
You can execute the `getActivityLogById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getActivityLogById(vars: GetActivityLogByIdVariables): QueryPromise<GetActivityLogByIdData, GetActivityLogByIdVariables>;

interface GetActivityLogByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetActivityLogByIdVariables): QueryRef<GetActivityLogByIdData, GetActivityLogByIdVariables>;
}
export const getActivityLogByIdRef: GetActivityLogByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getActivityLogById(dc: DataConnect, vars: GetActivityLogByIdVariables): QueryPromise<GetActivityLogByIdData, GetActivityLogByIdVariables>;

interface GetActivityLogByIdRef {
  ...
  (dc: DataConnect, vars: GetActivityLogByIdVariables): QueryRef<GetActivityLogByIdData, GetActivityLogByIdVariables>;
}
export const getActivityLogByIdRef: GetActivityLogByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getActivityLogByIdRef:
```typescript
const name = getActivityLogByIdRef.operationName;
console.log(name);
```

### Variables
The `getActivityLogById` query requires an argument of type `GetActivityLogByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetActivityLogByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getActivityLogById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetActivityLogByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetActivityLogByIdData {
  activityLog?: {
    id: UUIDString;
    title: string;
    description: string;
    activityType: ActivityType;
    userId: string;
    isRead?: boolean | null;
    iconType?: string | null;
    iconColor?: string | null;
  } & ActivityLog_Key;
}
```
### Using `getActivityLogById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getActivityLogById, GetActivityLogByIdVariables } from '@dataconnect/generated';

// The `getActivityLogById` query requires an argument of type `GetActivityLogByIdVariables`:
const getActivityLogByIdVars: GetActivityLogByIdVariables = {
  id: ..., 
};

// Call the `getActivityLogById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getActivityLogById(getActivityLogByIdVars);
// Variables can be defined inline as well.
const { data } = await getActivityLogById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getActivityLogById(dataConnect, getActivityLogByIdVars);

console.log(data.activityLog);

// Or, you can use the `Promise` API.
getActivityLogById(getActivityLogByIdVars).then((response) => {
  const data = response.data;
  console.log(data.activityLog);
});
```

### Using `getActivityLogById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getActivityLogByIdRef, GetActivityLogByIdVariables } from '@dataconnect/generated';

// The `getActivityLogById` query requires an argument of type `GetActivityLogByIdVariables`:
const getActivityLogByIdVars: GetActivityLogByIdVariables = {
  id: ..., 
};

// Call the `getActivityLogByIdRef()` function to get a reference to the query.
const ref = getActivityLogByIdRef(getActivityLogByIdVars);
// Variables can be defined inline as well.
const ref = getActivityLogByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getActivityLogByIdRef(dataConnect, getActivityLogByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.activityLog);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.activityLog);
});
```

## filterActivityLog
You can execute the `filterActivityLog` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterActivityLog(vars?: FilterActivityLogVariables): QueryPromise<FilterActivityLogData, FilterActivityLogVariables>;

interface FilterActivityLogRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterActivityLogVariables): QueryRef<FilterActivityLogData, FilterActivityLogVariables>;
}
export const filterActivityLogRef: FilterActivityLogRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterActivityLog(dc: DataConnect, vars?: FilterActivityLogVariables): QueryPromise<FilterActivityLogData, FilterActivityLogVariables>;

interface FilterActivityLogRef {
  ...
  (dc: DataConnect, vars?: FilterActivityLogVariables): QueryRef<FilterActivityLogData, FilterActivityLogVariables>;
}
export const filterActivityLogRef: FilterActivityLogRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterActivityLogRef:
```typescript
const name = filterActivityLogRef.operationName;
console.log(name);
```

### Variables
The `filterActivityLog` query has an optional argument of type `FilterActivityLogVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterActivityLogVariables {
  userId?: string | null;
  activityType?: ActivityType | null;
  isRead?: boolean | null;
}
```
### Return Type
Recall that executing the `filterActivityLog` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterActivityLogData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterActivityLogData {
  activityLogs: ({
    id: UUIDString;
    title: string;
    description: string;
    activityType: ActivityType;
    userId: string;
    isRead?: boolean | null;
    iconType?: string | null;
    iconColor?: string | null;
  } & ActivityLog_Key)[];
}
```
### Using `filterActivityLog`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterActivityLog, FilterActivityLogVariables } from '@dataconnect/generated';

// The `filterActivityLog` query has an optional argument of type `FilterActivityLogVariables`:
const filterActivityLogVars: FilterActivityLogVariables = {
  userId: ..., // optional
  activityType: ..., // optional
  isRead: ..., // optional
};

// Call the `filterActivityLog()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterActivityLog(filterActivityLogVars);
// Variables can be defined inline as well.
const { data } = await filterActivityLog({ userId: ..., activityType: ..., isRead: ..., });
// Since all variables are optional for this query, you can omit the `FilterActivityLogVariables` argument.
const { data } = await filterActivityLog();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterActivityLog(dataConnect, filterActivityLogVars);

console.log(data.activityLogs);

// Or, you can use the `Promise` API.
filterActivityLog(filterActivityLogVars).then((response) => {
  const data = response.data;
  console.log(data.activityLogs);
});
```

### Using `filterActivityLog`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterActivityLogRef, FilterActivityLogVariables } from '@dataconnect/generated';

// The `filterActivityLog` query has an optional argument of type `FilterActivityLogVariables`:
const filterActivityLogVars: FilterActivityLogVariables = {
  userId: ..., // optional
  activityType: ..., // optional
  isRead: ..., // optional
};

// Call the `filterActivityLogRef()` function to get a reference to the query.
const ref = filterActivityLogRef(filterActivityLogVars);
// Variables can be defined inline as well.
const ref = filterActivityLogRef({ userId: ..., activityType: ..., isRead: ..., });
// Since all variables are optional for this query, you can omit the `FilterActivityLogVariables` argument.
const ref = filterActivityLogRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterActivityLogRef(dataConnect, filterActivityLogVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.activityLogs);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.activityLogs);
});
```

## listTeam
You can execute the `listTeam` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listTeam(vars?: ListTeamVariables): QueryPromise<ListTeamData, ListTeamVariables>;

interface ListTeamRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: ListTeamVariables): QueryRef<ListTeamData, ListTeamVariables>;
}
export const listTeamRef: ListTeamRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listTeam(dc: DataConnect, vars?: ListTeamVariables): QueryPromise<ListTeamData, ListTeamVariables>;

interface ListTeamRef {
  ...
  (dc: DataConnect, vars?: ListTeamVariables): QueryRef<ListTeamData, ListTeamVariables>;
}
export const listTeamRef: ListTeamRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listTeamRef:
```typescript
const name = listTeamRef.operationName;
console.log(name);
```

### Variables
The `listTeam` query has an optional argument of type `ListTeamVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface ListTeamVariables {
  orderByCreatedDate?: OrderDirection | null;
  limit?: number | null;
}
```
### Return Type
Recall that executing the `listTeam` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListTeamData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListTeamData {
  teams: ({
    id: UUIDString;
    teamName: string;
    ownerId: string;
    ownerName: string;
    ownerRole: TeamOwnerRole;
    favoriteStaff?: string | null;
    blockedStaff?: string | null;
  } & Team_Key)[];
}
```
### Using `listTeam`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listTeam, ListTeamVariables } from '@dataconnect/generated';

// The `listTeam` query has an optional argument of type `ListTeamVariables`:
const listTeamVars: ListTeamVariables = {
  orderByCreatedDate: ..., // optional
  limit: ..., // optional
};

// Call the `listTeam()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listTeam(listTeamVars);
// Variables can be defined inline as well.
const { data } = await listTeam({ orderByCreatedDate: ..., limit: ..., });
// Since all variables are optional for this query, you can omit the `ListTeamVariables` argument.
const { data } = await listTeam();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listTeam(dataConnect, listTeamVars);

console.log(data.teams);

// Or, you can use the `Promise` API.
listTeam(listTeamVars).then((response) => {
  const data = response.data;
  console.log(data.teams);
});
```

### Using `listTeam`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listTeamRef, ListTeamVariables } from '@dataconnect/generated';

// The `listTeam` query has an optional argument of type `ListTeamVariables`:
const listTeamVars: ListTeamVariables = {
  orderByCreatedDate: ..., // optional
  limit: ..., // optional
};

// Call the `listTeamRef()` function to get a reference to the query.
const ref = listTeamRef(listTeamVars);
// Variables can be defined inline as well.
const ref = listTeamRef({ orderByCreatedDate: ..., limit: ..., });
// Since all variables are optional for this query, you can omit the `ListTeamVariables` argument.
const ref = listTeamRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listTeamRef(dataConnect, listTeamVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.teams);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.teams);
});
```

## getTeamById
You can execute the `getTeamById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getTeamById(vars: GetTeamByIdVariables): QueryPromise<GetTeamByIdData, GetTeamByIdVariables>;

interface GetTeamByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetTeamByIdVariables): QueryRef<GetTeamByIdData, GetTeamByIdVariables>;
}
export const getTeamByIdRef: GetTeamByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getTeamById(dc: DataConnect, vars: GetTeamByIdVariables): QueryPromise<GetTeamByIdData, GetTeamByIdVariables>;

interface GetTeamByIdRef {
  ...
  (dc: DataConnect, vars: GetTeamByIdVariables): QueryRef<GetTeamByIdData, GetTeamByIdVariables>;
}
export const getTeamByIdRef: GetTeamByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getTeamByIdRef:
```typescript
const name = getTeamByIdRef.operationName;
console.log(name);
```

### Variables
The `getTeamById` query requires an argument of type `GetTeamByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetTeamByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getTeamById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetTeamByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetTeamByIdData {
  team?: {
    id: UUIDString;
    teamName: string;
    ownerId: string;
    ownerName: string;
    ownerRole: TeamOwnerRole;
    favoriteStaff?: string | null;
    blockedStaff?: string | null;
  } & Team_Key;
}
```
### Using `getTeamById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getTeamById, GetTeamByIdVariables } from '@dataconnect/generated';

// The `getTeamById` query requires an argument of type `GetTeamByIdVariables`:
const getTeamByIdVars: GetTeamByIdVariables = {
  id: ..., 
};

// Call the `getTeamById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getTeamById(getTeamByIdVars);
// Variables can be defined inline as well.
const { data } = await getTeamById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getTeamById(dataConnect, getTeamByIdVars);

console.log(data.team);

// Or, you can use the `Promise` API.
getTeamById(getTeamByIdVars).then((response) => {
  const data = response.data;
  console.log(data.team);
});
```

### Using `getTeamById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getTeamByIdRef, GetTeamByIdVariables } from '@dataconnect/generated';

// The `getTeamById` query requires an argument of type `GetTeamByIdVariables`:
const getTeamByIdVars: GetTeamByIdVariables = {
  id: ..., 
};

// Call the `getTeamByIdRef()` function to get a reference to the query.
const ref = getTeamByIdRef(getTeamByIdVars);
// Variables can be defined inline as well.
const ref = getTeamByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getTeamByIdRef(dataConnect, getTeamByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.team);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.team);
});
```

## filterTeam
You can execute the `filterTeam` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterTeam(vars?: FilterTeamVariables): QueryPromise<FilterTeamData, FilterTeamVariables>;

interface FilterTeamRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterTeamVariables): QueryRef<FilterTeamData, FilterTeamVariables>;
}
export const filterTeamRef: FilterTeamRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterTeam(dc: DataConnect, vars?: FilterTeamVariables): QueryPromise<FilterTeamData, FilterTeamVariables>;

interface FilterTeamRef {
  ...
  (dc: DataConnect, vars?: FilterTeamVariables): QueryRef<FilterTeamData, FilterTeamVariables>;
}
export const filterTeamRef: FilterTeamRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterTeamRef:
```typescript
const name = filterTeamRef.operationName;
console.log(name);
```

### Variables
The `filterTeam` query has an optional argument of type `FilterTeamVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterTeamVariables {
  teamName?: string | null;
  ownerId?: string | null;
  ownerRole?: TeamOwnerRole | null;
}
```
### Return Type
Recall that executing the `filterTeam` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterTeamData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterTeamData {
  teams: ({
    id: UUIDString;
    teamName: string;
    ownerId: string;
    ownerName: string;
    ownerRole: TeamOwnerRole;
    favoriteStaff?: string | null;
    blockedStaff?: string | null;
  } & Team_Key)[];
}
```
### Using `filterTeam`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterTeam, FilterTeamVariables } from '@dataconnect/generated';

// The `filterTeam` query has an optional argument of type `FilterTeamVariables`:
const filterTeamVars: FilterTeamVariables = {
  teamName: ..., // optional
  ownerId: ..., // optional
  ownerRole: ..., // optional
};

// Call the `filterTeam()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterTeam(filterTeamVars);
// Variables can be defined inline as well.
const { data } = await filterTeam({ teamName: ..., ownerId: ..., ownerRole: ..., });
// Since all variables are optional for this query, you can omit the `FilterTeamVariables` argument.
const { data } = await filterTeam();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterTeam(dataConnect, filterTeamVars);

console.log(data.teams);

// Or, you can use the `Promise` API.
filterTeam(filterTeamVars).then((response) => {
  const data = response.data;
  console.log(data.teams);
});
```

### Using `filterTeam`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterTeamRef, FilterTeamVariables } from '@dataconnect/generated';

// The `filterTeam` query has an optional argument of type `FilterTeamVariables`:
const filterTeamVars: FilterTeamVariables = {
  teamName: ..., // optional
  ownerId: ..., // optional
  ownerRole: ..., // optional
};

// Call the `filterTeamRef()` function to get a reference to the query.
const ref = filterTeamRef(filterTeamVars);
// Variables can be defined inline as well.
const ref = filterTeamRef({ teamName: ..., ownerId: ..., ownerRole: ..., });
// Since all variables are optional for this query, you can omit the `FilterTeamVariables` argument.
const ref = filterTeamRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterTeamRef(dataConnect, filterTeamVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.teams);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.teams);
});
```

## listVendorRate
You can execute the `listVendorRate` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listVendorRate(): QueryPromise<ListVendorRateData, undefined>;

interface ListVendorRateRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListVendorRateData, undefined>;
}
export const listVendorRateRef: ListVendorRateRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listVendorRate(dc: DataConnect): QueryPromise<ListVendorRateData, undefined>;

interface ListVendorRateRef {
  ...
  (dc: DataConnect): QueryRef<ListVendorRateData, undefined>;
}
export const listVendorRateRef: ListVendorRateRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listVendorRateRef:
```typescript
const name = listVendorRateRef.operationName;
console.log(name);
```

### Variables
The `listVendorRate` query has no variables.
### Return Type
Recall that executing the `listVendorRate` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListVendorRateData {
  vendorRates: ({
    id: UUIDString;
    vendorName: string;
    category: VendorRateCategory;
    roleName: string;
    employeeWage: number;
    markupPercentage?: number | null;
    vendorFeePercentage?: number | null;
    clientRate: number;
  } & VendorRate_Key)[];
}
```
### Using `listVendorRate`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listVendorRate } from '@dataconnect/generated';


// Call the `listVendorRate()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listVendorRate();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listVendorRate(dataConnect);

console.log(data.vendorRates);

// Or, you can use the `Promise` API.
listVendorRate().then((response) => {
  const data = response.data;
  console.log(data.vendorRates);
});
```

### Using `listVendorRate`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listVendorRateRef } from '@dataconnect/generated';


// Call the `listVendorRateRef()` function to get a reference to the query.
const ref = listVendorRateRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listVendorRateRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.vendorRates);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.vendorRates);
});
```

## getVendorRateById
You can execute the `getVendorRateById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getVendorRateById(vars: GetVendorRateByIdVariables): QueryPromise<GetVendorRateByIdData, GetVendorRateByIdVariables>;

interface GetVendorRateByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetVendorRateByIdVariables): QueryRef<GetVendorRateByIdData, GetVendorRateByIdVariables>;
}
export const getVendorRateByIdRef: GetVendorRateByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getVendorRateById(dc: DataConnect, vars: GetVendorRateByIdVariables): QueryPromise<GetVendorRateByIdData, GetVendorRateByIdVariables>;

interface GetVendorRateByIdRef {
  ...
  (dc: DataConnect, vars: GetVendorRateByIdVariables): QueryRef<GetVendorRateByIdData, GetVendorRateByIdVariables>;
}
export const getVendorRateByIdRef: GetVendorRateByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getVendorRateByIdRef:
```typescript
const name = getVendorRateByIdRef.operationName;
console.log(name);
```

### Variables
The `getVendorRateById` query requires an argument of type `GetVendorRateByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetVendorRateByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getVendorRateById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetVendorRateByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetVendorRateByIdData {
  vendorRate?: {
    id: UUIDString;
    vendorName: string;
    category: VendorRateCategory;
    roleName: string;
    employeeWage: number;
    markupPercentage?: number | null;
    vendorFeePercentage?: number | null;
    clientRate: number;
    createdDate?: TimestampString | null;
    updatedDate?: TimestampString | null;
    createdBy?: string | null;
  } & VendorRate_Key;
}
```
### Using `getVendorRateById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getVendorRateById, GetVendorRateByIdVariables } from '@dataconnect/generated';

// The `getVendorRateById` query requires an argument of type `GetVendorRateByIdVariables`:
const getVendorRateByIdVars: GetVendorRateByIdVariables = {
  id: ..., 
};

// Call the `getVendorRateById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getVendorRateById(getVendorRateByIdVars);
// Variables can be defined inline as well.
const { data } = await getVendorRateById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getVendorRateById(dataConnect, getVendorRateByIdVars);

console.log(data.vendorRate);

// Or, you can use the `Promise` API.
getVendorRateById(getVendorRateByIdVars).then((response) => {
  const data = response.data;
  console.log(data.vendorRate);
});
```

### Using `getVendorRateById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getVendorRateByIdRef, GetVendorRateByIdVariables } from '@dataconnect/generated';

// The `getVendorRateById` query requires an argument of type `GetVendorRateByIdVariables`:
const getVendorRateByIdVars: GetVendorRateByIdVariables = {
  id: ..., 
};

// Call the `getVendorRateByIdRef()` function to get a reference to the query.
const ref = getVendorRateByIdRef(getVendorRateByIdVars);
// Variables can be defined inline as well.
const ref = getVendorRateByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getVendorRateByIdRef(dataConnect, getVendorRateByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.vendorRate);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.vendorRate);
});
```

## filterVendorRates
You can execute the `filterVendorRates` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterVendorRates(vars?: FilterVendorRatesVariables): QueryPromise<FilterVendorRatesData, FilterVendorRatesVariables>;

interface FilterVendorRatesRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterVendorRatesVariables): QueryRef<FilterVendorRatesData, FilterVendorRatesVariables>;
}
export const filterVendorRatesRef: FilterVendorRatesRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterVendorRates(dc: DataConnect, vars?: FilterVendorRatesVariables): QueryPromise<FilterVendorRatesData, FilterVendorRatesVariables>;

interface FilterVendorRatesRef {
  ...
  (dc: DataConnect, vars?: FilterVendorRatesVariables): QueryRef<FilterVendorRatesData, FilterVendorRatesVariables>;
}
export const filterVendorRatesRef: FilterVendorRatesRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterVendorRatesRef:
```typescript
const name = filterVendorRatesRef.operationName;
console.log(name);
```

### Variables
The `filterVendorRates` query has an optional argument of type `FilterVendorRatesVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterVendorRatesVariables {
  vendorName?: string | null;
  category?: VendorRateCategory | null;
  roleName?: string | null;
  minClientRate?: number | null;
  maxClientRate?: number | null;
}
```
### Return Type
Recall that executing the `filterVendorRates` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterVendorRatesData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterVendorRatesData {
  vendorRates: ({
    id: UUIDString;
    vendorName: string;
    category: VendorRateCategory;
    roleName: string;
    employeeWage: number;
    markupPercentage?: number | null;
    vendorFeePercentage?: number | null;
    clientRate: number;
  } & VendorRate_Key)[];
}
```
### Using `filterVendorRates`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterVendorRates, FilterVendorRatesVariables } from '@dataconnect/generated';

// The `filterVendorRates` query has an optional argument of type `FilterVendorRatesVariables`:
const filterVendorRatesVars: FilterVendorRatesVariables = {
  vendorName: ..., // optional
  category: ..., // optional
  roleName: ..., // optional
  minClientRate: ..., // optional
  maxClientRate: ..., // optional
};

// Call the `filterVendorRates()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterVendorRates(filterVendorRatesVars);
// Variables can be defined inline as well.
const { data } = await filterVendorRates({ vendorName: ..., category: ..., roleName: ..., minClientRate: ..., maxClientRate: ..., });
// Since all variables are optional for this query, you can omit the `FilterVendorRatesVariables` argument.
const { data } = await filterVendorRates();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterVendorRates(dataConnect, filterVendorRatesVars);

console.log(data.vendorRates);

// Or, you can use the `Promise` API.
filterVendorRates(filterVendorRatesVars).then((response) => {
  const data = response.data;
  console.log(data.vendorRates);
});
```

### Using `filterVendorRates`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterVendorRatesRef, FilterVendorRatesVariables } from '@dataconnect/generated';

// The `filterVendorRates` query has an optional argument of type `FilterVendorRatesVariables`:
const filterVendorRatesVars: FilterVendorRatesVariables = {
  vendorName: ..., // optional
  category: ..., // optional
  roleName: ..., // optional
  minClientRate: ..., // optional
  maxClientRate: ..., // optional
};

// Call the `filterVendorRatesRef()` function to get a reference to the query.
const ref = filterVendorRatesRef(filterVendorRatesVars);
// Variables can be defined inline as well.
const ref = filterVendorRatesRef({ vendorName: ..., category: ..., roleName: ..., minClientRate: ..., maxClientRate: ..., });
// Since all variables are optional for this query, you can omit the `FilterVendorRatesVariables` argument.
const ref = filterVendorRatesRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterVendorRatesRef(dataConnect, filterVendorRatesVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.vendorRates);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.vendorRates);
});
```

## listTeamHub
You can execute the `listTeamHub` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listTeamHub(): QueryPromise<ListTeamHubData, undefined>;

interface ListTeamHubRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListTeamHubData, undefined>;
}
export const listTeamHubRef: ListTeamHubRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listTeamHub(dc: DataConnect): QueryPromise<ListTeamHubData, undefined>;

interface ListTeamHubRef {
  ...
  (dc: DataConnect): QueryRef<ListTeamHubData, undefined>;
}
export const listTeamHubRef: ListTeamHubRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listTeamHubRef:
```typescript
const name = listTeamHubRef.operationName;
console.log(name);
```

### Variables
The `listTeamHub` query has no variables.
### Return Type
Recall that executing the `listTeamHub` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListTeamHubData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListTeamHubData {
  teamHubs: ({
    id: UUIDString;
    teamId: UUIDString;
    hubName: string;
    departments?: string | null;
  } & TeamHub_Key)[];
}
```
### Using `listTeamHub`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listTeamHub } from '@dataconnect/generated';


// Call the `listTeamHub()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listTeamHub();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listTeamHub(dataConnect);

console.log(data.teamHubs);

// Or, you can use the `Promise` API.
listTeamHub().then((response) => {
  const data = response.data;
  console.log(data.teamHubs);
});
```

### Using `listTeamHub`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listTeamHubRef } from '@dataconnect/generated';


// Call the `listTeamHubRef()` function to get a reference to the query.
const ref = listTeamHubRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listTeamHubRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.teamHubs);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.teamHubs);
});
```

## getTeamHubById
You can execute the `getTeamHubById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getTeamHubById(vars: GetTeamHubByIdVariables): QueryPromise<GetTeamHubByIdData, GetTeamHubByIdVariables>;

interface GetTeamHubByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetTeamHubByIdVariables): QueryRef<GetTeamHubByIdData, GetTeamHubByIdVariables>;
}
export const getTeamHubByIdRef: GetTeamHubByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getTeamHubById(dc: DataConnect, vars: GetTeamHubByIdVariables): QueryPromise<GetTeamHubByIdData, GetTeamHubByIdVariables>;

interface GetTeamHubByIdRef {
  ...
  (dc: DataConnect, vars: GetTeamHubByIdVariables): QueryRef<GetTeamHubByIdData, GetTeamHubByIdVariables>;
}
export const getTeamHubByIdRef: GetTeamHubByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getTeamHubByIdRef:
```typescript
const name = getTeamHubByIdRef.operationName;
console.log(name);
```

### Variables
The `getTeamHubById` query requires an argument of type `GetTeamHubByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetTeamHubByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getTeamHubById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetTeamHubByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetTeamHubByIdData {
  teamHub?: {
    id: UUIDString;
    teamId: UUIDString;
    hubName: string;
    departments?: string | null;
  } & TeamHub_Key;
}
```
### Using `getTeamHubById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getTeamHubById, GetTeamHubByIdVariables } from '@dataconnect/generated';

// The `getTeamHubById` query requires an argument of type `GetTeamHubByIdVariables`:
const getTeamHubByIdVars: GetTeamHubByIdVariables = {
  id: ..., 
};

// Call the `getTeamHubById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getTeamHubById(getTeamHubByIdVars);
// Variables can be defined inline as well.
const { data } = await getTeamHubById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getTeamHubById(dataConnect, getTeamHubByIdVars);

console.log(data.teamHub);

// Or, you can use the `Promise` API.
getTeamHubById(getTeamHubByIdVars).then((response) => {
  const data = response.data;
  console.log(data.teamHub);
});
```

### Using `getTeamHubById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getTeamHubByIdRef, GetTeamHubByIdVariables } from '@dataconnect/generated';

// The `getTeamHubById` query requires an argument of type `GetTeamHubByIdVariables`:
const getTeamHubByIdVars: GetTeamHubByIdVariables = {
  id: ..., 
};

// Call the `getTeamHubByIdRef()` function to get a reference to the query.
const ref = getTeamHubByIdRef(getTeamHubByIdVars);
// Variables can be defined inline as well.
const ref = getTeamHubByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getTeamHubByIdRef(dataConnect, getTeamHubByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.teamHub);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.teamHub);
});
```

## filterTeamHub
You can execute the `filterTeamHub` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterTeamHub(vars?: FilterTeamHubVariables): QueryPromise<FilterTeamHubData, FilterTeamHubVariables>;

interface FilterTeamHubRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterTeamHubVariables): QueryRef<FilterTeamHubData, FilterTeamHubVariables>;
}
export const filterTeamHubRef: FilterTeamHubRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterTeamHub(dc: DataConnect, vars?: FilterTeamHubVariables): QueryPromise<FilterTeamHubData, FilterTeamHubVariables>;

interface FilterTeamHubRef {
  ...
  (dc: DataConnect, vars?: FilterTeamHubVariables): QueryRef<FilterTeamHubData, FilterTeamHubVariables>;
}
export const filterTeamHubRef: FilterTeamHubRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterTeamHubRef:
```typescript
const name = filterTeamHubRef.operationName;
console.log(name);
```

### Variables
The `filterTeamHub` query has an optional argument of type `FilterTeamHubVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterTeamHubVariables {
  teamId?: UUIDString | null;
  hubName?: string | null;
}
```
### Return Type
Recall that executing the `filterTeamHub` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterTeamHubData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterTeamHubData {
  teamHubs: ({
    id: UUIDString;
    teamId: UUIDString;
    hubName: string;
    departments?: string | null;
  } & TeamHub_Key)[];
}
```
### Using `filterTeamHub`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterTeamHub, FilterTeamHubVariables } from '@dataconnect/generated';

// The `filterTeamHub` query has an optional argument of type `FilterTeamHubVariables`:
const filterTeamHubVars: FilterTeamHubVariables = {
  teamId: ..., // optional
  hubName: ..., // optional
};

// Call the `filterTeamHub()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterTeamHub(filterTeamHubVars);
// Variables can be defined inline as well.
const { data } = await filterTeamHub({ teamId: ..., hubName: ..., });
// Since all variables are optional for this query, you can omit the `FilterTeamHubVariables` argument.
const { data } = await filterTeamHub();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterTeamHub(dataConnect, filterTeamHubVars);

console.log(data.teamHubs);

// Or, you can use the `Promise` API.
filterTeamHub(filterTeamHubVars).then((response) => {
  const data = response.data;
  console.log(data.teamHubs);
});
```

### Using `filterTeamHub`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterTeamHubRef, FilterTeamHubVariables } from '@dataconnect/generated';

// The `filterTeamHub` query has an optional argument of type `FilterTeamHubVariables`:
const filterTeamHubVars: FilterTeamHubVariables = {
  teamId: ..., // optional
  hubName: ..., // optional
};

// Call the `filterTeamHubRef()` function to get a reference to the query.
const ref = filterTeamHubRef(filterTeamHubVars);
// Variables can be defined inline as well.
const ref = filterTeamHubRef({ teamId: ..., hubName: ..., });
// Since all variables are optional for this query, you can omit the `FilterTeamHubVariables` argument.
const ref = filterTeamHubRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterTeamHubRef(dataConnect, filterTeamHubVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.teamHubs);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.teamHubs);
});
```

## listBusiness
You can execute the `listBusiness` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
listBusiness(): QueryPromise<ListBusinessData, undefined>;

interface ListBusinessRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (): QueryRef<ListBusinessData, undefined>;
}
export const listBusinessRef: ListBusinessRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
listBusiness(dc: DataConnect): QueryPromise<ListBusinessData, undefined>;

interface ListBusinessRef {
  ...
  (dc: DataConnect): QueryRef<ListBusinessData, undefined>;
}
export const listBusinessRef: ListBusinessRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listBusinessRef:
```typescript
const name = listBusinessRef.operationName;
console.log(name);
```

### Variables
The `listBusiness` query has no variables.
### Return Type
Recall that executing the `listBusiness` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `ListBusinessData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface ListBusinessData {
  businesses: ({
    id: UUIDString;
    businessName: string;
    contactName: string;
    email?: string | null;
    sector?: BusinessSector | null;
    rateGroup: BusinessRateGroup;
    status?: BusinessStatus | null;
  } & Business_Key)[];
}
```
### Using `listBusiness`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, listBusiness } from '@dataconnect/generated';


// Call the `listBusiness()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await listBusiness();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await listBusiness(dataConnect);

console.log(data.businesses);

// Or, you can use the `Promise` API.
listBusiness().then((response) => {
  const data = response.data;
  console.log(data.businesses);
});
```

### Using `listBusiness`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, listBusinessRef } from '@dataconnect/generated';


// Call the `listBusinessRef()` function to get a reference to the query.
const ref = listBusinessRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = listBusinessRef(dataConnect);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.businesses);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.businesses);
});
```

## getBusinessById
You can execute the `getBusinessById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
getBusinessById(vars: GetBusinessByIdVariables): QueryPromise<GetBusinessByIdData, GetBusinessByIdVariables>;

interface GetBusinessByIdRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: GetBusinessByIdVariables): QueryRef<GetBusinessByIdData, GetBusinessByIdVariables>;
}
export const getBusinessByIdRef: GetBusinessByIdRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
getBusinessById(dc: DataConnect, vars: GetBusinessByIdVariables): QueryPromise<GetBusinessByIdData, GetBusinessByIdVariables>;

interface GetBusinessByIdRef {
  ...
  (dc: DataConnect, vars: GetBusinessByIdVariables): QueryRef<GetBusinessByIdData, GetBusinessByIdVariables>;
}
export const getBusinessByIdRef: GetBusinessByIdRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getBusinessByIdRef:
```typescript
const name = getBusinessByIdRef.operationName;
console.log(name);
```

### Variables
The `getBusinessById` query requires an argument of type `GetBusinessByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface GetBusinessByIdVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `getBusinessById` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `GetBusinessByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface GetBusinessByIdData {
  business?: {
    id: UUIDString;
    businessName: string;
    contactName: string;
    email?: string | null;
    sector?: BusinessSector | null;
    rateGroup: BusinessRateGroup;
    status?: BusinessStatus | null;
  } & Business_Key;
}
```
### Using `getBusinessById`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, getBusinessById, GetBusinessByIdVariables } from '@dataconnect/generated';

// The `getBusinessById` query requires an argument of type `GetBusinessByIdVariables`:
const getBusinessByIdVars: GetBusinessByIdVariables = {
  id: ..., 
};

// Call the `getBusinessById()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await getBusinessById(getBusinessByIdVars);
// Variables can be defined inline as well.
const { data } = await getBusinessById({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await getBusinessById(dataConnect, getBusinessByIdVars);

console.log(data.business);

// Or, you can use the `Promise` API.
getBusinessById(getBusinessByIdVars).then((response) => {
  const data = response.data;
  console.log(data.business);
});
```

### Using `getBusinessById`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, getBusinessByIdRef, GetBusinessByIdVariables } from '@dataconnect/generated';

// The `getBusinessById` query requires an argument of type `GetBusinessByIdVariables`:
const getBusinessByIdVars: GetBusinessByIdVariables = {
  id: ..., 
};

// Call the `getBusinessByIdRef()` function to get a reference to the query.
const ref = getBusinessByIdRef(getBusinessByIdVars);
// Variables can be defined inline as well.
const ref = getBusinessByIdRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = getBusinessByIdRef(dataConnect, getBusinessByIdVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.business);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.business);
});
```

## filterBusiness
You can execute the `filterBusiness` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
filterBusiness(vars?: FilterBusinessVariables): QueryPromise<FilterBusinessData, FilterBusinessVariables>;

interface FilterBusinessRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars?: FilterBusinessVariables): QueryRef<FilterBusinessData, FilterBusinessVariables>;
}
export const filterBusinessRef: FilterBusinessRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function.
```typescript
filterBusiness(dc: DataConnect, vars?: FilterBusinessVariables): QueryPromise<FilterBusinessData, FilterBusinessVariables>;

interface FilterBusinessRef {
  ...
  (dc: DataConnect, vars?: FilterBusinessVariables): QueryRef<FilterBusinessData, FilterBusinessVariables>;
}
export const filterBusinessRef: FilterBusinessRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterBusinessRef:
```typescript
const name = filterBusinessRef.operationName;
console.log(name);
```

### Variables
The `filterBusiness` query has an optional argument of type `FilterBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface FilterBusinessVariables {
  businessName?: string | null;
  contactName?: string | null;
  sector?: BusinessSector | null;
  rateGroup?: BusinessRateGroup | null;
  status?: BusinessStatus | null;
}
```
### Return Type
Recall that executing the `filterBusiness` query returns a `QueryPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `FilterBusinessData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface FilterBusinessData {
  businesses: ({
    id: UUIDString;
    businessName: string;
    contactName: string;
    email?: string | null;
    sector?: BusinessSector | null;
    rateGroup: BusinessRateGroup;
    status?: BusinessStatus | null;
  } & Business_Key)[];
}
```
### Using `filterBusiness`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, filterBusiness, FilterBusinessVariables } from '@dataconnect/generated';

// The `filterBusiness` query has an optional argument of type `FilterBusinessVariables`:
const filterBusinessVars: FilterBusinessVariables = {
  businessName: ..., // optional
  contactName: ..., // optional
  sector: ..., // optional
  rateGroup: ..., // optional
  status: ..., // optional
};

// Call the `filterBusiness()` function to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await filterBusiness(filterBusinessVars);
// Variables can be defined inline as well.
const { data } = await filterBusiness({ businessName: ..., contactName: ..., sector: ..., rateGroup: ..., status: ..., });
// Since all variables are optional for this query, you can omit the `FilterBusinessVariables` argument.
const { data } = await filterBusiness();

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await filterBusiness(dataConnect, filterBusinessVars);

console.log(data.businesses);

// Or, you can use the `Promise` API.
filterBusiness(filterBusinessVars).then((response) => {
  const data = response.data;
  console.log(data.businesses);
});
```

### Using `filterBusiness`'s `QueryRef` function

```typescript
import { getDataConnect, executeQuery } from 'firebase/data-connect';
import { connectorConfig, filterBusinessRef, FilterBusinessVariables } from '@dataconnect/generated';

// The `filterBusiness` query has an optional argument of type `FilterBusinessVariables`:
const filterBusinessVars: FilterBusinessVariables = {
  businessName: ..., // optional
  contactName: ..., // optional
  sector: ..., // optional
  rateGroup: ..., // optional
  status: ..., // optional
};

// Call the `filterBusinessRef()` function to get a reference to the query.
const ref = filterBusinessRef(filterBusinessVars);
// Variables can be defined inline as well.
const ref = filterBusinessRef({ businessName: ..., contactName: ..., sector: ..., rateGroup: ..., status: ..., });
// Since all variables are optional for this query, you can omit the `FilterBusinessVariables` argument.
const ref = filterBusinessRef();

// You can also pass in a `DataConnect` instance to the `QueryRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = filterBusinessRef(dataConnect, filterBusinessVars);

// Call `executeQuery()` on the reference to execute the query.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeQuery(ref);

console.log(data.businesses);

// Or, you can use the `Promise` API.
executeQuery(ref).then((response) => {
  const data = response.data;
  console.log(data.businesses);
});
```

# Mutations

There are two ways to execute a Data Connect Mutation using the generated Web SDK:
- Using a Mutation Reference function, which returns a `MutationRef`
  - The `MutationRef` can be used as an argument to `executeMutation()`, which will execute the Mutation and return a `MutationPromise`
- Using an action shortcut function, which returns a `MutationPromise`
  - Calling the action shortcut function will execute the Mutation and return a `MutationPromise`

The following is true for both the action shortcut function and the `MutationRef` function:
- The `MutationPromise` returned will resolve to the result of the Mutation once it has finished executing
- If the Mutation accepts arguments, both the action shortcut function and the `MutationRef` function accept a single argument: an object that contains all the required variables (and the optional variables) for the Mutation
- Both functions can be called with or without passing in a `DataConnect` instance as an argument. If no `DataConnect` argument is passed in, then the generated SDK will call `getDataConnect(connectorConfig)` behind the scenes for you.

Below are examples of how to use the `krow-connector` connector's generated functions to execute each mutation. You can also follow the examples from the [Data Connect documentation](https://firebase.google.com/docs/data-connect/web-sdk#using-mutations).

## CreateMessage
You can execute the `CreateMessage` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createMessage(vars: CreateMessageVariables): MutationPromise<CreateMessageData, CreateMessageVariables>;

interface CreateMessageRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateMessageVariables): MutationRef<CreateMessageData, CreateMessageVariables>;
}
export const createMessageRef: CreateMessageRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createMessage(dc: DataConnect, vars: CreateMessageVariables): MutationPromise<CreateMessageData, CreateMessageVariables>;

interface CreateMessageRef {
  ...
  (dc: DataConnect, vars: CreateMessageVariables): MutationRef<CreateMessageData, CreateMessageVariables>;
}
export const createMessageRef: CreateMessageRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createMessageRef:
```typescript
const name = createMessageRef.operationName;
console.log(name);
```

### Variables
The `CreateMessage` mutation requires an argument of type `CreateMessageVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateMessageVariables {
  conversationId: UUIDString;
  senderName: string;
  content: string;
  readBy?: string | null;
}
```
### Return Type
Recall that executing the `CreateMessage` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateMessageData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateMessageData {
  message_insert: Message_Key;
}
```
### Using `CreateMessage`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createMessage, CreateMessageVariables } from '@dataconnect/generated';

// The `CreateMessage` mutation requires an argument of type `CreateMessageVariables`:
const createMessageVars: CreateMessageVariables = {
  conversationId: ..., 
  senderName: ..., 
  content: ..., 
  readBy: ..., // optional
};

// Call the `createMessage()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createMessage(createMessageVars);
// Variables can be defined inline as well.
const { data } = await createMessage({ conversationId: ..., senderName: ..., content: ..., readBy: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createMessage(dataConnect, createMessageVars);

console.log(data.message_insert);

// Or, you can use the `Promise` API.
createMessage(createMessageVars).then((response) => {
  const data = response.data;
  console.log(data.message_insert);
});
```

### Using `CreateMessage`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createMessageRef, CreateMessageVariables } from '@dataconnect/generated';

// The `CreateMessage` mutation requires an argument of type `CreateMessageVariables`:
const createMessageVars: CreateMessageVariables = {
  conversationId: ..., 
  senderName: ..., 
  content: ..., 
  readBy: ..., // optional
};

// Call the `createMessageRef()` function to get a reference to the mutation.
const ref = createMessageRef(createMessageVars);
// Variables can be defined inline as well.
const ref = createMessageRef({ conversationId: ..., senderName: ..., content: ..., readBy: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createMessageRef(dataConnect, createMessageVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.message_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.message_insert);
});
```

## UpdateMessage
You can execute the `UpdateMessage` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateMessage(vars: UpdateMessageVariables): MutationPromise<UpdateMessageData, UpdateMessageVariables>;

interface UpdateMessageRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateMessageVariables): MutationRef<UpdateMessageData, UpdateMessageVariables>;
}
export const updateMessageRef: UpdateMessageRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateMessage(dc: DataConnect, vars: UpdateMessageVariables): MutationPromise<UpdateMessageData, UpdateMessageVariables>;

interface UpdateMessageRef {
  ...
  (dc: DataConnect, vars: UpdateMessageVariables): MutationRef<UpdateMessageData, UpdateMessageVariables>;
}
export const updateMessageRef: UpdateMessageRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateMessageRef:
```typescript
const name = updateMessageRef.operationName;
console.log(name);
```

### Variables
The `UpdateMessage` mutation requires an argument of type `UpdateMessageVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateMessageVariables {
  id: UUIDString;
  conversationId?: UUIDString | null;
  senderName?: string | null;
  content?: string | null;
  readBy?: string | null;
}
```
### Return Type
Recall that executing the `UpdateMessage` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateMessageData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateMessageData {
  message_update?: Message_Key | null;
}
```
### Using `UpdateMessage`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateMessage, UpdateMessageVariables } from '@dataconnect/generated';

// The `UpdateMessage` mutation requires an argument of type `UpdateMessageVariables`:
const updateMessageVars: UpdateMessageVariables = {
  id: ..., 
  conversationId: ..., // optional
  senderName: ..., // optional
  content: ..., // optional
  readBy: ..., // optional
};

// Call the `updateMessage()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateMessage(updateMessageVars);
// Variables can be defined inline as well.
const { data } = await updateMessage({ id: ..., conversationId: ..., senderName: ..., content: ..., readBy: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateMessage(dataConnect, updateMessageVars);

console.log(data.message_update);

// Or, you can use the `Promise` API.
updateMessage(updateMessageVars).then((response) => {
  const data = response.data;
  console.log(data.message_update);
});
```

### Using `UpdateMessage`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateMessageRef, UpdateMessageVariables } from '@dataconnect/generated';

// The `UpdateMessage` mutation requires an argument of type `UpdateMessageVariables`:
const updateMessageVars: UpdateMessageVariables = {
  id: ..., 
  conversationId: ..., // optional
  senderName: ..., // optional
  content: ..., // optional
  readBy: ..., // optional
};

// Call the `updateMessageRef()` function to get a reference to the mutation.
const ref = updateMessageRef(updateMessageVars);
// Variables can be defined inline as well.
const ref = updateMessageRef({ id: ..., conversationId: ..., senderName: ..., content: ..., readBy: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateMessageRef(dataConnect, updateMessageVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.message_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.message_update);
});
```

## DeleteMessage
You can execute the `DeleteMessage` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteMessage(vars: DeleteMessageVariables): MutationPromise<DeleteMessageData, DeleteMessageVariables>;

interface DeleteMessageRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteMessageVariables): MutationRef<DeleteMessageData, DeleteMessageVariables>;
}
export const deleteMessageRef: DeleteMessageRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteMessage(dc: DataConnect, vars: DeleteMessageVariables): MutationPromise<DeleteMessageData, DeleteMessageVariables>;

interface DeleteMessageRef {
  ...
  (dc: DataConnect, vars: DeleteMessageVariables): MutationRef<DeleteMessageData, DeleteMessageVariables>;
}
export const deleteMessageRef: DeleteMessageRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteMessageRef:
```typescript
const name = deleteMessageRef.operationName;
console.log(name);
```

### Variables
The `DeleteMessage` mutation requires an argument of type `DeleteMessageVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteMessageVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteMessage` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteMessageData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteMessageData {
  message_delete?: Message_Key | null;
}
```
### Using `DeleteMessage`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteMessage, DeleteMessageVariables } from '@dataconnect/generated';

// The `DeleteMessage` mutation requires an argument of type `DeleteMessageVariables`:
const deleteMessageVars: DeleteMessageVariables = {
  id: ..., 
};

// Call the `deleteMessage()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteMessage(deleteMessageVars);
// Variables can be defined inline as well.
const { data } = await deleteMessage({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteMessage(dataConnect, deleteMessageVars);

console.log(data.message_delete);

// Or, you can use the `Promise` API.
deleteMessage(deleteMessageVars).then((response) => {
  const data = response.data;
  console.log(data.message_delete);
});
```

### Using `DeleteMessage`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteMessageRef, DeleteMessageVariables } from '@dataconnect/generated';

// The `DeleteMessage` mutation requires an argument of type `DeleteMessageVariables`:
const deleteMessageVars: DeleteMessageVariables = {
  id: ..., 
};

// Call the `deleteMessageRef()` function to get a reference to the mutation.
const ref = deleteMessageRef(deleteMessageVars);
// Variables can be defined inline as well.
const ref = deleteMessageRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteMessageRef(dataConnect, deleteMessageVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.message_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.message_delete);
});
```

## CreateStaff
You can execute the `CreateStaff` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createStaff(vars: CreateStaffVariables): MutationPromise<CreateStaffData, CreateStaffVariables>;

interface CreateStaffRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateStaffVariables): MutationRef<CreateStaffData, CreateStaffVariables>;
}
export const createStaffRef: CreateStaffRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createStaff(dc: DataConnect, vars: CreateStaffVariables): MutationPromise<CreateStaffData, CreateStaffVariables>;

interface CreateStaffRef {
  ...
  (dc: DataConnect, vars: CreateStaffVariables): MutationRef<CreateStaffData, CreateStaffVariables>;
}
export const createStaffRef: CreateStaffRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createStaffRef:
```typescript
const name = createStaffRef.operationName;
console.log(name);
```

### Variables
The `CreateStaff` mutation requires an argument of type `CreateStaffVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateStaffVariables {
  employeeName: string;
  vendorId?: string | null;
  vendorName?: string | null;
  manager?: string | null;
  contactNumber?: string | null;
  phone?: string | null;
  email?: string | null;
  department?: StaffDepartment | null;
  hubLocation?: string | null;
  eventLocation?: string | null;
  address?: string | null;
  city?: string | null;
  track?: string | null;
  position?: string | null;
  position2?: string | null;
  initial?: string | null;
  profileType?: ProfileType | null;
  employmentType?: EmploymentType | null;
  english?: EnglishLevel | null;
  rate?: number | null;
  rating?: number | null;
  reliabilityScore?: number | null;
  backgroundCheckStatus?: BackgroundCheckStatus | null;
  notes?: string | null;
  accountingComments?: string | null;
  shiftCoveragePercentage?: number | null;
  cancellationCount?: number | null;
  noShowCount?: number | null;
  totalShifts?: number | null;
  invoiced?: boolean | null;
  englishRequired?: boolean | null;
  checkIn?: string | null;
  scheduleDays?: string | null;
  replacedBy?: string | null;
  action?: string | null;
  ro?: string | null;
  mon?: string | null;
}
```
### Return Type
Recall that executing the `CreateStaff` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateStaffData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateStaffData {
  staff_insert: Staff_Key;
}
```
### Using `CreateStaff`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createStaff, CreateStaffVariables } from '@dataconnect/generated';

// The `CreateStaff` mutation requires an argument of type `CreateStaffVariables`:
const createStaffVars: CreateStaffVariables = {
  employeeName: ..., 
  vendorId: ..., // optional
  vendorName: ..., // optional
  manager: ..., // optional
  contactNumber: ..., // optional
  phone: ..., // optional
  email: ..., // optional
  department: ..., // optional
  hubLocation: ..., // optional
  eventLocation: ..., // optional
  address: ..., // optional
  city: ..., // optional
  track: ..., // optional
  position: ..., // optional
  position2: ..., // optional
  initial: ..., // optional
  profileType: ..., // optional
  employmentType: ..., // optional
  english: ..., // optional
  rate: ..., // optional
  rating: ..., // optional
  reliabilityScore: ..., // optional
  backgroundCheckStatus: ..., // optional
  notes: ..., // optional
  accountingComments: ..., // optional
  shiftCoveragePercentage: ..., // optional
  cancellationCount: ..., // optional
  noShowCount: ..., // optional
  totalShifts: ..., // optional
  invoiced: ..., // optional
  englishRequired: ..., // optional
  checkIn: ..., // optional
  scheduleDays: ..., // optional
  replacedBy: ..., // optional
  action: ..., // optional
  ro: ..., // optional
  mon: ..., // optional
};

// Call the `createStaff()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createStaff(createStaffVars);
// Variables can be defined inline as well.
const { data } = await createStaff({ employeeName: ..., vendorId: ..., vendorName: ..., manager: ..., contactNumber: ..., phone: ..., email: ..., department: ..., hubLocation: ..., eventLocation: ..., address: ..., city: ..., track: ..., position: ..., position2: ..., initial: ..., profileType: ..., employmentType: ..., english: ..., rate: ..., rating: ..., reliabilityScore: ..., backgroundCheckStatus: ..., notes: ..., accountingComments: ..., shiftCoveragePercentage: ..., cancellationCount: ..., noShowCount: ..., totalShifts: ..., invoiced: ..., englishRequired: ..., checkIn: ..., scheduleDays: ..., replacedBy: ..., action: ..., ro: ..., mon: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createStaff(dataConnect, createStaffVars);

console.log(data.staff_insert);

// Or, you can use the `Promise` API.
createStaff(createStaffVars).then((response) => {
  const data = response.data;
  console.log(data.staff_insert);
});
```

### Using `CreateStaff`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createStaffRef, CreateStaffVariables } from '@dataconnect/generated';

// The `CreateStaff` mutation requires an argument of type `CreateStaffVariables`:
const createStaffVars: CreateStaffVariables = {
  employeeName: ..., 
  vendorId: ..., // optional
  vendorName: ..., // optional
  manager: ..., // optional
  contactNumber: ..., // optional
  phone: ..., // optional
  email: ..., // optional
  department: ..., // optional
  hubLocation: ..., // optional
  eventLocation: ..., // optional
  address: ..., // optional
  city: ..., // optional
  track: ..., // optional
  position: ..., // optional
  position2: ..., // optional
  initial: ..., // optional
  profileType: ..., // optional
  employmentType: ..., // optional
  english: ..., // optional
  rate: ..., // optional
  rating: ..., // optional
  reliabilityScore: ..., // optional
  backgroundCheckStatus: ..., // optional
  notes: ..., // optional
  accountingComments: ..., // optional
  shiftCoveragePercentage: ..., // optional
  cancellationCount: ..., // optional
  noShowCount: ..., // optional
  totalShifts: ..., // optional
  invoiced: ..., // optional
  englishRequired: ..., // optional
  checkIn: ..., // optional
  scheduleDays: ..., // optional
  replacedBy: ..., // optional
  action: ..., // optional
  ro: ..., // optional
  mon: ..., // optional
};

// Call the `createStaffRef()` function to get a reference to the mutation.
const ref = createStaffRef(createStaffVars);
// Variables can be defined inline as well.
const ref = createStaffRef({ employeeName: ..., vendorId: ..., vendorName: ..., manager: ..., contactNumber: ..., phone: ..., email: ..., department: ..., hubLocation: ..., eventLocation: ..., address: ..., city: ..., track: ..., position: ..., position2: ..., initial: ..., profileType: ..., employmentType: ..., english: ..., rate: ..., rating: ..., reliabilityScore: ..., backgroundCheckStatus: ..., notes: ..., accountingComments: ..., shiftCoveragePercentage: ..., cancellationCount: ..., noShowCount: ..., totalShifts: ..., invoiced: ..., englishRequired: ..., checkIn: ..., scheduleDays: ..., replacedBy: ..., action: ..., ro: ..., mon: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createStaffRef(dataConnect, createStaffVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.staff_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.staff_insert);
});
```

## UpdateStaff
You can execute the `UpdateStaff` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateStaff(vars: UpdateStaffVariables): MutationPromise<UpdateStaffData, UpdateStaffVariables>;

interface UpdateStaffRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateStaffVariables): MutationRef<UpdateStaffData, UpdateStaffVariables>;
}
export const updateStaffRef: UpdateStaffRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateStaff(dc: DataConnect, vars: UpdateStaffVariables): MutationPromise<UpdateStaffData, UpdateStaffVariables>;

interface UpdateStaffRef {
  ...
  (dc: DataConnect, vars: UpdateStaffVariables): MutationRef<UpdateStaffData, UpdateStaffVariables>;
}
export const updateStaffRef: UpdateStaffRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateStaffRef:
```typescript
const name = updateStaffRef.operationName;
console.log(name);
```

### Variables
The `UpdateStaff` mutation requires an argument of type `UpdateStaffVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateStaffVariables {
  id: UUIDString;
  employeeName?: string | null;
  vendorId?: string | null;
  vendorName?: string | null;
  manager?: string | null;
  contactNumber?: string | null;
  phone?: string | null;
  email?: string | null;
  department?: StaffDepartment | null;
  hubLocation?: string | null;
  eventLocation?: string | null;
  address?: string | null;
  city?: string | null;
  track?: string | null;
  position?: string | null;
  position2?: string | null;
  initial?: string | null;
  profileType?: ProfileType | null;
  employmentType?: EmploymentType | null;
  english?: EnglishLevel | null;
  englishRequired?: boolean | null;
  rate?: number | null;
  rating?: number | null;
  reliabilityScore?: number | null;
  backgroundCheckStatus?: BackgroundCheckStatus | null;
  notes?: string | null;
  accountingComments?: string | null;
  shiftCoveragePercentage?: number | null;
  cancellationCount?: number | null;
  noShowCount?: number | null;
  totalShifts?: number | null;
  invoiced?: boolean | null;
  checkIn?: string | null;
  scheduleDays?: string | null;
  replacedBy?: string | null;
  action?: string | null;
  ro?: string | null;
  mon?: string | null;
}
```
### Return Type
Recall that executing the `UpdateStaff` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateStaffData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateStaffData {
  staff_update?: Staff_Key | null;
}
```
### Using `UpdateStaff`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateStaff, UpdateStaffVariables } from '@dataconnect/generated';

// The `UpdateStaff` mutation requires an argument of type `UpdateStaffVariables`:
const updateStaffVars: UpdateStaffVariables = {
  id: ..., 
  employeeName: ..., // optional
  vendorId: ..., // optional
  vendorName: ..., // optional
  manager: ..., // optional
  contactNumber: ..., // optional
  phone: ..., // optional
  email: ..., // optional
  department: ..., // optional
  hubLocation: ..., // optional
  eventLocation: ..., // optional
  address: ..., // optional
  city: ..., // optional
  track: ..., // optional
  position: ..., // optional
  position2: ..., // optional
  initial: ..., // optional
  profileType: ..., // optional
  employmentType: ..., // optional
  english: ..., // optional
  englishRequired: ..., // optional
  rate: ..., // optional
  rating: ..., // optional
  reliabilityScore: ..., // optional
  backgroundCheckStatus: ..., // optional
  notes: ..., // optional
  accountingComments: ..., // optional
  shiftCoveragePercentage: ..., // optional
  cancellationCount: ..., // optional
  noShowCount: ..., // optional
  totalShifts: ..., // optional
  invoiced: ..., // optional
  checkIn: ..., // optional
  scheduleDays: ..., // optional
  replacedBy: ..., // optional
  action: ..., // optional
  ro: ..., // optional
  mon: ..., // optional
};

// Call the `updateStaff()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateStaff(updateStaffVars);
// Variables can be defined inline as well.
const { data } = await updateStaff({ id: ..., employeeName: ..., vendorId: ..., vendorName: ..., manager: ..., contactNumber: ..., phone: ..., email: ..., department: ..., hubLocation: ..., eventLocation: ..., address: ..., city: ..., track: ..., position: ..., position2: ..., initial: ..., profileType: ..., employmentType: ..., english: ..., englishRequired: ..., rate: ..., rating: ..., reliabilityScore: ..., backgroundCheckStatus: ..., notes: ..., accountingComments: ..., shiftCoveragePercentage: ..., cancellationCount: ..., noShowCount: ..., totalShifts: ..., invoiced: ..., checkIn: ..., scheduleDays: ..., replacedBy: ..., action: ..., ro: ..., mon: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateStaff(dataConnect, updateStaffVars);

console.log(data.staff_update);

// Or, you can use the `Promise` API.
updateStaff(updateStaffVars).then((response) => {
  const data = response.data;
  console.log(data.staff_update);
});
```

### Using `UpdateStaff`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateStaffRef, UpdateStaffVariables } from '@dataconnect/generated';

// The `UpdateStaff` mutation requires an argument of type `UpdateStaffVariables`:
const updateStaffVars: UpdateStaffVariables = {
  id: ..., 
  employeeName: ..., // optional
  vendorId: ..., // optional
  vendorName: ..., // optional
  manager: ..., // optional
  contactNumber: ..., // optional
  phone: ..., // optional
  email: ..., // optional
  department: ..., // optional
  hubLocation: ..., // optional
  eventLocation: ..., // optional
  address: ..., // optional
  city: ..., // optional
  track: ..., // optional
  position: ..., // optional
  position2: ..., // optional
  initial: ..., // optional
  profileType: ..., // optional
  employmentType: ..., // optional
  english: ..., // optional
  englishRequired: ..., // optional
  rate: ..., // optional
  rating: ..., // optional
  reliabilityScore: ..., // optional
  backgroundCheckStatus: ..., // optional
  notes: ..., // optional
  accountingComments: ..., // optional
  shiftCoveragePercentage: ..., // optional
  cancellationCount: ..., // optional
  noShowCount: ..., // optional
  totalShifts: ..., // optional
  invoiced: ..., // optional
  checkIn: ..., // optional
  scheduleDays: ..., // optional
  replacedBy: ..., // optional
  action: ..., // optional
  ro: ..., // optional
  mon: ..., // optional
};

// Call the `updateStaffRef()` function to get a reference to the mutation.
const ref = updateStaffRef(updateStaffVars);
// Variables can be defined inline as well.
const ref = updateStaffRef({ id: ..., employeeName: ..., vendorId: ..., vendorName: ..., manager: ..., contactNumber: ..., phone: ..., email: ..., department: ..., hubLocation: ..., eventLocation: ..., address: ..., city: ..., track: ..., position: ..., position2: ..., initial: ..., profileType: ..., employmentType: ..., english: ..., englishRequired: ..., rate: ..., rating: ..., reliabilityScore: ..., backgroundCheckStatus: ..., notes: ..., accountingComments: ..., shiftCoveragePercentage: ..., cancellationCount: ..., noShowCount: ..., totalShifts: ..., invoiced: ..., checkIn: ..., scheduleDays: ..., replacedBy: ..., action: ..., ro: ..., mon: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateStaffRef(dataConnect, updateStaffVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.staff_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.staff_update);
});
```

## DeleteStaff
You can execute the `DeleteStaff` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteStaff(vars: DeleteStaffVariables): MutationPromise<DeleteStaffData, DeleteStaffVariables>;

interface DeleteStaffRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteStaffVariables): MutationRef<DeleteStaffData, DeleteStaffVariables>;
}
export const deleteStaffRef: DeleteStaffRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteStaff(dc: DataConnect, vars: DeleteStaffVariables): MutationPromise<DeleteStaffData, DeleteStaffVariables>;

interface DeleteStaffRef {
  ...
  (dc: DataConnect, vars: DeleteStaffVariables): MutationRef<DeleteStaffData, DeleteStaffVariables>;
}
export const deleteStaffRef: DeleteStaffRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteStaffRef:
```typescript
const name = deleteStaffRef.operationName;
console.log(name);
```

### Variables
The `DeleteStaff` mutation requires an argument of type `DeleteStaffVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteStaffVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteStaff` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteStaffData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteStaffData {
  staff_delete?: Staff_Key | null;
}
```
### Using `DeleteStaff`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteStaff, DeleteStaffVariables } from '@dataconnect/generated';

// The `DeleteStaff` mutation requires an argument of type `DeleteStaffVariables`:
const deleteStaffVars: DeleteStaffVariables = {
  id: ..., 
};

// Call the `deleteStaff()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteStaff(deleteStaffVars);
// Variables can be defined inline as well.
const { data } = await deleteStaff({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteStaff(dataConnect, deleteStaffVars);

console.log(data.staff_delete);

// Or, you can use the `Promise` API.
deleteStaff(deleteStaffVars).then((response) => {
  const data = response.data;
  console.log(data.staff_delete);
});
```

### Using `DeleteStaff`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteStaffRef, DeleteStaffVariables } from '@dataconnect/generated';

// The `DeleteStaff` mutation requires an argument of type `DeleteStaffVariables`:
const deleteStaffVars: DeleteStaffVariables = {
  id: ..., 
};

// Call the `deleteStaffRef()` function to get a reference to the mutation.
const ref = deleteStaffRef(deleteStaffVars);
// Variables can be defined inline as well.
const ref = deleteStaffRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteStaffRef(dataConnect, deleteStaffVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.staff_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.staff_delete);
});
```

## CreateVendor
You can execute the `CreateVendor` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createVendor(vars: CreateVendorVariables): MutationPromise<CreateVendorData, CreateVendorVariables>;

interface CreateVendorRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateVendorVariables): MutationRef<CreateVendorData, CreateVendorVariables>;
}
export const createVendorRef: CreateVendorRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createVendor(dc: DataConnect, vars: CreateVendorVariables): MutationPromise<CreateVendorData, CreateVendorVariables>;

interface CreateVendorRef {
  ...
  (dc: DataConnect, vars: CreateVendorVariables): MutationRef<CreateVendorData, CreateVendorVariables>;
}
export const createVendorRef: CreateVendorRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createVendorRef:
```typescript
const name = createVendorRef.operationName;
console.log(name);
```

### Variables
The `CreateVendor` mutation requires an argument of type `CreateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateVendorVariables {
  vendorNumber: string;
  legalName: string;
  region: VendorRegion;
  platformType: VendorPlatformType;
  primaryContactEmail: string;
  approvalStatus: VendorApprovalStatus;
  isActive?: boolean | null;
}
```
### Return Type
Recall that executing the `CreateVendor` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateVendorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateVendorData {
  vendor_insert: Vendor_Key;
}
```
### Using `CreateVendor`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createVendor, CreateVendorVariables } from '@dataconnect/generated';

// The `CreateVendor` mutation requires an argument of type `CreateVendorVariables`:
const createVendorVars: CreateVendorVariables = {
  vendorNumber: ..., 
  legalName: ..., 
  region: ..., 
  platformType: ..., 
  primaryContactEmail: ..., 
  approvalStatus: ..., 
  isActive: ..., // optional
};

// Call the `createVendor()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createVendor(createVendorVars);
// Variables can be defined inline as well.
const { data } = await createVendor({ vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createVendor(dataConnect, createVendorVars);

console.log(data.vendor_insert);

// Or, you can use the `Promise` API.
createVendor(createVendorVars).then((response) => {
  const data = response.data;
  console.log(data.vendor_insert);
});
```

### Using `CreateVendor`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createVendorRef, CreateVendorVariables } from '@dataconnect/generated';

// The `CreateVendor` mutation requires an argument of type `CreateVendorVariables`:
const createVendorVars: CreateVendorVariables = {
  vendorNumber: ..., 
  legalName: ..., 
  region: ..., 
  platformType: ..., 
  primaryContactEmail: ..., 
  approvalStatus: ..., 
  isActive: ..., // optional
};

// Call the `createVendorRef()` function to get a reference to the mutation.
const ref = createVendorRef(createVendorVars);
// Variables can be defined inline as well.
const ref = createVendorRef({ vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createVendorRef(dataConnect, createVendorVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.vendor_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.vendor_insert);
});
```

## UpdateVendor
You can execute the `UpdateVendor` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateVendor(vars: UpdateVendorVariables): MutationPromise<UpdateVendorData, UpdateVendorVariables>;

interface UpdateVendorRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateVendorVariables): MutationRef<UpdateVendorData, UpdateVendorVariables>;
}
export const updateVendorRef: UpdateVendorRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateVendor(dc: DataConnect, vars: UpdateVendorVariables): MutationPromise<UpdateVendorData, UpdateVendorVariables>;

interface UpdateVendorRef {
  ...
  (dc: DataConnect, vars: UpdateVendorVariables): MutationRef<UpdateVendorData, UpdateVendorVariables>;
}
export const updateVendorRef: UpdateVendorRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateVendorRef:
```typescript
const name = updateVendorRef.operationName;
console.log(name);
```

### Variables
The `UpdateVendor` mutation requires an argument of type `UpdateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateVendorVariables {
  id: UUIDString;
  vendorNumber?: string | null;
  legalName?: string | null;
  region?: VendorRegion | null;
  platformType?: VendorPlatformType | null;
  primaryContactEmail?: string | null;
  approvalStatus?: VendorApprovalStatus | null;
  isActive?: boolean | null;
}
```
### Return Type
Recall that executing the `UpdateVendor` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateVendorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateVendorData {
  vendor_update?: Vendor_Key | null;
}
```
### Using `UpdateVendor`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateVendor, UpdateVendorVariables } from '@dataconnect/generated';

// The `UpdateVendor` mutation requires an argument of type `UpdateVendorVariables`:
const updateVendorVars: UpdateVendorVariables = {
  id: ..., 
  vendorNumber: ..., // optional
  legalName: ..., // optional
  region: ..., // optional
  platformType: ..., // optional
  primaryContactEmail: ..., // optional
  approvalStatus: ..., // optional
  isActive: ..., // optional
};

// Call the `updateVendor()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateVendor(updateVendorVars);
// Variables can be defined inline as well.
const { data } = await updateVendor({ id: ..., vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateVendor(dataConnect, updateVendorVars);

console.log(data.vendor_update);

// Or, you can use the `Promise` API.
updateVendor(updateVendorVars).then((response) => {
  const data = response.data;
  console.log(data.vendor_update);
});
```

### Using `UpdateVendor`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateVendorRef, UpdateVendorVariables } from '@dataconnect/generated';

// The `UpdateVendor` mutation requires an argument of type `UpdateVendorVariables`:
const updateVendorVars: UpdateVendorVariables = {
  id: ..., 
  vendorNumber: ..., // optional
  legalName: ..., // optional
  region: ..., // optional
  platformType: ..., // optional
  primaryContactEmail: ..., // optional
  approvalStatus: ..., // optional
  isActive: ..., // optional
};

// Call the `updateVendorRef()` function to get a reference to the mutation.
const ref = updateVendorRef(updateVendorVars);
// Variables can be defined inline as well.
const ref = updateVendorRef({ id: ..., vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateVendorRef(dataConnect, updateVendorVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.vendor_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.vendor_update);
});
```

## DeleteVendor
You can execute the `DeleteVendor` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteVendor(vars: DeleteVendorVariables): MutationPromise<DeleteVendorData, DeleteVendorVariables>;

interface DeleteVendorRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteVendorVariables): MutationRef<DeleteVendorData, DeleteVendorVariables>;
}
export const deleteVendorRef: DeleteVendorRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteVendor(dc: DataConnect, vars: DeleteVendorVariables): MutationPromise<DeleteVendorData, DeleteVendorVariables>;

interface DeleteVendorRef {
  ...
  (dc: DataConnect, vars: DeleteVendorVariables): MutationRef<DeleteVendorData, DeleteVendorVariables>;
}
export const deleteVendorRef: DeleteVendorRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteVendorRef:
```typescript
const name = deleteVendorRef.operationName;
console.log(name);
```

### Variables
The `DeleteVendor` mutation requires an argument of type `DeleteVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteVendorVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteVendor` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteVendorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteVendorData {
  vendor_delete?: Vendor_Key | null;
}
```
### Using `DeleteVendor`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteVendor, DeleteVendorVariables } from '@dataconnect/generated';

// The `DeleteVendor` mutation requires an argument of type `DeleteVendorVariables`:
const deleteVendorVars: DeleteVendorVariables = {
  id: ..., 
};

// Call the `deleteVendor()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteVendor(deleteVendorVars);
// Variables can be defined inline as well.
const { data } = await deleteVendor({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteVendor(dataConnect, deleteVendorVars);

console.log(data.vendor_delete);

// Or, you can use the `Promise` API.
deleteVendor(deleteVendorVars).then((response) => {
  const data = response.data;
  console.log(data.vendor_delete);
});
```

### Using `DeleteVendor`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteVendorRef, DeleteVendorVariables } from '@dataconnect/generated';

// The `DeleteVendor` mutation requires an argument of type `DeleteVendorVariables`:
const deleteVendorVars: DeleteVendorVariables = {
  id: ..., 
};

// Call the `deleteVendorRef()` function to get a reference to the mutation.
const ref = deleteVendorRef(deleteVendorVars);
// Variables can be defined inline as well.
const ref = deleteVendorRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteVendorRef(dataConnect, deleteVendorVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.vendor_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.vendor_delete);
});
```

## CreateActivityLog
You can execute the `CreateActivityLog` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createActivityLog(vars: CreateActivityLogVariables): MutationPromise<CreateActivityLogData, CreateActivityLogVariables>;

interface CreateActivityLogRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateActivityLogVariables): MutationRef<CreateActivityLogData, CreateActivityLogVariables>;
}
export const createActivityLogRef: CreateActivityLogRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createActivityLog(dc: DataConnect, vars: CreateActivityLogVariables): MutationPromise<CreateActivityLogData, CreateActivityLogVariables>;

interface CreateActivityLogRef {
  ...
  (dc: DataConnect, vars: CreateActivityLogVariables): MutationRef<CreateActivityLogData, CreateActivityLogVariables>;
}
export const createActivityLogRef: CreateActivityLogRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createActivityLogRef:
```typescript
const name = createActivityLogRef.operationName;
console.log(name);
```

### Variables
The `CreateActivityLog` mutation requires an argument of type `CreateActivityLogVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateActivityLogVariables {
  title: string;
  description: string;
  activityType: ActivityType;
  userId: string;
  isRead?: boolean | null;
  iconType?: string | null;
  iconColor?: string | null;
}
```
### Return Type
Recall that executing the `CreateActivityLog` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateActivityLogData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateActivityLogData {
  activityLog_insert: ActivityLog_Key;
}
```
### Using `CreateActivityLog`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createActivityLog, CreateActivityLogVariables } from '@dataconnect/generated';

// The `CreateActivityLog` mutation requires an argument of type `CreateActivityLogVariables`:
const createActivityLogVars: CreateActivityLogVariables = {
  title: ..., 
  description: ..., 
  activityType: ..., 
  userId: ..., 
  isRead: ..., // optional
  iconType: ..., // optional
  iconColor: ..., // optional
};

// Call the `createActivityLog()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createActivityLog(createActivityLogVars);
// Variables can be defined inline as well.
const { data } = await createActivityLog({ title: ..., description: ..., activityType: ..., userId: ..., isRead: ..., iconType: ..., iconColor: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createActivityLog(dataConnect, createActivityLogVars);

console.log(data.activityLog_insert);

// Or, you can use the `Promise` API.
createActivityLog(createActivityLogVars).then((response) => {
  const data = response.data;
  console.log(data.activityLog_insert);
});
```

### Using `CreateActivityLog`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createActivityLogRef, CreateActivityLogVariables } from '@dataconnect/generated';

// The `CreateActivityLog` mutation requires an argument of type `CreateActivityLogVariables`:
const createActivityLogVars: CreateActivityLogVariables = {
  title: ..., 
  description: ..., 
  activityType: ..., 
  userId: ..., 
  isRead: ..., // optional
  iconType: ..., // optional
  iconColor: ..., // optional
};

// Call the `createActivityLogRef()` function to get a reference to the mutation.
const ref = createActivityLogRef(createActivityLogVars);
// Variables can be defined inline as well.
const ref = createActivityLogRef({ title: ..., description: ..., activityType: ..., userId: ..., isRead: ..., iconType: ..., iconColor: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createActivityLogRef(dataConnect, createActivityLogVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.activityLog_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.activityLog_insert);
});
```

## UpdateActivityLog
You can execute the `UpdateActivityLog` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateActivityLog(vars: UpdateActivityLogVariables): MutationPromise<UpdateActivityLogData, UpdateActivityLogVariables>;

interface UpdateActivityLogRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateActivityLogVariables): MutationRef<UpdateActivityLogData, UpdateActivityLogVariables>;
}
export const updateActivityLogRef: UpdateActivityLogRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateActivityLog(dc: DataConnect, vars: UpdateActivityLogVariables): MutationPromise<UpdateActivityLogData, UpdateActivityLogVariables>;

interface UpdateActivityLogRef {
  ...
  (dc: DataConnect, vars: UpdateActivityLogVariables): MutationRef<UpdateActivityLogData, UpdateActivityLogVariables>;
}
export const updateActivityLogRef: UpdateActivityLogRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateActivityLogRef:
```typescript
const name = updateActivityLogRef.operationName;
console.log(name);
```

### Variables
The `UpdateActivityLog` mutation requires an argument of type `UpdateActivityLogVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateActivityLogVariables {
  id: UUIDString;
  title?: string | null;
  description?: string | null;
  activityType?: ActivityType | null;
  userId?: string | null;
  isRead?: boolean | null;
  iconType?: string | null;
  iconColor?: string | null;
}
```
### Return Type
Recall that executing the `UpdateActivityLog` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateActivityLogData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateActivityLogData {
  activityLog_update?: ActivityLog_Key | null;
}
```
### Using `UpdateActivityLog`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateActivityLog, UpdateActivityLogVariables } from '@dataconnect/generated';

// The `UpdateActivityLog` mutation requires an argument of type `UpdateActivityLogVariables`:
const updateActivityLogVars: UpdateActivityLogVariables = {
  id: ..., 
  title: ..., // optional
  description: ..., // optional
  activityType: ..., // optional
  userId: ..., // optional
  isRead: ..., // optional
  iconType: ..., // optional
  iconColor: ..., // optional
};

// Call the `updateActivityLog()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateActivityLog(updateActivityLogVars);
// Variables can be defined inline as well.
const { data } = await updateActivityLog({ id: ..., title: ..., description: ..., activityType: ..., userId: ..., isRead: ..., iconType: ..., iconColor: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateActivityLog(dataConnect, updateActivityLogVars);

console.log(data.activityLog_update);

// Or, you can use the `Promise` API.
updateActivityLog(updateActivityLogVars).then((response) => {
  const data = response.data;
  console.log(data.activityLog_update);
});
```

### Using `UpdateActivityLog`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateActivityLogRef, UpdateActivityLogVariables } from '@dataconnect/generated';

// The `UpdateActivityLog` mutation requires an argument of type `UpdateActivityLogVariables`:
const updateActivityLogVars: UpdateActivityLogVariables = {
  id: ..., 
  title: ..., // optional
  description: ..., // optional
  activityType: ..., // optional
  userId: ..., // optional
  isRead: ..., // optional
  iconType: ..., // optional
  iconColor: ..., // optional
};

// Call the `updateActivityLogRef()` function to get a reference to the mutation.
const ref = updateActivityLogRef(updateActivityLogVars);
// Variables can be defined inline as well.
const ref = updateActivityLogRef({ id: ..., title: ..., description: ..., activityType: ..., userId: ..., isRead: ..., iconType: ..., iconColor: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateActivityLogRef(dataConnect, updateActivityLogVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.activityLog_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.activityLog_update);
});
```

## DeleteActivityLog
You can execute the `DeleteActivityLog` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteActivityLog(vars: DeleteActivityLogVariables): MutationPromise<DeleteActivityLogData, DeleteActivityLogVariables>;

interface DeleteActivityLogRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteActivityLogVariables): MutationRef<DeleteActivityLogData, DeleteActivityLogVariables>;
}
export const deleteActivityLogRef: DeleteActivityLogRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteActivityLog(dc: DataConnect, vars: DeleteActivityLogVariables): MutationPromise<DeleteActivityLogData, DeleteActivityLogVariables>;

interface DeleteActivityLogRef {
  ...
  (dc: DataConnect, vars: DeleteActivityLogVariables): MutationRef<DeleteActivityLogData, DeleteActivityLogVariables>;
}
export const deleteActivityLogRef: DeleteActivityLogRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteActivityLogRef:
```typescript
const name = deleteActivityLogRef.operationName;
console.log(name);
```

### Variables
The `DeleteActivityLog` mutation requires an argument of type `DeleteActivityLogVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteActivityLogVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteActivityLog` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteActivityLogData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteActivityLogData {
  activityLog_delete?: ActivityLog_Key | null;
}
```
### Using `DeleteActivityLog`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteActivityLog, DeleteActivityLogVariables } from '@dataconnect/generated';

// The `DeleteActivityLog` mutation requires an argument of type `DeleteActivityLogVariables`:
const deleteActivityLogVars: DeleteActivityLogVariables = {
  id: ..., 
};

// Call the `deleteActivityLog()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteActivityLog(deleteActivityLogVars);
// Variables can be defined inline as well.
const { data } = await deleteActivityLog({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteActivityLog(dataConnect, deleteActivityLogVars);

console.log(data.activityLog_delete);

// Or, you can use the `Promise` API.
deleteActivityLog(deleteActivityLogVars).then((response) => {
  const data = response.data;
  console.log(data.activityLog_delete);
});
```

### Using `DeleteActivityLog`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteActivityLogRef, DeleteActivityLogVariables } from '@dataconnect/generated';

// The `DeleteActivityLog` mutation requires an argument of type `DeleteActivityLogVariables`:
const deleteActivityLogVars: DeleteActivityLogVariables = {
  id: ..., 
};

// Call the `deleteActivityLogRef()` function to get a reference to the mutation.
const ref = deleteActivityLogRef(deleteActivityLogVars);
// Variables can be defined inline as well.
const ref = deleteActivityLogRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteActivityLogRef(dataConnect, deleteActivityLogVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.activityLog_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.activityLog_delete);
});
```

## CreateAssignment
You can execute the `CreateAssignment` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createAssignment(vars: CreateAssignmentVariables): MutationPromise<CreateAssignmentData, CreateAssignmentVariables>;

interface CreateAssignmentRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateAssignmentVariables): MutationRef<CreateAssignmentData, CreateAssignmentVariables>;
}
export const createAssignmentRef: CreateAssignmentRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createAssignment(dc: DataConnect, vars: CreateAssignmentVariables): MutationPromise<CreateAssignmentData, CreateAssignmentVariables>;

interface CreateAssignmentRef {
  ...
  (dc: DataConnect, vars: CreateAssignmentVariables): MutationRef<CreateAssignmentData, CreateAssignmentVariables>;
}
export const createAssignmentRef: CreateAssignmentRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createAssignmentRef:
```typescript
const name = createAssignmentRef.operationName;
console.log(name);
```

### Variables
The `CreateAssignment` mutation requires an argument of type `CreateAssignmentVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateAssignmentVariables {
  assignmentNumber?: string | null;
  orderId: UUIDString;
  workforceId: UUIDString;
  vendorId: UUIDString;
  role: string;
  assignmentStatus: AssignmentStatus;
  scheduledStart: TimestampString;
}
```
### Return Type
Recall that executing the `CreateAssignment` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateAssignmentData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateAssignmentData {
  assignment_insert: Assignment_Key;
}
```
### Using `CreateAssignment`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createAssignment, CreateAssignmentVariables } from '@dataconnect/generated';

// The `CreateAssignment` mutation requires an argument of type `CreateAssignmentVariables`:
const createAssignmentVars: CreateAssignmentVariables = {
  assignmentNumber: ..., // optional
  orderId: ..., 
  workforceId: ..., 
  vendorId: ..., 
  role: ..., 
  assignmentStatus: ..., 
  scheduledStart: ..., 
};

// Call the `createAssignment()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createAssignment(createAssignmentVars);
// Variables can be defined inline as well.
const { data } = await createAssignment({ assignmentNumber: ..., orderId: ..., workforceId: ..., vendorId: ..., role: ..., assignmentStatus: ..., scheduledStart: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createAssignment(dataConnect, createAssignmentVars);

console.log(data.assignment_insert);

// Or, you can use the `Promise` API.
createAssignment(createAssignmentVars).then((response) => {
  const data = response.data;
  console.log(data.assignment_insert);
});
```

### Using `CreateAssignment`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createAssignmentRef, CreateAssignmentVariables } from '@dataconnect/generated';

// The `CreateAssignment` mutation requires an argument of type `CreateAssignmentVariables`:
const createAssignmentVars: CreateAssignmentVariables = {
  assignmentNumber: ..., // optional
  orderId: ..., 
  workforceId: ..., 
  vendorId: ..., 
  role: ..., 
  assignmentStatus: ..., 
  scheduledStart: ..., 
};

// Call the `createAssignmentRef()` function to get a reference to the mutation.
const ref = createAssignmentRef(createAssignmentVars);
// Variables can be defined inline as well.
const ref = createAssignmentRef({ assignmentNumber: ..., orderId: ..., workforceId: ..., vendorId: ..., role: ..., assignmentStatus: ..., scheduledStart: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createAssignmentRef(dataConnect, createAssignmentVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.assignment_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.assignment_insert);
});
```

## UpdateAssignment
You can execute the `UpdateAssignment` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateAssignment(vars: UpdateAssignmentVariables): MutationPromise<UpdateAssignmentData, UpdateAssignmentVariables>;

interface UpdateAssignmentRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateAssignmentVariables): MutationRef<UpdateAssignmentData, UpdateAssignmentVariables>;
}
export const updateAssignmentRef: UpdateAssignmentRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateAssignment(dc: DataConnect, vars: UpdateAssignmentVariables): MutationPromise<UpdateAssignmentData, UpdateAssignmentVariables>;

interface UpdateAssignmentRef {
  ...
  (dc: DataConnect, vars: UpdateAssignmentVariables): MutationRef<UpdateAssignmentData, UpdateAssignmentVariables>;
}
export const updateAssignmentRef: UpdateAssignmentRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateAssignmentRef:
```typescript
const name = updateAssignmentRef.operationName;
console.log(name);
```

### Variables
The `UpdateAssignment` mutation requires an argument of type `UpdateAssignmentVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateAssignmentVariables {
  id: UUIDString;
  assignmentNumber?: string | null;
  orderId?: UUIDString | null;
  workforceId?: UUIDString | null;
  vendorId?: UUIDString | null;
  role?: string | null;
  assignmentStatus?: AssignmentStatus | null;
  scheduledStart?: TimestampString | null;
}
```
### Return Type
Recall that executing the `UpdateAssignment` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateAssignmentData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateAssignmentData {
  assignment_update?: Assignment_Key | null;
}
```
### Using `UpdateAssignment`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateAssignment, UpdateAssignmentVariables } from '@dataconnect/generated';

// The `UpdateAssignment` mutation requires an argument of type `UpdateAssignmentVariables`:
const updateAssignmentVars: UpdateAssignmentVariables = {
  id: ..., 
  assignmentNumber: ..., // optional
  orderId: ..., // optional
  workforceId: ..., // optional
  vendorId: ..., // optional
  role: ..., // optional
  assignmentStatus: ..., // optional
  scheduledStart: ..., // optional
};

// Call the `updateAssignment()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateAssignment(updateAssignmentVars);
// Variables can be defined inline as well.
const { data } = await updateAssignment({ id: ..., assignmentNumber: ..., orderId: ..., workforceId: ..., vendorId: ..., role: ..., assignmentStatus: ..., scheduledStart: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateAssignment(dataConnect, updateAssignmentVars);

console.log(data.assignment_update);

// Or, you can use the `Promise` API.
updateAssignment(updateAssignmentVars).then((response) => {
  const data = response.data;
  console.log(data.assignment_update);
});
```

### Using `UpdateAssignment`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateAssignmentRef, UpdateAssignmentVariables } from '@dataconnect/generated';

// The `UpdateAssignment` mutation requires an argument of type `UpdateAssignmentVariables`:
const updateAssignmentVars: UpdateAssignmentVariables = {
  id: ..., 
  assignmentNumber: ..., // optional
  orderId: ..., // optional
  workforceId: ..., // optional
  vendorId: ..., // optional
  role: ..., // optional
  assignmentStatus: ..., // optional
  scheduledStart: ..., // optional
};

// Call the `updateAssignmentRef()` function to get a reference to the mutation.
const ref = updateAssignmentRef(updateAssignmentVars);
// Variables can be defined inline as well.
const ref = updateAssignmentRef({ id: ..., assignmentNumber: ..., orderId: ..., workforceId: ..., vendorId: ..., role: ..., assignmentStatus: ..., scheduledStart: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateAssignmentRef(dataConnect, updateAssignmentVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.assignment_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.assignment_update);
});
```

## DeleteAssignment
You can execute the `DeleteAssignment` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteAssignment(vars: DeleteAssignmentVariables): MutationPromise<DeleteAssignmentData, DeleteAssignmentVariables>;

interface DeleteAssignmentRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteAssignmentVariables): MutationRef<DeleteAssignmentData, DeleteAssignmentVariables>;
}
export const deleteAssignmentRef: DeleteAssignmentRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteAssignment(dc: DataConnect, vars: DeleteAssignmentVariables): MutationPromise<DeleteAssignmentData, DeleteAssignmentVariables>;

interface DeleteAssignmentRef {
  ...
  (dc: DataConnect, vars: DeleteAssignmentVariables): MutationRef<DeleteAssignmentData, DeleteAssignmentVariables>;
}
export const deleteAssignmentRef: DeleteAssignmentRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteAssignmentRef:
```typescript
const name = deleteAssignmentRef.operationName;
console.log(name);
```

### Variables
The `DeleteAssignment` mutation requires an argument of type `DeleteAssignmentVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteAssignmentVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteAssignment` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteAssignmentData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteAssignmentData {
  assignment_delete?: Assignment_Key | null;
}
```
### Using `DeleteAssignment`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteAssignment, DeleteAssignmentVariables } from '@dataconnect/generated';

// The `DeleteAssignment` mutation requires an argument of type `DeleteAssignmentVariables`:
const deleteAssignmentVars: DeleteAssignmentVariables = {
  id: ..., 
};

// Call the `deleteAssignment()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteAssignment(deleteAssignmentVars);
// Variables can be defined inline as well.
const { data } = await deleteAssignment({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteAssignment(dataConnect, deleteAssignmentVars);

console.log(data.assignment_delete);

// Or, you can use the `Promise` API.
deleteAssignment(deleteAssignmentVars).then((response) => {
  const data = response.data;
  console.log(data.assignment_delete);
});
```

### Using `DeleteAssignment`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteAssignmentRef, DeleteAssignmentVariables } from '@dataconnect/generated';

// The `DeleteAssignment` mutation requires an argument of type `DeleteAssignmentVariables`:
const deleteAssignmentVars: DeleteAssignmentVariables = {
  id: ..., 
};

// Call the `deleteAssignmentRef()` function to get a reference to the mutation.
const ref = deleteAssignmentRef(deleteAssignmentVars);
// Variables can be defined inline as well.
const ref = deleteAssignmentRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteAssignmentRef(dataConnect, deleteAssignmentVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.assignment_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.assignment_delete);
});
```

## CreateCertification
You can execute the `CreateCertification` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createCertification(vars: CreateCertificationVariables): MutationPromise<CreateCertificationData, CreateCertificationVariables>;

interface CreateCertificationRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateCertificationVariables): MutationRef<CreateCertificationData, CreateCertificationVariables>;
}
export const createCertificationRef: CreateCertificationRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createCertification(dc: DataConnect, vars: CreateCertificationVariables): MutationPromise<CreateCertificationData, CreateCertificationVariables>;

interface CreateCertificationRef {
  ...
  (dc: DataConnect, vars: CreateCertificationVariables): MutationRef<CreateCertificationData, CreateCertificationVariables>;
}
export const createCertificationRef: CreateCertificationRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createCertificationRef:
```typescript
const name = createCertificationRef.operationName;
console.log(name);
```

### Variables
The `CreateCertification` mutation requires an argument of type `CreateCertificationVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateCertificationVariables {
  employeeName: string;
  certificationName: string;
  certificationType?: CertificationType | null;
  status?: CertificationStatus | null;
  expiryDate: string;
  validationStatus?: CertificationValidationStatus | null;
}
```
### Return Type
Recall that executing the `CreateCertification` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateCertificationData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateCertificationData {
  certification_insert: Certification_Key;
}
```
### Using `CreateCertification`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createCertification, CreateCertificationVariables } from '@dataconnect/generated';

// The `CreateCertification` mutation requires an argument of type `CreateCertificationVariables`:
const createCertificationVars: CreateCertificationVariables = {
  employeeName: ..., 
  certificationName: ..., 
  certificationType: ..., // optional
  status: ..., // optional
  expiryDate: ..., 
  validationStatus: ..., // optional
};

// Call the `createCertification()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createCertification(createCertificationVars);
// Variables can be defined inline as well.
const { data } = await createCertification({ employeeName: ..., certificationName: ..., certificationType: ..., status: ..., expiryDate: ..., validationStatus: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createCertification(dataConnect, createCertificationVars);

console.log(data.certification_insert);

// Or, you can use the `Promise` API.
createCertification(createCertificationVars).then((response) => {
  const data = response.data;
  console.log(data.certification_insert);
});
```

### Using `CreateCertification`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createCertificationRef, CreateCertificationVariables } from '@dataconnect/generated';

// The `CreateCertification` mutation requires an argument of type `CreateCertificationVariables`:
const createCertificationVars: CreateCertificationVariables = {
  employeeName: ..., 
  certificationName: ..., 
  certificationType: ..., // optional
  status: ..., // optional
  expiryDate: ..., 
  validationStatus: ..., // optional
};

// Call the `createCertificationRef()` function to get a reference to the mutation.
const ref = createCertificationRef(createCertificationVars);
// Variables can be defined inline as well.
const ref = createCertificationRef({ employeeName: ..., certificationName: ..., certificationType: ..., status: ..., expiryDate: ..., validationStatus: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createCertificationRef(dataConnect, createCertificationVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.certification_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.certification_insert);
});
```

## UpdateCertification
You can execute the `UpdateCertification` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateCertification(vars: UpdateCertificationVariables): MutationPromise<UpdateCertificationData, UpdateCertificationVariables>;

interface UpdateCertificationRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateCertificationVariables): MutationRef<UpdateCertificationData, UpdateCertificationVariables>;
}
export const updateCertificationRef: UpdateCertificationRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateCertification(dc: DataConnect, vars: UpdateCertificationVariables): MutationPromise<UpdateCertificationData, UpdateCertificationVariables>;

interface UpdateCertificationRef {
  ...
  (dc: DataConnect, vars: UpdateCertificationVariables): MutationRef<UpdateCertificationData, UpdateCertificationVariables>;
}
export const updateCertificationRef: UpdateCertificationRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateCertificationRef:
```typescript
const name = updateCertificationRef.operationName;
console.log(name);
```

### Variables
The `UpdateCertification` mutation requires an argument of type `UpdateCertificationVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateCertificationVariables {
  id: UUIDString;
  employeeName?: string | null;
  certificationName?: string | null;
  certificationType?: CertificationType | null;
  status?: CertificationStatus | null;
  expiryDate?: string | null;
  validationStatus?: CertificationValidationStatus | null;
}
```
### Return Type
Recall that executing the `UpdateCertification` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateCertificationData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateCertificationData {
  certification_update?: Certification_Key | null;
}
```
### Using `UpdateCertification`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateCertification, UpdateCertificationVariables } from '@dataconnect/generated';

// The `UpdateCertification` mutation requires an argument of type `UpdateCertificationVariables`:
const updateCertificationVars: UpdateCertificationVariables = {
  id: ..., 
  employeeName: ..., // optional
  certificationName: ..., // optional
  certificationType: ..., // optional
  status: ..., // optional
  expiryDate: ..., // optional
  validationStatus: ..., // optional
};

// Call the `updateCertification()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateCertification(updateCertificationVars);
// Variables can be defined inline as well.
const { data } = await updateCertification({ id: ..., employeeName: ..., certificationName: ..., certificationType: ..., status: ..., expiryDate: ..., validationStatus: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateCertification(dataConnect, updateCertificationVars);

console.log(data.certification_update);

// Or, you can use the `Promise` API.
updateCertification(updateCertificationVars).then((response) => {
  const data = response.data;
  console.log(data.certification_update);
});
```

### Using `UpdateCertification`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateCertificationRef, UpdateCertificationVariables } from '@dataconnect/generated';

// The `UpdateCertification` mutation requires an argument of type `UpdateCertificationVariables`:
const updateCertificationVars: UpdateCertificationVariables = {
  id: ..., 
  employeeName: ..., // optional
  certificationName: ..., // optional
  certificationType: ..., // optional
  status: ..., // optional
  expiryDate: ..., // optional
  validationStatus: ..., // optional
};

// Call the `updateCertificationRef()` function to get a reference to the mutation.
const ref = updateCertificationRef(updateCertificationVars);
// Variables can be defined inline as well.
const ref = updateCertificationRef({ id: ..., employeeName: ..., certificationName: ..., certificationType: ..., status: ..., expiryDate: ..., validationStatus: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateCertificationRef(dataConnect, updateCertificationVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.certification_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.certification_update);
});
```

## DeleteCertification
You can execute the `DeleteCertification` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteCertification(vars: DeleteCertificationVariables): MutationPromise<DeleteCertificationData, DeleteCertificationVariables>;

interface DeleteCertificationRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteCertificationVariables): MutationRef<DeleteCertificationData, DeleteCertificationVariables>;
}
export const deleteCertificationRef: DeleteCertificationRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteCertification(dc: DataConnect, vars: DeleteCertificationVariables): MutationPromise<DeleteCertificationData, DeleteCertificationVariables>;

interface DeleteCertificationRef {
  ...
  (dc: DataConnect, vars: DeleteCertificationVariables): MutationRef<DeleteCertificationData, DeleteCertificationVariables>;
}
export const deleteCertificationRef: DeleteCertificationRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteCertificationRef:
```typescript
const name = deleteCertificationRef.operationName;
console.log(name);
```

### Variables
The `DeleteCertification` mutation requires an argument of type `DeleteCertificationVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteCertificationVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteCertification` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteCertificationData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteCertificationData {
  certification_delete?: Certification_Key | null;
}
```
### Using `DeleteCertification`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteCertification, DeleteCertificationVariables } from '@dataconnect/generated';

// The `DeleteCertification` mutation requires an argument of type `DeleteCertificationVariables`:
const deleteCertificationVars: DeleteCertificationVariables = {
  id: ..., 
};

// Call the `deleteCertification()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteCertification(deleteCertificationVars);
// Variables can be defined inline as well.
const { data } = await deleteCertification({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteCertification(dataConnect, deleteCertificationVars);

console.log(data.certification_delete);

// Or, you can use the `Promise` API.
deleteCertification(deleteCertificationVars).then((response) => {
  const data = response.data;
  console.log(data.certification_delete);
});
```

### Using `DeleteCertification`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteCertificationRef, DeleteCertificationVariables } from '@dataconnect/generated';

// The `DeleteCertification` mutation requires an argument of type `DeleteCertificationVariables`:
const deleteCertificationVars: DeleteCertificationVariables = {
  id: ..., 
};

// Call the `deleteCertificationRef()` function to get a reference to the mutation.
const ref = deleteCertificationRef(deleteCertificationVars);
// Variables can be defined inline as well.
const ref = deleteCertificationRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteCertificationRef(dataConnect, deleteCertificationVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.certification_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.certification_delete);
});
```

## CreateShift
You can execute the `CreateShift` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createShift(vars: CreateShiftVariables): MutationPromise<CreateShiftData, CreateShiftVariables>;

interface CreateShiftRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateShiftVariables): MutationRef<CreateShiftData, CreateShiftVariables>;
}
export const createShiftRef: CreateShiftRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createShift(dc: DataConnect, vars: CreateShiftVariables): MutationPromise<CreateShiftData, CreateShiftVariables>;

interface CreateShiftRef {
  ...
  (dc: DataConnect, vars: CreateShiftVariables): MutationRef<CreateShiftData, CreateShiftVariables>;
}
export const createShiftRef: CreateShiftRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createShiftRef:
```typescript
const name = createShiftRef.operationName;
console.log(name);
```

### Variables
The `CreateShift` mutation requires an argument of type `CreateShiftVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateShiftVariables {
  shiftName: string;
  startDate: TimestampString;
  endDate?: TimestampString | null;
  assignedStaff?: string | null;
}
```
### Return Type
Recall that executing the `CreateShift` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateShiftData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateShiftData {
  shift_insert: Shift_Key;
}
```
### Using `CreateShift`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createShift, CreateShiftVariables } from '@dataconnect/generated';

// The `CreateShift` mutation requires an argument of type `CreateShiftVariables`:
const createShiftVars: CreateShiftVariables = {
  shiftName: ..., 
  startDate: ..., 
  endDate: ..., // optional
  assignedStaff: ..., // optional
};

// Call the `createShift()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createShift(createShiftVars);
// Variables can be defined inline as well.
const { data } = await createShift({ shiftName: ..., startDate: ..., endDate: ..., assignedStaff: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createShift(dataConnect, createShiftVars);

console.log(data.shift_insert);

// Or, you can use the `Promise` API.
createShift(createShiftVars).then((response) => {
  const data = response.data;
  console.log(data.shift_insert);
});
```

### Using `CreateShift`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createShiftRef, CreateShiftVariables } from '@dataconnect/generated';

// The `CreateShift` mutation requires an argument of type `CreateShiftVariables`:
const createShiftVars: CreateShiftVariables = {
  shiftName: ..., 
  startDate: ..., 
  endDate: ..., // optional
  assignedStaff: ..., // optional
};

// Call the `createShiftRef()` function to get a reference to the mutation.
const ref = createShiftRef(createShiftVars);
// Variables can be defined inline as well.
const ref = createShiftRef({ shiftName: ..., startDate: ..., endDate: ..., assignedStaff: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createShiftRef(dataConnect, createShiftVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.shift_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.shift_insert);
});
```

## UpdateShift
You can execute the `UpdateShift` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateShift(vars: UpdateShiftVariables): MutationPromise<UpdateShiftData, UpdateShiftVariables>;

interface UpdateShiftRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateShiftVariables): MutationRef<UpdateShiftData, UpdateShiftVariables>;
}
export const updateShiftRef: UpdateShiftRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateShift(dc: DataConnect, vars: UpdateShiftVariables): MutationPromise<UpdateShiftData, UpdateShiftVariables>;

interface UpdateShiftRef {
  ...
  (dc: DataConnect, vars: UpdateShiftVariables): MutationRef<UpdateShiftData, UpdateShiftVariables>;
}
export const updateShiftRef: UpdateShiftRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateShiftRef:
```typescript
const name = updateShiftRef.operationName;
console.log(name);
```

### Variables
The `UpdateShift` mutation requires an argument of type `UpdateShiftVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateShiftVariables {
  id: UUIDString;
  shiftName?: string | null;
  startDate?: TimestampString | null;
  endDate?: TimestampString | null;
  assignedStaff?: string | null;
}
```
### Return Type
Recall that executing the `UpdateShift` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateShiftData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateShiftData {
  shift_update?: Shift_Key | null;
}
```
### Using `UpdateShift`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateShift, UpdateShiftVariables } from '@dataconnect/generated';

// The `UpdateShift` mutation requires an argument of type `UpdateShiftVariables`:
const updateShiftVars: UpdateShiftVariables = {
  id: ..., 
  shiftName: ..., // optional
  startDate: ..., // optional
  endDate: ..., // optional
  assignedStaff: ..., // optional
};

// Call the `updateShift()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateShift(updateShiftVars);
// Variables can be defined inline as well.
const { data } = await updateShift({ id: ..., shiftName: ..., startDate: ..., endDate: ..., assignedStaff: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateShift(dataConnect, updateShiftVars);

console.log(data.shift_update);

// Or, you can use the `Promise` API.
updateShift(updateShiftVars).then((response) => {
  const data = response.data;
  console.log(data.shift_update);
});
```

### Using `UpdateShift`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateShiftRef, UpdateShiftVariables } from '@dataconnect/generated';

// The `UpdateShift` mutation requires an argument of type `UpdateShiftVariables`:
const updateShiftVars: UpdateShiftVariables = {
  id: ..., 
  shiftName: ..., // optional
  startDate: ..., // optional
  endDate: ..., // optional
  assignedStaff: ..., // optional
};

// Call the `updateShiftRef()` function to get a reference to the mutation.
const ref = updateShiftRef(updateShiftVars);
// Variables can be defined inline as well.
const ref = updateShiftRef({ id: ..., shiftName: ..., startDate: ..., endDate: ..., assignedStaff: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateShiftRef(dataConnect, updateShiftVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.shift_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.shift_update);
});
```

## DeleteShift
You can execute the `DeleteShift` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteShift(vars: DeleteShiftVariables): MutationPromise<DeleteShiftData, DeleteShiftVariables>;

interface DeleteShiftRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteShiftVariables): MutationRef<DeleteShiftData, DeleteShiftVariables>;
}
export const deleteShiftRef: DeleteShiftRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteShift(dc: DataConnect, vars: DeleteShiftVariables): MutationPromise<DeleteShiftData, DeleteShiftVariables>;

interface DeleteShiftRef {
  ...
  (dc: DataConnect, vars: DeleteShiftVariables): MutationRef<DeleteShiftData, DeleteShiftVariables>;
}
export const deleteShiftRef: DeleteShiftRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteShiftRef:
```typescript
const name = deleteShiftRef.operationName;
console.log(name);
```

### Variables
The `DeleteShift` mutation requires an argument of type `DeleteShiftVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteShiftVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteShift` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteShiftData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteShiftData {
  shift_delete?: Shift_Key | null;
}
```
### Using `DeleteShift`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteShift, DeleteShiftVariables } from '@dataconnect/generated';

// The `DeleteShift` mutation requires an argument of type `DeleteShiftVariables`:
const deleteShiftVars: DeleteShiftVariables = {
  id: ..., 
};

// Call the `deleteShift()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteShift(deleteShiftVars);
// Variables can be defined inline as well.
const { data } = await deleteShift({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteShift(dataConnect, deleteShiftVars);

console.log(data.shift_delete);

// Or, you can use the `Promise` API.
deleteShift(deleteShiftVars).then((response) => {
  const data = response.data;
  console.log(data.shift_delete);
});
```

### Using `DeleteShift`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteShiftRef, DeleteShiftVariables } from '@dataconnect/generated';

// The `DeleteShift` mutation requires an argument of type `DeleteShiftVariables`:
const deleteShiftVars: DeleteShiftVariables = {
  id: ..., 
};

// Call the `deleteShiftRef()` function to get a reference to the mutation.
const ref = deleteShiftRef(deleteShiftVars);
// Variables can be defined inline as well.
const ref = deleteShiftRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteShiftRef(dataConnect, deleteShiftVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.shift_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.shift_delete);
});
```

## CreateTeamHub
You can execute the `CreateTeamHub` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createTeamHub(vars: CreateTeamHubVariables): MutationPromise<CreateTeamHubData, CreateTeamHubVariables>;

interface CreateTeamHubRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateTeamHubVariables): MutationRef<CreateTeamHubData, CreateTeamHubVariables>;
}
export const createTeamHubRef: CreateTeamHubRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createTeamHub(dc: DataConnect, vars: CreateTeamHubVariables): MutationPromise<CreateTeamHubData, CreateTeamHubVariables>;

interface CreateTeamHubRef {
  ...
  (dc: DataConnect, vars: CreateTeamHubVariables): MutationRef<CreateTeamHubData, CreateTeamHubVariables>;
}
export const createTeamHubRef: CreateTeamHubRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createTeamHubRef:
```typescript
const name = createTeamHubRef.operationName;
console.log(name);
```

### Variables
The `CreateTeamHub` mutation requires an argument of type `CreateTeamHubVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateTeamHubVariables {
  teamId: UUIDString;
  hubName: string;
  departments?: string | null;
}
```
### Return Type
Recall that executing the `CreateTeamHub` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateTeamHubData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateTeamHubData {
  teamHub_insert: TeamHub_Key;
}
```
### Using `CreateTeamHub`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createTeamHub, CreateTeamHubVariables } from '@dataconnect/generated';

// The `CreateTeamHub` mutation requires an argument of type `CreateTeamHubVariables`:
const createTeamHubVars: CreateTeamHubVariables = {
  teamId: ..., 
  hubName: ..., 
  departments: ..., // optional
};

// Call the `createTeamHub()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createTeamHub(createTeamHubVars);
// Variables can be defined inline as well.
const { data } = await createTeamHub({ teamId: ..., hubName: ..., departments: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createTeamHub(dataConnect, createTeamHubVars);

console.log(data.teamHub_insert);

// Or, you can use the `Promise` API.
createTeamHub(createTeamHubVars).then((response) => {
  const data = response.data;
  console.log(data.teamHub_insert);
});
```

### Using `CreateTeamHub`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createTeamHubRef, CreateTeamHubVariables } from '@dataconnect/generated';

// The `CreateTeamHub` mutation requires an argument of type `CreateTeamHubVariables`:
const createTeamHubVars: CreateTeamHubVariables = {
  teamId: ..., 
  hubName: ..., 
  departments: ..., // optional
};

// Call the `createTeamHubRef()` function to get a reference to the mutation.
const ref = createTeamHubRef(createTeamHubVars);
// Variables can be defined inline as well.
const ref = createTeamHubRef({ teamId: ..., hubName: ..., departments: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createTeamHubRef(dataConnect, createTeamHubVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.teamHub_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.teamHub_insert);
});
```

## UpdateTeamHub
You can execute the `UpdateTeamHub` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateTeamHub(vars: UpdateTeamHubVariables): MutationPromise<UpdateTeamHubData, UpdateTeamHubVariables>;

interface UpdateTeamHubRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateTeamHubVariables): MutationRef<UpdateTeamHubData, UpdateTeamHubVariables>;
}
export const updateTeamHubRef: UpdateTeamHubRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateTeamHub(dc: DataConnect, vars: UpdateTeamHubVariables): MutationPromise<UpdateTeamHubData, UpdateTeamHubVariables>;

interface UpdateTeamHubRef {
  ...
  (dc: DataConnect, vars: UpdateTeamHubVariables): MutationRef<UpdateTeamHubData, UpdateTeamHubVariables>;
}
export const updateTeamHubRef: UpdateTeamHubRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateTeamHubRef:
```typescript
const name = updateTeamHubRef.operationName;
console.log(name);
```

### Variables
The `UpdateTeamHub` mutation requires an argument of type `UpdateTeamHubVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateTeamHubVariables {
  id: UUIDString;
  teamId?: UUIDString | null;
  hubName?: string | null;
  departments?: string | null;
}
```
### Return Type
Recall that executing the `UpdateTeamHub` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateTeamHubData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateTeamHubData {
  teamHub_update?: TeamHub_Key | null;
}
```
### Using `UpdateTeamHub`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateTeamHub, UpdateTeamHubVariables } from '@dataconnect/generated';

// The `UpdateTeamHub` mutation requires an argument of type `UpdateTeamHubVariables`:
const updateTeamHubVars: UpdateTeamHubVariables = {
  id: ..., 
  teamId: ..., // optional
  hubName: ..., // optional
  departments: ..., // optional
};

// Call the `updateTeamHub()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateTeamHub(updateTeamHubVars);
// Variables can be defined inline as well.
const { data } = await updateTeamHub({ id: ..., teamId: ..., hubName: ..., departments: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateTeamHub(dataConnect, updateTeamHubVars);

console.log(data.teamHub_update);

// Or, you can use the `Promise` API.
updateTeamHub(updateTeamHubVars).then((response) => {
  const data = response.data;
  console.log(data.teamHub_update);
});
```

### Using `UpdateTeamHub`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateTeamHubRef, UpdateTeamHubVariables } from '@dataconnect/generated';

// The `UpdateTeamHub` mutation requires an argument of type `UpdateTeamHubVariables`:
const updateTeamHubVars: UpdateTeamHubVariables = {
  id: ..., 
  teamId: ..., // optional
  hubName: ..., // optional
  departments: ..., // optional
};

// Call the `updateTeamHubRef()` function to get a reference to the mutation.
const ref = updateTeamHubRef(updateTeamHubVars);
// Variables can be defined inline as well.
const ref = updateTeamHubRef({ id: ..., teamId: ..., hubName: ..., departments: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateTeamHubRef(dataConnect, updateTeamHubVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.teamHub_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.teamHub_update);
});
```

## DeleteTeamHub
You can execute the `DeleteTeamHub` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteTeamHub(vars: DeleteTeamHubVariables): MutationPromise<DeleteTeamHubData, DeleteTeamHubVariables>;

interface DeleteTeamHubRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteTeamHubVariables): MutationRef<DeleteTeamHubData, DeleteTeamHubVariables>;
}
export const deleteTeamHubRef: DeleteTeamHubRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteTeamHub(dc: DataConnect, vars: DeleteTeamHubVariables): MutationPromise<DeleteTeamHubData, DeleteTeamHubVariables>;

interface DeleteTeamHubRef {
  ...
  (dc: DataConnect, vars: DeleteTeamHubVariables): MutationRef<DeleteTeamHubData, DeleteTeamHubVariables>;
}
export const deleteTeamHubRef: DeleteTeamHubRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteTeamHubRef:
```typescript
const name = deleteTeamHubRef.operationName;
console.log(name);
```

### Variables
The `DeleteTeamHub` mutation requires an argument of type `DeleteTeamHubVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteTeamHubVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteTeamHub` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteTeamHubData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteTeamHubData {
  teamHub_delete?: TeamHub_Key | null;
}
```
### Using `DeleteTeamHub`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteTeamHub, DeleteTeamHubVariables } from '@dataconnect/generated';

// The `DeleteTeamHub` mutation requires an argument of type `DeleteTeamHubVariables`:
const deleteTeamHubVars: DeleteTeamHubVariables = {
  id: ..., 
};

// Call the `deleteTeamHub()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteTeamHub(deleteTeamHubVars);
// Variables can be defined inline as well.
const { data } = await deleteTeamHub({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteTeamHub(dataConnect, deleteTeamHubVars);

console.log(data.teamHub_delete);

// Or, you can use the `Promise` API.
deleteTeamHub(deleteTeamHubVars).then((response) => {
  const data = response.data;
  console.log(data.teamHub_delete);
});
```

### Using `DeleteTeamHub`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteTeamHubRef, DeleteTeamHubVariables } from '@dataconnect/generated';

// The `DeleteTeamHub` mutation requires an argument of type `DeleteTeamHubVariables`:
const deleteTeamHubVars: DeleteTeamHubVariables = {
  id: ..., 
};

// Call the `deleteTeamHubRef()` function to get a reference to the mutation.
const ref = deleteTeamHubRef(deleteTeamHubVars);
// Variables can be defined inline as well.
const ref = deleteTeamHubRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteTeamHubRef(dataConnect, deleteTeamHubVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.teamHub_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.teamHub_delete);
});
```

## CreateOrder
You can execute the `CreateOrder` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createOrder(vars: CreateOrderVariables): MutationPromise<CreateOrderData, CreateOrderVariables>;

interface CreateOrderRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateOrderVariables): MutationRef<CreateOrderData, CreateOrderVariables>;
}
export const createOrderRef: CreateOrderRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createOrder(dc: DataConnect, vars: CreateOrderVariables): MutationPromise<CreateOrderData, CreateOrderVariables>;

interface CreateOrderRef {
  ...
  (dc: DataConnect, vars: CreateOrderVariables): MutationRef<CreateOrderData, CreateOrderVariables>;
}
export const createOrderRef: CreateOrderRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createOrderRef:
```typescript
const name = createOrderRef.operationName;
console.log(name);
```

### Variables
The `CreateOrder` mutation requires an argument of type `CreateOrderVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateOrderVariables {
  orderNumber: string;
  partnerId: UUIDString;
  orderType?: OrderType | null;
  orderStatus?: OrderStatus | null;
}
```
### Return Type
Recall that executing the `CreateOrder` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateOrderData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateOrderData {
  order_insert: Order_Key;
}
```
### Using `CreateOrder`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createOrder, CreateOrderVariables } from '@dataconnect/generated';

// The `CreateOrder` mutation requires an argument of type `CreateOrderVariables`:
const createOrderVars: CreateOrderVariables = {
  orderNumber: ..., 
  partnerId: ..., 
  orderType: ..., // optional
  orderStatus: ..., // optional
};

// Call the `createOrder()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createOrder(createOrderVars);
// Variables can be defined inline as well.
const { data } = await createOrder({ orderNumber: ..., partnerId: ..., orderType: ..., orderStatus: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createOrder(dataConnect, createOrderVars);

console.log(data.order_insert);

// Or, you can use the `Promise` API.
createOrder(createOrderVars).then((response) => {
  const data = response.data;
  console.log(data.order_insert);
});
```

### Using `CreateOrder`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createOrderRef, CreateOrderVariables } from '@dataconnect/generated';

// The `CreateOrder` mutation requires an argument of type `CreateOrderVariables`:
const createOrderVars: CreateOrderVariables = {
  orderNumber: ..., 
  partnerId: ..., 
  orderType: ..., // optional
  orderStatus: ..., // optional
};

// Call the `createOrderRef()` function to get a reference to the mutation.
const ref = createOrderRef(createOrderVars);
// Variables can be defined inline as well.
const ref = createOrderRef({ orderNumber: ..., partnerId: ..., orderType: ..., orderStatus: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createOrderRef(dataConnect, createOrderVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.order_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.order_insert);
});
```

## UpdateOrder
You can execute the `UpdateOrder` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateOrder(vars: UpdateOrderVariables): MutationPromise<UpdateOrderData, UpdateOrderVariables>;

interface UpdateOrderRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateOrderVariables): MutationRef<UpdateOrderData, UpdateOrderVariables>;
}
export const updateOrderRef: UpdateOrderRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateOrder(dc: DataConnect, vars: UpdateOrderVariables): MutationPromise<UpdateOrderData, UpdateOrderVariables>;

interface UpdateOrderRef {
  ...
  (dc: DataConnect, vars: UpdateOrderVariables): MutationRef<UpdateOrderData, UpdateOrderVariables>;
}
export const updateOrderRef: UpdateOrderRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateOrderRef:
```typescript
const name = updateOrderRef.operationName;
console.log(name);
```

### Variables
The `UpdateOrder` mutation requires an argument of type `UpdateOrderVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateOrderVariables {
  id: UUIDString;
  orderNumber?: string | null;
  partnerId?: UUIDString | null;
  orderType?: OrderType | null;
  orderStatus?: OrderStatus | null;
}
```
### Return Type
Recall that executing the `UpdateOrder` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateOrderData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateOrderData {
  order_update?: Order_Key | null;
}
```
### Using `UpdateOrder`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateOrder, UpdateOrderVariables } from '@dataconnect/generated';

// The `UpdateOrder` mutation requires an argument of type `UpdateOrderVariables`:
const updateOrderVars: UpdateOrderVariables = {
  id: ..., 
  orderNumber: ..., // optional
  partnerId: ..., // optional
  orderType: ..., // optional
  orderStatus: ..., // optional
};

// Call the `updateOrder()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateOrder(updateOrderVars);
// Variables can be defined inline as well.
const { data } = await updateOrder({ id: ..., orderNumber: ..., partnerId: ..., orderType: ..., orderStatus: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateOrder(dataConnect, updateOrderVars);

console.log(data.order_update);

// Or, you can use the `Promise` API.
updateOrder(updateOrderVars).then((response) => {
  const data = response.data;
  console.log(data.order_update);
});
```

### Using `UpdateOrder`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateOrderRef, UpdateOrderVariables } from '@dataconnect/generated';

// The `UpdateOrder` mutation requires an argument of type `UpdateOrderVariables`:
const updateOrderVars: UpdateOrderVariables = {
  id: ..., 
  orderNumber: ..., // optional
  partnerId: ..., // optional
  orderType: ..., // optional
  orderStatus: ..., // optional
};

// Call the `updateOrderRef()` function to get a reference to the mutation.
const ref = updateOrderRef(updateOrderVars);
// Variables can be defined inline as well.
const ref = updateOrderRef({ id: ..., orderNumber: ..., partnerId: ..., orderType: ..., orderStatus: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateOrderRef(dataConnect, updateOrderVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.order_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.order_update);
});
```

## DeleteOrder
You can execute the `DeleteOrder` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteOrder(vars: DeleteOrderVariables): MutationPromise<DeleteOrderData, DeleteOrderVariables>;

interface DeleteOrderRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteOrderVariables): MutationRef<DeleteOrderData, DeleteOrderVariables>;
}
export const deleteOrderRef: DeleteOrderRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteOrder(dc: DataConnect, vars: DeleteOrderVariables): MutationPromise<DeleteOrderData, DeleteOrderVariables>;

interface DeleteOrderRef {
  ...
  (dc: DataConnect, vars: DeleteOrderVariables): MutationRef<DeleteOrderData, DeleteOrderVariables>;
}
export const deleteOrderRef: DeleteOrderRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteOrderRef:
```typescript
const name = deleteOrderRef.operationName;
console.log(name);
```

### Variables
The `DeleteOrder` mutation requires an argument of type `DeleteOrderVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteOrderVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteOrder` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteOrderData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteOrderData {
  order_delete?: Order_Key | null;
}
```
### Using `DeleteOrder`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteOrder, DeleteOrderVariables } from '@dataconnect/generated';

// The `DeleteOrder` mutation requires an argument of type `DeleteOrderVariables`:
const deleteOrderVars: DeleteOrderVariables = {
  id: ..., 
};

// Call the `deleteOrder()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteOrder(deleteOrderVars);
// Variables can be defined inline as well.
const { data } = await deleteOrder({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteOrder(dataConnect, deleteOrderVars);

console.log(data.order_delete);

// Or, you can use the `Promise` API.
deleteOrder(deleteOrderVars).then((response) => {
  const data = response.data;
  console.log(data.order_delete);
});
```

### Using `DeleteOrder`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteOrderRef, DeleteOrderVariables } from '@dataconnect/generated';

// The `DeleteOrder` mutation requires an argument of type `DeleteOrderVariables`:
const deleteOrderVars: DeleteOrderVariables = {
  id: ..., 
};

// Call the `deleteOrderRef()` function to get a reference to the mutation.
const ref = deleteOrderRef(deleteOrderVars);
// Variables can be defined inline as well.
const ref = deleteOrderRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteOrderRef(dataConnect, deleteOrderVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.order_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.order_delete);
});
```

## CreateSector
You can execute the `CreateSector` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createSector(vars: CreateSectorVariables): MutationPromise<CreateSectorData, CreateSectorVariables>;

interface CreateSectorRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateSectorVariables): MutationRef<CreateSectorData, CreateSectorVariables>;
}
export const createSectorRef: CreateSectorRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createSector(dc: DataConnect, vars: CreateSectorVariables): MutationPromise<CreateSectorData, CreateSectorVariables>;

interface CreateSectorRef {
  ...
  (dc: DataConnect, vars: CreateSectorVariables): MutationRef<CreateSectorData, CreateSectorVariables>;
}
export const createSectorRef: CreateSectorRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createSectorRef:
```typescript
const name = createSectorRef.operationName;
console.log(name);
```

### Variables
The `CreateSector` mutation requires an argument of type `CreateSectorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateSectorVariables {
  sectorNumber: string;
  sectorName: string;
  sectorType?: SectorType | null;
}
```
### Return Type
Recall that executing the `CreateSector` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateSectorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateSectorData {
  sector_insert: Sector_Key;
}
```
### Using `CreateSector`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createSector, CreateSectorVariables } from '@dataconnect/generated';

// The `CreateSector` mutation requires an argument of type `CreateSectorVariables`:
const createSectorVars: CreateSectorVariables = {
  sectorNumber: ..., 
  sectorName: ..., 
  sectorType: ..., // optional
};

// Call the `createSector()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createSector(createSectorVars);
// Variables can be defined inline as well.
const { data } = await createSector({ sectorNumber: ..., sectorName: ..., sectorType: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createSector(dataConnect, createSectorVars);

console.log(data.sector_insert);

// Or, you can use the `Promise` API.
createSector(createSectorVars).then((response) => {
  const data = response.data;
  console.log(data.sector_insert);
});
```

### Using `CreateSector`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createSectorRef, CreateSectorVariables } from '@dataconnect/generated';

// The `CreateSector` mutation requires an argument of type `CreateSectorVariables`:
const createSectorVars: CreateSectorVariables = {
  sectorNumber: ..., 
  sectorName: ..., 
  sectorType: ..., // optional
};

// Call the `createSectorRef()` function to get a reference to the mutation.
const ref = createSectorRef(createSectorVars);
// Variables can be defined inline as well.
const ref = createSectorRef({ sectorNumber: ..., sectorName: ..., sectorType: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createSectorRef(dataConnect, createSectorVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.sector_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.sector_insert);
});
```

## UpdateSector
You can execute the `UpdateSector` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateSector(vars: UpdateSectorVariables): MutationPromise<UpdateSectorData, UpdateSectorVariables>;

interface UpdateSectorRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateSectorVariables): MutationRef<UpdateSectorData, UpdateSectorVariables>;
}
export const updateSectorRef: UpdateSectorRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateSector(dc: DataConnect, vars: UpdateSectorVariables): MutationPromise<UpdateSectorData, UpdateSectorVariables>;

interface UpdateSectorRef {
  ...
  (dc: DataConnect, vars: UpdateSectorVariables): MutationRef<UpdateSectorData, UpdateSectorVariables>;
}
export const updateSectorRef: UpdateSectorRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateSectorRef:
```typescript
const name = updateSectorRef.operationName;
console.log(name);
```

### Variables
The `UpdateSector` mutation requires an argument of type `UpdateSectorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateSectorVariables {
  id: UUIDString;
  sectorNumber?: string | null;
  sectorName?: string | null;
  sectorType?: SectorType | null;
}
```
### Return Type
Recall that executing the `UpdateSector` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateSectorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateSectorData {
  sector_update?: Sector_Key | null;
}
```
### Using `UpdateSector`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateSector, UpdateSectorVariables } from '@dataconnect/generated';

// The `UpdateSector` mutation requires an argument of type `UpdateSectorVariables`:
const updateSectorVars: UpdateSectorVariables = {
  id: ..., 
  sectorNumber: ..., // optional
  sectorName: ..., // optional
  sectorType: ..., // optional
};

// Call the `updateSector()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateSector(updateSectorVars);
// Variables can be defined inline as well.
const { data } = await updateSector({ id: ..., sectorNumber: ..., sectorName: ..., sectorType: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateSector(dataConnect, updateSectorVars);

console.log(data.sector_update);

// Or, you can use the `Promise` API.
updateSector(updateSectorVars).then((response) => {
  const data = response.data;
  console.log(data.sector_update);
});
```

### Using `UpdateSector`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateSectorRef, UpdateSectorVariables } from '@dataconnect/generated';

// The `UpdateSector` mutation requires an argument of type `UpdateSectorVariables`:
const updateSectorVars: UpdateSectorVariables = {
  id: ..., 
  sectorNumber: ..., // optional
  sectorName: ..., // optional
  sectorType: ..., // optional
};

// Call the `updateSectorRef()` function to get a reference to the mutation.
const ref = updateSectorRef(updateSectorVars);
// Variables can be defined inline as well.
const ref = updateSectorRef({ id: ..., sectorNumber: ..., sectorName: ..., sectorType: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateSectorRef(dataConnect, updateSectorVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.sector_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.sector_update);
});
```

## DeleteSector
You can execute the `DeleteSector` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteSector(vars: DeleteSectorVariables): MutationPromise<DeleteSectorData, DeleteSectorVariables>;

interface DeleteSectorRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteSectorVariables): MutationRef<DeleteSectorData, DeleteSectorVariables>;
}
export const deleteSectorRef: DeleteSectorRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteSector(dc: DataConnect, vars: DeleteSectorVariables): MutationPromise<DeleteSectorData, DeleteSectorVariables>;

interface DeleteSectorRef {
  ...
  (dc: DataConnect, vars: DeleteSectorVariables): MutationRef<DeleteSectorData, DeleteSectorVariables>;
}
export const deleteSectorRef: DeleteSectorRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteSectorRef:
```typescript
const name = deleteSectorRef.operationName;
console.log(name);
```

### Variables
The `DeleteSector` mutation requires an argument of type `DeleteSectorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteSectorVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteSector` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteSectorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteSectorData {
  sector_delete?: Sector_Key | null;
}
```
### Using `DeleteSector`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteSector, DeleteSectorVariables } from '@dataconnect/generated';

// The `DeleteSector` mutation requires an argument of type `DeleteSectorVariables`:
const deleteSectorVars: DeleteSectorVariables = {
  id: ..., 
};

// Call the `deleteSector()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteSector(deleteSectorVars);
// Variables can be defined inline as well.
const { data } = await deleteSector({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteSector(dataConnect, deleteSectorVars);

console.log(data.sector_delete);

// Or, you can use the `Promise` API.
deleteSector(deleteSectorVars).then((response) => {
  const data = response.data;
  console.log(data.sector_delete);
});
```

### Using `DeleteSector`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteSectorRef, DeleteSectorVariables } from '@dataconnect/generated';

// The `DeleteSector` mutation requires an argument of type `DeleteSectorVariables`:
const deleteSectorVars: DeleteSectorVariables = {
  id: ..., 
};

// Call the `deleteSectorRef()` function to get a reference to the mutation.
const ref = deleteSectorRef(deleteSectorVars);
// Variables can be defined inline as well.
const ref = deleteSectorRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteSectorRef(dataConnect, deleteSectorVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.sector_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.sector_delete);
});
```

## CreateUser
You can execute the `CreateUser` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createUser(vars: CreateUserVariables): MutationPromise<CreateUserData, CreateUserVariables>;

interface CreateUserRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateUserVariables): MutationRef<CreateUserData, CreateUserVariables>;
}
export const createUserRef: CreateUserRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createUser(dc: DataConnect, vars: CreateUserVariables): MutationPromise<CreateUserData, CreateUserVariables>;

interface CreateUserRef {
  ...
  (dc: DataConnect, vars: CreateUserVariables): MutationRef<CreateUserData, CreateUserVariables>;
}
export const createUserRef: CreateUserRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createUserRef:
```typescript
const name = createUserRef.operationName;
console.log(name);
```

### Variables
The `CreateUser` mutation requires an argument of type `CreateUserVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateUserVariables {
  id: string;
  email: string;
  fullName: string;
  role: UserBaseRole;
  userRole?: string | null;
}
```
### Return Type
Recall that executing the `CreateUser` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateUserData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateUserData {
  user_insert: User_Key;
}
```
### Using `CreateUser`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createUser, CreateUserVariables } from '@dataconnect/generated';

// The `CreateUser` mutation requires an argument of type `CreateUserVariables`:
const createUserVars: CreateUserVariables = {
  id: ..., 
  email: ..., 
  fullName: ..., 
  role: ..., 
  userRole: ..., // optional
};

// Call the `createUser()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createUser(createUserVars);
// Variables can be defined inline as well.
const { data } = await createUser({ id: ..., email: ..., fullName: ..., role: ..., userRole: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createUser(dataConnect, createUserVars);

console.log(data.user_insert);

// Or, you can use the `Promise` API.
createUser(createUserVars).then((response) => {
  const data = response.data;
  console.log(data.user_insert);
});
```

### Using `CreateUser`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createUserRef, CreateUserVariables } from '@dataconnect/generated';

// The `CreateUser` mutation requires an argument of type `CreateUserVariables`:
const createUserVars: CreateUserVariables = {
  id: ..., 
  email: ..., 
  fullName: ..., 
  role: ..., 
  userRole: ..., // optional
};

// Call the `createUserRef()` function to get a reference to the mutation.
const ref = createUserRef(createUserVars);
// Variables can be defined inline as well.
const ref = createUserRef({ id: ..., email: ..., fullName: ..., role: ..., userRole: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createUserRef(dataConnect, createUserVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.user_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.user_insert);
});
```

## UpdateUser
You can execute the `UpdateUser` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateUser(vars: UpdateUserVariables): MutationPromise<UpdateUserData, UpdateUserVariables>;

interface UpdateUserRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateUserVariables): MutationRef<UpdateUserData, UpdateUserVariables>;
}
export const updateUserRef: UpdateUserRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateUser(dc: DataConnect, vars: UpdateUserVariables): MutationPromise<UpdateUserData, UpdateUserVariables>;

interface UpdateUserRef {
  ...
  (dc: DataConnect, vars: UpdateUserVariables): MutationRef<UpdateUserData, UpdateUserVariables>;
}
export const updateUserRef: UpdateUserRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateUserRef:
```typescript
const name = updateUserRef.operationName;
console.log(name);
```

### Variables
The `UpdateUser` mutation requires an argument of type `UpdateUserVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateUserVariables {
  id: string;
  email?: string | null;
  fullName?: string | null;
  role?: UserBaseRole | null;
  userRole?: string | null;
}
```
### Return Type
Recall that executing the `UpdateUser` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateUserData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateUserData {
  user_update?: User_Key | null;
}
```
### Using `UpdateUser`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateUser, UpdateUserVariables } from '@dataconnect/generated';

// The `UpdateUser` mutation requires an argument of type `UpdateUserVariables`:
const updateUserVars: UpdateUserVariables = {
  id: ..., 
  email: ..., // optional
  fullName: ..., // optional
  role: ..., // optional
  userRole: ..., // optional
};

// Call the `updateUser()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateUser(updateUserVars);
// Variables can be defined inline as well.
const { data } = await updateUser({ id: ..., email: ..., fullName: ..., role: ..., userRole: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateUser(dataConnect, updateUserVars);

console.log(data.user_update);

// Or, you can use the `Promise` API.
updateUser(updateUserVars).then((response) => {
  const data = response.data;
  console.log(data.user_update);
});
```

### Using `UpdateUser`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateUserRef, UpdateUserVariables } from '@dataconnect/generated';

// The `UpdateUser` mutation requires an argument of type `UpdateUserVariables`:
const updateUserVars: UpdateUserVariables = {
  id: ..., 
  email: ..., // optional
  fullName: ..., // optional
  role: ..., // optional
  userRole: ..., // optional
};

// Call the `updateUserRef()` function to get a reference to the mutation.
const ref = updateUserRef(updateUserVars);
// Variables can be defined inline as well.
const ref = updateUserRef({ id: ..., email: ..., fullName: ..., role: ..., userRole: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateUserRef(dataConnect, updateUserVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.user_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.user_update);
});
```

## DeleteUser
You can execute the `DeleteUser` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteUser(vars: DeleteUserVariables): MutationPromise<DeleteUserData, DeleteUserVariables>;

interface DeleteUserRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteUserVariables): MutationRef<DeleteUserData, DeleteUserVariables>;
}
export const deleteUserRef: DeleteUserRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteUser(dc: DataConnect, vars: DeleteUserVariables): MutationPromise<DeleteUserData, DeleteUserVariables>;

interface DeleteUserRef {
  ...
  (dc: DataConnect, vars: DeleteUserVariables): MutationRef<DeleteUserData, DeleteUserVariables>;
}
export const deleteUserRef: DeleteUserRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteUserRef:
```typescript
const name = deleteUserRef.operationName;
console.log(name);
```

### Variables
The `DeleteUser` mutation requires an argument of type `DeleteUserVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteUserVariables {
  id: string;
}
```
### Return Type
Recall that executing the `DeleteUser` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteUserData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteUserData {
  user_delete?: User_Key | null;
}
```
### Using `DeleteUser`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteUser, DeleteUserVariables } from '@dataconnect/generated';

// The `DeleteUser` mutation requires an argument of type `DeleteUserVariables`:
const deleteUserVars: DeleteUserVariables = {
  id: ..., 
};

// Call the `deleteUser()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteUser(deleteUserVars);
// Variables can be defined inline as well.
const { data } = await deleteUser({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteUser(dataConnect, deleteUserVars);

console.log(data.user_delete);

// Or, you can use the `Promise` API.
deleteUser(deleteUserVars).then((response) => {
  const data = response.data;
  console.log(data.user_delete);
});
```

### Using `DeleteUser`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteUserRef, DeleteUserVariables } from '@dataconnect/generated';

// The `DeleteUser` mutation requires an argument of type `DeleteUserVariables`:
const deleteUserVars: DeleteUserVariables = {
  id: ..., 
};

// Call the `deleteUserRef()` function to get a reference to the mutation.
const ref = deleteUserRef(deleteUserVars);
// Variables can be defined inline as well.
const ref = deleteUserRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteUserRef(dataConnect, deleteUserVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.user_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.user_delete);
});
```

## CreateTeamMemberInvite
You can execute the `CreateTeamMemberInvite` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createTeamMemberInvite(vars: CreateTeamMemberInviteVariables): MutationPromise<CreateTeamMemberInviteData, CreateTeamMemberInviteVariables>;

interface CreateTeamMemberInviteRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateTeamMemberInviteVariables): MutationRef<CreateTeamMemberInviteData, CreateTeamMemberInviteVariables>;
}
export const createTeamMemberInviteRef: CreateTeamMemberInviteRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createTeamMemberInvite(dc: DataConnect, vars: CreateTeamMemberInviteVariables): MutationPromise<CreateTeamMemberInviteData, CreateTeamMemberInviteVariables>;

interface CreateTeamMemberInviteRef {
  ...
  (dc: DataConnect, vars: CreateTeamMemberInviteVariables): MutationRef<CreateTeamMemberInviteData, CreateTeamMemberInviteVariables>;
}
export const createTeamMemberInviteRef: CreateTeamMemberInviteRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createTeamMemberInviteRef:
```typescript
const name = createTeamMemberInviteRef.operationName;
console.log(name);
```

### Variables
The `CreateTeamMemberInvite` mutation requires an argument of type `CreateTeamMemberInviteVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateTeamMemberInviteVariables {
  teamId: UUIDString;
  email: string;
  inviteStatus: TeamMemberInviteStatus;
}
```
### Return Type
Recall that executing the `CreateTeamMemberInvite` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateTeamMemberInviteData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateTeamMemberInviteData {
  teamMemberInvite_insert: TeamMemberInvite_Key;
}
```
### Using `CreateTeamMemberInvite`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createTeamMemberInvite, CreateTeamMemberInviteVariables } from '@dataconnect/generated';

// The `CreateTeamMemberInvite` mutation requires an argument of type `CreateTeamMemberInviteVariables`:
const createTeamMemberInviteVars: CreateTeamMemberInviteVariables = {
  teamId: ..., 
  email: ..., 
  inviteStatus: ..., 
};

// Call the `createTeamMemberInvite()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createTeamMemberInvite(createTeamMemberInviteVars);
// Variables can be defined inline as well.
const { data } = await createTeamMemberInvite({ teamId: ..., email: ..., inviteStatus: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createTeamMemberInvite(dataConnect, createTeamMemberInviteVars);

console.log(data.teamMemberInvite_insert);

// Or, you can use the `Promise` API.
createTeamMemberInvite(createTeamMemberInviteVars).then((response) => {
  const data = response.data;
  console.log(data.teamMemberInvite_insert);
});
```

### Using `CreateTeamMemberInvite`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createTeamMemberInviteRef, CreateTeamMemberInviteVariables } from '@dataconnect/generated';

// The `CreateTeamMemberInvite` mutation requires an argument of type `CreateTeamMemberInviteVariables`:
const createTeamMemberInviteVars: CreateTeamMemberInviteVariables = {
  teamId: ..., 
  email: ..., 
  inviteStatus: ..., 
};

// Call the `createTeamMemberInviteRef()` function to get a reference to the mutation.
const ref = createTeamMemberInviteRef(createTeamMemberInviteVars);
// Variables can be defined inline as well.
const ref = createTeamMemberInviteRef({ teamId: ..., email: ..., inviteStatus: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createTeamMemberInviteRef(dataConnect, createTeamMemberInviteVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.teamMemberInvite_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.teamMemberInvite_insert);
});
```

## UpdateTeamMemberInvite
You can execute the `UpdateTeamMemberInvite` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateTeamMemberInvite(vars: UpdateTeamMemberInviteVariables): MutationPromise<UpdateTeamMemberInviteData, UpdateTeamMemberInviteVariables>;

interface UpdateTeamMemberInviteRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateTeamMemberInviteVariables): MutationRef<UpdateTeamMemberInviteData, UpdateTeamMemberInviteVariables>;
}
export const updateTeamMemberInviteRef: UpdateTeamMemberInviteRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateTeamMemberInvite(dc: DataConnect, vars: UpdateTeamMemberInviteVariables): MutationPromise<UpdateTeamMemberInviteData, UpdateTeamMemberInviteVariables>;

interface UpdateTeamMemberInviteRef {
  ...
  (dc: DataConnect, vars: UpdateTeamMemberInviteVariables): MutationRef<UpdateTeamMemberInviteData, UpdateTeamMemberInviteVariables>;
}
export const updateTeamMemberInviteRef: UpdateTeamMemberInviteRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateTeamMemberInviteRef:
```typescript
const name = updateTeamMemberInviteRef.operationName;
console.log(name);
```

### Variables
The `UpdateTeamMemberInvite` mutation requires an argument of type `UpdateTeamMemberInviteVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateTeamMemberInviteVariables {
  id: UUIDString;
  teamId?: UUIDString | null;
  email?: string | null;
  inviteStatus?: TeamMemberInviteStatus | null;
}
```
### Return Type
Recall that executing the `UpdateTeamMemberInvite` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateTeamMemberInviteData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateTeamMemberInviteData {
  teamMemberInvite_update?: TeamMemberInvite_Key | null;
}
```
### Using `UpdateTeamMemberInvite`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateTeamMemberInvite, UpdateTeamMemberInviteVariables } from '@dataconnect/generated';

// The `UpdateTeamMemberInvite` mutation requires an argument of type `UpdateTeamMemberInviteVariables`:
const updateTeamMemberInviteVars: UpdateTeamMemberInviteVariables = {
  id: ..., 
  teamId: ..., // optional
  email: ..., // optional
  inviteStatus: ..., // optional
};

// Call the `updateTeamMemberInvite()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateTeamMemberInvite(updateTeamMemberInviteVars);
// Variables can be defined inline as well.
const { data } = await updateTeamMemberInvite({ id: ..., teamId: ..., email: ..., inviteStatus: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateTeamMemberInvite(dataConnect, updateTeamMemberInviteVars);

console.log(data.teamMemberInvite_update);

// Or, you can use the `Promise` API.
updateTeamMemberInvite(updateTeamMemberInviteVars).then((response) => {
  const data = response.data;
  console.log(data.teamMemberInvite_update);
});
```

### Using `UpdateTeamMemberInvite`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateTeamMemberInviteRef, UpdateTeamMemberInviteVariables } from '@dataconnect/generated';

// The `UpdateTeamMemberInvite` mutation requires an argument of type `UpdateTeamMemberInviteVariables`:
const updateTeamMemberInviteVars: UpdateTeamMemberInviteVariables = {
  id: ..., 
  teamId: ..., // optional
  email: ..., // optional
  inviteStatus: ..., // optional
};

// Call the `updateTeamMemberInviteRef()` function to get a reference to the mutation.
const ref = updateTeamMemberInviteRef(updateTeamMemberInviteVars);
// Variables can be defined inline as well.
const ref = updateTeamMemberInviteRef({ id: ..., teamId: ..., email: ..., inviteStatus: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateTeamMemberInviteRef(dataConnect, updateTeamMemberInviteVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.teamMemberInvite_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.teamMemberInvite_update);
});
```

## DeleteTeamMemberInvite
You can execute the `DeleteTeamMemberInvite` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteTeamMemberInvite(vars: DeleteTeamMemberInviteVariables): MutationPromise<DeleteTeamMemberInviteData, DeleteTeamMemberInviteVariables>;

interface DeleteTeamMemberInviteRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteTeamMemberInviteVariables): MutationRef<DeleteTeamMemberInviteData, DeleteTeamMemberInviteVariables>;
}
export const deleteTeamMemberInviteRef: DeleteTeamMemberInviteRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteTeamMemberInvite(dc: DataConnect, vars: DeleteTeamMemberInviteVariables): MutationPromise<DeleteTeamMemberInviteData, DeleteTeamMemberInviteVariables>;

interface DeleteTeamMemberInviteRef {
  ...
  (dc: DataConnect, vars: DeleteTeamMemberInviteVariables): MutationRef<DeleteTeamMemberInviteData, DeleteTeamMemberInviteVariables>;
}
export const deleteTeamMemberInviteRef: DeleteTeamMemberInviteRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteTeamMemberInviteRef:
```typescript
const name = deleteTeamMemberInviteRef.operationName;
console.log(name);
```

### Variables
The `DeleteTeamMemberInvite` mutation requires an argument of type `DeleteTeamMemberInviteVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteTeamMemberInviteVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteTeamMemberInvite` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteTeamMemberInviteData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteTeamMemberInviteData {
  teamMemberInvite_delete?: TeamMemberInvite_Key | null;
}
```
### Using `DeleteTeamMemberInvite`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteTeamMemberInvite, DeleteTeamMemberInviteVariables } from '@dataconnect/generated';

// The `DeleteTeamMemberInvite` mutation requires an argument of type `DeleteTeamMemberInviteVariables`:
const deleteTeamMemberInviteVars: DeleteTeamMemberInviteVariables = {
  id: ..., 
};

// Call the `deleteTeamMemberInvite()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteTeamMemberInvite(deleteTeamMemberInviteVars);
// Variables can be defined inline as well.
const { data } = await deleteTeamMemberInvite({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteTeamMemberInvite(dataConnect, deleteTeamMemberInviteVars);

console.log(data.teamMemberInvite_delete);

// Or, you can use the `Promise` API.
deleteTeamMemberInvite(deleteTeamMemberInviteVars).then((response) => {
  const data = response.data;
  console.log(data.teamMemberInvite_delete);
});
```

### Using `DeleteTeamMemberInvite`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteTeamMemberInviteRef, DeleteTeamMemberInviteVariables } from '@dataconnect/generated';

// The `DeleteTeamMemberInvite` mutation requires an argument of type `DeleteTeamMemberInviteVariables`:
const deleteTeamMemberInviteVars: DeleteTeamMemberInviteVariables = {
  id: ..., 
};

// Call the `deleteTeamMemberInviteRef()` function to get a reference to the mutation.
const ref = deleteTeamMemberInviteRef(deleteTeamMemberInviteVars);
// Variables can be defined inline as well.
const ref = deleteTeamMemberInviteRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteTeamMemberInviteRef(dataConnect, deleteTeamMemberInviteVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.teamMemberInvite_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.teamMemberInvite_delete);
});
```

## CreateVendorDefaultSetting
You can execute the `CreateVendorDefaultSetting` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createVendorDefaultSetting(vars: CreateVendorDefaultSettingVariables): MutationPromise<CreateVendorDefaultSettingData, CreateVendorDefaultSettingVariables>;

interface CreateVendorDefaultSettingRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateVendorDefaultSettingVariables): MutationRef<CreateVendorDefaultSettingData, CreateVendorDefaultSettingVariables>;
}
export const createVendorDefaultSettingRef: CreateVendorDefaultSettingRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createVendorDefaultSetting(dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationPromise<CreateVendorDefaultSettingData, CreateVendorDefaultSettingVariables>;

interface CreateVendorDefaultSettingRef {
  ...
  (dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationRef<CreateVendorDefaultSettingData, CreateVendorDefaultSettingVariables>;
}
export const createVendorDefaultSettingRef: CreateVendorDefaultSettingRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createVendorDefaultSettingRef:
```typescript
const name = createVendorDefaultSettingRef.operationName;
console.log(name);
```

### Variables
The `CreateVendorDefaultSetting` mutation requires an argument of type `CreateVendorDefaultSettingVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateVendorDefaultSettingVariables {
  vendorName: string;
  defaultMarkupPercentage: number;
  defaultVendorFeePercentage: number;
}
```
### Return Type
Recall that executing the `CreateVendorDefaultSetting` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateVendorDefaultSettingData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateVendorDefaultSettingData {
  vendorDefaultSetting_insert: VendorDefaultSetting_Key;
}
```
### Using `CreateVendorDefaultSetting`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createVendorDefaultSetting, CreateVendorDefaultSettingVariables } from '@dataconnect/generated';

// The `CreateVendorDefaultSetting` mutation requires an argument of type `CreateVendorDefaultSettingVariables`:
const createVendorDefaultSettingVars: CreateVendorDefaultSettingVariables = {
  vendorName: ..., 
  defaultMarkupPercentage: ..., 
  defaultVendorFeePercentage: ..., 
};

// Call the `createVendorDefaultSetting()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createVendorDefaultSetting(createVendorDefaultSettingVars);
// Variables can be defined inline as well.
const { data } = await createVendorDefaultSetting({ vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createVendorDefaultSetting(dataConnect, createVendorDefaultSettingVars);

console.log(data.vendorDefaultSetting_insert);

// Or, you can use the `Promise` API.
createVendorDefaultSetting(createVendorDefaultSettingVars).then((response) => {
  const data = response.data;
  console.log(data.vendorDefaultSetting_insert);
});
```

### Using `CreateVendorDefaultSetting`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createVendorDefaultSettingRef, CreateVendorDefaultSettingVariables } from '@dataconnect/generated';

// The `CreateVendorDefaultSetting` mutation requires an argument of type `CreateVendorDefaultSettingVariables`:
const createVendorDefaultSettingVars: CreateVendorDefaultSettingVariables = {
  vendorName: ..., 
  defaultMarkupPercentage: ..., 
  defaultVendorFeePercentage: ..., 
};

// Call the `createVendorDefaultSettingRef()` function to get a reference to the mutation.
const ref = createVendorDefaultSettingRef(createVendorDefaultSettingVars);
// Variables can be defined inline as well.
const ref = createVendorDefaultSettingRef({ vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createVendorDefaultSettingRef(dataConnect, createVendorDefaultSettingVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.vendorDefaultSetting_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.vendorDefaultSetting_insert);
});
```

## UpdateVendorDefaultSetting
You can execute the `UpdateVendorDefaultSetting` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateVendorDefaultSetting(vars: UpdateVendorDefaultSettingVariables): MutationPromise<UpdateVendorDefaultSettingData, UpdateVendorDefaultSettingVariables>;

interface UpdateVendorDefaultSettingRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateVendorDefaultSettingVariables): MutationRef<UpdateVendorDefaultSettingData, UpdateVendorDefaultSettingVariables>;
}
export const updateVendorDefaultSettingRef: UpdateVendorDefaultSettingRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateVendorDefaultSetting(dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationPromise<UpdateVendorDefaultSettingData, UpdateVendorDefaultSettingVariables>;

interface UpdateVendorDefaultSettingRef {
  ...
  (dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationRef<UpdateVendorDefaultSettingData, UpdateVendorDefaultSettingVariables>;
}
export const updateVendorDefaultSettingRef: UpdateVendorDefaultSettingRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateVendorDefaultSettingRef:
```typescript
const name = updateVendorDefaultSettingRef.operationName;
console.log(name);
```

### Variables
The `UpdateVendorDefaultSetting` mutation requires an argument of type `UpdateVendorDefaultSettingVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateVendorDefaultSettingVariables {
  id: UUIDString;
  vendorName?: string | null;
  defaultMarkupPercentage?: number | null;
  defaultVendorFeePercentage?: number | null;
}
```
### Return Type
Recall that executing the `UpdateVendorDefaultSetting` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateVendorDefaultSettingData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateVendorDefaultSettingData {
  vendorDefaultSetting_update?: VendorDefaultSetting_Key | null;
}
```
### Using `UpdateVendorDefaultSetting`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateVendorDefaultSetting, UpdateVendorDefaultSettingVariables } from '@dataconnect/generated';

// The `UpdateVendorDefaultSetting` mutation requires an argument of type `UpdateVendorDefaultSettingVariables`:
const updateVendorDefaultSettingVars: UpdateVendorDefaultSettingVariables = {
  id: ..., 
  vendorName: ..., // optional
  defaultMarkupPercentage: ..., // optional
  defaultVendorFeePercentage: ..., // optional
};

// Call the `updateVendorDefaultSetting()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateVendorDefaultSetting(updateVendorDefaultSettingVars);
// Variables can be defined inline as well.
const { data } = await updateVendorDefaultSetting({ id: ..., vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateVendorDefaultSetting(dataConnect, updateVendorDefaultSettingVars);

console.log(data.vendorDefaultSetting_update);

// Or, you can use the `Promise` API.
updateVendorDefaultSetting(updateVendorDefaultSettingVars).then((response) => {
  const data = response.data;
  console.log(data.vendorDefaultSetting_update);
});
```

### Using `UpdateVendorDefaultSetting`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateVendorDefaultSettingRef, UpdateVendorDefaultSettingVariables } from '@dataconnect/generated';

// The `UpdateVendorDefaultSetting` mutation requires an argument of type `UpdateVendorDefaultSettingVariables`:
const updateVendorDefaultSettingVars: UpdateVendorDefaultSettingVariables = {
  id: ..., 
  vendorName: ..., // optional
  defaultMarkupPercentage: ..., // optional
  defaultVendorFeePercentage: ..., // optional
};

// Call the `updateVendorDefaultSettingRef()` function to get a reference to the mutation.
const ref = updateVendorDefaultSettingRef(updateVendorDefaultSettingVars);
// Variables can be defined inline as well.
const ref = updateVendorDefaultSettingRef({ id: ..., vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateVendorDefaultSettingRef(dataConnect, updateVendorDefaultSettingVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.vendorDefaultSetting_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.vendorDefaultSetting_update);
});
```

## DeleteVendorDefaultSetting
You can execute the `DeleteVendorDefaultSetting` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteVendorDefaultSetting(vars: DeleteVendorDefaultSettingVariables): MutationPromise<DeleteVendorDefaultSettingData, DeleteVendorDefaultSettingVariables>;

interface DeleteVendorDefaultSettingRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteVendorDefaultSettingVariables): MutationRef<DeleteVendorDefaultSettingData, DeleteVendorDefaultSettingVariables>;
}
export const deleteVendorDefaultSettingRef: DeleteVendorDefaultSettingRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteVendorDefaultSetting(dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationPromise<DeleteVendorDefaultSettingData, DeleteVendorDefaultSettingVariables>;

interface DeleteVendorDefaultSettingRef {
  ...
  (dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationRef<DeleteVendorDefaultSettingData, DeleteVendorDefaultSettingVariables>;
}
export const deleteVendorDefaultSettingRef: DeleteVendorDefaultSettingRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteVendorDefaultSettingRef:
```typescript
const name = deleteVendorDefaultSettingRef.operationName;
console.log(name);
```

### Variables
The `DeleteVendorDefaultSetting` mutation requires an argument of type `DeleteVendorDefaultSettingVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteVendorDefaultSettingVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteVendorDefaultSetting` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteVendorDefaultSettingData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteVendorDefaultSettingData {
  vendorDefaultSetting_delete?: VendorDefaultSetting_Key | null;
}
```
### Using `DeleteVendorDefaultSetting`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteVendorDefaultSetting, DeleteVendorDefaultSettingVariables } from '@dataconnect/generated';

// The `DeleteVendorDefaultSetting` mutation requires an argument of type `DeleteVendorDefaultSettingVariables`:
const deleteVendorDefaultSettingVars: DeleteVendorDefaultSettingVariables = {
  id: ..., 
};

// Call the `deleteVendorDefaultSetting()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteVendorDefaultSetting(deleteVendorDefaultSettingVars);
// Variables can be defined inline as well.
const { data } = await deleteVendorDefaultSetting({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteVendorDefaultSetting(dataConnect, deleteVendorDefaultSettingVars);

console.log(data.vendorDefaultSetting_delete);

// Or, you can use the `Promise` API.
deleteVendorDefaultSetting(deleteVendorDefaultSettingVars).then((response) => {
  const data = response.data;
  console.log(data.vendorDefaultSetting_delete);
});
```

### Using `DeleteVendorDefaultSetting`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteVendorDefaultSettingRef, DeleteVendorDefaultSettingVariables } from '@dataconnect/generated';

// The `DeleteVendorDefaultSetting` mutation requires an argument of type `DeleteVendorDefaultSettingVariables`:
const deleteVendorDefaultSettingVars: DeleteVendorDefaultSettingVariables = {
  id: ..., 
};

// Call the `deleteVendorDefaultSettingRef()` function to get a reference to the mutation.
const ref = deleteVendorDefaultSettingRef(deleteVendorDefaultSettingVars);
// Variables can be defined inline as well.
const ref = deleteVendorDefaultSettingRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteVendorDefaultSettingRef(dataConnect, deleteVendorDefaultSettingVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.vendorDefaultSetting_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.vendorDefaultSetting_delete);
});
```

## CreateVendorRate
You can execute the `CreateVendorRate` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createVendorRate(vars: CreateVendorRateVariables): MutationPromise<CreateVendorRateData, CreateVendorRateVariables>;

interface CreateVendorRateRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateVendorRateVariables): MutationRef<CreateVendorRateData, CreateVendorRateVariables>;
}
export const createVendorRateRef: CreateVendorRateRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createVendorRate(dc: DataConnect, vars: CreateVendorRateVariables): MutationPromise<CreateVendorRateData, CreateVendorRateVariables>;

interface CreateVendorRateRef {
  ...
  (dc: DataConnect, vars: CreateVendorRateVariables): MutationRef<CreateVendorRateData, CreateVendorRateVariables>;
}
export const createVendorRateRef: CreateVendorRateRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createVendorRateRef:
```typescript
const name = createVendorRateRef.operationName;
console.log(name);
```

### Variables
The `CreateVendorRate` mutation requires an argument of type `CreateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateVendorRateVariables {
  vendorName: string;
  category: VendorRateCategory;
  roleName: string;
  employeeWage: number;
  markupPercentage?: number | null;
  vendorFeePercentage?: number | null;
  clientRate: number;
}
```
### Return Type
Recall that executing the `CreateVendorRate` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateVendorRateData {
  vendorRate_insert: VendorRate_Key;
}
```
### Using `CreateVendorRate`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createVendorRate, CreateVendorRateVariables } from '@dataconnect/generated';

// The `CreateVendorRate` mutation requires an argument of type `CreateVendorRateVariables`:
const createVendorRateVars: CreateVendorRateVariables = {
  vendorName: ..., 
  category: ..., 
  roleName: ..., 
  employeeWage: ..., 
  markupPercentage: ..., // optional
  vendorFeePercentage: ..., // optional
  clientRate: ..., 
};

// Call the `createVendorRate()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createVendorRate(createVendorRateVars);
// Variables can be defined inline as well.
const { data } = await createVendorRate({ vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createVendorRate(dataConnect, createVendorRateVars);

console.log(data.vendorRate_insert);

// Or, you can use the `Promise` API.
createVendorRate(createVendorRateVars).then((response) => {
  const data = response.data;
  console.log(data.vendorRate_insert);
});
```

### Using `CreateVendorRate`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createVendorRateRef, CreateVendorRateVariables } from '@dataconnect/generated';

// The `CreateVendorRate` mutation requires an argument of type `CreateVendorRateVariables`:
const createVendorRateVars: CreateVendorRateVariables = {
  vendorName: ..., 
  category: ..., 
  roleName: ..., 
  employeeWage: ..., 
  markupPercentage: ..., // optional
  vendorFeePercentage: ..., // optional
  clientRate: ..., 
};

// Call the `createVendorRateRef()` function to get a reference to the mutation.
const ref = createVendorRateRef(createVendorRateVars);
// Variables can be defined inline as well.
const ref = createVendorRateRef({ vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createVendorRateRef(dataConnect, createVendorRateVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.vendorRate_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.vendorRate_insert);
});
```

## UpdateVendorRate
You can execute the `UpdateVendorRate` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateVendorRate(vars: UpdateVendorRateVariables): MutationPromise<UpdateVendorRateData, UpdateVendorRateVariables>;

interface UpdateVendorRateRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateVendorRateVariables): MutationRef<UpdateVendorRateData, UpdateVendorRateVariables>;
}
export const updateVendorRateRef: UpdateVendorRateRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateVendorRate(dc: DataConnect, vars: UpdateVendorRateVariables): MutationPromise<UpdateVendorRateData, UpdateVendorRateVariables>;

interface UpdateVendorRateRef {
  ...
  (dc: DataConnect, vars: UpdateVendorRateVariables): MutationRef<UpdateVendorRateData, UpdateVendorRateVariables>;
}
export const updateVendorRateRef: UpdateVendorRateRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateVendorRateRef:
```typescript
const name = updateVendorRateRef.operationName;
console.log(name);
```

### Variables
The `UpdateVendorRate` mutation requires an argument of type `UpdateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateVendorRateVariables {
  id: UUIDString;
  vendorName?: string | null;
  category?: VendorRateCategory | null;
  roleName?: string | null;
  employeeWage?: number | null;
  markupPercentage?: number | null;
  vendorFeePercentage?: number | null;
  clientRate?: number | null;
}
```
### Return Type
Recall that executing the `UpdateVendorRate` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateVendorRateData {
  vendorRate_update?: VendorRate_Key | null;
}
```
### Using `UpdateVendorRate`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateVendorRate, UpdateVendorRateVariables } from '@dataconnect/generated';

// The `UpdateVendorRate` mutation requires an argument of type `UpdateVendorRateVariables`:
const updateVendorRateVars: UpdateVendorRateVariables = {
  id: ..., 
  vendorName: ..., // optional
  category: ..., // optional
  roleName: ..., // optional
  employeeWage: ..., // optional
  markupPercentage: ..., // optional
  vendorFeePercentage: ..., // optional
  clientRate: ..., // optional
};

// Call the `updateVendorRate()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateVendorRate(updateVendorRateVars);
// Variables can be defined inline as well.
const { data } = await updateVendorRate({ id: ..., vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateVendorRate(dataConnect, updateVendorRateVars);

console.log(data.vendorRate_update);

// Or, you can use the `Promise` API.
updateVendorRate(updateVendorRateVars).then((response) => {
  const data = response.data;
  console.log(data.vendorRate_update);
});
```

### Using `UpdateVendorRate`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateVendorRateRef, UpdateVendorRateVariables } from '@dataconnect/generated';

// The `UpdateVendorRate` mutation requires an argument of type `UpdateVendorRateVariables`:
const updateVendorRateVars: UpdateVendorRateVariables = {
  id: ..., 
  vendorName: ..., // optional
  category: ..., // optional
  roleName: ..., // optional
  employeeWage: ..., // optional
  markupPercentage: ..., // optional
  vendorFeePercentage: ..., // optional
  clientRate: ..., // optional
};

// Call the `updateVendorRateRef()` function to get a reference to the mutation.
const ref = updateVendorRateRef(updateVendorRateVars);
// Variables can be defined inline as well.
const ref = updateVendorRateRef({ id: ..., vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateVendorRateRef(dataConnect, updateVendorRateVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.vendorRate_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.vendorRate_update);
});
```

## DeleteVendorRate
You can execute the `DeleteVendorRate` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteVendorRate(vars: DeleteVendorRateVariables): MutationPromise<DeleteVendorRateData, DeleteVendorRateVariables>;

interface DeleteVendorRateRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteVendorRateVariables): MutationRef<DeleteVendorRateData, DeleteVendorRateVariables>;
}
export const deleteVendorRateRef: DeleteVendorRateRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteVendorRate(dc: DataConnect, vars: DeleteVendorRateVariables): MutationPromise<DeleteVendorRateData, DeleteVendorRateVariables>;

interface DeleteVendorRateRef {
  ...
  (dc: DataConnect, vars: DeleteVendorRateVariables): MutationRef<DeleteVendorRateData, DeleteVendorRateVariables>;
}
export const deleteVendorRateRef: DeleteVendorRateRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteVendorRateRef:
```typescript
const name = deleteVendorRateRef.operationName;
console.log(name);
```

### Variables
The `DeleteVendorRate` mutation requires an argument of type `DeleteVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteVendorRateVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteVendorRate` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteVendorRateData {
  vendorRate_delete?: VendorRate_Key | null;
}
```
### Using `DeleteVendorRate`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteVendorRate, DeleteVendorRateVariables } from '@dataconnect/generated';

// The `DeleteVendorRate` mutation requires an argument of type `DeleteVendorRateVariables`:
const deleteVendorRateVars: DeleteVendorRateVariables = {
  id: ..., 
};

// Call the `deleteVendorRate()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteVendorRate(deleteVendorRateVars);
// Variables can be defined inline as well.
const { data } = await deleteVendorRate({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteVendorRate(dataConnect, deleteVendorRateVars);

console.log(data.vendorRate_delete);

// Or, you can use the `Promise` API.
deleteVendorRate(deleteVendorRateVars).then((response) => {
  const data = response.data;
  console.log(data.vendorRate_delete);
});
```

### Using `DeleteVendorRate`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteVendorRateRef, DeleteVendorRateVariables } from '@dataconnect/generated';

// The `DeleteVendorRate` mutation requires an argument of type `DeleteVendorRateVariables`:
const deleteVendorRateVars: DeleteVendorRateVariables = {
  id: ..., 
};

// Call the `deleteVendorRateRef()` function to get a reference to the mutation.
const ref = deleteVendorRateRef(deleteVendorRateVars);
// Variables can be defined inline as well.
const ref = deleteVendorRateRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteVendorRateRef(dataConnect, deleteVendorRateVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.vendorRate_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.vendorRate_delete);
});
```

## CreateEnterprise
You can execute the `CreateEnterprise` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createEnterprise(vars: CreateEnterpriseVariables): MutationPromise<CreateEnterpriseData, CreateEnterpriseVariables>;

interface CreateEnterpriseRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateEnterpriseVariables): MutationRef<CreateEnterpriseData, CreateEnterpriseVariables>;
}
export const createEnterpriseRef: CreateEnterpriseRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createEnterprise(dc: DataConnect, vars: CreateEnterpriseVariables): MutationPromise<CreateEnterpriseData, CreateEnterpriseVariables>;

interface CreateEnterpriseRef {
  ...
  (dc: DataConnect, vars: CreateEnterpriseVariables): MutationRef<CreateEnterpriseData, CreateEnterpriseVariables>;
}
export const createEnterpriseRef: CreateEnterpriseRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createEnterpriseRef:
```typescript
const name = createEnterpriseRef.operationName;
console.log(name);
```

### Variables
The `CreateEnterprise` mutation requires an argument of type `CreateEnterpriseVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateEnterpriseVariables {
  enterpriseNumber: string;
  enterpriseName: string;
  enterpriseCode: string;
}
```
### Return Type
Recall that executing the `CreateEnterprise` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateEnterpriseData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateEnterpriseData {
  enterprise_insert: Enterprise_Key;
}
```
### Using `CreateEnterprise`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createEnterprise, CreateEnterpriseVariables } from '@dataconnect/generated';

// The `CreateEnterprise` mutation requires an argument of type `CreateEnterpriseVariables`:
const createEnterpriseVars: CreateEnterpriseVariables = {
  enterpriseNumber: ..., 
  enterpriseName: ..., 
  enterpriseCode: ..., 
};

// Call the `createEnterprise()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createEnterprise(createEnterpriseVars);
// Variables can be defined inline as well.
const { data } = await createEnterprise({ enterpriseNumber: ..., enterpriseName: ..., enterpriseCode: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createEnterprise(dataConnect, createEnterpriseVars);

console.log(data.enterprise_insert);

// Or, you can use the `Promise` API.
createEnterprise(createEnterpriseVars).then((response) => {
  const data = response.data;
  console.log(data.enterprise_insert);
});
```

### Using `CreateEnterprise`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createEnterpriseRef, CreateEnterpriseVariables } from '@dataconnect/generated';

// The `CreateEnterprise` mutation requires an argument of type `CreateEnterpriseVariables`:
const createEnterpriseVars: CreateEnterpriseVariables = {
  enterpriseNumber: ..., 
  enterpriseName: ..., 
  enterpriseCode: ..., 
};

// Call the `createEnterpriseRef()` function to get a reference to the mutation.
const ref = createEnterpriseRef(createEnterpriseVars);
// Variables can be defined inline as well.
const ref = createEnterpriseRef({ enterpriseNumber: ..., enterpriseName: ..., enterpriseCode: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createEnterpriseRef(dataConnect, createEnterpriseVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.enterprise_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.enterprise_insert);
});
```

## UpdateEnterprise
You can execute the `UpdateEnterprise` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateEnterprise(vars: UpdateEnterpriseVariables): MutationPromise<UpdateEnterpriseData, UpdateEnterpriseVariables>;

interface UpdateEnterpriseRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateEnterpriseVariables): MutationRef<UpdateEnterpriseData, UpdateEnterpriseVariables>;
}
export const updateEnterpriseRef: UpdateEnterpriseRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateEnterprise(dc: DataConnect, vars: UpdateEnterpriseVariables): MutationPromise<UpdateEnterpriseData, UpdateEnterpriseVariables>;

interface UpdateEnterpriseRef {
  ...
  (dc: DataConnect, vars: UpdateEnterpriseVariables): MutationRef<UpdateEnterpriseData, UpdateEnterpriseVariables>;
}
export const updateEnterpriseRef: UpdateEnterpriseRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateEnterpriseRef:
```typescript
const name = updateEnterpriseRef.operationName;
console.log(name);
```

### Variables
The `UpdateEnterprise` mutation requires an argument of type `UpdateEnterpriseVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateEnterpriseVariables {
  id: UUIDString;
  enterpriseNumber?: string | null;
  enterpriseName?: string | null;
  enterpriseCode?: string | null;
}
```
### Return Type
Recall that executing the `UpdateEnterprise` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateEnterpriseData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateEnterpriseData {
  enterprise_update?: Enterprise_Key | null;
}
```
### Using `UpdateEnterprise`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateEnterprise, UpdateEnterpriseVariables } from '@dataconnect/generated';

// The `UpdateEnterprise` mutation requires an argument of type `UpdateEnterpriseVariables`:
const updateEnterpriseVars: UpdateEnterpriseVariables = {
  id: ..., 
  enterpriseNumber: ..., // optional
  enterpriseName: ..., // optional
  enterpriseCode: ..., // optional
};

// Call the `updateEnterprise()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateEnterprise(updateEnterpriseVars);
// Variables can be defined inline as well.
const { data } = await updateEnterprise({ id: ..., enterpriseNumber: ..., enterpriseName: ..., enterpriseCode: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateEnterprise(dataConnect, updateEnterpriseVars);

console.log(data.enterprise_update);

// Or, you can use the `Promise` API.
updateEnterprise(updateEnterpriseVars).then((response) => {
  const data = response.data;
  console.log(data.enterprise_update);
});
```

### Using `UpdateEnterprise`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateEnterpriseRef, UpdateEnterpriseVariables } from '@dataconnect/generated';

// The `UpdateEnterprise` mutation requires an argument of type `UpdateEnterpriseVariables`:
const updateEnterpriseVars: UpdateEnterpriseVariables = {
  id: ..., 
  enterpriseNumber: ..., // optional
  enterpriseName: ..., // optional
  enterpriseCode: ..., // optional
};

// Call the `updateEnterpriseRef()` function to get a reference to the mutation.
const ref = updateEnterpriseRef(updateEnterpriseVars);
// Variables can be defined inline as well.
const ref = updateEnterpriseRef({ id: ..., enterpriseNumber: ..., enterpriseName: ..., enterpriseCode: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateEnterpriseRef(dataConnect, updateEnterpriseVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.enterprise_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.enterprise_update);
});
```

## DeleteEnterprise
You can execute the `DeleteEnterprise` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteEnterprise(vars: DeleteEnterpriseVariables): MutationPromise<DeleteEnterpriseData, DeleteEnterpriseVariables>;

interface DeleteEnterpriseRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteEnterpriseVariables): MutationRef<DeleteEnterpriseData, DeleteEnterpriseVariables>;
}
export const deleteEnterpriseRef: DeleteEnterpriseRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteEnterprise(dc: DataConnect, vars: DeleteEnterpriseVariables): MutationPromise<DeleteEnterpriseData, DeleteEnterpriseVariables>;

interface DeleteEnterpriseRef {
  ...
  (dc: DataConnect, vars: DeleteEnterpriseVariables): MutationRef<DeleteEnterpriseData, DeleteEnterpriseVariables>;
}
export const deleteEnterpriseRef: DeleteEnterpriseRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteEnterpriseRef:
```typescript
const name = deleteEnterpriseRef.operationName;
console.log(name);
```

### Variables
The `DeleteEnterprise` mutation requires an argument of type `DeleteEnterpriseVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteEnterpriseVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteEnterprise` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteEnterpriseData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteEnterpriseData {
  enterprise_delete?: Enterprise_Key | null;
}
```
### Using `DeleteEnterprise`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteEnterprise, DeleteEnterpriseVariables } from '@dataconnect/generated';

// The `DeleteEnterprise` mutation requires an argument of type `DeleteEnterpriseVariables`:
const deleteEnterpriseVars: DeleteEnterpriseVariables = {
  id: ..., 
};

// Call the `deleteEnterprise()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteEnterprise(deleteEnterpriseVars);
// Variables can be defined inline as well.
const { data } = await deleteEnterprise({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteEnterprise(dataConnect, deleteEnterpriseVars);

console.log(data.enterprise_delete);

// Or, you can use the `Promise` API.
deleteEnterprise(deleteEnterpriseVars).then((response) => {
  const data = response.data;
  console.log(data.enterprise_delete);
});
```

### Using `DeleteEnterprise`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteEnterpriseRef, DeleteEnterpriseVariables } from '@dataconnect/generated';

// The `DeleteEnterprise` mutation requires an argument of type `DeleteEnterpriseVariables`:
const deleteEnterpriseVars: DeleteEnterpriseVariables = {
  id: ..., 
};

// Call the `deleteEnterpriseRef()` function to get a reference to the mutation.
const ref = deleteEnterpriseRef(deleteEnterpriseVars);
// Variables can be defined inline as well.
const ref = deleteEnterpriseRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteEnterpriseRef(dataConnect, deleteEnterpriseVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.enterprise_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.enterprise_delete);
});
```

## CreatePartner
You can execute the `CreatePartner` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createPartner(vars: CreatePartnerVariables): MutationPromise<CreatePartnerData, CreatePartnerVariables>;

interface CreatePartnerRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreatePartnerVariables): MutationRef<CreatePartnerData, CreatePartnerVariables>;
}
export const createPartnerRef: CreatePartnerRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createPartner(dc: DataConnect, vars: CreatePartnerVariables): MutationPromise<CreatePartnerData, CreatePartnerVariables>;

interface CreatePartnerRef {
  ...
  (dc: DataConnect, vars: CreatePartnerVariables): MutationRef<CreatePartnerData, CreatePartnerVariables>;
}
export const createPartnerRef: CreatePartnerRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createPartnerRef:
```typescript
const name = createPartnerRef.operationName;
console.log(name);
```

### Variables
The `CreatePartner` mutation requires an argument of type `CreatePartnerVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreatePartnerVariables {
  partnerName: string;
  partnerNumber: string;
  partnerType?: PartnerType | null;
}
```
### Return Type
Recall that executing the `CreatePartner` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreatePartnerData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreatePartnerData {
  partner_insert: Partner_Key;
}
```
### Using `CreatePartner`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createPartner, CreatePartnerVariables } from '@dataconnect/generated';

// The `CreatePartner` mutation requires an argument of type `CreatePartnerVariables`:
const createPartnerVars: CreatePartnerVariables = {
  partnerName: ..., 
  partnerNumber: ..., 
  partnerType: ..., // optional
};

// Call the `createPartner()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createPartner(createPartnerVars);
// Variables can be defined inline as well.
const { data } = await createPartner({ partnerName: ..., partnerNumber: ..., partnerType: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createPartner(dataConnect, createPartnerVars);

console.log(data.partner_insert);

// Or, you can use the `Promise` API.
createPartner(createPartnerVars).then((response) => {
  const data = response.data;
  console.log(data.partner_insert);
});
```

### Using `CreatePartner`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createPartnerRef, CreatePartnerVariables } from '@dataconnect/generated';

// The `CreatePartner` mutation requires an argument of type `CreatePartnerVariables`:
const createPartnerVars: CreatePartnerVariables = {
  partnerName: ..., 
  partnerNumber: ..., 
  partnerType: ..., // optional
};

// Call the `createPartnerRef()` function to get a reference to the mutation.
const ref = createPartnerRef(createPartnerVars);
// Variables can be defined inline as well.
const ref = createPartnerRef({ partnerName: ..., partnerNumber: ..., partnerType: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createPartnerRef(dataConnect, createPartnerVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.partner_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.partner_insert);
});
```

## UpdatePartner
You can execute the `UpdatePartner` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updatePartner(vars: UpdatePartnerVariables): MutationPromise<UpdatePartnerData, UpdatePartnerVariables>;

interface UpdatePartnerRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdatePartnerVariables): MutationRef<UpdatePartnerData, UpdatePartnerVariables>;
}
export const updatePartnerRef: UpdatePartnerRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updatePartner(dc: DataConnect, vars: UpdatePartnerVariables): MutationPromise<UpdatePartnerData, UpdatePartnerVariables>;

interface UpdatePartnerRef {
  ...
  (dc: DataConnect, vars: UpdatePartnerVariables): MutationRef<UpdatePartnerData, UpdatePartnerVariables>;
}
export const updatePartnerRef: UpdatePartnerRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updatePartnerRef:
```typescript
const name = updatePartnerRef.operationName;
console.log(name);
```

### Variables
The `UpdatePartner` mutation requires an argument of type `UpdatePartnerVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdatePartnerVariables {
  id: UUIDString;
  partnerName?: string | null;
  partnerNumber?: string | null;
  partnerType?: PartnerType | null;
}
```
### Return Type
Recall that executing the `UpdatePartner` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdatePartnerData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdatePartnerData {
  partner_update?: Partner_Key | null;
}
```
### Using `UpdatePartner`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updatePartner, UpdatePartnerVariables } from '@dataconnect/generated';

// The `UpdatePartner` mutation requires an argument of type `UpdatePartnerVariables`:
const updatePartnerVars: UpdatePartnerVariables = {
  id: ..., 
  partnerName: ..., // optional
  partnerNumber: ..., // optional
  partnerType: ..., // optional
};

// Call the `updatePartner()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updatePartner(updatePartnerVars);
// Variables can be defined inline as well.
const { data } = await updatePartner({ id: ..., partnerName: ..., partnerNumber: ..., partnerType: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updatePartner(dataConnect, updatePartnerVars);

console.log(data.partner_update);

// Or, you can use the `Promise` API.
updatePartner(updatePartnerVars).then((response) => {
  const data = response.data;
  console.log(data.partner_update);
});
```

### Using `UpdatePartner`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updatePartnerRef, UpdatePartnerVariables } from '@dataconnect/generated';

// The `UpdatePartner` mutation requires an argument of type `UpdatePartnerVariables`:
const updatePartnerVars: UpdatePartnerVariables = {
  id: ..., 
  partnerName: ..., // optional
  partnerNumber: ..., // optional
  partnerType: ..., // optional
};

// Call the `updatePartnerRef()` function to get a reference to the mutation.
const ref = updatePartnerRef(updatePartnerVars);
// Variables can be defined inline as well.
const ref = updatePartnerRef({ id: ..., partnerName: ..., partnerNumber: ..., partnerType: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updatePartnerRef(dataConnect, updatePartnerVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.partner_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.partner_update);
});
```

## DeletePartner
You can execute the `DeletePartner` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deletePartner(vars: DeletePartnerVariables): MutationPromise<DeletePartnerData, DeletePartnerVariables>;

interface DeletePartnerRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeletePartnerVariables): MutationRef<DeletePartnerData, DeletePartnerVariables>;
}
export const deletePartnerRef: DeletePartnerRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deletePartner(dc: DataConnect, vars: DeletePartnerVariables): MutationPromise<DeletePartnerData, DeletePartnerVariables>;

interface DeletePartnerRef {
  ...
  (dc: DataConnect, vars: DeletePartnerVariables): MutationRef<DeletePartnerData, DeletePartnerVariables>;
}
export const deletePartnerRef: DeletePartnerRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deletePartnerRef:
```typescript
const name = deletePartnerRef.operationName;
console.log(name);
```

### Variables
The `DeletePartner` mutation requires an argument of type `DeletePartnerVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeletePartnerVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeletePartner` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeletePartnerData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeletePartnerData {
  partner_delete?: Partner_Key | null;
}
```
### Using `DeletePartner`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deletePartner, DeletePartnerVariables } from '@dataconnect/generated';

// The `DeletePartner` mutation requires an argument of type `DeletePartnerVariables`:
const deletePartnerVars: DeletePartnerVariables = {
  id: ..., 
};

// Call the `deletePartner()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deletePartner(deletePartnerVars);
// Variables can be defined inline as well.
const { data } = await deletePartner({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deletePartner(dataConnect, deletePartnerVars);

console.log(data.partner_delete);

// Or, you can use the `Promise` API.
deletePartner(deletePartnerVars).then((response) => {
  const data = response.data;
  console.log(data.partner_delete);
});
```

### Using `DeletePartner`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deletePartnerRef, DeletePartnerVariables } from '@dataconnect/generated';

// The `DeletePartner` mutation requires an argument of type `DeletePartnerVariables`:
const deletePartnerVars: DeletePartnerVariables = {
  id: ..., 
};

// Call the `deletePartnerRef()` function to get a reference to the mutation.
const ref = deletePartnerRef(deletePartnerVars);
// Variables can be defined inline as well.
const ref = deletePartnerRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deletePartnerRef(dataConnect, deletePartnerVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.partner_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.partner_delete);
});
```

## CreateTeamMember
You can execute the `CreateTeamMember` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createTeamMember(vars: CreateTeamMemberVariables): MutationPromise<CreateTeamMemberData, CreateTeamMemberVariables>;

interface CreateTeamMemberRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateTeamMemberVariables): MutationRef<CreateTeamMemberData, CreateTeamMemberVariables>;
}
export const createTeamMemberRef: CreateTeamMemberRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createTeamMember(dc: DataConnect, vars: CreateTeamMemberVariables): MutationPromise<CreateTeamMemberData, CreateTeamMemberVariables>;

interface CreateTeamMemberRef {
  ...
  (dc: DataConnect, vars: CreateTeamMemberVariables): MutationRef<CreateTeamMemberData, CreateTeamMemberVariables>;
}
export const createTeamMemberRef: CreateTeamMemberRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createTeamMemberRef:
```typescript
const name = createTeamMemberRef.operationName;
console.log(name);
```

### Variables
The `CreateTeamMember` mutation requires an argument of type `CreateTeamMemberVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateTeamMemberVariables {
  teamId: UUIDString;
  memberName: string;
  email: string;
  role?: TeamMemberRole | null;
  isActive?: boolean | null;
}
```
### Return Type
Recall that executing the `CreateTeamMember` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateTeamMemberData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateTeamMemberData {
  teamMember_insert: TeamMember_Key;
}
```
### Using `CreateTeamMember`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createTeamMember, CreateTeamMemberVariables } from '@dataconnect/generated';

// The `CreateTeamMember` mutation requires an argument of type `CreateTeamMemberVariables`:
const createTeamMemberVars: CreateTeamMemberVariables = {
  teamId: ..., 
  memberName: ..., 
  email: ..., 
  role: ..., // optional
  isActive: ..., // optional
};

// Call the `createTeamMember()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createTeamMember(createTeamMemberVars);
// Variables can be defined inline as well.
const { data } = await createTeamMember({ teamId: ..., memberName: ..., email: ..., role: ..., isActive: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createTeamMember(dataConnect, createTeamMemberVars);

console.log(data.teamMember_insert);

// Or, you can use the `Promise` API.
createTeamMember(createTeamMemberVars).then((response) => {
  const data = response.data;
  console.log(data.teamMember_insert);
});
```

### Using `CreateTeamMember`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createTeamMemberRef, CreateTeamMemberVariables } from '@dataconnect/generated';

// The `CreateTeamMember` mutation requires an argument of type `CreateTeamMemberVariables`:
const createTeamMemberVars: CreateTeamMemberVariables = {
  teamId: ..., 
  memberName: ..., 
  email: ..., 
  role: ..., // optional
  isActive: ..., // optional
};

// Call the `createTeamMemberRef()` function to get a reference to the mutation.
const ref = createTeamMemberRef(createTeamMemberVars);
// Variables can be defined inline as well.
const ref = createTeamMemberRef({ teamId: ..., memberName: ..., email: ..., role: ..., isActive: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createTeamMemberRef(dataConnect, createTeamMemberVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.teamMember_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.teamMember_insert);
});
```

## UpdateTeamMember
You can execute the `UpdateTeamMember` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateTeamMember(vars: UpdateTeamMemberVariables): MutationPromise<UpdateTeamMemberData, UpdateTeamMemberVariables>;

interface UpdateTeamMemberRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateTeamMemberVariables): MutationRef<UpdateTeamMemberData, UpdateTeamMemberVariables>;
}
export const updateTeamMemberRef: UpdateTeamMemberRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateTeamMember(dc: DataConnect, vars: UpdateTeamMemberVariables): MutationPromise<UpdateTeamMemberData, UpdateTeamMemberVariables>;

interface UpdateTeamMemberRef {
  ...
  (dc: DataConnect, vars: UpdateTeamMemberVariables): MutationRef<UpdateTeamMemberData, UpdateTeamMemberVariables>;
}
export const updateTeamMemberRef: UpdateTeamMemberRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateTeamMemberRef:
```typescript
const name = updateTeamMemberRef.operationName;
console.log(name);
```

### Variables
The `UpdateTeamMember` mutation requires an argument of type `UpdateTeamMemberVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateTeamMemberVariables {
  id: UUIDString;
  teamId?: UUIDString | null;
  memberName?: string | null;
  email?: string | null;
  role?: TeamMemberRole | null;
  isActive?: boolean | null;
}
```
### Return Type
Recall that executing the `UpdateTeamMember` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateTeamMemberData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateTeamMemberData {
  teamMember_update?: TeamMember_Key | null;
}
```
### Using `UpdateTeamMember`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateTeamMember, UpdateTeamMemberVariables } from '@dataconnect/generated';

// The `UpdateTeamMember` mutation requires an argument of type `UpdateTeamMemberVariables`:
const updateTeamMemberVars: UpdateTeamMemberVariables = {
  id: ..., 
  teamId: ..., // optional
  memberName: ..., // optional
  email: ..., // optional
  role: ..., // optional
  isActive: ..., // optional
};

// Call the `updateTeamMember()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateTeamMember(updateTeamMemberVars);
// Variables can be defined inline as well.
const { data } = await updateTeamMember({ id: ..., teamId: ..., memberName: ..., email: ..., role: ..., isActive: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateTeamMember(dataConnect, updateTeamMemberVars);

console.log(data.teamMember_update);

// Or, you can use the `Promise` API.
updateTeamMember(updateTeamMemberVars).then((response) => {
  const data = response.data;
  console.log(data.teamMember_update);
});
```

### Using `UpdateTeamMember`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateTeamMemberRef, UpdateTeamMemberVariables } from '@dataconnect/generated';

// The `UpdateTeamMember` mutation requires an argument of type `UpdateTeamMemberVariables`:
const updateTeamMemberVars: UpdateTeamMemberVariables = {
  id: ..., 
  teamId: ..., // optional
  memberName: ..., // optional
  email: ..., // optional
  role: ..., // optional
  isActive: ..., // optional
};

// Call the `updateTeamMemberRef()` function to get a reference to the mutation.
const ref = updateTeamMemberRef(updateTeamMemberVars);
// Variables can be defined inline as well.
const ref = updateTeamMemberRef({ id: ..., teamId: ..., memberName: ..., email: ..., role: ..., isActive: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateTeamMemberRef(dataConnect, updateTeamMemberVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.teamMember_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.teamMember_update);
});
```

## DeleteTeamMember
You can execute the `DeleteTeamMember` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteTeamMember(vars: DeleteTeamMemberVariables): MutationPromise<DeleteTeamMemberData, DeleteTeamMemberVariables>;

interface DeleteTeamMemberRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteTeamMemberVariables): MutationRef<DeleteTeamMemberData, DeleteTeamMemberVariables>;
}
export const deleteTeamMemberRef: DeleteTeamMemberRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteTeamMember(dc: DataConnect, vars: DeleteTeamMemberVariables): MutationPromise<DeleteTeamMemberData, DeleteTeamMemberVariables>;

interface DeleteTeamMemberRef {
  ...
  (dc: DataConnect, vars: DeleteTeamMemberVariables): MutationRef<DeleteTeamMemberData, DeleteTeamMemberVariables>;
}
export const deleteTeamMemberRef: DeleteTeamMemberRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteTeamMemberRef:
```typescript
const name = deleteTeamMemberRef.operationName;
console.log(name);
```

### Variables
The `DeleteTeamMember` mutation requires an argument of type `DeleteTeamMemberVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteTeamMemberVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteTeamMember` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteTeamMemberData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteTeamMemberData {
  teamMember_delete?: TeamMember_Key | null;
}
```
### Using `DeleteTeamMember`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteTeamMember, DeleteTeamMemberVariables } from '@dataconnect/generated';

// The `DeleteTeamMember` mutation requires an argument of type `DeleteTeamMemberVariables`:
const deleteTeamMemberVars: DeleteTeamMemberVariables = {
  id: ..., 
};

// Call the `deleteTeamMember()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteTeamMember(deleteTeamMemberVars);
// Variables can be defined inline as well.
const { data } = await deleteTeamMember({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteTeamMember(dataConnect, deleteTeamMemberVars);

console.log(data.teamMember_delete);

// Or, you can use the `Promise` API.
deleteTeamMember(deleteTeamMemberVars).then((response) => {
  const data = response.data;
  console.log(data.teamMember_delete);
});
```

### Using `DeleteTeamMember`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteTeamMemberRef, DeleteTeamMemberVariables } from '@dataconnect/generated';

// The `DeleteTeamMember` mutation requires an argument of type `DeleteTeamMemberVariables`:
const deleteTeamMemberVars: DeleteTeamMemberVariables = {
  id: ..., 
};

// Call the `deleteTeamMemberRef()` function to get a reference to the mutation.
const ref = deleteTeamMemberRef(deleteTeamMemberVars);
// Variables can be defined inline as well.
const ref = deleteTeamMemberRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteTeamMemberRef(dataConnect, deleteTeamMemberVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.teamMember_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.teamMember_delete);
});
```

## CreateConversation
You can execute the `CreateConversation` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createConversation(vars: CreateConversationVariables): MutationPromise<CreateConversationData, CreateConversationVariables>;

interface CreateConversationRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateConversationVariables): MutationRef<CreateConversationData, CreateConversationVariables>;
}
export const createConversationRef: CreateConversationRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createConversation(dc: DataConnect, vars: CreateConversationVariables): MutationPromise<CreateConversationData, CreateConversationVariables>;

interface CreateConversationRef {
  ...
  (dc: DataConnect, vars: CreateConversationVariables): MutationRef<CreateConversationData, CreateConversationVariables>;
}
export const createConversationRef: CreateConversationRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createConversationRef:
```typescript
const name = createConversationRef.operationName;
console.log(name);
```

### Variables
The `CreateConversation` mutation requires an argument of type `CreateConversationVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateConversationVariables {
  participants: string;
  conversationType: ConversationType;
  relatedTo: UUIDString;
  status?: ConversationStatus | null;
}
```
### Return Type
Recall that executing the `CreateConversation` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateConversationData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateConversationData {
  conversation_insert: Conversation_Key;
}
```
### Using `CreateConversation`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createConversation, CreateConversationVariables } from '@dataconnect/generated';

// The `CreateConversation` mutation requires an argument of type `CreateConversationVariables`:
const createConversationVars: CreateConversationVariables = {
  participants: ..., 
  conversationType: ..., 
  relatedTo: ..., 
  status: ..., // optional
};

// Call the `createConversation()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createConversation(createConversationVars);
// Variables can be defined inline as well.
const { data } = await createConversation({ participants: ..., conversationType: ..., relatedTo: ..., status: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createConversation(dataConnect, createConversationVars);

console.log(data.conversation_insert);

// Or, you can use the `Promise` API.
createConversation(createConversationVars).then((response) => {
  const data = response.data;
  console.log(data.conversation_insert);
});
```

### Using `CreateConversation`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createConversationRef, CreateConversationVariables } from '@dataconnect/generated';

// The `CreateConversation` mutation requires an argument of type `CreateConversationVariables`:
const createConversationVars: CreateConversationVariables = {
  participants: ..., 
  conversationType: ..., 
  relatedTo: ..., 
  status: ..., // optional
};

// Call the `createConversationRef()` function to get a reference to the mutation.
const ref = createConversationRef(createConversationVars);
// Variables can be defined inline as well.
const ref = createConversationRef({ participants: ..., conversationType: ..., relatedTo: ..., status: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createConversationRef(dataConnect, createConversationVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.conversation_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.conversation_insert);
});
```

## UpdateConversation
You can execute the `UpdateConversation` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateConversation(vars: UpdateConversationVariables): MutationPromise<UpdateConversationData, UpdateConversationVariables>;

interface UpdateConversationRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateConversationVariables): MutationRef<UpdateConversationData, UpdateConversationVariables>;
}
export const updateConversationRef: UpdateConversationRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateConversation(dc: DataConnect, vars: UpdateConversationVariables): MutationPromise<UpdateConversationData, UpdateConversationVariables>;

interface UpdateConversationRef {
  ...
  (dc: DataConnect, vars: UpdateConversationVariables): MutationRef<UpdateConversationData, UpdateConversationVariables>;
}
export const updateConversationRef: UpdateConversationRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateConversationRef:
```typescript
const name = updateConversationRef.operationName;
console.log(name);
```

### Variables
The `UpdateConversation` mutation requires an argument of type `UpdateConversationVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateConversationVariables {
  id: UUIDString;
  participants?: string | null;
  conversationType?: ConversationType | null;
  relatedTo?: UUIDString | null;
  status?: ConversationStatus | null;
}
```
### Return Type
Recall that executing the `UpdateConversation` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateConversationData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateConversationData {
  conversation_update?: Conversation_Key | null;
}
```
### Using `UpdateConversation`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateConversation, UpdateConversationVariables } from '@dataconnect/generated';

// The `UpdateConversation` mutation requires an argument of type `UpdateConversationVariables`:
const updateConversationVars: UpdateConversationVariables = {
  id: ..., 
  participants: ..., // optional
  conversationType: ..., // optional
  relatedTo: ..., // optional
  status: ..., // optional
};

// Call the `updateConversation()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateConversation(updateConversationVars);
// Variables can be defined inline as well.
const { data } = await updateConversation({ id: ..., participants: ..., conversationType: ..., relatedTo: ..., status: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateConversation(dataConnect, updateConversationVars);

console.log(data.conversation_update);

// Or, you can use the `Promise` API.
updateConversation(updateConversationVars).then((response) => {
  const data = response.data;
  console.log(data.conversation_update);
});
```

### Using `UpdateConversation`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateConversationRef, UpdateConversationVariables } from '@dataconnect/generated';

// The `UpdateConversation` mutation requires an argument of type `UpdateConversationVariables`:
const updateConversationVars: UpdateConversationVariables = {
  id: ..., 
  participants: ..., // optional
  conversationType: ..., // optional
  relatedTo: ..., // optional
  status: ..., // optional
};

// Call the `updateConversationRef()` function to get a reference to the mutation.
const ref = updateConversationRef(updateConversationVars);
// Variables can be defined inline as well.
const ref = updateConversationRef({ id: ..., participants: ..., conversationType: ..., relatedTo: ..., status: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateConversationRef(dataConnect, updateConversationVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.conversation_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.conversation_update);
});
```

## DeleteConversation
You can execute the `DeleteConversation` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteConversation(vars: DeleteConversationVariables): MutationPromise<DeleteConversationData, DeleteConversationVariables>;

interface DeleteConversationRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteConversationVariables): MutationRef<DeleteConversationData, DeleteConversationVariables>;
}
export const deleteConversationRef: DeleteConversationRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteConversation(dc: DataConnect, vars: DeleteConversationVariables): MutationPromise<DeleteConversationData, DeleteConversationVariables>;

interface DeleteConversationRef {
  ...
  (dc: DataConnect, vars: DeleteConversationVariables): MutationRef<DeleteConversationData, DeleteConversationVariables>;
}
export const deleteConversationRef: DeleteConversationRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteConversationRef:
```typescript
const name = deleteConversationRef.operationName;
console.log(name);
```

### Variables
The `DeleteConversation` mutation requires an argument of type `DeleteConversationVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteConversationVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteConversation` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteConversationData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteConversationData {
  conversation_delete?: Conversation_Key | null;
}
```
### Using `DeleteConversation`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteConversation, DeleteConversationVariables } from '@dataconnect/generated';

// The `DeleteConversation` mutation requires an argument of type `DeleteConversationVariables`:
const deleteConversationVars: DeleteConversationVariables = {
  id: ..., 
};

// Call the `deleteConversation()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteConversation(deleteConversationVars);
// Variables can be defined inline as well.
const { data } = await deleteConversation({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteConversation(dataConnect, deleteConversationVars);

console.log(data.conversation_delete);

// Or, you can use the `Promise` API.
deleteConversation(deleteConversationVars).then((response) => {
  const data = response.data;
  console.log(data.conversation_delete);
});
```

### Using `DeleteConversation`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteConversationRef, DeleteConversationVariables } from '@dataconnect/generated';

// The `DeleteConversation` mutation requires an argument of type `DeleteConversationVariables`:
const deleteConversationVars: DeleteConversationVariables = {
  id: ..., 
};

// Call the `deleteConversationRef()` function to get a reference to the mutation.
const ref = deleteConversationRef(deleteConversationVars);
// Variables can be defined inline as well.
const ref = deleteConversationRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteConversationRef(dataConnect, deleteConversationVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.conversation_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.conversation_delete);
});
```

## CreateInvoice
You can execute the `CreateInvoice` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createInvoice(vars: CreateInvoiceVariables): MutationPromise<CreateInvoiceData, CreateInvoiceVariables>;

interface CreateInvoiceRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateInvoiceVariables): MutationRef<CreateInvoiceData, CreateInvoiceVariables>;
}
export const createInvoiceRef: CreateInvoiceRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createInvoice(dc: DataConnect, vars: CreateInvoiceVariables): MutationPromise<CreateInvoiceData, CreateInvoiceVariables>;

interface CreateInvoiceRef {
  ...
  (dc: DataConnect, vars: CreateInvoiceVariables): MutationRef<CreateInvoiceData, CreateInvoiceVariables>;
}
export const createInvoiceRef: CreateInvoiceRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createInvoiceRef:
```typescript
const name = createInvoiceRef.operationName;
console.log(name);
```

### Variables
The `CreateInvoice` mutation requires an argument of type `CreateInvoiceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateInvoiceVariables {
  invoiceNumber: string;
  amount: number;
  status: InvoiceStatus;
  issueDate: TimestampString;
  dueDate: TimestampString;
  disputedItems?: string | null;
  isAutoGenerated?: boolean | null;
}
```
### Return Type
Recall that executing the `CreateInvoice` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateInvoiceData {
  invoice_insert: Invoice_Key;
}
```
### Using `CreateInvoice`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createInvoice, CreateInvoiceVariables } from '@dataconnect/generated';

// The `CreateInvoice` mutation requires an argument of type `CreateInvoiceVariables`:
const createInvoiceVars: CreateInvoiceVariables = {
  invoiceNumber: ..., 
  amount: ..., 
  status: ..., 
  issueDate: ..., 
  dueDate: ..., 
  disputedItems: ..., // optional
  isAutoGenerated: ..., // optional
};

// Call the `createInvoice()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createInvoice(createInvoiceVars);
// Variables can be defined inline as well.
const { data } = await createInvoice({ invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createInvoice(dataConnect, createInvoiceVars);

console.log(data.invoice_insert);

// Or, you can use the `Promise` API.
createInvoice(createInvoiceVars).then((response) => {
  const data = response.data;
  console.log(data.invoice_insert);
});
```

### Using `CreateInvoice`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createInvoiceRef, CreateInvoiceVariables } from '@dataconnect/generated';

// The `CreateInvoice` mutation requires an argument of type `CreateInvoiceVariables`:
const createInvoiceVars: CreateInvoiceVariables = {
  invoiceNumber: ..., 
  amount: ..., 
  status: ..., 
  issueDate: ..., 
  dueDate: ..., 
  disputedItems: ..., // optional
  isAutoGenerated: ..., // optional
};

// Call the `createInvoiceRef()` function to get a reference to the mutation.
const ref = createInvoiceRef(createInvoiceVars);
// Variables can be defined inline as well.
const ref = createInvoiceRef({ invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createInvoiceRef(dataConnect, createInvoiceVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.invoice_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.invoice_insert);
});
```

## UpdateInvoice
You can execute the `UpdateInvoice` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateInvoice(vars: UpdateInvoiceVariables): MutationPromise<UpdateInvoiceData, UpdateInvoiceVariables>;

interface UpdateInvoiceRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateInvoiceVariables): MutationRef<UpdateInvoiceData, UpdateInvoiceVariables>;
}
export const updateInvoiceRef: UpdateInvoiceRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateInvoice(dc: DataConnect, vars: UpdateInvoiceVariables): MutationPromise<UpdateInvoiceData, UpdateInvoiceVariables>;

interface UpdateInvoiceRef {
  ...
  (dc: DataConnect, vars: UpdateInvoiceVariables): MutationRef<UpdateInvoiceData, UpdateInvoiceVariables>;
}
export const updateInvoiceRef: UpdateInvoiceRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateInvoiceRef:
```typescript
const name = updateInvoiceRef.operationName;
console.log(name);
```

### Variables
The `UpdateInvoice` mutation requires an argument of type `UpdateInvoiceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateInvoiceVariables {
  id: UUIDString;
  invoiceNumber?: string | null;
  amount?: number | null;
  status?: InvoiceStatus | null;
  issueDate?: TimestampString | null;
  dueDate?: TimestampString | null;
  disputedItems?: string | null;
  isAutoGenerated?: boolean | null;
}
```
### Return Type
Recall that executing the `UpdateInvoice` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateInvoiceData {
  invoice_update?: Invoice_Key | null;
}
```
### Using `UpdateInvoice`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateInvoice, UpdateInvoiceVariables } from '@dataconnect/generated';

// The `UpdateInvoice` mutation requires an argument of type `UpdateInvoiceVariables`:
const updateInvoiceVars: UpdateInvoiceVariables = {
  id: ..., 
  invoiceNumber: ..., // optional
  amount: ..., // optional
  status: ..., // optional
  issueDate: ..., // optional
  dueDate: ..., // optional
  disputedItems: ..., // optional
  isAutoGenerated: ..., // optional
};

// Call the `updateInvoice()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateInvoice(updateInvoiceVars);
// Variables can be defined inline as well.
const { data } = await updateInvoice({ id: ..., invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateInvoice(dataConnect, updateInvoiceVars);

console.log(data.invoice_update);

// Or, you can use the `Promise` API.
updateInvoice(updateInvoiceVars).then((response) => {
  const data = response.data;
  console.log(data.invoice_update);
});
```

### Using `UpdateInvoice`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateInvoiceRef, UpdateInvoiceVariables } from '@dataconnect/generated';

// The `UpdateInvoice` mutation requires an argument of type `UpdateInvoiceVariables`:
const updateInvoiceVars: UpdateInvoiceVariables = {
  id: ..., 
  invoiceNumber: ..., // optional
  amount: ..., // optional
  status: ..., // optional
  issueDate: ..., // optional
  dueDate: ..., // optional
  disputedItems: ..., // optional
  isAutoGenerated: ..., // optional
};

// Call the `updateInvoiceRef()` function to get a reference to the mutation.
const ref = updateInvoiceRef(updateInvoiceVars);
// Variables can be defined inline as well.
const ref = updateInvoiceRef({ id: ..., invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateInvoiceRef(dataConnect, updateInvoiceVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.invoice_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.invoice_update);
});
```

## DeleteInvoice
You can execute the `DeleteInvoice` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteInvoice(vars: DeleteInvoiceVariables): MutationPromise<DeleteInvoiceData, DeleteInvoiceVariables>;

interface DeleteInvoiceRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteInvoiceVariables): MutationRef<DeleteInvoiceData, DeleteInvoiceVariables>;
}
export const deleteInvoiceRef: DeleteInvoiceRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteInvoice(dc: DataConnect, vars: DeleteInvoiceVariables): MutationPromise<DeleteInvoiceData, DeleteInvoiceVariables>;

interface DeleteInvoiceRef {
  ...
  (dc: DataConnect, vars: DeleteInvoiceVariables): MutationRef<DeleteInvoiceData, DeleteInvoiceVariables>;
}
export const deleteInvoiceRef: DeleteInvoiceRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteInvoiceRef:
```typescript
const name = deleteInvoiceRef.operationName;
console.log(name);
```

### Variables
The `DeleteInvoice` mutation requires an argument of type `DeleteInvoiceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteInvoiceVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteInvoice` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteInvoiceData {
  invoice_delete?: Invoice_Key | null;
}
```
### Using `DeleteInvoice`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteInvoice, DeleteInvoiceVariables } from '@dataconnect/generated';

// The `DeleteInvoice` mutation requires an argument of type `DeleteInvoiceVariables`:
const deleteInvoiceVars: DeleteInvoiceVariables = {
  id: ..., 
};

// Call the `deleteInvoice()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteInvoice(deleteInvoiceVars);
// Variables can be defined inline as well.
const { data } = await deleteInvoice({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteInvoice(dataConnect, deleteInvoiceVars);

console.log(data.invoice_delete);

// Or, you can use the `Promise` API.
deleteInvoice(deleteInvoiceVars).then((response) => {
  const data = response.data;
  console.log(data.invoice_delete);
});
```

### Using `DeleteInvoice`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteInvoiceRef, DeleteInvoiceVariables } from '@dataconnect/generated';

// The `DeleteInvoice` mutation requires an argument of type `DeleteInvoiceVariables`:
const deleteInvoiceVars: DeleteInvoiceVariables = {
  id: ..., 
};

// Call the `deleteInvoiceRef()` function to get a reference to the mutation.
const ref = deleteInvoiceRef(deleteInvoiceVars);
// Variables can be defined inline as well.
const ref = deleteInvoiceRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteInvoiceRef(dataConnect, deleteInvoiceVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.invoice_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.invoice_delete);
});
```

## CreateBusiness
You can execute the `CreateBusiness` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createBusiness(vars: CreateBusinessVariables): MutationPromise<CreateBusinessData, CreateBusinessVariables>;

interface CreateBusinessRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateBusinessVariables): MutationRef<CreateBusinessData, CreateBusinessVariables>;
}
export const createBusinessRef: CreateBusinessRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createBusiness(dc: DataConnect, vars: CreateBusinessVariables): MutationPromise<CreateBusinessData, CreateBusinessVariables>;

interface CreateBusinessRef {
  ...
  (dc: DataConnect, vars: CreateBusinessVariables): MutationRef<CreateBusinessData, CreateBusinessVariables>;
}
export const createBusinessRef: CreateBusinessRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createBusinessRef:
```typescript
const name = createBusinessRef.operationName;
console.log(name);
```

### Variables
The `CreateBusiness` mutation requires an argument of type `CreateBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateBusinessVariables {
  businessName: string;
  contactName: string;
  email?: string | null;
  sector?: BusinessSector | null;
  rateGroup: BusinessRateGroup;
  status?: BusinessStatus | null;
}
```
### Return Type
Recall that executing the `CreateBusiness` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateBusinessData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateBusinessData {
  business_insert: Business_Key;
}
```
### Using `CreateBusiness`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createBusiness, CreateBusinessVariables } from '@dataconnect/generated';

// The `CreateBusiness` mutation requires an argument of type `CreateBusinessVariables`:
const createBusinessVars: CreateBusinessVariables = {
  businessName: ..., 
  contactName: ..., 
  email: ..., // optional
  sector: ..., // optional
  rateGroup: ..., 
  status: ..., // optional
};

// Call the `createBusiness()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createBusiness(createBusinessVars);
// Variables can be defined inline as well.
const { data } = await createBusiness({ businessName: ..., contactName: ..., email: ..., sector: ..., rateGroup: ..., status: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createBusiness(dataConnect, createBusinessVars);

console.log(data.business_insert);

// Or, you can use the `Promise` API.
createBusiness(createBusinessVars).then((response) => {
  const data = response.data;
  console.log(data.business_insert);
});
```

### Using `CreateBusiness`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createBusinessRef, CreateBusinessVariables } from '@dataconnect/generated';

// The `CreateBusiness` mutation requires an argument of type `CreateBusinessVariables`:
const createBusinessVars: CreateBusinessVariables = {
  businessName: ..., 
  contactName: ..., 
  email: ..., // optional
  sector: ..., // optional
  rateGroup: ..., 
  status: ..., // optional
};

// Call the `createBusinessRef()` function to get a reference to the mutation.
const ref = createBusinessRef(createBusinessVars);
// Variables can be defined inline as well.
const ref = createBusinessRef({ businessName: ..., contactName: ..., email: ..., sector: ..., rateGroup: ..., status: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createBusinessRef(dataConnect, createBusinessVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.business_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.business_insert);
});
```

## UpdateBusiness
You can execute the `UpdateBusiness` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateBusiness(vars: UpdateBusinessVariables): MutationPromise<UpdateBusinessData, UpdateBusinessVariables>;

interface UpdateBusinessRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateBusinessVariables): MutationRef<UpdateBusinessData, UpdateBusinessVariables>;
}
export const updateBusinessRef: UpdateBusinessRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateBusiness(dc: DataConnect, vars: UpdateBusinessVariables): MutationPromise<UpdateBusinessData, UpdateBusinessVariables>;

interface UpdateBusinessRef {
  ...
  (dc: DataConnect, vars: UpdateBusinessVariables): MutationRef<UpdateBusinessData, UpdateBusinessVariables>;
}
export const updateBusinessRef: UpdateBusinessRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateBusinessRef:
```typescript
const name = updateBusinessRef.operationName;
console.log(name);
```

### Variables
The `UpdateBusiness` mutation requires an argument of type `UpdateBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateBusinessVariables {
  id: UUIDString;
  businessName?: string | null;
  contactName?: string | null;
  email?: string | null;
  sector?: BusinessSector | null;
  rateGroup?: BusinessRateGroup | null;
  status?: BusinessStatus | null;
}
```
### Return Type
Recall that executing the `UpdateBusiness` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateBusinessData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateBusinessData {
  business_update?: Business_Key | null;
}
```
### Using `UpdateBusiness`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateBusiness, UpdateBusinessVariables } from '@dataconnect/generated';

// The `UpdateBusiness` mutation requires an argument of type `UpdateBusinessVariables`:
const updateBusinessVars: UpdateBusinessVariables = {
  id: ..., 
  businessName: ..., // optional
  contactName: ..., // optional
  email: ..., // optional
  sector: ..., // optional
  rateGroup: ..., // optional
  status: ..., // optional
};

// Call the `updateBusiness()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateBusiness(updateBusinessVars);
// Variables can be defined inline as well.
const { data } = await updateBusiness({ id: ..., businessName: ..., contactName: ..., email: ..., sector: ..., rateGroup: ..., status: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateBusiness(dataConnect, updateBusinessVars);

console.log(data.business_update);

// Or, you can use the `Promise` API.
updateBusiness(updateBusinessVars).then((response) => {
  const data = response.data;
  console.log(data.business_update);
});
```

### Using `UpdateBusiness`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateBusinessRef, UpdateBusinessVariables } from '@dataconnect/generated';

// The `UpdateBusiness` mutation requires an argument of type `UpdateBusinessVariables`:
const updateBusinessVars: UpdateBusinessVariables = {
  id: ..., 
  businessName: ..., // optional
  contactName: ..., // optional
  email: ..., // optional
  sector: ..., // optional
  rateGroup: ..., // optional
  status: ..., // optional
};

// Call the `updateBusinessRef()` function to get a reference to the mutation.
const ref = updateBusinessRef(updateBusinessVars);
// Variables can be defined inline as well.
const ref = updateBusinessRef({ id: ..., businessName: ..., contactName: ..., email: ..., sector: ..., rateGroup: ..., status: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateBusinessRef(dataConnect, updateBusinessVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.business_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.business_update);
});
```

## DeleteBusiness
You can execute the `DeleteBusiness` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteBusiness(vars: DeleteBusinessVariables): MutationPromise<DeleteBusinessData, DeleteBusinessVariables>;

interface DeleteBusinessRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteBusinessVariables): MutationRef<DeleteBusinessData, DeleteBusinessVariables>;
}
export const deleteBusinessRef: DeleteBusinessRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteBusiness(dc: DataConnect, vars: DeleteBusinessVariables): MutationPromise<DeleteBusinessData, DeleteBusinessVariables>;

interface DeleteBusinessRef {
  ...
  (dc: DataConnect, vars: DeleteBusinessVariables): MutationRef<DeleteBusinessData, DeleteBusinessVariables>;
}
export const deleteBusinessRef: DeleteBusinessRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteBusinessRef:
```typescript
const name = deleteBusinessRef.operationName;
console.log(name);
```

### Variables
The `DeleteBusiness` mutation requires an argument of type `DeleteBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteBusinessVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteBusiness` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteBusinessData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteBusinessData {
  business_delete?: Business_Key | null;
}
```
### Using `DeleteBusiness`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteBusiness, DeleteBusinessVariables } from '@dataconnect/generated';

// The `DeleteBusiness` mutation requires an argument of type `DeleteBusinessVariables`:
const deleteBusinessVars: DeleteBusinessVariables = {
  id: ..., 
};

// Call the `deleteBusiness()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteBusiness(deleteBusinessVars);
// Variables can be defined inline as well.
const { data } = await deleteBusiness({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteBusiness(dataConnect, deleteBusinessVars);

console.log(data.business_delete);

// Or, you can use the `Promise` API.
deleteBusiness(deleteBusinessVars).then((response) => {
  const data = response.data;
  console.log(data.business_delete);
});
```

### Using `DeleteBusiness`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteBusinessRef, DeleteBusinessVariables } from '@dataconnect/generated';

// The `DeleteBusiness` mutation requires an argument of type `DeleteBusinessVariables`:
const deleteBusinessVars: DeleteBusinessVariables = {
  id: ..., 
};

// Call the `deleteBusinessRef()` function to get a reference to the mutation.
const ref = deleteBusinessRef(deleteBusinessVars);
// Variables can be defined inline as well.
const ref = deleteBusinessRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteBusinessRef(dataConnect, deleteBusinessVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.business_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.business_delete);
});
```

## CreateEvent
You can execute the `CreateEvent` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createEvent(vars: CreateEventVariables): MutationPromise<CreateEventData, CreateEventVariables>;

interface CreateEventRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateEventVariables): MutationRef<CreateEventData, CreateEventVariables>;
}
export const createEventRef: CreateEventRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createEvent(dc: DataConnect, vars: CreateEventVariables): MutationPromise<CreateEventData, CreateEventVariables>;

interface CreateEventRef {
  ...
  (dc: DataConnect, vars: CreateEventVariables): MutationRef<CreateEventData, CreateEventVariables>;
}
export const createEventRef: CreateEventRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createEventRef:
```typescript
const name = createEventRef.operationName;
console.log(name);
```

### Variables
The `CreateEvent` mutation requires an argument of type `CreateEventVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateEventVariables {
  eventName: string;
  isRapid?: boolean | null;
  isRecurring?: boolean | null;
  isMultiDay?: boolean | null;
  recurrenceType?: RecurrenceType | null;
  recurrenceStartDate?: TimestampString | null;
  recurrenceEndDate?: TimestampString | null;
  scatterDates?: unknown | null;
  multiDayStartDate?: TimestampString | null;
  multiDayEndDate?: TimestampString | null;
  bufferTimeBefore?: number | null;
  bufferTimeAfter?: number | null;
  conflictDetectionEnabled?: boolean | null;
  detectedConflicts?: unknown | null;
  businessId: UUIDString;
  businessName?: string | null;
  vendorId?: string | null;
  vendorName?: string | null;
  hub?: string | null;
  eventLocation?: string | null;
  contractType?: ContractType | null;
  poReference?: string | null;
  status: EventStatus;
  date: string;
  shifts?: unknown | null;
  addons?: unknown | null;
  total?: number | null;
  clientName?: string | null;
  clientEmail?: string | null;
  clientPhone?: string | null;
  invoiceId?: UUIDString | null;
  notes?: string | null;
  requested?: number | null;
  assignedStaff?: unknown | null;
  department?: string | null;
  createdBy?: string | null;
  orderType?: string | null;
  recurringStartDate?: string | null;
  recurringEndDate?: string | null;
  recurringDays?: unknown | null;
  permanentStartDate?: string | null;
  permanentDays?: unknown | null;
  includeBackup?: boolean | null;
  backupStaffCount?: number | null;
  recurringTime?: string | null;
  permanentTime?: string | null;
}
```
### Return Type
Recall that executing the `CreateEvent` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateEventData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateEventData {
  event_insert: Event_Key;
}
```
### Using `CreateEvent`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createEvent, CreateEventVariables } from '@dataconnect/generated';

// The `CreateEvent` mutation requires an argument of type `CreateEventVariables`:
const createEventVars: CreateEventVariables = {
  eventName: ..., 
  isRapid: ..., // optional
  isRecurring: ..., // optional
  isMultiDay: ..., // optional
  recurrenceType: ..., // optional
  recurrenceStartDate: ..., // optional
  recurrenceEndDate: ..., // optional
  scatterDates: ..., // optional
  multiDayStartDate: ..., // optional
  multiDayEndDate: ..., // optional
  bufferTimeBefore: ..., // optional
  bufferTimeAfter: ..., // optional
  conflictDetectionEnabled: ..., // optional
  detectedConflicts: ..., // optional
  businessId: ..., 
  businessName: ..., // optional
  vendorId: ..., // optional
  vendorName: ..., // optional
  hub: ..., // optional
  eventLocation: ..., // optional
  contractType: ..., // optional
  poReference: ..., // optional
  status: ..., 
  date: ..., 
  shifts: ..., // optional
  addons: ..., // optional
  total: ..., // optional
  clientName: ..., // optional
  clientEmail: ..., // optional
  clientPhone: ..., // optional
  invoiceId: ..., // optional
  notes: ..., // optional
  requested: ..., // optional
  assignedStaff: ..., // optional
  department: ..., // optional
  createdBy: ..., // optional
  orderType: ..., // optional
  recurringStartDate: ..., // optional
  recurringEndDate: ..., // optional
  recurringDays: ..., // optional
  permanentStartDate: ..., // optional
  permanentDays: ..., // optional
  includeBackup: ..., // optional
  backupStaffCount: ..., // optional
  recurringTime: ..., // optional
  permanentTime: ..., // optional
};

// Call the `createEvent()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createEvent(createEventVars);
// Variables can be defined inline as well.
const { data } = await createEvent({ eventName: ..., isRapid: ..., isRecurring: ..., isMultiDay: ..., recurrenceType: ..., recurrenceStartDate: ..., recurrenceEndDate: ..., scatterDates: ..., multiDayStartDate: ..., multiDayEndDate: ..., bufferTimeBefore: ..., bufferTimeAfter: ..., conflictDetectionEnabled: ..., detectedConflicts: ..., businessId: ..., businessName: ..., vendorId: ..., vendorName: ..., hub: ..., eventLocation: ..., contractType: ..., poReference: ..., status: ..., date: ..., shifts: ..., addons: ..., total: ..., clientName: ..., clientEmail: ..., clientPhone: ..., invoiceId: ..., notes: ..., requested: ..., assignedStaff: ..., department: ..., createdBy: ..., orderType: ..., recurringStartDate: ..., recurringEndDate: ..., recurringDays: ..., permanentStartDate: ..., permanentDays: ..., includeBackup: ..., backupStaffCount: ..., recurringTime: ..., permanentTime: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createEvent(dataConnect, createEventVars);

console.log(data.event_insert);

// Or, you can use the `Promise` API.
createEvent(createEventVars).then((response) => {
  const data = response.data;
  console.log(data.event_insert);
});
```

### Using `CreateEvent`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createEventRef, CreateEventVariables } from '@dataconnect/generated';

// The `CreateEvent` mutation requires an argument of type `CreateEventVariables`:
const createEventVars: CreateEventVariables = {
  eventName: ..., 
  isRapid: ..., // optional
  isRecurring: ..., // optional
  isMultiDay: ..., // optional
  recurrenceType: ..., // optional
  recurrenceStartDate: ..., // optional
  recurrenceEndDate: ..., // optional
  scatterDates: ..., // optional
  multiDayStartDate: ..., // optional
  multiDayEndDate: ..., // optional
  bufferTimeBefore: ..., // optional
  bufferTimeAfter: ..., // optional
  conflictDetectionEnabled: ..., // optional
  detectedConflicts: ..., // optional
  businessId: ..., 
  businessName: ..., // optional
  vendorId: ..., // optional
  vendorName: ..., // optional
  hub: ..., // optional
  eventLocation: ..., // optional
  contractType: ..., // optional
  poReference: ..., // optional
  status: ..., 
  date: ..., 
  shifts: ..., // optional
  addons: ..., // optional
  total: ..., // optional
  clientName: ..., // optional
  clientEmail: ..., // optional
  clientPhone: ..., // optional
  invoiceId: ..., // optional
  notes: ..., // optional
  requested: ..., // optional
  assignedStaff: ..., // optional
  department: ..., // optional
  createdBy: ..., // optional
  orderType: ..., // optional
  recurringStartDate: ..., // optional
  recurringEndDate: ..., // optional
  recurringDays: ..., // optional
  permanentStartDate: ..., // optional
  permanentDays: ..., // optional
  includeBackup: ..., // optional
  backupStaffCount: ..., // optional
  recurringTime: ..., // optional
  permanentTime: ..., // optional
};

// Call the `createEventRef()` function to get a reference to the mutation.
const ref = createEventRef(createEventVars);
// Variables can be defined inline as well.
const ref = createEventRef({ eventName: ..., isRapid: ..., isRecurring: ..., isMultiDay: ..., recurrenceType: ..., recurrenceStartDate: ..., recurrenceEndDate: ..., scatterDates: ..., multiDayStartDate: ..., multiDayEndDate: ..., bufferTimeBefore: ..., bufferTimeAfter: ..., conflictDetectionEnabled: ..., detectedConflicts: ..., businessId: ..., businessName: ..., vendorId: ..., vendorName: ..., hub: ..., eventLocation: ..., contractType: ..., poReference: ..., status: ..., date: ..., shifts: ..., addons: ..., total: ..., clientName: ..., clientEmail: ..., clientPhone: ..., invoiceId: ..., notes: ..., requested: ..., assignedStaff: ..., department: ..., createdBy: ..., orderType: ..., recurringStartDate: ..., recurringEndDate: ..., recurringDays: ..., permanentStartDate: ..., permanentDays: ..., includeBackup: ..., backupStaffCount: ..., recurringTime: ..., permanentTime: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createEventRef(dataConnect, createEventVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.event_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.event_insert);
});
```

## UpdateEvent
You can execute the `UpdateEvent` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateEvent(vars: UpdateEventVariables): MutationPromise<UpdateEventData, UpdateEventVariables>;

interface UpdateEventRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateEventVariables): MutationRef<UpdateEventData, UpdateEventVariables>;
}
export const updateEventRef: UpdateEventRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateEvent(dc: DataConnect, vars: UpdateEventVariables): MutationPromise<UpdateEventData, UpdateEventVariables>;

interface UpdateEventRef {
  ...
  (dc: DataConnect, vars: UpdateEventVariables): MutationRef<UpdateEventData, UpdateEventVariables>;
}
export const updateEventRef: UpdateEventRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateEventRef:
```typescript
const name = updateEventRef.operationName;
console.log(name);
```

### Variables
The `UpdateEvent` mutation requires an argument of type `UpdateEventVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateEventVariables {
  id: UUIDString;
  eventName?: string | null;
  isRapid?: boolean | null;
  isRecurring?: boolean | null;
  isMultiDay?: boolean | null;
  recurrenceType?: RecurrenceType | null;
  recurrenceStartDate?: TimestampString | null;
  recurrenceEndDate?: TimestampString | null;
  scatterDates?: unknown | null;
  multiDayStartDate?: TimestampString | null;
  multiDayEndDate?: TimestampString | null;
  bufferTimeBefore?: number | null;
  bufferTimeAfter?: number | null;
  conflictDetectionEnabled?: boolean | null;
  detectedConflicts?: unknown | null;
  businessId?: UUIDString | null;
  businessName?: string | null;
  vendorId?: string | null;
  vendorName?: string | null;
  hub?: string | null;
  eventLocation?: string | null;
  contractType?: ContractType | null;
  poReference?: string | null;
  status?: EventStatus | null;
  date?: string | null;
  shifts?: unknown | null;
  addons?: unknown | null;
  total?: number | null;
  clientName?: string | null;
  clientEmail?: string | null;
  clientPhone?: string | null;
  invoiceId?: UUIDString | null;
  notes?: string | null;
  requested?: number | null;
  orderType?: string | null;
  department?: string | null;
  assignedStaff?: unknown | null;
  createdBy?: string | null;
  recurringStartDate?: string | null;
  recurringEndDate?: string | null;
  recurringDays?: unknown | null;
  permanentStartDate?: string | null;
  permanentDays?: unknown | null;
  includeBackup?: boolean | null;
  backupStaffCount?: number | null;
  recurringTime?: string | null;
  permanentTime?: string | null;
}
```
### Return Type
Recall that executing the `UpdateEvent` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateEventData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateEventData {
  event_update?: Event_Key | null;
}
```
### Using `UpdateEvent`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateEvent, UpdateEventVariables } from '@dataconnect/generated';

// The `UpdateEvent` mutation requires an argument of type `UpdateEventVariables`:
const updateEventVars: UpdateEventVariables = {
  id: ..., 
  eventName: ..., // optional
  isRapid: ..., // optional
  isRecurring: ..., // optional
  isMultiDay: ..., // optional
  recurrenceType: ..., // optional
  recurrenceStartDate: ..., // optional
  recurrenceEndDate: ..., // optional
  scatterDates: ..., // optional
  multiDayStartDate: ..., // optional
  multiDayEndDate: ..., // optional
  bufferTimeBefore: ..., // optional
  bufferTimeAfter: ..., // optional
  conflictDetectionEnabled: ..., // optional
  detectedConflicts: ..., // optional
  businessId: ..., // optional
  businessName: ..., // optional
  vendorId: ..., // optional
  vendorName: ..., // optional
  hub: ..., // optional
  eventLocation: ..., // optional
  contractType: ..., // optional
  poReference: ..., // optional
  status: ..., // optional
  date: ..., // optional
  shifts: ..., // optional
  addons: ..., // optional
  total: ..., // optional
  clientName: ..., // optional
  clientEmail: ..., // optional
  clientPhone: ..., // optional
  invoiceId: ..., // optional
  notes: ..., // optional
  requested: ..., // optional
  orderType: ..., // optional
  department: ..., // optional
  assignedStaff: ..., // optional
  createdBy: ..., // optional
  recurringStartDate: ..., // optional
  recurringEndDate: ..., // optional
  recurringDays: ..., // optional
  permanentStartDate: ..., // optional
  permanentDays: ..., // optional
  includeBackup: ..., // optional
  backupStaffCount: ..., // optional
  recurringTime: ..., // optional
  permanentTime: ..., // optional
};

// Call the `updateEvent()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateEvent(updateEventVars);
// Variables can be defined inline as well.
const { data } = await updateEvent({ id: ..., eventName: ..., isRapid: ..., isRecurring: ..., isMultiDay: ..., recurrenceType: ..., recurrenceStartDate: ..., recurrenceEndDate: ..., scatterDates: ..., multiDayStartDate: ..., multiDayEndDate: ..., bufferTimeBefore: ..., bufferTimeAfter: ..., conflictDetectionEnabled: ..., detectedConflicts: ..., businessId: ..., businessName: ..., vendorId: ..., vendorName: ..., hub: ..., eventLocation: ..., contractType: ..., poReference: ..., status: ..., date: ..., shifts: ..., addons: ..., total: ..., clientName: ..., clientEmail: ..., clientPhone: ..., invoiceId: ..., notes: ..., requested: ..., orderType: ..., department: ..., assignedStaff: ..., createdBy: ..., recurringStartDate: ..., recurringEndDate: ..., recurringDays: ..., permanentStartDate: ..., permanentDays: ..., includeBackup: ..., backupStaffCount: ..., recurringTime: ..., permanentTime: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateEvent(dataConnect, updateEventVars);

console.log(data.event_update);

// Or, you can use the `Promise` API.
updateEvent(updateEventVars).then((response) => {
  const data = response.data;
  console.log(data.event_update);
});
```

### Using `UpdateEvent`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateEventRef, UpdateEventVariables } from '@dataconnect/generated';

// The `UpdateEvent` mutation requires an argument of type `UpdateEventVariables`:
const updateEventVars: UpdateEventVariables = {
  id: ..., 
  eventName: ..., // optional
  isRapid: ..., // optional
  isRecurring: ..., // optional
  isMultiDay: ..., // optional
  recurrenceType: ..., // optional
  recurrenceStartDate: ..., // optional
  recurrenceEndDate: ..., // optional
  scatterDates: ..., // optional
  multiDayStartDate: ..., // optional
  multiDayEndDate: ..., // optional
  bufferTimeBefore: ..., // optional
  bufferTimeAfter: ..., // optional
  conflictDetectionEnabled: ..., // optional
  detectedConflicts: ..., // optional
  businessId: ..., // optional
  businessName: ..., // optional
  vendorId: ..., // optional
  vendorName: ..., // optional
  hub: ..., // optional
  eventLocation: ..., // optional
  contractType: ..., // optional
  poReference: ..., // optional
  status: ..., // optional
  date: ..., // optional
  shifts: ..., // optional
  addons: ..., // optional
  total: ..., // optional
  clientName: ..., // optional
  clientEmail: ..., // optional
  clientPhone: ..., // optional
  invoiceId: ..., // optional
  notes: ..., // optional
  requested: ..., // optional
  orderType: ..., // optional
  department: ..., // optional
  assignedStaff: ..., // optional
  createdBy: ..., // optional
  recurringStartDate: ..., // optional
  recurringEndDate: ..., // optional
  recurringDays: ..., // optional
  permanentStartDate: ..., // optional
  permanentDays: ..., // optional
  includeBackup: ..., // optional
  backupStaffCount: ..., // optional
  recurringTime: ..., // optional
  permanentTime: ..., // optional
};

// Call the `updateEventRef()` function to get a reference to the mutation.
const ref = updateEventRef(updateEventVars);
// Variables can be defined inline as well.
const ref = updateEventRef({ id: ..., eventName: ..., isRapid: ..., isRecurring: ..., isMultiDay: ..., recurrenceType: ..., recurrenceStartDate: ..., recurrenceEndDate: ..., scatterDates: ..., multiDayStartDate: ..., multiDayEndDate: ..., bufferTimeBefore: ..., bufferTimeAfter: ..., conflictDetectionEnabled: ..., detectedConflicts: ..., businessId: ..., businessName: ..., vendorId: ..., vendorName: ..., hub: ..., eventLocation: ..., contractType: ..., poReference: ..., status: ..., date: ..., shifts: ..., addons: ..., total: ..., clientName: ..., clientEmail: ..., clientPhone: ..., invoiceId: ..., notes: ..., requested: ..., orderType: ..., department: ..., assignedStaff: ..., createdBy: ..., recurringStartDate: ..., recurringEndDate: ..., recurringDays: ..., permanentStartDate: ..., permanentDays: ..., includeBackup: ..., backupStaffCount: ..., recurringTime: ..., permanentTime: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateEventRef(dataConnect, updateEventVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.event_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.event_update);
});
```

## DeleteEvent
You can execute the `DeleteEvent` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteEvent(vars: DeleteEventVariables): MutationPromise<DeleteEventData, DeleteEventVariables>;

interface DeleteEventRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteEventVariables): MutationRef<DeleteEventData, DeleteEventVariables>;
}
export const deleteEventRef: DeleteEventRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteEvent(dc: DataConnect, vars: DeleteEventVariables): MutationPromise<DeleteEventData, DeleteEventVariables>;

interface DeleteEventRef {
  ...
  (dc: DataConnect, vars: DeleteEventVariables): MutationRef<DeleteEventData, DeleteEventVariables>;
}
export const deleteEventRef: DeleteEventRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteEventRef:
```typescript
const name = deleteEventRef.operationName;
console.log(name);
```

### Variables
The `DeleteEvent` mutation requires an argument of type `DeleteEventVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteEventVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteEvent` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteEventData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteEventData {
  event_delete?: Event_Key | null;
}
```
### Using `DeleteEvent`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteEvent, DeleteEventVariables } from '@dataconnect/generated';

// The `DeleteEvent` mutation requires an argument of type `DeleteEventVariables`:
const deleteEventVars: DeleteEventVariables = {
  id: ..., 
};

// Call the `deleteEvent()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteEvent(deleteEventVars);
// Variables can be defined inline as well.
const { data } = await deleteEvent({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteEvent(dataConnect, deleteEventVars);

console.log(data.event_delete);

// Or, you can use the `Promise` API.
deleteEvent(deleteEventVars).then((response) => {
  const data = response.data;
  console.log(data.event_delete);
});
```

### Using `DeleteEvent`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteEventRef, DeleteEventVariables } from '@dataconnect/generated';

// The `DeleteEvent` mutation requires an argument of type `DeleteEventVariables`:
const deleteEventVars: DeleteEventVariables = {
  id: ..., 
};

// Call the `deleteEventRef()` function to get a reference to the mutation.
const ref = deleteEventRef(deleteEventVars);
// Variables can be defined inline as well.
const ref = deleteEventRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteEventRef(dataConnect, deleteEventVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.event_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.event_delete);
});
```

## CreateTeam
You can execute the `CreateTeam` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createTeam(vars: CreateTeamVariables): MutationPromise<CreateTeamData, CreateTeamVariables>;

interface CreateTeamRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateTeamVariables): MutationRef<CreateTeamData, CreateTeamVariables>;
}
export const createTeamRef: CreateTeamRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createTeam(dc: DataConnect, vars: CreateTeamVariables): MutationPromise<CreateTeamData, CreateTeamVariables>;

interface CreateTeamRef {
  ...
  (dc: DataConnect, vars: CreateTeamVariables): MutationRef<CreateTeamData, CreateTeamVariables>;
}
export const createTeamRef: CreateTeamRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createTeamRef:
```typescript
const name = createTeamRef.operationName;
console.log(name);
```

### Variables
The `CreateTeam` mutation requires an argument of type `CreateTeamVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateTeamVariables {
  teamName: string;
  ownerId: string;
  ownerName: string;
  ownerRole: TeamOwnerRole;
  favoriteStaff?: string | null;
  blockedStaff?: string | null;
}
```
### Return Type
Recall that executing the `CreateTeam` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateTeamData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateTeamData {
  team_insert: Team_Key;
}
```
### Using `CreateTeam`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createTeam, CreateTeamVariables } from '@dataconnect/generated';

// The `CreateTeam` mutation requires an argument of type `CreateTeamVariables`:
const createTeamVars: CreateTeamVariables = {
  teamName: ..., 
  ownerId: ..., 
  ownerName: ..., 
  ownerRole: ..., 
  favoriteStaff: ..., // optional
  blockedStaff: ..., // optional
};

// Call the `createTeam()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createTeam(createTeamVars);
// Variables can be defined inline as well.
const { data } = await createTeam({ teamName: ..., ownerId: ..., ownerName: ..., ownerRole: ..., favoriteStaff: ..., blockedStaff: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createTeam(dataConnect, createTeamVars);

console.log(data.team_insert);

// Or, you can use the `Promise` API.
createTeam(createTeamVars).then((response) => {
  const data = response.data;
  console.log(data.team_insert);
});
```

### Using `CreateTeam`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createTeamRef, CreateTeamVariables } from '@dataconnect/generated';

// The `CreateTeam` mutation requires an argument of type `CreateTeamVariables`:
const createTeamVars: CreateTeamVariables = {
  teamName: ..., 
  ownerId: ..., 
  ownerName: ..., 
  ownerRole: ..., 
  favoriteStaff: ..., // optional
  blockedStaff: ..., // optional
};

// Call the `createTeamRef()` function to get a reference to the mutation.
const ref = createTeamRef(createTeamVars);
// Variables can be defined inline as well.
const ref = createTeamRef({ teamName: ..., ownerId: ..., ownerName: ..., ownerRole: ..., favoriteStaff: ..., blockedStaff: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createTeamRef(dataConnect, createTeamVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.team_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.team_insert);
});
```

## UpdateTeam
You can execute the `UpdateTeam` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateTeam(vars: UpdateTeamVariables): MutationPromise<UpdateTeamData, UpdateTeamVariables>;

interface UpdateTeamRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateTeamVariables): MutationRef<UpdateTeamData, UpdateTeamVariables>;
}
export const updateTeamRef: UpdateTeamRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateTeam(dc: DataConnect, vars: UpdateTeamVariables): MutationPromise<UpdateTeamData, UpdateTeamVariables>;

interface UpdateTeamRef {
  ...
  (dc: DataConnect, vars: UpdateTeamVariables): MutationRef<UpdateTeamData, UpdateTeamVariables>;
}
export const updateTeamRef: UpdateTeamRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateTeamRef:
```typescript
const name = updateTeamRef.operationName;
console.log(name);
```

### Variables
The `UpdateTeam` mutation requires an argument of type `UpdateTeamVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateTeamVariables {
  id: UUIDString;
  teamName?: string | null;
  ownerId?: string | null;
  ownerName?: string | null;
  ownerRole?: TeamOwnerRole | null;
  favoriteStaff?: string | null;
  blockedStaff?: string | null;
}
```
### Return Type
Recall that executing the `UpdateTeam` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateTeamData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateTeamData {
  team_update?: Team_Key | null;
}
```
### Using `UpdateTeam`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateTeam, UpdateTeamVariables } from '@dataconnect/generated';

// The `UpdateTeam` mutation requires an argument of type `UpdateTeamVariables`:
const updateTeamVars: UpdateTeamVariables = {
  id: ..., 
  teamName: ..., // optional
  ownerId: ..., // optional
  ownerName: ..., // optional
  ownerRole: ..., // optional
  favoriteStaff: ..., // optional
  blockedStaff: ..., // optional
};

// Call the `updateTeam()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateTeam(updateTeamVars);
// Variables can be defined inline as well.
const { data } = await updateTeam({ id: ..., teamName: ..., ownerId: ..., ownerName: ..., ownerRole: ..., favoriteStaff: ..., blockedStaff: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateTeam(dataConnect, updateTeamVars);

console.log(data.team_update);

// Or, you can use the `Promise` API.
updateTeam(updateTeamVars).then((response) => {
  const data = response.data;
  console.log(data.team_update);
});
```

### Using `UpdateTeam`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateTeamRef, UpdateTeamVariables } from '@dataconnect/generated';

// The `UpdateTeam` mutation requires an argument of type `UpdateTeamVariables`:
const updateTeamVars: UpdateTeamVariables = {
  id: ..., 
  teamName: ..., // optional
  ownerId: ..., // optional
  ownerName: ..., // optional
  ownerRole: ..., // optional
  favoriteStaff: ..., // optional
  blockedStaff: ..., // optional
};

// Call the `updateTeamRef()` function to get a reference to the mutation.
const ref = updateTeamRef(updateTeamVars);
// Variables can be defined inline as well.
const ref = updateTeamRef({ id: ..., teamName: ..., ownerId: ..., ownerName: ..., ownerRole: ..., favoriteStaff: ..., blockedStaff: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateTeamRef(dataConnect, updateTeamVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.team_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.team_update);
});
```

## DeleteTeam
You can execute the `DeleteTeam` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteTeam(vars: DeleteTeamVariables): MutationPromise<DeleteTeamData, DeleteTeamVariables>;

interface DeleteTeamRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteTeamVariables): MutationRef<DeleteTeamData, DeleteTeamVariables>;
}
export const deleteTeamRef: DeleteTeamRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteTeam(dc: DataConnect, vars: DeleteTeamVariables): MutationPromise<DeleteTeamData, DeleteTeamVariables>;

interface DeleteTeamRef {
  ...
  (dc: DataConnect, vars: DeleteTeamVariables): MutationRef<DeleteTeamData, DeleteTeamVariables>;
}
export const deleteTeamRef: DeleteTeamRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteTeamRef:
```typescript
const name = deleteTeamRef.operationName;
console.log(name);
```

### Variables
The `DeleteTeam` mutation requires an argument of type `DeleteTeamVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteTeamVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteTeam` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteTeamData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteTeamData {
  team_delete?: Team_Key | null;
}
```
### Using `DeleteTeam`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteTeam, DeleteTeamVariables } from '@dataconnect/generated';

// The `DeleteTeam` mutation requires an argument of type `DeleteTeamVariables`:
const deleteTeamVars: DeleteTeamVariables = {
  id: ..., 
};

// Call the `deleteTeam()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteTeam(deleteTeamVars);
// Variables can be defined inline as well.
const { data } = await deleteTeam({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteTeam(dataConnect, deleteTeamVars);

console.log(data.team_delete);

// Or, you can use the `Promise` API.
deleteTeam(deleteTeamVars).then((response) => {
  const data = response.data;
  console.log(data.team_delete);
});
```

### Using `DeleteTeam`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteTeamRef, DeleteTeamVariables } from '@dataconnect/generated';

// The `DeleteTeam` mutation requires an argument of type `DeleteTeamVariables`:
const deleteTeamVars: DeleteTeamVariables = {
  id: ..., 
};

// Call the `deleteTeamRef()` function to get a reference to the mutation.
const ref = deleteTeamRef(deleteTeamVars);
// Variables can be defined inline as well.
const ref = deleteTeamRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteTeamRef(dataConnect, deleteTeamVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.team_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.team_delete);
});
```

## CreateWorkforce
You can execute the `CreateWorkforce` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
createWorkforce(vars: CreateWorkforceVariables): MutationPromise<CreateWorkforceData, CreateWorkforceVariables>;

interface CreateWorkforceRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: CreateWorkforceVariables): MutationRef<CreateWorkforceData, CreateWorkforceVariables>;
}
export const createWorkforceRef: CreateWorkforceRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
createWorkforce(dc: DataConnect, vars: CreateWorkforceVariables): MutationPromise<CreateWorkforceData, CreateWorkforceVariables>;

interface CreateWorkforceRef {
  ...
  (dc: DataConnect, vars: CreateWorkforceVariables): MutationRef<CreateWorkforceData, CreateWorkforceVariables>;
}
export const createWorkforceRef: CreateWorkforceRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createWorkforceRef:
```typescript
const name = createWorkforceRef.operationName;
console.log(name);
```

### Variables
The `CreateWorkforce` mutation requires an argument of type `CreateWorkforceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface CreateWorkforceVariables {
  workforceNumber: string;
  vendorId: UUIDString;
  firstName: string;
  lastName: string;
  employmentType?: WorkforceEmploymentType | null;
}
```
### Return Type
Recall that executing the `CreateWorkforce` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `CreateWorkforceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface CreateWorkforceData {
  workforce_insert: Workforce_Key;
}
```
### Using `CreateWorkforce`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, createWorkforce, CreateWorkforceVariables } from '@dataconnect/generated';

// The `CreateWorkforce` mutation requires an argument of type `CreateWorkforceVariables`:
const createWorkforceVars: CreateWorkforceVariables = {
  workforceNumber: ..., 
  vendorId: ..., 
  firstName: ..., 
  lastName: ..., 
  employmentType: ..., // optional
};

// Call the `createWorkforce()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await createWorkforce(createWorkforceVars);
// Variables can be defined inline as well.
const { data } = await createWorkforce({ workforceNumber: ..., vendorId: ..., firstName: ..., lastName: ..., employmentType: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await createWorkforce(dataConnect, createWorkforceVars);

console.log(data.workforce_insert);

// Or, you can use the `Promise` API.
createWorkforce(createWorkforceVars).then((response) => {
  const data = response.data;
  console.log(data.workforce_insert);
});
```

### Using `CreateWorkforce`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, createWorkforceRef, CreateWorkforceVariables } from '@dataconnect/generated';

// The `CreateWorkforce` mutation requires an argument of type `CreateWorkforceVariables`:
const createWorkforceVars: CreateWorkforceVariables = {
  workforceNumber: ..., 
  vendorId: ..., 
  firstName: ..., 
  lastName: ..., 
  employmentType: ..., // optional
};

// Call the `createWorkforceRef()` function to get a reference to the mutation.
const ref = createWorkforceRef(createWorkforceVars);
// Variables can be defined inline as well.
const ref = createWorkforceRef({ workforceNumber: ..., vendorId: ..., firstName: ..., lastName: ..., employmentType: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = createWorkforceRef(dataConnect, createWorkforceVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.workforce_insert);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.workforce_insert);
});
```

## UpdateWorkforce
You can execute the `UpdateWorkforce` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
updateWorkforce(vars: UpdateWorkforceVariables): MutationPromise<UpdateWorkforceData, UpdateWorkforceVariables>;

interface UpdateWorkforceRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: UpdateWorkforceVariables): MutationRef<UpdateWorkforceData, UpdateWorkforceVariables>;
}
export const updateWorkforceRef: UpdateWorkforceRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
updateWorkforce(dc: DataConnect, vars: UpdateWorkforceVariables): MutationPromise<UpdateWorkforceData, UpdateWorkforceVariables>;

interface UpdateWorkforceRef {
  ...
  (dc: DataConnect, vars: UpdateWorkforceVariables): MutationRef<UpdateWorkforceData, UpdateWorkforceVariables>;
}
export const updateWorkforceRef: UpdateWorkforceRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateWorkforceRef:
```typescript
const name = updateWorkforceRef.operationName;
console.log(name);
```

### Variables
The `UpdateWorkforce` mutation requires an argument of type `UpdateWorkforceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface UpdateWorkforceVariables {
  id: UUIDString;
  workforceNumber?: string | null;
  vendorId?: UUIDString | null;
  firstName?: string | null;
  lastName?: string | null;
  employmentType?: WorkforceEmploymentType | null;
}
```
### Return Type
Recall that executing the `UpdateWorkforce` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `UpdateWorkforceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface UpdateWorkforceData {
  workforce_update?: Workforce_Key | null;
}
```
### Using `UpdateWorkforce`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, updateWorkforce, UpdateWorkforceVariables } from '@dataconnect/generated';

// The `UpdateWorkforce` mutation requires an argument of type `UpdateWorkforceVariables`:
const updateWorkforceVars: UpdateWorkforceVariables = {
  id: ..., 
  workforceNumber: ..., // optional
  vendorId: ..., // optional
  firstName: ..., // optional
  lastName: ..., // optional
  employmentType: ..., // optional
};

// Call the `updateWorkforce()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await updateWorkforce(updateWorkforceVars);
// Variables can be defined inline as well.
const { data } = await updateWorkforce({ id: ..., workforceNumber: ..., vendorId: ..., firstName: ..., lastName: ..., employmentType: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await updateWorkforce(dataConnect, updateWorkforceVars);

console.log(data.workforce_update);

// Or, you can use the `Promise` API.
updateWorkforce(updateWorkforceVars).then((response) => {
  const data = response.data;
  console.log(data.workforce_update);
});
```

### Using `UpdateWorkforce`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, updateWorkforceRef, UpdateWorkforceVariables } from '@dataconnect/generated';

// The `UpdateWorkforce` mutation requires an argument of type `UpdateWorkforceVariables`:
const updateWorkforceVars: UpdateWorkforceVariables = {
  id: ..., 
  workforceNumber: ..., // optional
  vendorId: ..., // optional
  firstName: ..., // optional
  lastName: ..., // optional
  employmentType: ..., // optional
};

// Call the `updateWorkforceRef()` function to get a reference to the mutation.
const ref = updateWorkforceRef(updateWorkforceVars);
// Variables can be defined inline as well.
const ref = updateWorkforceRef({ id: ..., workforceNumber: ..., vendorId: ..., firstName: ..., lastName: ..., employmentType: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = updateWorkforceRef(dataConnect, updateWorkforceVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.workforce_update);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.workforce_update);
});
```

## DeleteWorkforce
You can execute the `DeleteWorkforce` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts):
```typescript
deleteWorkforce(vars: DeleteWorkforceVariables): MutationPromise<DeleteWorkforceData, DeleteWorkforceVariables>;

interface DeleteWorkforceRef {
  ...
  /* Allow users to create refs without passing in DataConnect */
  (vars: DeleteWorkforceVariables): MutationRef<DeleteWorkforceData, DeleteWorkforceVariables>;
}
export const deleteWorkforceRef: DeleteWorkforceRef;
```
You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function.
```typescript
deleteWorkforce(dc: DataConnect, vars: DeleteWorkforceVariables): MutationPromise<DeleteWorkforceData, DeleteWorkforceVariables>;

interface DeleteWorkforceRef {
  ...
  (dc: DataConnect, vars: DeleteWorkforceVariables): MutationRef<DeleteWorkforceData, DeleteWorkforceVariables>;
}
export const deleteWorkforceRef: DeleteWorkforceRef;
```

If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteWorkforceRef:
```typescript
const name = deleteWorkforceRef.operationName;
console.log(name);
```

### Variables
The `DeleteWorkforce` mutation requires an argument of type `DeleteWorkforceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:

```typescript
export interface DeleteWorkforceVariables {
  id: UUIDString;
}
```
### Return Type
Recall that executing the `DeleteWorkforce` mutation returns a `MutationPromise` that resolves to an object with a `data` property.

The `data` property is an object of type `DeleteWorkforceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields:
```typescript
export interface DeleteWorkforceData {
  workforce_delete?: Workforce_Key | null;
}
```
### Using `DeleteWorkforce`'s action shortcut function

```typescript
import { getDataConnect } from 'firebase/data-connect';
import { connectorConfig, deleteWorkforce, DeleteWorkforceVariables } from '@dataconnect/generated';

// The `DeleteWorkforce` mutation requires an argument of type `DeleteWorkforceVariables`:
const deleteWorkforceVars: DeleteWorkforceVariables = {
  id: ..., 
};

// Call the `deleteWorkforce()` function to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await deleteWorkforce(deleteWorkforceVars);
// Variables can be defined inline as well.
const { data } = await deleteWorkforce({ id: ..., });

// You can also pass in a `DataConnect` instance to the action shortcut function.
const dataConnect = getDataConnect(connectorConfig);
const { data } = await deleteWorkforce(dataConnect, deleteWorkforceVars);

console.log(data.workforce_delete);

// Or, you can use the `Promise` API.
deleteWorkforce(deleteWorkforceVars).then((response) => {
  const data = response.data;
  console.log(data.workforce_delete);
});
```

### Using `DeleteWorkforce`'s `MutationRef` function

```typescript
import { getDataConnect, executeMutation } from 'firebase/data-connect';
import { connectorConfig, deleteWorkforceRef, DeleteWorkforceVariables } from '@dataconnect/generated';

// The `DeleteWorkforce` mutation requires an argument of type `DeleteWorkforceVariables`:
const deleteWorkforceVars: DeleteWorkforceVariables = {
  id: ..., 
};

// Call the `deleteWorkforceRef()` function to get a reference to the mutation.
const ref = deleteWorkforceRef(deleteWorkforceVars);
// Variables can be defined inline as well.
const ref = deleteWorkforceRef({ id: ..., });

// You can also pass in a `DataConnect` instance to the `MutationRef` function.
const dataConnect = getDataConnect(connectorConfig);
const ref = deleteWorkforceRef(dataConnect, deleteWorkforceVars);

// Call `executeMutation()` on the reference to execute the mutation.
// You can use the `await` keyword to wait for the promise to resolve.
const { data } = await executeMutation(ref);

console.log(data.workforce_delete);

// Or, you can use the `Promise` API.
executeMutation(ref).then((response) => {
  const data = response.data;
  console.log(data.workforce_delete);
});
```

