Krow/Krow-workspace

Fork 0

Files

History

bwnyasse d43a14ee0c clean

2026-01-10 21:22:35 -05:00

.guides

clean

2026-01-10 21:22:35 -05:00

esm

clean

2026-01-10 21:22:35 -05:00

react

clean

2026-01-10 21:22:35 -05:00

index.cjs.js

clean

2026-01-10 21:22:35 -05:00

index.d.ts

clean

2026-01-10 21:22:35 -05:00

package.json

clean

2026-01-10 21:22:35 -05:00

README.md

clean

2026-01-10 21:22:35 -05:00

README.md

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

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.

Overview
Accessing the connector
- Connecting to the local Emulator
Queries
Mutations

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.

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.

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.

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 and 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.

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:

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.

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:

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. It has the following fields:

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

Using `listTeamMemberInvite`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `getTeamMemberInviteById`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `filterTeamMemberInvite`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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

Using `listConversation`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `getConversationById`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `filterConversation`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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

Using `listShift`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `filterShift`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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

Using `listEnterprise`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `getEnterpriseById`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `filterEnterprise`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `getUserById`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `filterUsers`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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

Using `listVendorDefaultSettings`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `getVendorDefaultSettingById`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `filterVendorDefaultSettings`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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

Using `listMessage`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `getMessageById`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `filterMessage`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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

Using `listSector`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `getSectorById`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `filterSector`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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

Using `listOrder`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `getOrderById`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `filterOrder`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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

Using `listPartner`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `getPartnerById`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `filterPartner`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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

Using `listTeamHub`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `getTeamHubById`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `filterTeamHub`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

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

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.

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateMessageData {
  message_insert: Message_Key;
}

Using `CreateMessage`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateMessage`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteMessage`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateStaffData {
  staff_insert: Staff_Key;
}

Using `CreateStaff`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateStaff`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteStaff`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateVendorData {
  vendor_insert: Vendor_Key;
}

Using `CreateVendor`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateVendor`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteVendor`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateActivityLogData {
  activityLog_insert: ActivityLog_Key;
}

Using `CreateActivityLog`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateActivityLog`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteActivityLog`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateAssignmentData {
  assignment_insert: Assignment_Key;
}

Using `CreateAssignment`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateAssignment`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteAssignment`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateCertificationData {
  certification_insert: Certification_Key;
}

Using `CreateCertification`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateCertification`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteCertification`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateShiftData {
  shift_insert: Shift_Key;
}

Using `CreateShift`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateShift`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteShift`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateTeamHubData {
  teamHub_insert: TeamHub_Key;
}

Using `CreateTeamHub`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateTeamHub`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteTeamHub`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateOrderData {
  order_insert: Order_Key;
}

Using `CreateOrder`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateOrder`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteOrder`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateSectorData {
  sector_insert: Sector_Key;
}

Using `CreateSector`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateSector`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteSector`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateUserData {
  user_insert: User_Key;
}

Using `CreateUser`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateUser`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteUser`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateTeamMemberInviteData {
  teamMemberInvite_insert: TeamMemberInvite_Key;
}

Using `CreateTeamMemberInvite`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateTeamMemberInvite`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteTeamMemberInvite`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateVendorDefaultSettingData {
  vendorDefaultSetting_insert: VendorDefaultSetting_Key;
}

Using `CreateVendorDefaultSetting`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateVendorDefaultSetting`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteVendorDefaultSetting`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateVendorRateData {
  vendorRate_insert: VendorRate_Key;
}

Using `CreateVendorRate`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateVendorRate`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteVendorRate`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateEnterpriseData {
  enterprise_insert: Enterprise_Key;
}

Using `CreateEnterprise`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateEnterprise`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteEnterprise`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreatePartnerData {
  partner_insert: Partner_Key;
}

Using `CreatePartner`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdatePartner`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeletePartner`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateTeamMemberData {
  teamMember_insert: TeamMember_Key;
}

Using `CreateTeamMember`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateTeamMember`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteTeamMember`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateConversationData {
  conversation_insert: Conversation_Key;
}

Using `CreateConversation`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateConversation`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteConversation`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateInvoiceData {
  invoice_insert: Invoice_Key;
}

Using `CreateInvoice`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateInvoice`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteInvoice`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateBusinessData {
  business_insert: Business_Key;
}

Using `CreateBusiness`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateBusiness`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteBusiness`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateEventData {
  event_insert: Event_Key;
}

Using `CreateEvent`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateEvent`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteEvent`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateTeamData {
  team_insert: Team_Key;
}

Using `CreateTeam`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateTeam`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteTeam`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

export interface CreateWorkforceData {
  workforce_insert: Workforce_Key;
}

Using `CreateWorkforce`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `UpdateWorkforce`'s action shortcut function

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

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:

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.

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:

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. It has the following fields:

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. It has the following fields:

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

Using `DeleteWorkforce`'s action shortcut function

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

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);
});

README.md

Generated TypeScript README

Table of Contents

Accessing the connector

Connecting to the local Emulator

Queries

listTeamMemberInvite

Variables

Return Type

Using listTeamMemberInvite's action shortcut function

Using listTeamMemberInvite's QueryRef function

getTeamMemberInviteById

Variables

Return Type

Using getTeamMemberInviteById's action shortcut function

Using getTeamMemberInviteById's QueryRef function

filterTeamMemberInvite

Variables

Return Type

Using filterTeamMemberInvite's action shortcut function

Using filterTeamMemberInvite's QueryRef function

listCertification

Variables

Return Type

Using listCertification's action shortcut function

Using listCertification's QueryRef function

getCertificationById

Variables

Return Type

Using getCertificationById's action shortcut function

Using getCertificationById's QueryRef function

filterCertification

Variables

Return Type

Using filterCertification's action shortcut function

Using filterCertification's QueryRef function

listConversation

Variables

Return Type

Using listConversation's action shortcut function

Using listConversation's QueryRef function

getConversationById

Variables

Return Type

Using getConversationById's action shortcut function

Using getConversationById's QueryRef function

filterConversation

Variables

Return Type

Using filterConversation's action shortcut function

Using filterConversation's QueryRef function

listShift

Variables

Return Type

Using listShift's action shortcut function

Using listShift's QueryRef function

getShiftById

Variables

Return Type

Using getShiftById's action shortcut function

Using getShiftById's QueryRef function

filterShift

Variables

Return Type

Using filterShift's action shortcut function

Using filterShift's QueryRef function

listEnterprise

Variables

Return Type

Using listEnterprise's action shortcut function

Using listEnterprise's QueryRef function

getEnterpriseById

Variables

Return Type

Using getEnterpriseById's action shortcut function

Using getEnterpriseById's QueryRef function

filterEnterprise

Variables

Return Type

Using filterEnterprise's action shortcut function

Using `listTeamMemberInvite`'s action shortcut function

Using `listTeamMemberInvite`'s `QueryRef` function

Using `getTeamMemberInviteById`'s action shortcut function

Using `getTeamMemberInviteById`'s `QueryRef` function

Using `filterTeamMemberInvite`'s action shortcut function

Using `filterTeamMemberInvite`'s `QueryRef` function

Using `listCertification`'s action shortcut function

Using `listCertification`'s `QueryRef` function

Using `getCertificationById`'s action shortcut function

Using `getCertificationById`'s `QueryRef` function

Using `filterCertification`'s action shortcut function

Using `filterCertification`'s `QueryRef` function

Using `listConversation`'s action shortcut function

Using `listConversation`'s `QueryRef` function

Using `getConversationById`'s action shortcut function

Using `getConversationById`'s `QueryRef` function

Using `filterConversation`'s action shortcut function

Using `filterConversation`'s `QueryRef` function

Using `listShift`'s action shortcut function

Using `listShift`'s `QueryRef` function

Using `getShiftById`'s action shortcut function

Using `getShiftById`'s `QueryRef` function

Using `filterShift`'s action shortcut function

Using `filterShift`'s `QueryRef` function

Using `listEnterprise`'s action shortcut function

Using `listEnterprise`'s `QueryRef` function

Using `getEnterpriseById`'s action shortcut function

Using `getEnterpriseById`'s `QueryRef` function

Using `filterEnterprise`'s action shortcut function

Using `filterEnterprise`'s `QueryRef` function

Using `listInvoice`'s action shortcut function

Using `listInvoice`'s `QueryRef` function

Using `getInvoiceById`'s action shortcut function

Using `getInvoiceById`'s `QueryRef` function

Using `filterInvoices`'s action shortcut function

Using `filterInvoices`'s `QueryRef` function

Using `listTeamMember`'s action shortcut function

Using `listTeamMember`'s `QueryRef` function

Using `getTeamMemberById`'s action shortcut function

Using `getTeamMemberById`'s `QueryRef` function

Using `filterTeamMember`'s action shortcut function

Using `filterTeamMember`'s `QueryRef` function

Using `listUsers`'s action shortcut function

Using `listUsers`'s `QueryRef` function

Using `getUserById`'s action shortcut function

Using `getUserById`'s `QueryRef` function

Using `filterUsers`'s action shortcut function

Using `filterUsers`'s `QueryRef` function

Using `listVendorDefaultSettings`'s action shortcut function

Using `listVendorDefaultSettings`'s `QueryRef` function

Using `getVendorDefaultSettingById`'s action shortcut function

Using `getVendorDefaultSettingById`'s `QueryRef` function

Using `filterVendorDefaultSettings`'s action shortcut function

Using `filterVendorDefaultSettings`'s `QueryRef` function

Using `listAssignment`'s action shortcut function

Using `listAssignment`'s `QueryRef` function

Using `getAssignmentById`'s action shortcut function