From 6c90d39dae58f905e174076ed6b137f6a9ddc244 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Salazar?= <73718835+joshrs23@users.noreply.github.com> Date: Tue, 25 Nov 2025 14:32:17 -0500 Subject: [PATCH 1/3] new business entity --- dataconnect/connector/business/mutations.gql | 47 ++++++++++++++++++ dataconnect/connector/business/queries.gql | 51 ++++++++++++++++++++ dataconnect/schema/business.gql | 34 +++++++++++++ 3 files changed, 132 insertions(+) create mode 100644 dataconnect/connector/business/mutations.gql create mode 100644 dataconnect/connector/business/queries.gql create mode 100644 dataconnect/schema/business.gql diff --git a/dataconnect/connector/business/mutations.gql b/dataconnect/connector/business/mutations.gql new file mode 100644 index 00000000..9be33782 --- /dev/null +++ b/dataconnect/connector/business/mutations.gql @@ -0,0 +1,47 @@ +mutation CreateBusiness( + $businessName: String!, + $contactName: String!, + $email: String, + $sector: BusinessSector, + $rateGroup: BusinessRateGroup!, + $status: BusinessStatus +) @auth(level: USER) { + business_insert( + data: { + businessName: $businessName + contactName: $contactName + email: $email + sector: $sector + rateGroup: $rateGroup + status: $status + } + ) +} + +mutation UpdateBusiness( + $id: UUID!, + $businessName: String, + $contactName: String, + $email: String, + $sector: BusinessSector, + $rateGroup: BusinessRateGroup, + $status: BusinessStatus +) @auth(level: USER) { + business_update( + id: $id, + data: { + businessName: $businessName + contactName: $contactName + email: $email + sector: $sector + rateGroup: $rateGroup + status: $status + } + ) +} + +mutation DeleteBusiness( + $id: UUID! +) @auth(level: USER) { + business_delete(id: $id) +} diff --git a/dataconnect/connector/business/queries.gql b/dataconnect/connector/business/queries.gql new file mode 100644 index 00000000..3b721dc8 --- /dev/null +++ b/dataconnect/connector/business/queries.gql @@ -0,0 +1,51 @@ +query listBusiness @auth(level: USER) { + business { + id + businessName + contactName + email + sector + rateGroup + status + } +} + +query getBusinessById( + $id: UUID! +) @auth(level: USER) { + business(id: $id) { + id + businessName + contactName + email + sector + rateGroup + status + } +} + +query filterBusiness( + $businessName: String, + $contactName: String, + $sector: BusinessSector, + $rateGroup: BusinessRateGroup, + $status: BusinessStatus +) @auth(level: USER) { + business( + where: { + businessName: { eq: $businessName } + contactName: { eq: $contactName } + sector: { eq: $sector } + rateGroup: { eq: $rateGroup } + status: { eq: $status } + } + ) { + id + businessName + contactName + email + sector + rateGroup + status + } +} diff --git a/dataconnect/schema/business.gql b/dataconnect/schema/business.gql new file mode 100644 index 00000000..b517aaf6 --- /dev/null +++ b/dataconnect/schema/business.gql @@ -0,0 +1,34 @@ +enum BusinessSector { + BON_APPETIT + EUREST + ARAMARK + EPICUREAN_GROUP + CHARTWELLS + OTHER +} + +enum BusinessRateGroup { + STANDARD + PREMIUM + ENTERPRISE + CUSTOM +} + +enum BusinessStatus { + ACTIVE + INACTIVE + PENDING +} + +type Business @table(name: "business") { + id: UUID! @default(expr: "uuidV4()") + businessName: String! + contactName: String! + email: String + sector: BusinessSector + rateGroup: BusinessRateGroup! + status: BusinessStatus + createdDate: Timestamp @default(expr: "request.time") + updatedDate: Timestamp @default(expr: "request.time") + createdBy: String @default(expr: "auth.uid") +} From c0006902554b43be356daf33bd9bfcc6ca23f3a4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Salazar?= <73718835+joshrs23@users.noreply.github.com> Date: Tue, 25 Nov 2025 14:43:46 -0500 Subject: [PATCH 2/3] solving problem with plural table name in filter --- dataconnect/connector/business/queries.gql | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dataconnect/connector/business/queries.gql b/dataconnect/connector/business/queries.gql index 3b721dc8..4eeceead 100644 --- a/dataconnect/connector/business/queries.gql +++ b/dataconnect/connector/business/queries.gql @@ -1,5 +1,5 @@ query listBusiness @auth(level: USER) { - business { + businesses { id businessName contactName @@ -31,7 +31,7 @@ query filterBusiness( $rateGroup: BusinessRateGroup, $status: BusinessStatus ) @auth(level: USER) { - business( + businesses( where: { businessName: { eq: $businessName } contactName: { eq: $contactName } From a603af4c2a4813e28f54face78b2561c2d3c6d65 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Salazar?= <73718835+joshrs23@users.noreply.github.com> Date: Tue, 25 Nov 2025 14:44:19 -0500 Subject: [PATCH 3/3] adding new schema and crud of business --- .../dataconnect-generated/.guides/usage.md | 54 +- .../src/dataconnect-generated/README.md | 5379 ++++++++++------- .../dataconnect-generated/esm/index.esm.js | 444 +- .../src/dataconnect-generated/index.cjs.js | 497 +- .../src/dataconnect-generated/index.d.ts | 578 +- .../src/dataconnect-generated/react/README.md | 3125 ++++++---- .../react/esm/index.esm.js | 193 +- .../dataconnect-generated/react/index.cjs.js | 193 +- .../dataconnect-generated/react/index.d.ts | 126 +- .../dataconnect-generated/.guides/usage.md | 54 +- .../src/dataconnect-generated/README.md | 5379 ++++++++++------- .../dataconnect-generated/esm/index.esm.js | 444 +- .../src/dataconnect-generated/index.cjs.js | 497 +- .../src/dataconnect-generated/index.d.ts | 578 +- .../src/dataconnect-generated/react/README.md | 3125 ++++++---- .../react/esm/index.esm.js | 193 +- .../dataconnect-generated/react/index.cjs.js | 193 +- .../dataconnect-generated/react/index.d.ts | 126 +- 18 files changed, 12352 insertions(+), 8826 deletions(-) diff --git a/frontend-web/src/dataconnect-generated/.guides/usage.md b/frontend-web/src/dataconnect-generated/.guides/usage.md index 29b57da6..76991bc0 100644 --- a/frontend-web/src/dataconnect-generated/.guides/usage.md +++ b/frontend-web/src/dataconnect-generated/.guides/usage.md @@ -12,16 +12,20 @@ For each operation, there is a wrapper hook that can be used to call the operati Here are all of the hooks that get generated: ```ts -import { useListStaff, useCreateVendor, useUpdateVendor, useDeleteVendor, useListVendorDefaultSettings, useGetVendorDefaultSettingById, useFilterVendorDefaultSettings, useListEvents, useGetEventById, useFilterEvents } from '@dataconnect/generated/react'; +import { useListBusiness, useGetBusinessById, useFilterBusiness, useCreateEvent, useUpdateEvent, useDeleteEvent, useListVendorDefaultSettings, useGetVendorDefaultSettingById, useFilterVendorDefaultSettings, useCreateVendorRate } from '@dataconnect/generated/react'; // The types of these hooks are available in react/index.d.ts -const { data, isPending, isSuccess, isError, error } = useListStaff(); +const { data, isPending, isSuccess, isError, error } = useListBusiness(); -const { data, isPending, isSuccess, isError, error } = useCreateVendor(createVendorVars); +const { data, isPending, isSuccess, isError, error } = useGetBusinessById(getBusinessByIdVars); -const { data, isPending, isSuccess, isError, error } = useUpdateVendor(updateVendorVars); +const { data, isPending, isSuccess, isError, error } = useFilterBusiness(filterBusinessVars); -const { data, isPending, isSuccess, isError, error } = useDeleteVendor(deleteVendorVars); +const { data, isPending, isSuccess, isError, error } = useCreateEvent(createEventVars); + +const { data, isPending, isSuccess, isError, error } = useUpdateEvent(updateEventVars); + +const { data, isPending, isSuccess, isError, error } = useDeleteEvent(deleteEventVars); const { data, isPending, isSuccess, isError, error } = useListVendorDefaultSettings(); @@ -29,11 +33,7 @@ const { data, isPending, isSuccess, isError, error } = useGetVendorDefaultSettin const { data, isPending, isSuccess, isError, error } = useFilterVendorDefaultSettings(filterVendorDefaultSettingsVars); -const { data, isPending, isSuccess, isError, error } = useListEvents(); - -const { data, isPending, isSuccess, isError, error } = useGetEventById(getEventByIdVars); - -const { data, isPending, isSuccess, isError, error } = useFilterEvents(filterEventsVars); +const { data, isPending, isSuccess, isError, error } = useCreateVendorRate(createVendorRateVars); ``` @@ -72,20 +72,26 @@ If a user is not using a supported framework, they can use the generated SDK dir Here's an example of how to use it with the first 5 operations: ```js -import { listStaff, createVendor, updateVendor, deleteVendor, listVendorDefaultSettings, getVendorDefaultSettingById, filterVendorDefaultSettings, listEvents, getEventById, filterEvents } from '@dataconnect/generated'; +import { listBusiness, getBusinessById, filterBusiness, createEvent, updateEvent, deleteEvent, listVendorDefaultSettings, getVendorDefaultSettingById, filterVendorDefaultSettings, createVendorRate } from '@dataconnect/generated'; -// Operation listStaff: -const { data } = await ListStaff(dataConnect); +// Operation listBusiness: +const { data } = await ListBusiness(dataConnect); -// Operation CreateVendor: For variables, look at type CreateVendorVars in ../index.d.ts -const { data } = await CreateVendor(dataConnect, createVendorVars); +// Operation getBusinessById: For variables, look at type GetBusinessByIdVars in ../index.d.ts +const { data } = await GetBusinessById(dataConnect, getBusinessByIdVars); -// Operation UpdateVendor: For variables, look at type UpdateVendorVars in ../index.d.ts -const { data } = await UpdateVendor(dataConnect, updateVendorVars); +// Operation filterBusiness: For variables, look at type FilterBusinessVars in ../index.d.ts +const { data } = await FilterBusiness(dataConnect, filterBusinessVars); -// Operation DeleteVendor: For variables, look at type DeleteVendorVars in ../index.d.ts -const { data } = await DeleteVendor(dataConnect, deleteVendorVars); +// Operation CreateEvent: For variables, look at type CreateEventVars in ../index.d.ts +const { data } = await CreateEvent(dataConnect, createEventVars); + +// Operation UpdateEvent: For variables, look at type UpdateEventVars in ../index.d.ts +const { data } = await UpdateEvent(dataConnect, updateEventVars); + +// Operation DeleteEvent: For variables, look at type DeleteEventVars in ../index.d.ts +const { data } = await DeleteEvent(dataConnect, deleteEventVars); // Operation listVendorDefaultSettings: const { data } = await ListVendorDefaultSettings(dataConnect); @@ -96,14 +102,8 @@ const { data } = await GetVendorDefaultSettingById(dataConnect, getVendorDefault // Operation filterVendorDefaultSettings: For variables, look at type FilterVendorDefaultSettingsVars in ../index.d.ts const { data } = await FilterVendorDefaultSettings(dataConnect, filterVendorDefaultSettingsVars); -// Operation listEvents: -const { data } = await ListEvents(dataConnect); - -// Operation getEventById: For variables, look at type GetEventByIdVars in ../index.d.ts -const { data } = await GetEventById(dataConnect, getEventByIdVars); - -// Operation filterEvents: For variables, look at type FilterEventsVars in ../index.d.ts -const { data } = await FilterEvents(dataConnect, filterEventsVars); +// Operation CreateVendorRate: For variables, look at type CreateVendorRateVars in ../index.d.ts +const { data } = await CreateVendorRate(dataConnect, createVendorRateVars); ``` \ No newline at end of file diff --git a/frontend-web/src/dataconnect-generated/README.md b/frontend-web/src/dataconnect-generated/README.md index 3035cccb..165ef7f8 100644 --- a/frontend-web/src/dataconnect-generated/README.md +++ b/frontend-web/src/dataconnect-generated/README.md @@ -10,39 +10,45 @@ This README will guide you through the process of using the generated JavaScript - [**Accessing the connector**](#accessing-the-connector) - [*Connecting to the local Emulator*](#connecting-to-the-local-emulator) - [**Queries**](#queries) - - [*listStaff*](#liststaff) + - [*listBusiness*](#listbusiness) + - [*getBusinessById*](#getbusinessbyid) + - [*filterBusiness*](#filterbusiness) - [*listVendorDefaultSettings*](#listvendordefaultsettings) - [*getVendorDefaultSettingById*](#getvendordefaultsettingbyid) - [*filterVendorDefaultSettings*](#filtervendordefaultsettings) - - [*listEvents*](#listevents) - - [*getEventById*](#geteventbyid) - - [*filterEvents*](#filterevents) - - [*listVendor*](#listvendor) - - [*getVendorById*](#getvendorbyid) - - [*filterVendors*](#filtervendors) - [*listVendorRate*](#listvendorrate) - [*getVendorRateById*](#getvendorratebyid) - [*filterVendorRates*](#filtervendorrates) + - [*listEvents*](#listevents) + - [*getEventById*](#geteventbyid) + - [*filterEvents*](#filterevents) - [*listInvoice*](#listinvoice) - [*getInvoiceById*](#getinvoicebyid) - [*filterInvoices*](#filterinvoices) + - [*listStaff*](#liststaff) + - [*listVendor*](#listvendor) + - [*getVendorById*](#getvendorbyid) + - [*filterVendors*](#filtervendors) - [**Mutations**](#mutations) - - [*CreateVendor*](#createvendor) - - [*UpdateVendor*](#updatevendor) - - [*DeleteVendor*](#deletevendor) + - [*CreateEvent*](#createevent) + - [*UpdateEvent*](#updateevent) + - [*DeleteEvent*](#deleteevent) + - [*CreateVendorRate*](#createvendorrate) + - [*UpdateVendorRate*](#updatevendorrate) + - [*DeleteVendorRate*](#deletevendorrate) - [*CreateInvoice*](#createinvoice) - [*UpdateInvoice*](#updateinvoice) - [*DeleteInvoice*](#deleteinvoice) - [*CreateStaff*](#createstaff) + - [*CreateVendor*](#createvendor) + - [*UpdateVendor*](#updatevendor) + - [*DeleteVendor*](#deletevendor) - [*CreateVendorDefaultSetting*](#createvendordefaultsetting) - [*UpdateVendorDefaultSetting*](#updatevendordefaultsetting) - [*DeleteVendorDefaultSetting*](#deletevendordefaultsetting) - - [*CreateVendorRate*](#createvendorrate) - - [*UpdateVendorRate*](#updatevendorrate) - - [*DeleteVendorRate*](#deletevendorrate) - - [*CreateEvent*](#createevent) - - [*UpdateEvent*](#updateevent) - - [*DeleteEvent*](#deleteevent) + - [*CreateBusiness*](#createbusiness) + - [*UpdateBusiness*](#updatebusiness) + - [*DeleteBusiness*](#deletebusiness) # Accessing the connector A connector is a collection of Queries and Mutations. One SDK is generated for each connector - this SDK is generated for the connector `krow-connector`. You can find more information about connectors in the [Data Connect documentation](https://firebase.google.com/docs/data-connect#how-does). @@ -89,105 +95,352 @@ The following is true for both the action shortcut function and the `QueryRef` f Below are examples of how to use the `krow-connector` connector's generated functions to execute each query. You can also follow the examples from the [Data Connect documentation](https://firebase.google.com/docs/data-connect/web-sdk#using-queries). -## listStaff -You can execute the `listStaff` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +## listBusiness +You can execute the `listBusiness` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): ```typescript -listStaff(): QueryPromise; +listBusiness(): QueryPromise; -interface ListStaffRef { +interface ListBusinessRef { ... /* Allow users to create refs without passing in DataConnect */ - (): QueryRef; + (): QueryRef; } -export const listStaffRef: ListStaffRef; +export const listBusinessRef: ListBusinessRef; ``` You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. ```typescript -listStaff(dc: DataConnect): QueryPromise; +listBusiness(dc: DataConnect): QueryPromise; -interface ListStaffRef { +interface ListBusinessRef { ... - (dc: DataConnect): QueryRef; + (dc: DataConnect): QueryRef; } -export const listStaffRef: ListStaffRef; +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 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 listBusinessRef: ```typescript -const name = listStaffRef.operationName; +const name = listBusinessRef.operationName; console.log(name); ``` ### Variables -The `listStaff` query has no variables. +The `listBusiness` query has no variables. ### Return Type -Recall that executing the `listStaff` query returns a `QueryPromise` that resolves to an object with a `data` property. +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 `ListStaffData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +The `data` property is an object of type `ListBusinessData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: ```typescript -export interface ListStaffData { - staffs: ({ +export interface ListBusinessData { + businesses: ({ id: UUIDString; - employeeName: string; - vendorId?: UUIDString | null; + businessName: string; + contactName: string; email?: string | null; - position?: string | null; - employmentType: EmploymentType; - rating?: number | null; - reliabilityScore?: number | null; - backgroundCheckStatus: BackgroundCheckStatus; - certifications?: string | null; - } & Staff_Key)[]; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key)[]; } ``` -### Using `listStaff`'s action shortcut function +### Using `listBusiness`'s action shortcut function ```typescript import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, listStaff } from '@dataconnect/generated'; +import { connectorConfig, listBusiness } from '@dataconnect/generated'; -// Call the `listStaff()` function to execute the query. +// Call the `listBusiness()` function to execute the query. // You can use the `await` keyword to wait for the promise to resolve. -const { data } = await listStaff(); +const { data } = await listBusiness(); // You can also pass in a `DataConnect` instance to the action shortcut function. const dataConnect = getDataConnect(connectorConfig); -const { data } = await listStaff(dataConnect); +const { data } = await listBusiness(dataConnect); -console.log(data.staffs); +console.log(data.businesses); // Or, you can use the `Promise` API. -listStaff().then((response) => { +listBusiness().then((response) => { const data = response.data; - console.log(data.staffs); + console.log(data.businesses); }); ``` -### Using `listStaff`'s `QueryRef` function +### Using `listBusiness`'s `QueryRef` function ```typescript import { getDataConnect, executeQuery } from 'firebase/data-connect'; -import { connectorConfig, listStaffRef } from '@dataconnect/generated'; +import { connectorConfig, listBusinessRef } from '@dataconnect/generated'; -// Call the `listStaffRef()` function to get a reference to the query. -const ref = listStaffRef(); +// 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 = listStaffRef(dataConnect); +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.staffs); +console.log(data.businesses); // Or, you can use the `Promise` API. executeQuery(ref).then((response) => { const data = response.data; - console.log(data.staffs); + console.log(data.businesses); +}); +``` + +## getBusinessById +You can execute the `getBusinessById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +getBusinessById(vars: GetBusinessByIdVariables): QueryPromise; + +interface GetBusinessByIdRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: GetBusinessByIdVariables): QueryRef; +} +export const getBusinessByIdRef: GetBusinessByIdRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +getBusinessById(dc: DataConnect, vars: GetBusinessByIdVariables): QueryPromise; + +interface GetBusinessByIdRef { + ... + (dc: DataConnect, vars: GetBusinessByIdVariables): QueryRef; +} +export const getBusinessByIdRef: GetBusinessByIdRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getBusinessByIdRef: +```typescript +const name = getBusinessByIdRef.operationName; +console.log(name); +``` + +### Variables +The `getBusinessById` query requires an argument of type `GetBusinessByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface GetBusinessByIdVariables { + id: UUIDString; +} +``` +### Return Type +Recall that executing the `getBusinessById` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `GetBusinessByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface GetBusinessByIdData { + business?: { + id: UUIDString; + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key; +} +``` +### Using `getBusinessById`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, getBusinessById, GetBusinessByIdVariables } from '@dataconnect/generated'; + +// The `getBusinessById` query requires an argument of type `GetBusinessByIdVariables`: +const getBusinessByIdVars: GetBusinessByIdVariables = { + id: ..., +}; + +// Call the `getBusinessById()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await getBusinessById(getBusinessByIdVars); +// Variables can be defined inline as well. +const { data } = await getBusinessById({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await getBusinessById(dataConnect, getBusinessByIdVars); + +console.log(data.business); + +// Or, you can use the `Promise` API. +getBusinessById(getBusinessByIdVars).then((response) => { + const data = response.data; + console.log(data.business); +}); +``` + +### Using `getBusinessById`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, getBusinessByIdRef, GetBusinessByIdVariables } from '@dataconnect/generated'; + +// The `getBusinessById` query requires an argument of type `GetBusinessByIdVariables`: +const getBusinessByIdVars: GetBusinessByIdVariables = { + id: ..., +}; + +// Call the `getBusinessByIdRef()` function to get a reference to the query. +const ref = getBusinessByIdRef(getBusinessByIdVars); +// Variables can be defined inline as well. +const ref = getBusinessByIdRef({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = getBusinessByIdRef(dataConnect, getBusinessByIdVars); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.business); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.business); +}); +``` + +## filterBusiness +You can execute the `filterBusiness` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +filterBusiness(vars?: FilterBusinessVariables): QueryPromise; + +interface FilterBusinessRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars?: FilterBusinessVariables): QueryRef; +} +export const filterBusinessRef: FilterBusinessRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +filterBusiness(dc: DataConnect, vars?: FilterBusinessVariables): QueryPromise; + +interface FilterBusinessRef { + ... + (dc: DataConnect, vars?: FilterBusinessVariables): QueryRef; +} +export const filterBusinessRef: FilterBusinessRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterBusinessRef: +```typescript +const name = filterBusinessRef.operationName; +console.log(name); +``` + +### Variables +The `filterBusiness` query has an optional argument of type `FilterBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface FilterBusinessVariables { + businessName?: string | null; + contactName?: string | null; + sector?: BusinessSector | null; + rateGroup?: BusinessRateGroup | null; + status?: BusinessStatus | null; +} +``` +### Return Type +Recall that executing the `filterBusiness` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `FilterBusinessData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface FilterBusinessData { + businesses: ({ + id: UUIDString; + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key)[]; +} +``` +### Using `filterBusiness`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, filterBusiness, FilterBusinessVariables } from '@dataconnect/generated'; + +// The `filterBusiness` query has an optional argument of type `FilterBusinessVariables`: +const filterBusinessVars: FilterBusinessVariables = { + businessName: ..., // optional + contactName: ..., // optional + sector: ..., // optional + rateGroup: ..., // optional + status: ..., // optional +}; + +// Call the `filterBusiness()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await filterBusiness(filterBusinessVars); +// Variables can be defined inline as well. +const { data } = await filterBusiness({ businessName: ..., contactName: ..., sector: ..., rateGroup: ..., status: ..., }); +// Since all variables are optional for this query, you can omit the `FilterBusinessVariables` argument. +const { data } = await filterBusiness(); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await filterBusiness(dataConnect, filterBusinessVars); + +console.log(data.businesses); + +// Or, you can use the `Promise` API. +filterBusiness(filterBusinessVars).then((response) => { + const data = response.data; + console.log(data.businesses); +}); +``` + +### Using `filterBusiness`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, filterBusinessRef, FilterBusinessVariables } from '@dataconnect/generated'; + +// The `filterBusiness` query has an optional argument of type `FilterBusinessVariables`: +const filterBusinessVars: FilterBusinessVariables = { + businessName: ..., // optional + contactName: ..., // optional + sector: ..., // optional + rateGroup: ..., // optional + status: ..., // optional +}; + +// Call the `filterBusinessRef()` function to get a reference to the query. +const ref = filterBusinessRef(filterBusinessVars); +// Variables can be defined inline as well. +const ref = filterBusinessRef({ businessName: ..., contactName: ..., sector: ..., rateGroup: ..., status: ..., }); +// Since all variables are optional for this query, you can omit the `FilterBusinessVariables` argument. +const ref = filterBusinessRef(); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = filterBusinessRef(dataConnect, filterBusinessVars); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.businesses); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.businesses); }); ``` @@ -525,6 +778,361 @@ executeQuery(ref).then((response) => { }); ``` +## listVendorRate +You can execute the `listVendorRate` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +listVendorRate(): QueryPromise; + +interface ListVendorRateRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (): QueryRef; +} +export const listVendorRateRef: ListVendorRateRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +listVendorRate(dc: DataConnect): QueryPromise; + +interface ListVendorRateRef { + ... + (dc: DataConnect): QueryRef; +} +export const listVendorRateRef: ListVendorRateRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listVendorRateRef: +```typescript +const name = listVendorRateRef.operationName; +console.log(name); +``` + +### Variables +The `listVendorRate` query has no variables. +### Return Type +Recall that executing the `listVendorRate` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `ListVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface ListVendorRateData { + vendorRates: ({ + id: UUIDString; + vendorName: string; + category: VendorRateCategory; + roleName: string; + employeeWage: number; + markupPercentage?: number | null; + vendorFeePercentage?: number | null; + clientRate: number; + } & VendorRate_Key)[]; +} +``` +### Using `listVendorRate`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, listVendorRate } from '@dataconnect/generated'; + + +// Call the `listVendorRate()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await listVendorRate(); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await listVendorRate(dataConnect); + +console.log(data.vendorRates); + +// Or, you can use the `Promise` API. +listVendorRate().then((response) => { + const data = response.data; + console.log(data.vendorRates); +}); +``` + +### Using `listVendorRate`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, listVendorRateRef } from '@dataconnect/generated'; + + +// Call the `listVendorRateRef()` function to get a reference to the query. +const ref = listVendorRateRef(); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = listVendorRateRef(dataConnect); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.vendorRates); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.vendorRates); +}); +``` + +## getVendorRateById +You can execute the `getVendorRateById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +getVendorRateById(vars: GetVendorRateByIdVariables): QueryPromise; + +interface GetVendorRateByIdRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: GetVendorRateByIdVariables): QueryRef; +} +export const getVendorRateByIdRef: GetVendorRateByIdRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +getVendorRateById(dc: DataConnect, vars: GetVendorRateByIdVariables): QueryPromise; + +interface GetVendorRateByIdRef { + ... + (dc: DataConnect, vars: GetVendorRateByIdVariables): QueryRef; +} +export const getVendorRateByIdRef: GetVendorRateByIdRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getVendorRateByIdRef: +```typescript +const name = getVendorRateByIdRef.operationName; +console.log(name); +``` + +### Variables +The `getVendorRateById` query requires an argument of type `GetVendorRateByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface GetVendorRateByIdVariables { + id: UUIDString; +} +``` +### Return Type +Recall that executing the `getVendorRateById` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `GetVendorRateByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface GetVendorRateByIdData { + vendorRate?: { + id: UUIDString; + vendorName: string; + category: VendorRateCategory; + roleName: string; + employeeWage: number; + markupPercentage?: number | null; + vendorFeePercentage?: number | null; + clientRate: number; + createdDate?: TimestampString | null; + updatedDate?: TimestampString | null; + createdBy?: string | null; + } & VendorRate_Key; +} +``` +### Using `getVendorRateById`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, getVendorRateById, GetVendorRateByIdVariables } from '@dataconnect/generated'; + +// The `getVendorRateById` query requires an argument of type `GetVendorRateByIdVariables`: +const getVendorRateByIdVars: GetVendorRateByIdVariables = { + id: ..., +}; + +// Call the `getVendorRateById()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await getVendorRateById(getVendorRateByIdVars); +// Variables can be defined inline as well. +const { data } = await getVendorRateById({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await getVendorRateById(dataConnect, getVendorRateByIdVars); + +console.log(data.vendorRate); + +// Or, you can use the `Promise` API. +getVendorRateById(getVendorRateByIdVars).then((response) => { + const data = response.data; + console.log(data.vendorRate); +}); +``` + +### Using `getVendorRateById`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, getVendorRateByIdRef, GetVendorRateByIdVariables } from '@dataconnect/generated'; + +// The `getVendorRateById` query requires an argument of type `GetVendorRateByIdVariables`: +const getVendorRateByIdVars: GetVendorRateByIdVariables = { + id: ..., +}; + +// Call the `getVendorRateByIdRef()` function to get a reference to the query. +const ref = getVendorRateByIdRef(getVendorRateByIdVars); +// Variables can be defined inline as well. +const ref = getVendorRateByIdRef({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = getVendorRateByIdRef(dataConnect, getVendorRateByIdVars); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.vendorRate); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.vendorRate); +}); +``` + +## filterVendorRates +You can execute the `filterVendorRates` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +filterVendorRates(vars?: FilterVendorRatesVariables): QueryPromise; + +interface FilterVendorRatesRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars?: FilterVendorRatesVariables): QueryRef; +} +export const filterVendorRatesRef: FilterVendorRatesRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +filterVendorRates(dc: DataConnect, vars?: FilterVendorRatesVariables): QueryPromise; + +interface FilterVendorRatesRef { + ... + (dc: DataConnect, vars?: FilterVendorRatesVariables): QueryRef; +} +export const filterVendorRatesRef: FilterVendorRatesRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterVendorRatesRef: +```typescript +const name = filterVendorRatesRef.operationName; +console.log(name); +``` + +### Variables +The `filterVendorRates` query has an optional argument of type `FilterVendorRatesVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface FilterVendorRatesVariables { + vendorName?: string | null; + category?: VendorRateCategory | null; + roleName?: string | null; + minClientRate?: number | null; + maxClientRate?: number | null; +} +``` +### Return Type +Recall that executing the `filterVendorRates` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `FilterVendorRatesData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface FilterVendorRatesData { + vendorRates: ({ + id: UUIDString; + vendorName: string; + category: VendorRateCategory; + roleName: string; + employeeWage: number; + markupPercentage?: number | null; + vendorFeePercentage?: number | null; + clientRate: number; + } & VendorRate_Key)[]; +} +``` +### Using `filterVendorRates`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, filterVendorRates, FilterVendorRatesVariables } from '@dataconnect/generated'; + +// The `filterVendorRates` query has an optional argument of type `FilterVendorRatesVariables`: +const filterVendorRatesVars: FilterVendorRatesVariables = { + vendorName: ..., // optional + category: ..., // optional + roleName: ..., // optional + minClientRate: ..., // optional + maxClientRate: ..., // optional +}; + +// Call the `filterVendorRates()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await filterVendorRates(filterVendorRatesVars); +// Variables can be defined inline as well. +const { data } = await filterVendorRates({ vendorName: ..., category: ..., roleName: ..., minClientRate: ..., maxClientRate: ..., }); +// Since all variables are optional for this query, you can omit the `FilterVendorRatesVariables` argument. +const { data } = await filterVendorRates(); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await filterVendorRates(dataConnect, filterVendorRatesVars); + +console.log(data.vendorRates); + +// Or, you can use the `Promise` API. +filterVendorRates(filterVendorRatesVars).then((response) => { + const data = response.data; + console.log(data.vendorRates); +}); +``` + +### Using `filterVendorRates`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, filterVendorRatesRef, FilterVendorRatesVariables } from '@dataconnect/generated'; + +// The `filterVendorRates` query has an optional argument of type `FilterVendorRatesVariables`: +const filterVendorRatesVars: FilterVendorRatesVariables = { + vendorName: ..., // optional + category: ..., // optional + roleName: ..., // optional + minClientRate: ..., // optional + maxClientRate: ..., // optional +}; + +// Call the `filterVendorRatesRef()` function to get a reference to the query. +const ref = filterVendorRatesRef(filterVendorRatesVars); +// Variables can be defined inline as well. +const ref = filterVendorRatesRef({ vendorName: ..., category: ..., roleName: ..., minClientRate: ..., maxClientRate: ..., }); +// Since all variables are optional for this query, you can omit the `FilterVendorRatesVariables` argument. +const ref = filterVendorRatesRef(); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = filterVendorRatesRef(dataConnect, filterVendorRatesVars); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.vendorRates); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.vendorRates); +}); +``` + ## listEvents You can execute the `listEvents` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): ```typescript @@ -979,6 +1587,455 @@ executeQuery(ref).then((response) => { }); ``` +## listInvoice +You can execute the `listInvoice` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +listInvoice(): QueryPromise; + +interface ListInvoiceRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (): QueryRef; +} +export const listInvoiceRef: ListInvoiceRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +listInvoice(dc: DataConnect): QueryPromise; + +interface ListInvoiceRef { + ... + (dc: DataConnect): QueryRef; +} +export const listInvoiceRef: ListInvoiceRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listInvoiceRef: +```typescript +const name = listInvoiceRef.operationName; +console.log(name); +``` + +### Variables +The `listInvoice` query has no variables. +### Return Type +Recall that executing the `listInvoice` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `ListInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface ListInvoiceData { + invoices: ({ + id: UUIDString; + invoiceNumber: string; + amount: number; + status: InvoiceStatus; + issueDate: TimestampString; + dueDate: TimestampString; + isAutoGenerated?: boolean | null; + } & Invoice_Key)[]; +} +``` +### Using `listInvoice`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, listInvoice } from '@dataconnect/generated'; + + +// Call the `listInvoice()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await listInvoice(); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await listInvoice(dataConnect); + +console.log(data.invoices); + +// Or, you can use the `Promise` API. +listInvoice().then((response) => { + const data = response.data; + console.log(data.invoices); +}); +``` + +### Using `listInvoice`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, listInvoiceRef } from '@dataconnect/generated'; + + +// Call the `listInvoiceRef()` function to get a reference to the query. +const ref = listInvoiceRef(); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = listInvoiceRef(dataConnect); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.invoices); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.invoices); +}); +``` + +## getInvoiceById +You can execute the `getInvoiceById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +getInvoiceById(vars: GetInvoiceByIdVariables): QueryPromise; + +interface GetInvoiceByIdRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: GetInvoiceByIdVariables): QueryRef; +} +export const getInvoiceByIdRef: GetInvoiceByIdRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +getInvoiceById(dc: DataConnect, vars: GetInvoiceByIdVariables): QueryPromise; + +interface GetInvoiceByIdRef { + ... + (dc: DataConnect, vars: GetInvoiceByIdVariables): QueryRef; +} +export const getInvoiceByIdRef: GetInvoiceByIdRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getInvoiceByIdRef: +```typescript +const name = getInvoiceByIdRef.operationName; +console.log(name); +``` + +### Variables +The `getInvoiceById` query requires an argument of type `GetInvoiceByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface GetInvoiceByIdVariables { + id: UUIDString; +} +``` +### Return Type +Recall that executing the `getInvoiceById` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `GetInvoiceByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface GetInvoiceByIdData { + invoice?: { + id: UUIDString; + invoiceNumber: string; + amount: number; + status: InvoiceStatus; + issueDate: TimestampString; + dueDate: TimestampString; + disputedItems?: string | null; + isAutoGenerated?: boolean | null; + } & Invoice_Key; +} +``` +### Using `getInvoiceById`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, getInvoiceById, GetInvoiceByIdVariables } from '@dataconnect/generated'; + +// The `getInvoiceById` query requires an argument of type `GetInvoiceByIdVariables`: +const getInvoiceByIdVars: GetInvoiceByIdVariables = { + id: ..., +}; + +// Call the `getInvoiceById()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await getInvoiceById(getInvoiceByIdVars); +// Variables can be defined inline as well. +const { data } = await getInvoiceById({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await getInvoiceById(dataConnect, getInvoiceByIdVars); + +console.log(data.invoice); + +// Or, you can use the `Promise` API. +getInvoiceById(getInvoiceByIdVars).then((response) => { + const data = response.data; + console.log(data.invoice); +}); +``` + +### Using `getInvoiceById`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, getInvoiceByIdRef, GetInvoiceByIdVariables } from '@dataconnect/generated'; + +// The `getInvoiceById` query requires an argument of type `GetInvoiceByIdVariables`: +const getInvoiceByIdVars: GetInvoiceByIdVariables = { + id: ..., +}; + +// Call the `getInvoiceByIdRef()` function to get a reference to the query. +const ref = getInvoiceByIdRef(getInvoiceByIdVars); +// Variables can be defined inline as well. +const ref = getInvoiceByIdRef({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = getInvoiceByIdRef(dataConnect, getInvoiceByIdVars); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.invoice); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.invoice); +}); +``` + +## filterInvoices +You can execute the `filterInvoices` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +filterInvoices(vars?: FilterInvoicesVariables): QueryPromise; + +interface FilterInvoicesRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars?: FilterInvoicesVariables): QueryRef; +} +export const filterInvoicesRef: FilterInvoicesRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +filterInvoices(dc: DataConnect, vars?: FilterInvoicesVariables): QueryPromise; + +interface FilterInvoicesRef { + ... + (dc: DataConnect, vars?: FilterInvoicesVariables): QueryRef; +} +export const filterInvoicesRef: FilterInvoicesRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterInvoicesRef: +```typescript +const name = filterInvoicesRef.operationName; +console.log(name); +``` + +### Variables +The `filterInvoices` query has an optional argument of type `FilterInvoicesVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface FilterInvoicesVariables { + invoiceNumber?: string | null; + status?: InvoiceStatus | null; + isAutoGenerated?: boolean | null; + amount?: number | null; +} +``` +### Return Type +Recall that executing the `filterInvoices` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `FilterInvoicesData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface FilterInvoicesData { + invoices: ({ + id: UUIDString; + invoiceNumber: string; + amount: number; + status: InvoiceStatus; + issueDate: TimestampString; + dueDate: TimestampString; + isAutoGenerated?: boolean | null; + } & Invoice_Key)[]; +} +``` +### Using `filterInvoices`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, filterInvoices, FilterInvoicesVariables } from '@dataconnect/generated'; + +// The `filterInvoices` query has an optional argument of type `FilterInvoicesVariables`: +const filterInvoicesVars: FilterInvoicesVariables = { + invoiceNumber: ..., // optional + status: ..., // optional + isAutoGenerated: ..., // optional + amount: ..., // optional +}; + +// Call the `filterInvoices()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await filterInvoices(filterInvoicesVars); +// Variables can be defined inline as well. +const { data } = await filterInvoices({ invoiceNumber: ..., status: ..., isAutoGenerated: ..., amount: ..., }); +// Since all variables are optional for this query, you can omit the `FilterInvoicesVariables` argument. +const { data } = await filterInvoices(); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await filterInvoices(dataConnect, filterInvoicesVars); + +console.log(data.invoices); + +// Or, you can use the `Promise` API. +filterInvoices(filterInvoicesVars).then((response) => { + const data = response.data; + console.log(data.invoices); +}); +``` + +### Using `filterInvoices`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, filterInvoicesRef, FilterInvoicesVariables } from '@dataconnect/generated'; + +// The `filterInvoices` query has an optional argument of type `FilterInvoicesVariables`: +const filterInvoicesVars: FilterInvoicesVariables = { + invoiceNumber: ..., // optional + status: ..., // optional + isAutoGenerated: ..., // optional + amount: ..., // optional +}; + +// Call the `filterInvoicesRef()` function to get a reference to the query. +const ref = filterInvoicesRef(filterInvoicesVars); +// Variables can be defined inline as well. +const ref = filterInvoicesRef({ invoiceNumber: ..., status: ..., isAutoGenerated: ..., amount: ..., }); +// Since all variables are optional for this query, you can omit the `FilterInvoicesVariables` argument. +const ref = filterInvoicesRef(); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = filterInvoicesRef(dataConnect, filterInvoicesVars); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.invoices); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.invoices); +}); +``` + +## listStaff +You can execute the `listStaff` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +listStaff(): QueryPromise; + +interface ListStaffRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (): QueryRef; +} +export const listStaffRef: ListStaffRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +listStaff(dc: DataConnect): QueryPromise; + +interface ListStaffRef { + ... + (dc: DataConnect): QueryRef; +} +export const listStaffRef: ListStaffRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listStaffRef: +```typescript +const name = listStaffRef.operationName; +console.log(name); +``` + +### Variables +The `listStaff` query has no variables. +### Return Type +Recall that executing the `listStaff` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `ListStaffData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface ListStaffData { + staffs: ({ + id: UUIDString; + employeeName: string; + vendorId?: UUIDString | null; + email?: string | null; + position?: string | null; + employmentType: EmploymentType; + rating?: number | null; + reliabilityScore?: number | null; + backgroundCheckStatus: BackgroundCheckStatus; + certifications?: string | null; + } & Staff_Key)[]; +} +``` +### Using `listStaff`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, listStaff } from '@dataconnect/generated'; + + +// Call the `listStaff()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await listStaff(); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await listStaff(dataConnect); + +console.log(data.staffs); + +// Or, you can use the `Promise` API. +listStaff().then((response) => { + const data = response.data; + console.log(data.staffs); +}); +``` + +### Using `listStaff`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, listStaffRef } from '@dataconnect/generated'; + + +// Call the `listStaffRef()` function to get a reference to the query. +const ref = listStaffRef(); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = listStaffRef(dataConnect); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.staffs); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.staffs); +}); +``` + ## listVendor You can execute the `listVendor` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): ```typescript @@ -1337,708 +2394,6 @@ executeQuery(ref).then((response) => { }); ``` -## listVendorRate -You can execute the `listVendorRate` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -listVendorRate(): QueryPromise; - -interface ListVendorRateRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (): QueryRef; -} -export const listVendorRateRef: ListVendorRateRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. -```typescript -listVendorRate(dc: DataConnect): QueryPromise; - -interface ListVendorRateRef { - ... - (dc: DataConnect): QueryRef; -} -export const listVendorRateRef: ListVendorRateRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listVendorRateRef: -```typescript -const name = listVendorRateRef.operationName; -console.log(name); -``` - -### Variables -The `listVendorRate` query has no variables. -### Return Type -Recall that executing the `listVendorRate` query returns a `QueryPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `ListVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface ListVendorRateData { - vendorRates: ({ - id: UUIDString; - vendorName: string; - category: VendorRateCategory; - roleName: string; - employeeWage: number; - markupPercentage?: number | null; - vendorFeePercentage?: number | null; - clientRate: number; - } & VendorRate_Key)[]; -} -``` -### Using `listVendorRate`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, listVendorRate } from '@dataconnect/generated'; - - -// Call the `listVendorRate()` function to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await listVendorRate(); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await listVendorRate(dataConnect); - -console.log(data.vendorRates); - -// Or, you can use the `Promise` API. -listVendorRate().then((response) => { - const data = response.data; - console.log(data.vendorRates); -}); -``` - -### Using `listVendorRate`'s `QueryRef` function - -```typescript -import { getDataConnect, executeQuery } from 'firebase/data-connect'; -import { connectorConfig, listVendorRateRef } from '@dataconnect/generated'; - - -// Call the `listVendorRateRef()` function to get a reference to the query. -const ref = listVendorRateRef(); - -// You can also pass in a `DataConnect` instance to the `QueryRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = listVendorRateRef(dataConnect); - -// Call `executeQuery()` on the reference to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeQuery(ref); - -console.log(data.vendorRates); - -// Or, you can use the `Promise` API. -executeQuery(ref).then((response) => { - const data = response.data; - console.log(data.vendorRates); -}); -``` - -## getVendorRateById -You can execute the `getVendorRateById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -getVendorRateById(vars: GetVendorRateByIdVariables): QueryPromise; - -interface GetVendorRateByIdRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: GetVendorRateByIdVariables): QueryRef; -} -export const getVendorRateByIdRef: GetVendorRateByIdRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. -```typescript -getVendorRateById(dc: DataConnect, vars: GetVendorRateByIdVariables): QueryPromise; - -interface GetVendorRateByIdRef { - ... - (dc: DataConnect, vars: GetVendorRateByIdVariables): QueryRef; -} -export const getVendorRateByIdRef: GetVendorRateByIdRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getVendorRateByIdRef: -```typescript -const name = getVendorRateByIdRef.operationName; -console.log(name); -``` - -### Variables -The `getVendorRateById` query requires an argument of type `GetVendorRateByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface GetVendorRateByIdVariables { - id: UUIDString; -} -``` -### Return Type -Recall that executing the `getVendorRateById` query returns a `QueryPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `GetVendorRateByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface GetVendorRateByIdData { - vendorRate?: { - id: UUIDString; - vendorName: string; - category: VendorRateCategory; - roleName: string; - employeeWage: number; - markupPercentage?: number | null; - vendorFeePercentage?: number | null; - clientRate: number; - createdDate?: TimestampString | null; - updatedDate?: TimestampString | null; - createdBy?: string | null; - } & VendorRate_Key; -} -``` -### Using `getVendorRateById`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, getVendorRateById, GetVendorRateByIdVariables } from '@dataconnect/generated'; - -// The `getVendorRateById` query requires an argument of type `GetVendorRateByIdVariables`: -const getVendorRateByIdVars: GetVendorRateByIdVariables = { - id: ..., -}; - -// Call the `getVendorRateById()` function to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await getVendorRateById(getVendorRateByIdVars); -// Variables can be defined inline as well. -const { data } = await getVendorRateById({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await getVendorRateById(dataConnect, getVendorRateByIdVars); - -console.log(data.vendorRate); - -// Or, you can use the `Promise` API. -getVendorRateById(getVendorRateByIdVars).then((response) => { - const data = response.data; - console.log(data.vendorRate); -}); -``` - -### Using `getVendorRateById`'s `QueryRef` function - -```typescript -import { getDataConnect, executeQuery } from 'firebase/data-connect'; -import { connectorConfig, getVendorRateByIdRef, GetVendorRateByIdVariables } from '@dataconnect/generated'; - -// The `getVendorRateById` query requires an argument of type `GetVendorRateByIdVariables`: -const getVendorRateByIdVars: GetVendorRateByIdVariables = { - id: ..., -}; - -// Call the `getVendorRateByIdRef()` function to get a reference to the query. -const ref = getVendorRateByIdRef(getVendorRateByIdVars); -// Variables can be defined inline as well. -const ref = getVendorRateByIdRef({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the `QueryRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = getVendorRateByIdRef(dataConnect, getVendorRateByIdVars); - -// Call `executeQuery()` on the reference to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeQuery(ref); - -console.log(data.vendorRate); - -// Or, you can use the `Promise` API. -executeQuery(ref).then((response) => { - const data = response.data; - console.log(data.vendorRate); -}); -``` - -## filterVendorRates -You can execute the `filterVendorRates` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -filterVendorRates(vars?: FilterVendorRatesVariables): QueryPromise; - -interface FilterVendorRatesRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars?: FilterVendorRatesVariables): QueryRef; -} -export const filterVendorRatesRef: FilterVendorRatesRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. -```typescript -filterVendorRates(dc: DataConnect, vars?: FilterVendorRatesVariables): QueryPromise; - -interface FilterVendorRatesRef { - ... - (dc: DataConnect, vars?: FilterVendorRatesVariables): QueryRef; -} -export const filterVendorRatesRef: FilterVendorRatesRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterVendorRatesRef: -```typescript -const name = filterVendorRatesRef.operationName; -console.log(name); -``` - -### Variables -The `filterVendorRates` query has an optional argument of type `FilterVendorRatesVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface FilterVendorRatesVariables { - vendorName?: string | null; - category?: VendorRateCategory | null; - roleName?: string | null; - minClientRate?: number | null; - maxClientRate?: number | null; -} -``` -### Return Type -Recall that executing the `filterVendorRates` query returns a `QueryPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `FilterVendorRatesData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface FilterVendorRatesData { - vendorRates: ({ - id: UUIDString; - vendorName: string; - category: VendorRateCategory; - roleName: string; - employeeWage: number; - markupPercentage?: number | null; - vendorFeePercentage?: number | null; - clientRate: number; - } & VendorRate_Key)[]; -} -``` -### Using `filterVendorRates`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, filterVendorRates, FilterVendorRatesVariables } from '@dataconnect/generated'; - -// The `filterVendorRates` query has an optional argument of type `FilterVendorRatesVariables`: -const filterVendorRatesVars: FilterVendorRatesVariables = { - vendorName: ..., // optional - category: ..., // optional - roleName: ..., // optional - minClientRate: ..., // optional - maxClientRate: ..., // optional -}; - -// Call the `filterVendorRates()` function to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await filterVendorRates(filterVendorRatesVars); -// Variables can be defined inline as well. -const { data } = await filterVendorRates({ vendorName: ..., category: ..., roleName: ..., minClientRate: ..., maxClientRate: ..., }); -// Since all variables are optional for this query, you can omit the `FilterVendorRatesVariables` argument. -const { data } = await filterVendorRates(); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await filterVendorRates(dataConnect, filterVendorRatesVars); - -console.log(data.vendorRates); - -// Or, you can use the `Promise` API. -filterVendorRates(filterVendorRatesVars).then((response) => { - const data = response.data; - console.log(data.vendorRates); -}); -``` - -### Using `filterVendorRates`'s `QueryRef` function - -```typescript -import { getDataConnect, executeQuery } from 'firebase/data-connect'; -import { connectorConfig, filterVendorRatesRef, FilterVendorRatesVariables } from '@dataconnect/generated'; - -// The `filterVendorRates` query has an optional argument of type `FilterVendorRatesVariables`: -const filterVendorRatesVars: FilterVendorRatesVariables = { - vendorName: ..., // optional - category: ..., // optional - roleName: ..., // optional - minClientRate: ..., // optional - maxClientRate: ..., // optional -}; - -// Call the `filterVendorRatesRef()` function to get a reference to the query. -const ref = filterVendorRatesRef(filterVendorRatesVars); -// Variables can be defined inline as well. -const ref = filterVendorRatesRef({ vendorName: ..., category: ..., roleName: ..., minClientRate: ..., maxClientRate: ..., }); -// Since all variables are optional for this query, you can omit the `FilterVendorRatesVariables` argument. -const ref = filterVendorRatesRef(); - -// You can also pass in a `DataConnect` instance to the `QueryRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = filterVendorRatesRef(dataConnect, filterVendorRatesVars); - -// Call `executeQuery()` on the reference to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeQuery(ref); - -console.log(data.vendorRates); - -// Or, you can use the `Promise` API. -executeQuery(ref).then((response) => { - const data = response.data; - console.log(data.vendorRates); -}); -``` - -## listInvoice -You can execute the `listInvoice` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -listInvoice(): QueryPromise; - -interface ListInvoiceRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (): QueryRef; -} -export const listInvoiceRef: ListInvoiceRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. -```typescript -listInvoice(dc: DataConnect): QueryPromise; - -interface ListInvoiceRef { - ... - (dc: DataConnect): QueryRef; -} -export const listInvoiceRef: ListInvoiceRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listInvoiceRef: -```typescript -const name = listInvoiceRef.operationName; -console.log(name); -``` - -### Variables -The `listInvoice` query has no variables. -### Return Type -Recall that executing the `listInvoice` query returns a `QueryPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `ListInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface ListInvoiceData { - invoices: ({ - id: UUIDString; - invoiceNumber: string; - amount: number; - status: InvoiceStatus; - issueDate: TimestampString; - dueDate: TimestampString; - isAutoGenerated?: boolean | null; - } & Invoice_Key)[]; -} -``` -### Using `listInvoice`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, listInvoice } from '@dataconnect/generated'; - - -// Call the `listInvoice()` function to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await listInvoice(); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await listInvoice(dataConnect); - -console.log(data.invoices); - -// Or, you can use the `Promise` API. -listInvoice().then((response) => { - const data = response.data; - console.log(data.invoices); -}); -``` - -### Using `listInvoice`'s `QueryRef` function - -```typescript -import { getDataConnect, executeQuery } from 'firebase/data-connect'; -import { connectorConfig, listInvoiceRef } from '@dataconnect/generated'; - - -// Call the `listInvoiceRef()` function to get a reference to the query. -const ref = listInvoiceRef(); - -// You can also pass in a `DataConnect` instance to the `QueryRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = listInvoiceRef(dataConnect); - -// Call `executeQuery()` on the reference to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeQuery(ref); - -console.log(data.invoices); - -// Or, you can use the `Promise` API. -executeQuery(ref).then((response) => { - const data = response.data; - console.log(data.invoices); -}); -``` - -## getInvoiceById -You can execute the `getInvoiceById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -getInvoiceById(vars: GetInvoiceByIdVariables): QueryPromise; - -interface GetInvoiceByIdRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: GetInvoiceByIdVariables): QueryRef; -} -export const getInvoiceByIdRef: GetInvoiceByIdRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. -```typescript -getInvoiceById(dc: DataConnect, vars: GetInvoiceByIdVariables): QueryPromise; - -interface GetInvoiceByIdRef { - ... - (dc: DataConnect, vars: GetInvoiceByIdVariables): QueryRef; -} -export const getInvoiceByIdRef: GetInvoiceByIdRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getInvoiceByIdRef: -```typescript -const name = getInvoiceByIdRef.operationName; -console.log(name); -``` - -### Variables -The `getInvoiceById` query requires an argument of type `GetInvoiceByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface GetInvoiceByIdVariables { - id: UUIDString; -} -``` -### Return Type -Recall that executing the `getInvoiceById` query returns a `QueryPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `GetInvoiceByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface GetInvoiceByIdData { - invoice?: { - id: UUIDString; - invoiceNumber: string; - amount: number; - status: InvoiceStatus; - issueDate: TimestampString; - dueDate: TimestampString; - disputedItems?: string | null; - isAutoGenerated?: boolean | null; - } & Invoice_Key; -} -``` -### Using `getInvoiceById`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, getInvoiceById, GetInvoiceByIdVariables } from '@dataconnect/generated'; - -// The `getInvoiceById` query requires an argument of type `GetInvoiceByIdVariables`: -const getInvoiceByIdVars: GetInvoiceByIdVariables = { - id: ..., -}; - -// Call the `getInvoiceById()` function to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await getInvoiceById(getInvoiceByIdVars); -// Variables can be defined inline as well. -const { data } = await getInvoiceById({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await getInvoiceById(dataConnect, getInvoiceByIdVars); - -console.log(data.invoice); - -// Or, you can use the `Promise` API. -getInvoiceById(getInvoiceByIdVars).then((response) => { - const data = response.data; - console.log(data.invoice); -}); -``` - -### Using `getInvoiceById`'s `QueryRef` function - -```typescript -import { getDataConnect, executeQuery } from 'firebase/data-connect'; -import { connectorConfig, getInvoiceByIdRef, GetInvoiceByIdVariables } from '@dataconnect/generated'; - -// The `getInvoiceById` query requires an argument of type `GetInvoiceByIdVariables`: -const getInvoiceByIdVars: GetInvoiceByIdVariables = { - id: ..., -}; - -// Call the `getInvoiceByIdRef()` function to get a reference to the query. -const ref = getInvoiceByIdRef(getInvoiceByIdVars); -// Variables can be defined inline as well. -const ref = getInvoiceByIdRef({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the `QueryRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = getInvoiceByIdRef(dataConnect, getInvoiceByIdVars); - -// Call `executeQuery()` on the reference to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeQuery(ref); - -console.log(data.invoice); - -// Or, you can use the `Promise` API. -executeQuery(ref).then((response) => { - const data = response.data; - console.log(data.invoice); -}); -``` - -## filterInvoices -You can execute the `filterInvoices` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -filterInvoices(vars?: FilterInvoicesVariables): QueryPromise; - -interface FilterInvoicesRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars?: FilterInvoicesVariables): QueryRef; -} -export const filterInvoicesRef: FilterInvoicesRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. -```typescript -filterInvoices(dc: DataConnect, vars?: FilterInvoicesVariables): QueryPromise; - -interface FilterInvoicesRef { - ... - (dc: DataConnect, vars?: FilterInvoicesVariables): QueryRef; -} -export const filterInvoicesRef: FilterInvoicesRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterInvoicesRef: -```typescript -const name = filterInvoicesRef.operationName; -console.log(name); -``` - -### Variables -The `filterInvoices` query has an optional argument of type `FilterInvoicesVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface FilterInvoicesVariables { - invoiceNumber?: string | null; - status?: InvoiceStatus | null; - isAutoGenerated?: boolean | null; - amount?: number | null; -} -``` -### Return Type -Recall that executing the `filterInvoices` query returns a `QueryPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `FilterInvoicesData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface FilterInvoicesData { - invoices: ({ - id: UUIDString; - invoiceNumber: string; - amount: number; - status: InvoiceStatus; - issueDate: TimestampString; - dueDate: TimestampString; - isAutoGenerated?: boolean | null; - } & Invoice_Key)[]; -} -``` -### Using `filterInvoices`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, filterInvoices, FilterInvoicesVariables } from '@dataconnect/generated'; - -// The `filterInvoices` query has an optional argument of type `FilterInvoicesVariables`: -const filterInvoicesVars: FilterInvoicesVariables = { - invoiceNumber: ..., // optional - status: ..., // optional - isAutoGenerated: ..., // optional - amount: ..., // optional -}; - -// Call the `filterInvoices()` function to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await filterInvoices(filterInvoicesVars); -// Variables can be defined inline as well. -const { data } = await filterInvoices({ invoiceNumber: ..., status: ..., isAutoGenerated: ..., amount: ..., }); -// Since all variables are optional for this query, you can omit the `FilterInvoicesVariables` argument. -const { data } = await filterInvoices(); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await filterInvoices(dataConnect, filterInvoicesVars); - -console.log(data.invoices); - -// Or, you can use the `Promise` API. -filterInvoices(filterInvoicesVars).then((response) => { - const data = response.data; - console.log(data.invoices); -}); -``` - -### Using `filterInvoices`'s `QueryRef` function - -```typescript -import { getDataConnect, executeQuery } from 'firebase/data-connect'; -import { connectorConfig, filterInvoicesRef, FilterInvoicesVariables } from '@dataconnect/generated'; - -// The `filterInvoices` query has an optional argument of type `FilterInvoicesVariables`: -const filterInvoicesVars: FilterInvoicesVariables = { - invoiceNumber: ..., // optional - status: ..., // optional - isAutoGenerated: ..., // optional - amount: ..., // optional -}; - -// Call the `filterInvoicesRef()` function to get a reference to the query. -const ref = filterInvoicesRef(filterInvoicesVars); -// Variables can be defined inline as well. -const ref = filterInvoicesRef({ invoiceNumber: ..., status: ..., isAutoGenerated: ..., amount: ..., }); -// Since all variables are optional for this query, you can omit the `FilterInvoicesVariables` argument. -const ref = filterInvoicesRef(); - -// You can also pass in a `DataConnect` instance to the `QueryRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = filterInvoicesRef(dataConnect, filterInvoicesVars); - -// Call `executeQuery()` on the reference to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeQuery(ref); - -console.log(data.invoices); - -// Or, you can use the `Promise` API. -executeQuery(ref).then((response) => { - const data = response.data; - console.log(data.invoices); -}); -``` - # Mutations There are two ways to execute a Data Connect Mutation using the generated Web SDK: @@ -2054,1579 +2409,6 @@ The following is true for both the action shortcut function and the `MutationRef Below are examples of how to use the `krow-connector` connector's generated functions to execute each mutation. You can also follow the examples from the [Data Connect documentation](https://firebase.google.com/docs/data-connect/web-sdk#using-mutations). -## CreateVendor -You can execute the `CreateVendor` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -createVendor(vars: CreateVendorVariables): MutationPromise; - -interface CreateVendorRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: CreateVendorVariables): MutationRef; -} -export const createVendorRef: CreateVendorRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -createVendor(dc: DataConnect, vars: CreateVendorVariables): MutationPromise; - -interface CreateVendorRef { - ... - (dc: DataConnect, vars: CreateVendorVariables): MutationRef; -} -export const createVendorRef: CreateVendorRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createVendorRef: -```typescript -const name = createVendorRef.operationName; -console.log(name); -``` - -### Variables -The `CreateVendor` mutation requires an argument of type `CreateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface CreateVendorVariables { - vendorNumber: string; - legalName: string; - region: VendorRegion; - platformType: VendorPlatformType; - primaryContactEmail: string; - approvalStatus: VendorApprovalStatus; - isActive?: boolean | null; -} -``` -### Return Type -Recall that executing the `CreateVendor` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `CreateVendorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface CreateVendorData { - vendor_insert: Vendor_Key; -} -``` -### Using `CreateVendor`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, createVendor, CreateVendorVariables } from '@dataconnect/generated'; - -// The `CreateVendor` mutation requires an argument of type `CreateVendorVariables`: -const createVendorVars: CreateVendorVariables = { - vendorNumber: ..., - legalName: ..., - region: ..., - platformType: ..., - primaryContactEmail: ..., - approvalStatus: ..., - isActive: ..., // optional -}; - -// Call the `createVendor()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await createVendor(createVendorVars); -// Variables can be defined inline as well. -const { data } = await createVendor({ vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await createVendor(dataConnect, createVendorVars); - -console.log(data.vendor_insert); - -// Or, you can use the `Promise` API. -createVendor(createVendorVars).then((response) => { - const data = response.data; - console.log(data.vendor_insert); -}); -``` - -### Using `CreateVendor`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, createVendorRef, CreateVendorVariables } from '@dataconnect/generated'; - -// The `CreateVendor` mutation requires an argument of type `CreateVendorVariables`: -const createVendorVars: CreateVendorVariables = { - vendorNumber: ..., - legalName: ..., - region: ..., - platformType: ..., - primaryContactEmail: ..., - approvalStatus: ..., - isActive: ..., // optional -}; - -// Call the `createVendorRef()` function to get a reference to the mutation. -const ref = createVendorRef(createVendorVars); -// Variables can be defined inline as well. -const ref = createVendorRef({ vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = createVendorRef(dataConnect, createVendorVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendor_insert); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendor_insert); -}); -``` - -## UpdateVendor -You can execute the `UpdateVendor` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -updateVendor(vars: UpdateVendorVariables): MutationPromise; - -interface UpdateVendorRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: UpdateVendorVariables): MutationRef; -} -export const updateVendorRef: UpdateVendorRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -updateVendor(dc: DataConnect, vars: UpdateVendorVariables): MutationPromise; - -interface UpdateVendorRef { - ... - (dc: DataConnect, vars: UpdateVendorVariables): MutationRef; -} -export const updateVendorRef: UpdateVendorRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateVendorRef: -```typescript -const name = updateVendorRef.operationName; -console.log(name); -``` - -### Variables -The `UpdateVendor` mutation requires an argument of type `UpdateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface UpdateVendorVariables { - id: UUIDString; - vendorNumber?: string | null; - legalName?: string | null; - region?: VendorRegion | null; - platformType?: VendorPlatformType | null; - primaryContactEmail?: string | null; - approvalStatus?: VendorApprovalStatus | null; - isActive?: boolean | null; -} -``` -### Return Type -Recall that executing the `UpdateVendor` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `UpdateVendorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface UpdateVendorData { - vendor_update?: Vendor_Key | null; -} -``` -### Using `UpdateVendor`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, updateVendor, UpdateVendorVariables } from '@dataconnect/generated'; - -// The `UpdateVendor` mutation requires an argument of type `UpdateVendorVariables`: -const updateVendorVars: UpdateVendorVariables = { - id: ..., - vendorNumber: ..., // optional - legalName: ..., // optional - region: ..., // optional - platformType: ..., // optional - primaryContactEmail: ..., // optional - approvalStatus: ..., // optional - isActive: ..., // optional -}; - -// Call the `updateVendor()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await updateVendor(updateVendorVars); -// Variables can be defined inline as well. -const { data } = await updateVendor({ id: ..., vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await updateVendor(dataConnect, updateVendorVars); - -console.log(data.vendor_update); - -// Or, you can use the `Promise` API. -updateVendor(updateVendorVars).then((response) => { - const data = response.data; - console.log(data.vendor_update); -}); -``` - -### Using `UpdateVendor`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, updateVendorRef, UpdateVendorVariables } from '@dataconnect/generated'; - -// The `UpdateVendor` mutation requires an argument of type `UpdateVendorVariables`: -const updateVendorVars: UpdateVendorVariables = { - id: ..., - vendorNumber: ..., // optional - legalName: ..., // optional - region: ..., // optional - platformType: ..., // optional - primaryContactEmail: ..., // optional - approvalStatus: ..., // optional - isActive: ..., // optional -}; - -// Call the `updateVendorRef()` function to get a reference to the mutation. -const ref = updateVendorRef(updateVendorVars); -// Variables can be defined inline as well. -const ref = updateVendorRef({ id: ..., vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = updateVendorRef(dataConnect, updateVendorVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendor_update); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendor_update); -}); -``` - -## DeleteVendor -You can execute the `DeleteVendor` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -deleteVendor(vars: DeleteVendorVariables): MutationPromise; - -interface DeleteVendorRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: DeleteVendorVariables): MutationRef; -} -export const deleteVendorRef: DeleteVendorRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -deleteVendor(dc: DataConnect, vars: DeleteVendorVariables): MutationPromise; - -interface DeleteVendorRef { - ... - (dc: DataConnect, vars: DeleteVendorVariables): MutationRef; -} -export const deleteVendorRef: DeleteVendorRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteVendorRef: -```typescript -const name = deleteVendorRef.operationName; -console.log(name); -``` - -### Variables -The `DeleteVendor` mutation requires an argument of type `DeleteVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface DeleteVendorVariables { - id: UUIDString; -} -``` -### Return Type -Recall that executing the `DeleteVendor` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `DeleteVendorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface DeleteVendorData { - vendor_delete?: Vendor_Key | null; -} -``` -### Using `DeleteVendor`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, deleteVendor, DeleteVendorVariables } from '@dataconnect/generated'; - -// The `DeleteVendor` mutation requires an argument of type `DeleteVendorVariables`: -const deleteVendorVars: DeleteVendorVariables = { - id: ..., -}; - -// Call the `deleteVendor()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await deleteVendor(deleteVendorVars); -// Variables can be defined inline as well. -const { data } = await deleteVendor({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await deleteVendor(dataConnect, deleteVendorVars); - -console.log(data.vendor_delete); - -// Or, you can use the `Promise` API. -deleteVendor(deleteVendorVars).then((response) => { - const data = response.data; - console.log(data.vendor_delete); -}); -``` - -### Using `DeleteVendor`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, deleteVendorRef, DeleteVendorVariables } from '@dataconnect/generated'; - -// The `DeleteVendor` mutation requires an argument of type `DeleteVendorVariables`: -const deleteVendorVars: DeleteVendorVariables = { - id: ..., -}; - -// Call the `deleteVendorRef()` function to get a reference to the mutation. -const ref = deleteVendorRef(deleteVendorVars); -// Variables can be defined inline as well. -const ref = deleteVendorRef({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = deleteVendorRef(dataConnect, deleteVendorVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendor_delete); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendor_delete); -}); -``` - -## CreateInvoice -You can execute the `CreateInvoice` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -createInvoice(vars: CreateInvoiceVariables): MutationPromise; - -interface CreateInvoiceRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: CreateInvoiceVariables): MutationRef; -} -export const createInvoiceRef: CreateInvoiceRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -createInvoice(dc: DataConnect, vars: CreateInvoiceVariables): MutationPromise; - -interface CreateInvoiceRef { - ... - (dc: DataConnect, vars: CreateInvoiceVariables): MutationRef; -} -export const createInvoiceRef: CreateInvoiceRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createInvoiceRef: -```typescript -const name = createInvoiceRef.operationName; -console.log(name); -``` - -### Variables -The `CreateInvoice` mutation requires an argument of type `CreateInvoiceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface CreateInvoiceVariables { - invoiceNumber: string; - amount: number; - status: InvoiceStatus; - issueDate: TimestampString; - dueDate: TimestampString; - disputedItems?: string | null; - isAutoGenerated?: boolean | null; -} -``` -### Return Type -Recall that executing the `CreateInvoice` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `CreateInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface CreateInvoiceData { - invoice_insert: Invoice_Key; -} -``` -### Using `CreateInvoice`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, createInvoice, CreateInvoiceVariables } from '@dataconnect/generated'; - -// The `CreateInvoice` mutation requires an argument of type `CreateInvoiceVariables`: -const createInvoiceVars: CreateInvoiceVariables = { - invoiceNumber: ..., - amount: ..., - status: ..., - issueDate: ..., - dueDate: ..., - disputedItems: ..., // optional - isAutoGenerated: ..., // optional -}; - -// Call the `createInvoice()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await createInvoice(createInvoiceVars); -// Variables can be defined inline as well. -const { data } = await createInvoice({ invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await createInvoice(dataConnect, createInvoiceVars); - -console.log(data.invoice_insert); - -// Or, you can use the `Promise` API. -createInvoice(createInvoiceVars).then((response) => { - const data = response.data; - console.log(data.invoice_insert); -}); -``` - -### Using `CreateInvoice`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, createInvoiceRef, CreateInvoiceVariables } from '@dataconnect/generated'; - -// The `CreateInvoice` mutation requires an argument of type `CreateInvoiceVariables`: -const createInvoiceVars: CreateInvoiceVariables = { - invoiceNumber: ..., - amount: ..., - status: ..., - issueDate: ..., - dueDate: ..., - disputedItems: ..., // optional - isAutoGenerated: ..., // optional -}; - -// Call the `createInvoiceRef()` function to get a reference to the mutation. -const ref = createInvoiceRef(createInvoiceVars); -// Variables can be defined inline as well. -const ref = createInvoiceRef({ invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = createInvoiceRef(dataConnect, createInvoiceVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.invoice_insert); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.invoice_insert); -}); -``` - -## UpdateInvoice -You can execute the `UpdateInvoice` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -updateInvoice(vars: UpdateInvoiceVariables): MutationPromise; - -interface UpdateInvoiceRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: UpdateInvoiceVariables): MutationRef; -} -export const updateInvoiceRef: UpdateInvoiceRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -updateInvoice(dc: DataConnect, vars: UpdateInvoiceVariables): MutationPromise; - -interface UpdateInvoiceRef { - ... - (dc: DataConnect, vars: UpdateInvoiceVariables): MutationRef; -} -export const updateInvoiceRef: UpdateInvoiceRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateInvoiceRef: -```typescript -const name = updateInvoiceRef.operationName; -console.log(name); -``` - -### Variables -The `UpdateInvoice` mutation requires an argument of type `UpdateInvoiceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface UpdateInvoiceVariables { - id: UUIDString; - invoiceNumber?: string | null; - amount?: number | null; - status?: InvoiceStatus | null; - issueDate?: TimestampString | null; - dueDate?: TimestampString | null; - disputedItems?: string | null; - isAutoGenerated?: boolean | null; -} -``` -### Return Type -Recall that executing the `UpdateInvoice` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `UpdateInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface UpdateInvoiceData { - invoice_update?: Invoice_Key | null; -} -``` -### Using `UpdateInvoice`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, updateInvoice, UpdateInvoiceVariables } from '@dataconnect/generated'; - -// The `UpdateInvoice` mutation requires an argument of type `UpdateInvoiceVariables`: -const updateInvoiceVars: UpdateInvoiceVariables = { - id: ..., - invoiceNumber: ..., // optional - amount: ..., // optional - status: ..., // optional - issueDate: ..., // optional - dueDate: ..., // optional - disputedItems: ..., // optional - isAutoGenerated: ..., // optional -}; - -// Call the `updateInvoice()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await updateInvoice(updateInvoiceVars); -// Variables can be defined inline as well. -const { data } = await updateInvoice({ id: ..., invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await updateInvoice(dataConnect, updateInvoiceVars); - -console.log(data.invoice_update); - -// Or, you can use the `Promise` API. -updateInvoice(updateInvoiceVars).then((response) => { - const data = response.data; - console.log(data.invoice_update); -}); -``` - -### Using `UpdateInvoice`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, updateInvoiceRef, UpdateInvoiceVariables } from '@dataconnect/generated'; - -// The `UpdateInvoice` mutation requires an argument of type `UpdateInvoiceVariables`: -const updateInvoiceVars: UpdateInvoiceVariables = { - id: ..., - invoiceNumber: ..., // optional - amount: ..., // optional - status: ..., // optional - issueDate: ..., // optional - dueDate: ..., // optional - disputedItems: ..., // optional - isAutoGenerated: ..., // optional -}; - -// Call the `updateInvoiceRef()` function to get a reference to the mutation. -const ref = updateInvoiceRef(updateInvoiceVars); -// Variables can be defined inline as well. -const ref = updateInvoiceRef({ id: ..., invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = updateInvoiceRef(dataConnect, updateInvoiceVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.invoice_update); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.invoice_update); -}); -``` - -## DeleteInvoice -You can execute the `DeleteInvoice` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -deleteInvoice(vars: DeleteInvoiceVariables): MutationPromise; - -interface DeleteInvoiceRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: DeleteInvoiceVariables): MutationRef; -} -export const deleteInvoiceRef: DeleteInvoiceRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -deleteInvoice(dc: DataConnect, vars: DeleteInvoiceVariables): MutationPromise; - -interface DeleteInvoiceRef { - ... - (dc: DataConnect, vars: DeleteInvoiceVariables): MutationRef; -} -export const deleteInvoiceRef: DeleteInvoiceRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteInvoiceRef: -```typescript -const name = deleteInvoiceRef.operationName; -console.log(name); -``` - -### Variables -The `DeleteInvoice` mutation requires an argument of type `DeleteInvoiceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface DeleteInvoiceVariables { - id: UUIDString; -} -``` -### Return Type -Recall that executing the `DeleteInvoice` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `DeleteInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface DeleteInvoiceData { - invoice_delete?: Invoice_Key | null; -} -``` -### Using `DeleteInvoice`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, deleteInvoice, DeleteInvoiceVariables } from '@dataconnect/generated'; - -// The `DeleteInvoice` mutation requires an argument of type `DeleteInvoiceVariables`: -const deleteInvoiceVars: DeleteInvoiceVariables = { - id: ..., -}; - -// Call the `deleteInvoice()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await deleteInvoice(deleteInvoiceVars); -// Variables can be defined inline as well. -const { data } = await deleteInvoice({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await deleteInvoice(dataConnect, deleteInvoiceVars); - -console.log(data.invoice_delete); - -// Or, you can use the `Promise` API. -deleteInvoice(deleteInvoiceVars).then((response) => { - const data = response.data; - console.log(data.invoice_delete); -}); -``` - -### Using `DeleteInvoice`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, deleteInvoiceRef, DeleteInvoiceVariables } from '@dataconnect/generated'; - -// The `DeleteInvoice` mutation requires an argument of type `DeleteInvoiceVariables`: -const deleteInvoiceVars: DeleteInvoiceVariables = { - id: ..., -}; - -// Call the `deleteInvoiceRef()` function to get a reference to the mutation. -const ref = deleteInvoiceRef(deleteInvoiceVars); -// Variables can be defined inline as well. -const ref = deleteInvoiceRef({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = deleteInvoiceRef(dataConnect, deleteInvoiceVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.invoice_delete); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.invoice_delete); -}); -``` - -## CreateStaff -You can execute the `CreateStaff` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -createStaff(vars: CreateStaffVariables): MutationPromise; - -interface CreateStaffRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: CreateStaffVariables): MutationRef; -} -export const createStaffRef: CreateStaffRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -createStaff(dc: DataConnect, vars: CreateStaffVariables): MutationPromise; - -interface CreateStaffRef { - ... - (dc: DataConnect, vars: CreateStaffVariables): MutationRef; -} -export const createStaffRef: CreateStaffRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createStaffRef: -```typescript -const name = createStaffRef.operationName; -console.log(name); -``` - -### Variables -The `CreateStaff` mutation requires an argument of type `CreateStaffVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface CreateStaffVariables { - employeeName: string; - vendorId?: UUIDString | null; - email?: string | null; - position?: string | null; - employmentType: EmploymentType; - rating?: number | null; - reliabilityScore?: number | null; - backgroundCheckStatus: BackgroundCheckStatus; - certifications?: string | null; -} -``` -### Return Type -Recall that executing the `CreateStaff` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `CreateStaffData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface CreateStaffData { - staff_insert: Staff_Key; -} -``` -### Using `CreateStaff`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, createStaff, CreateStaffVariables } from '@dataconnect/generated'; - -// The `CreateStaff` mutation requires an argument of type `CreateStaffVariables`: -const createStaffVars: CreateStaffVariables = { - employeeName: ..., - vendorId: ..., // optional - email: ..., // optional - position: ..., // optional - employmentType: ..., - rating: ..., // optional - reliabilityScore: ..., // optional - backgroundCheckStatus: ..., - certifications: ..., // 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: ..., email: ..., position: ..., employmentType: ..., rating: ..., reliabilityScore: ..., backgroundCheckStatus: ..., certifications: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await createStaff(dataConnect, createStaffVars); - -console.log(data.staff_insert); - -// Or, you can use the `Promise` API. -createStaff(createStaffVars).then((response) => { - const data = response.data; - console.log(data.staff_insert); -}); -``` - -### Using `CreateStaff`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, createStaffRef, CreateStaffVariables } from '@dataconnect/generated'; - -// The `CreateStaff` mutation requires an argument of type `CreateStaffVariables`: -const createStaffVars: CreateStaffVariables = { - employeeName: ..., - vendorId: ..., // optional - email: ..., // optional - position: ..., // optional - employmentType: ..., - rating: ..., // optional - reliabilityScore: ..., // optional - backgroundCheckStatus: ..., - certifications: ..., // 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: ..., email: ..., position: ..., employmentType: ..., rating: ..., reliabilityScore: ..., backgroundCheckStatus: ..., certifications: ..., }); - -// 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); -}); -``` - -## CreateVendorDefaultSetting -You can execute the `CreateVendorDefaultSetting` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -createVendorDefaultSetting(vars: CreateVendorDefaultSettingVariables): MutationPromise; - -interface CreateVendorDefaultSettingRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: CreateVendorDefaultSettingVariables): MutationRef; -} -export const createVendorDefaultSettingRef: CreateVendorDefaultSettingRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -createVendorDefaultSetting(dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationPromise; - -interface CreateVendorDefaultSettingRef { - ... - (dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationRef; -} -export const createVendorDefaultSettingRef: CreateVendorDefaultSettingRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createVendorDefaultSettingRef: -```typescript -const name = createVendorDefaultSettingRef.operationName; -console.log(name); -``` - -### Variables -The `CreateVendorDefaultSetting` mutation requires an argument of type `CreateVendorDefaultSettingVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface CreateVendorDefaultSettingVariables { - vendorName: string; - defaultMarkupPercentage: number; - defaultVendorFeePercentage: number; -} -``` -### Return Type -Recall that executing the `CreateVendorDefaultSetting` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `CreateVendorDefaultSettingData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface CreateVendorDefaultSettingData { - vendorDefaultSetting_insert: VendorDefaultSetting_Key; -} -``` -### Using `CreateVendorDefaultSetting`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, createVendorDefaultSetting, CreateVendorDefaultSettingVariables } from '@dataconnect/generated'; - -// The `CreateVendorDefaultSetting` mutation requires an argument of type `CreateVendorDefaultSettingVariables`: -const createVendorDefaultSettingVars: CreateVendorDefaultSettingVariables = { - vendorName: ..., - defaultMarkupPercentage: ..., - defaultVendorFeePercentage: ..., -}; - -// Call the `createVendorDefaultSetting()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await createVendorDefaultSetting(createVendorDefaultSettingVars); -// Variables can be defined inline as well. -const { data } = await createVendorDefaultSetting({ vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await createVendorDefaultSetting(dataConnect, createVendorDefaultSettingVars); - -console.log(data.vendorDefaultSetting_insert); - -// Or, you can use the `Promise` API. -createVendorDefaultSetting(createVendorDefaultSettingVars).then((response) => { - const data = response.data; - console.log(data.vendorDefaultSetting_insert); -}); -``` - -### Using `CreateVendorDefaultSetting`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, createVendorDefaultSettingRef, CreateVendorDefaultSettingVariables } from '@dataconnect/generated'; - -// The `CreateVendorDefaultSetting` mutation requires an argument of type `CreateVendorDefaultSettingVariables`: -const createVendorDefaultSettingVars: CreateVendorDefaultSettingVariables = { - vendorName: ..., - defaultMarkupPercentage: ..., - defaultVendorFeePercentage: ..., -}; - -// Call the `createVendorDefaultSettingRef()` function to get a reference to the mutation. -const ref = createVendorDefaultSettingRef(createVendorDefaultSettingVars); -// Variables can be defined inline as well. -const ref = createVendorDefaultSettingRef({ vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = createVendorDefaultSettingRef(dataConnect, createVendorDefaultSettingVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendorDefaultSetting_insert); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendorDefaultSetting_insert); -}); -``` - -## UpdateVendorDefaultSetting -You can execute the `UpdateVendorDefaultSetting` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -updateVendorDefaultSetting(vars: UpdateVendorDefaultSettingVariables): MutationPromise; - -interface UpdateVendorDefaultSettingRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: UpdateVendorDefaultSettingVariables): MutationRef; -} -export const updateVendorDefaultSettingRef: UpdateVendorDefaultSettingRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -updateVendorDefaultSetting(dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationPromise; - -interface UpdateVendorDefaultSettingRef { - ... - (dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationRef; -} -export const updateVendorDefaultSettingRef: UpdateVendorDefaultSettingRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateVendorDefaultSettingRef: -```typescript -const name = updateVendorDefaultSettingRef.operationName; -console.log(name); -``` - -### Variables -The `UpdateVendorDefaultSetting` mutation requires an argument of type `UpdateVendorDefaultSettingVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface UpdateVendorDefaultSettingVariables { - id: UUIDString; - vendorName?: string | null; - defaultMarkupPercentage?: number | null; - defaultVendorFeePercentage?: number | null; -} -``` -### Return Type -Recall that executing the `UpdateVendorDefaultSetting` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `UpdateVendorDefaultSettingData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface UpdateVendorDefaultSettingData { - vendorDefaultSetting_update?: VendorDefaultSetting_Key | null; -} -``` -### Using `UpdateVendorDefaultSetting`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, updateVendorDefaultSetting, UpdateVendorDefaultSettingVariables } from '@dataconnect/generated'; - -// The `UpdateVendorDefaultSetting` mutation requires an argument of type `UpdateVendorDefaultSettingVariables`: -const updateVendorDefaultSettingVars: UpdateVendorDefaultSettingVariables = { - id: ..., - vendorName: ..., // optional - defaultMarkupPercentage: ..., // optional - defaultVendorFeePercentage: ..., // optional -}; - -// Call the `updateVendorDefaultSetting()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await updateVendorDefaultSetting(updateVendorDefaultSettingVars); -// Variables can be defined inline as well. -const { data } = await updateVendorDefaultSetting({ id: ..., vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await updateVendorDefaultSetting(dataConnect, updateVendorDefaultSettingVars); - -console.log(data.vendorDefaultSetting_update); - -// Or, you can use the `Promise` API. -updateVendorDefaultSetting(updateVendorDefaultSettingVars).then((response) => { - const data = response.data; - console.log(data.vendorDefaultSetting_update); -}); -``` - -### Using `UpdateVendorDefaultSetting`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, updateVendorDefaultSettingRef, UpdateVendorDefaultSettingVariables } from '@dataconnect/generated'; - -// The `UpdateVendorDefaultSetting` mutation requires an argument of type `UpdateVendorDefaultSettingVariables`: -const updateVendorDefaultSettingVars: UpdateVendorDefaultSettingVariables = { - id: ..., - vendorName: ..., // optional - defaultMarkupPercentage: ..., // optional - defaultVendorFeePercentage: ..., // optional -}; - -// Call the `updateVendorDefaultSettingRef()` function to get a reference to the mutation. -const ref = updateVendorDefaultSettingRef(updateVendorDefaultSettingVars); -// Variables can be defined inline as well. -const ref = updateVendorDefaultSettingRef({ id: ..., vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = updateVendorDefaultSettingRef(dataConnect, updateVendorDefaultSettingVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendorDefaultSetting_update); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendorDefaultSetting_update); -}); -``` - -## DeleteVendorDefaultSetting -You can execute the `DeleteVendorDefaultSetting` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -deleteVendorDefaultSetting(vars: DeleteVendorDefaultSettingVariables): MutationPromise; - -interface DeleteVendorDefaultSettingRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: DeleteVendorDefaultSettingVariables): MutationRef; -} -export const deleteVendorDefaultSettingRef: DeleteVendorDefaultSettingRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -deleteVendorDefaultSetting(dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationPromise; - -interface DeleteVendorDefaultSettingRef { - ... - (dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationRef; -} -export const deleteVendorDefaultSettingRef: DeleteVendorDefaultSettingRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteVendorDefaultSettingRef: -```typescript -const name = deleteVendorDefaultSettingRef.operationName; -console.log(name); -``` - -### Variables -The `DeleteVendorDefaultSetting` mutation requires an argument of type `DeleteVendorDefaultSettingVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface DeleteVendorDefaultSettingVariables { - id: UUIDString; -} -``` -### Return Type -Recall that executing the `DeleteVendorDefaultSetting` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `DeleteVendorDefaultSettingData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface DeleteVendorDefaultSettingData { - vendorDefaultSetting_delete?: VendorDefaultSetting_Key | null; -} -``` -### Using `DeleteVendorDefaultSetting`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, deleteVendorDefaultSetting, DeleteVendorDefaultSettingVariables } from '@dataconnect/generated'; - -// The `DeleteVendorDefaultSetting` mutation requires an argument of type `DeleteVendorDefaultSettingVariables`: -const deleteVendorDefaultSettingVars: DeleteVendorDefaultSettingVariables = { - id: ..., -}; - -// Call the `deleteVendorDefaultSetting()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await deleteVendorDefaultSetting(deleteVendorDefaultSettingVars); -// Variables can be defined inline as well. -const { data } = await deleteVendorDefaultSetting({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await deleteVendorDefaultSetting(dataConnect, deleteVendorDefaultSettingVars); - -console.log(data.vendorDefaultSetting_delete); - -// Or, you can use the `Promise` API. -deleteVendorDefaultSetting(deleteVendorDefaultSettingVars).then((response) => { - const data = response.data; - console.log(data.vendorDefaultSetting_delete); -}); -``` - -### Using `DeleteVendorDefaultSetting`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, deleteVendorDefaultSettingRef, DeleteVendorDefaultSettingVariables } from '@dataconnect/generated'; - -// The `DeleteVendorDefaultSetting` mutation requires an argument of type `DeleteVendorDefaultSettingVariables`: -const deleteVendorDefaultSettingVars: DeleteVendorDefaultSettingVariables = { - id: ..., -}; - -// Call the `deleteVendorDefaultSettingRef()` function to get a reference to the mutation. -const ref = deleteVendorDefaultSettingRef(deleteVendorDefaultSettingVars); -// Variables can be defined inline as well. -const ref = deleteVendorDefaultSettingRef({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = deleteVendorDefaultSettingRef(dataConnect, deleteVendorDefaultSettingVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendorDefaultSetting_delete); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendorDefaultSetting_delete); -}); -``` - -## CreateVendorRate -You can execute the `CreateVendorRate` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -createVendorRate(vars: CreateVendorRateVariables): MutationPromise; - -interface CreateVendorRateRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: CreateVendorRateVariables): MutationRef; -} -export const createVendorRateRef: CreateVendorRateRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -createVendorRate(dc: DataConnect, vars: CreateVendorRateVariables): MutationPromise; - -interface CreateVendorRateRef { - ... - (dc: DataConnect, vars: CreateVendorRateVariables): MutationRef; -} -export const createVendorRateRef: CreateVendorRateRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createVendorRateRef: -```typescript -const name = createVendorRateRef.operationName; -console.log(name); -``` - -### Variables -The `CreateVendorRate` mutation requires an argument of type `CreateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface CreateVendorRateVariables { - vendorName: string; - category: VendorRateCategory; - roleName: string; - employeeWage: number; - markupPercentage?: number | null; - vendorFeePercentage?: number | null; - clientRate: number; -} -``` -### Return Type -Recall that executing the `CreateVendorRate` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `CreateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface CreateVendorRateData { - vendorRate_insert: VendorRate_Key; -} -``` -### Using `CreateVendorRate`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, createVendorRate, CreateVendorRateVariables } from '@dataconnect/generated'; - -// The `CreateVendorRate` mutation requires an argument of type `CreateVendorRateVariables`: -const createVendorRateVars: CreateVendorRateVariables = { - vendorName: ..., - category: ..., - roleName: ..., - employeeWage: ..., - markupPercentage: ..., // optional - vendorFeePercentage: ..., // optional - clientRate: ..., -}; - -// Call the `createVendorRate()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await createVendorRate(createVendorRateVars); -// Variables can be defined inline as well. -const { data } = await createVendorRate({ vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await createVendorRate(dataConnect, createVendorRateVars); - -console.log(data.vendorRate_insert); - -// Or, you can use the `Promise` API. -createVendorRate(createVendorRateVars).then((response) => { - const data = response.data; - console.log(data.vendorRate_insert); -}); -``` - -### Using `CreateVendorRate`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, createVendorRateRef, CreateVendorRateVariables } from '@dataconnect/generated'; - -// The `CreateVendorRate` mutation requires an argument of type `CreateVendorRateVariables`: -const createVendorRateVars: CreateVendorRateVariables = { - vendorName: ..., - category: ..., - roleName: ..., - employeeWage: ..., - markupPercentage: ..., // optional - vendorFeePercentage: ..., // optional - clientRate: ..., -}; - -// Call the `createVendorRateRef()` function to get a reference to the mutation. -const ref = createVendorRateRef(createVendorRateVars); -// Variables can be defined inline as well. -const ref = createVendorRateRef({ vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = createVendorRateRef(dataConnect, createVendorRateVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendorRate_insert); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendorRate_insert); -}); -``` - -## UpdateVendorRate -You can execute the `UpdateVendorRate` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -updateVendorRate(vars: UpdateVendorRateVariables): MutationPromise; - -interface UpdateVendorRateRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: UpdateVendorRateVariables): MutationRef; -} -export const updateVendorRateRef: UpdateVendorRateRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -updateVendorRate(dc: DataConnect, vars: UpdateVendorRateVariables): MutationPromise; - -interface UpdateVendorRateRef { - ... - (dc: DataConnect, vars: UpdateVendorRateVariables): MutationRef; -} -export const updateVendorRateRef: UpdateVendorRateRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateVendorRateRef: -```typescript -const name = updateVendorRateRef.operationName; -console.log(name); -``` - -### Variables -The `UpdateVendorRate` mutation requires an argument of type `UpdateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface UpdateVendorRateVariables { - id: UUIDString; - vendorName?: string | null; - category?: VendorRateCategory | null; - roleName?: string | null; - employeeWage?: number | null; - markupPercentage?: number | null; - vendorFeePercentage?: number | null; - clientRate?: number | null; -} -``` -### Return Type -Recall that executing the `UpdateVendorRate` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `UpdateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface UpdateVendorRateData { - vendorRate_update?: VendorRate_Key | null; -} -``` -### Using `UpdateVendorRate`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, updateVendorRate, UpdateVendorRateVariables } from '@dataconnect/generated'; - -// The `UpdateVendorRate` mutation requires an argument of type `UpdateVendorRateVariables`: -const updateVendorRateVars: UpdateVendorRateVariables = { - id: ..., - vendorName: ..., // optional - category: ..., // optional - roleName: ..., // optional - employeeWage: ..., // optional - markupPercentage: ..., // optional - vendorFeePercentage: ..., // optional - clientRate: ..., // optional -}; - -// Call the `updateVendorRate()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await updateVendorRate(updateVendorRateVars); -// Variables can be defined inline as well. -const { data } = await updateVendorRate({ id: ..., vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await updateVendorRate(dataConnect, updateVendorRateVars); - -console.log(data.vendorRate_update); - -// Or, you can use the `Promise` API. -updateVendorRate(updateVendorRateVars).then((response) => { - const data = response.data; - console.log(data.vendorRate_update); -}); -``` - -### Using `UpdateVendorRate`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, updateVendorRateRef, UpdateVendorRateVariables } from '@dataconnect/generated'; - -// The `UpdateVendorRate` mutation requires an argument of type `UpdateVendorRateVariables`: -const updateVendorRateVars: UpdateVendorRateVariables = { - id: ..., - vendorName: ..., // optional - category: ..., // optional - roleName: ..., // optional - employeeWage: ..., // optional - markupPercentage: ..., // optional - vendorFeePercentage: ..., // optional - clientRate: ..., // optional -}; - -// Call the `updateVendorRateRef()` function to get a reference to the mutation. -const ref = updateVendorRateRef(updateVendorRateVars); -// Variables can be defined inline as well. -const ref = updateVendorRateRef({ id: ..., vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = updateVendorRateRef(dataConnect, updateVendorRateVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendorRate_update); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendorRate_update); -}); -``` - -## DeleteVendorRate -You can execute the `DeleteVendorRate` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -deleteVendorRate(vars: DeleteVendorRateVariables): MutationPromise; - -interface DeleteVendorRateRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: DeleteVendorRateVariables): MutationRef; -} -export const deleteVendorRateRef: DeleteVendorRateRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -deleteVendorRate(dc: DataConnect, vars: DeleteVendorRateVariables): MutationPromise; - -interface DeleteVendorRateRef { - ... - (dc: DataConnect, vars: DeleteVendorRateVariables): MutationRef; -} -export const deleteVendorRateRef: DeleteVendorRateRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteVendorRateRef: -```typescript -const name = deleteVendorRateRef.operationName; -console.log(name); -``` - -### Variables -The `DeleteVendorRate` mutation requires an argument of type `DeleteVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface DeleteVendorRateVariables { - id: UUIDString; -} -``` -### Return Type -Recall that executing the `DeleteVendorRate` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `DeleteVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface DeleteVendorRateData { - vendorRate_delete?: VendorRate_Key | null; -} -``` -### Using `DeleteVendorRate`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, deleteVendorRate, DeleteVendorRateVariables } from '@dataconnect/generated'; - -// The `DeleteVendorRate` mutation requires an argument of type `DeleteVendorRateVariables`: -const deleteVendorRateVars: DeleteVendorRateVariables = { - id: ..., -}; - -// Call the `deleteVendorRate()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await deleteVendorRate(deleteVendorRateVars); -// Variables can be defined inline as well. -const { data } = await deleteVendorRate({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await deleteVendorRate(dataConnect, deleteVendorRateVars); - -console.log(data.vendorRate_delete); - -// Or, you can use the `Promise` API. -deleteVendorRate(deleteVendorRateVars).then((response) => { - const data = response.data; - console.log(data.vendorRate_delete); -}); -``` - -### Using `DeleteVendorRate`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, deleteVendorRateRef, DeleteVendorRateVariables } from '@dataconnect/generated'; - -// The `DeleteVendorRate` mutation requires an argument of type `DeleteVendorRateVariables`: -const deleteVendorRateVars: DeleteVendorRateVariables = { - id: ..., -}; - -// Call the `deleteVendorRateRef()` function to get a reference to the mutation. -const ref = deleteVendorRateRef(deleteVendorRateVars); -// Variables can be defined inline as well. -const ref = deleteVendorRateRef({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = deleteVendorRateRef(dataConnect, deleteVendorRateVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendorRate_delete); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendorRate_delete); -}); -``` - ## CreateEvent You can execute the `CreateEvent` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): ```typescript @@ -4155,3 +2937,1936 @@ executeMutation(ref).then((response) => { }); ``` +## CreateVendorRate +You can execute the `CreateVendorRate` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +createVendorRate(vars: CreateVendorRateVariables): MutationPromise; + +interface CreateVendorRateRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateVendorRateVariables): MutationRef; +} +export const createVendorRateRef: CreateVendorRateRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +createVendorRate(dc: DataConnect, vars: CreateVendorRateVariables): MutationPromise; + +interface CreateVendorRateRef { + ... + (dc: DataConnect, vars: CreateVendorRateVariables): MutationRef; +} +export const createVendorRateRef: CreateVendorRateRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createVendorRateRef: +```typescript +const name = createVendorRateRef.operationName; +console.log(name); +``` + +### Variables +The `CreateVendorRate` mutation requires an argument of type `CreateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface CreateVendorRateVariables { + vendorName: string; + category: VendorRateCategory; + roleName: string; + employeeWage: number; + markupPercentage?: number | null; + vendorFeePercentage?: number | null; + clientRate: number; +} +``` +### Return Type +Recall that executing the `CreateVendorRate` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `CreateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface CreateVendorRateData { + vendorRate_insert: VendorRate_Key; +} +``` +### Using `CreateVendorRate`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, createVendorRate, CreateVendorRateVariables } from '@dataconnect/generated'; + +// The `CreateVendorRate` mutation requires an argument of type `CreateVendorRateVariables`: +const createVendorRateVars: CreateVendorRateVariables = { + vendorName: ..., + category: ..., + roleName: ..., + employeeWage: ..., + markupPercentage: ..., // optional + vendorFeePercentage: ..., // optional + clientRate: ..., +}; + +// Call the `createVendorRate()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await createVendorRate(createVendorRateVars); +// Variables can be defined inline as well. +const { data } = await createVendorRate({ vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await createVendorRate(dataConnect, createVendorRateVars); + +console.log(data.vendorRate_insert); + +// Or, you can use the `Promise` API. +createVendorRate(createVendorRateVars).then((response) => { + const data = response.data; + console.log(data.vendorRate_insert); +}); +``` + +### Using `CreateVendorRate`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, createVendorRateRef, CreateVendorRateVariables } from '@dataconnect/generated'; + +// The `CreateVendorRate` mutation requires an argument of type `CreateVendorRateVariables`: +const createVendorRateVars: CreateVendorRateVariables = { + vendorName: ..., + category: ..., + roleName: ..., + employeeWage: ..., + markupPercentage: ..., // optional + vendorFeePercentage: ..., // optional + clientRate: ..., +}; + +// Call the `createVendorRateRef()` function to get a reference to the mutation. +const ref = createVendorRateRef(createVendorRateVars); +// Variables can be defined inline as well. +const ref = createVendorRateRef({ vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = createVendorRateRef(dataConnect, createVendorRateVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendorRate_insert); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendorRate_insert); +}); +``` + +## UpdateVendorRate +You can execute the `UpdateVendorRate` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +updateVendorRate(vars: UpdateVendorRateVariables): MutationPromise; + +interface UpdateVendorRateRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateVendorRateVariables): MutationRef; +} +export const updateVendorRateRef: UpdateVendorRateRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +updateVendorRate(dc: DataConnect, vars: UpdateVendorRateVariables): MutationPromise; + +interface UpdateVendorRateRef { + ... + (dc: DataConnect, vars: UpdateVendorRateVariables): MutationRef; +} +export const updateVendorRateRef: UpdateVendorRateRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateVendorRateRef: +```typescript +const name = updateVendorRateRef.operationName; +console.log(name); +``` + +### Variables +The `UpdateVendorRate` mutation requires an argument of type `UpdateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface UpdateVendorRateVariables { + id: UUIDString; + vendorName?: string | null; + category?: VendorRateCategory | null; + roleName?: string | null; + employeeWage?: number | null; + markupPercentage?: number | null; + vendorFeePercentage?: number | null; + clientRate?: number | null; +} +``` +### Return Type +Recall that executing the `UpdateVendorRate` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `UpdateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface UpdateVendorRateData { + vendorRate_update?: VendorRate_Key | null; +} +``` +### Using `UpdateVendorRate`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, updateVendorRate, UpdateVendorRateVariables } from '@dataconnect/generated'; + +// The `UpdateVendorRate` mutation requires an argument of type `UpdateVendorRateVariables`: +const updateVendorRateVars: UpdateVendorRateVariables = { + id: ..., + vendorName: ..., // optional + category: ..., // optional + roleName: ..., // optional + employeeWage: ..., // optional + markupPercentage: ..., // optional + vendorFeePercentage: ..., // optional + clientRate: ..., // optional +}; + +// Call the `updateVendorRate()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await updateVendorRate(updateVendorRateVars); +// Variables can be defined inline as well. +const { data } = await updateVendorRate({ id: ..., vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await updateVendorRate(dataConnect, updateVendorRateVars); + +console.log(data.vendorRate_update); + +// Or, you can use the `Promise` API. +updateVendorRate(updateVendorRateVars).then((response) => { + const data = response.data; + console.log(data.vendorRate_update); +}); +``` + +### Using `UpdateVendorRate`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, updateVendorRateRef, UpdateVendorRateVariables } from '@dataconnect/generated'; + +// The `UpdateVendorRate` mutation requires an argument of type `UpdateVendorRateVariables`: +const updateVendorRateVars: UpdateVendorRateVariables = { + id: ..., + vendorName: ..., // optional + category: ..., // optional + roleName: ..., // optional + employeeWage: ..., // optional + markupPercentage: ..., // optional + vendorFeePercentage: ..., // optional + clientRate: ..., // optional +}; + +// Call the `updateVendorRateRef()` function to get a reference to the mutation. +const ref = updateVendorRateRef(updateVendorRateVars); +// Variables can be defined inline as well. +const ref = updateVendorRateRef({ id: ..., vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = updateVendorRateRef(dataConnect, updateVendorRateVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendorRate_update); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendorRate_update); +}); +``` + +## DeleteVendorRate +You can execute the `DeleteVendorRate` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +deleteVendorRate(vars: DeleteVendorRateVariables): MutationPromise; + +interface DeleteVendorRateRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteVendorRateVariables): MutationRef; +} +export const deleteVendorRateRef: DeleteVendorRateRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +deleteVendorRate(dc: DataConnect, vars: DeleteVendorRateVariables): MutationPromise; + +interface DeleteVendorRateRef { + ... + (dc: DataConnect, vars: DeleteVendorRateVariables): MutationRef; +} +export const deleteVendorRateRef: DeleteVendorRateRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteVendorRateRef: +```typescript +const name = deleteVendorRateRef.operationName; +console.log(name); +``` + +### Variables +The `DeleteVendorRate` mutation requires an argument of type `DeleteVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface DeleteVendorRateVariables { + id: UUIDString; +} +``` +### Return Type +Recall that executing the `DeleteVendorRate` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `DeleteVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface DeleteVendorRateData { + vendorRate_delete?: VendorRate_Key | null; +} +``` +### Using `DeleteVendorRate`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, deleteVendorRate, DeleteVendorRateVariables } from '@dataconnect/generated'; + +// The `DeleteVendorRate` mutation requires an argument of type `DeleteVendorRateVariables`: +const deleteVendorRateVars: DeleteVendorRateVariables = { + id: ..., +}; + +// Call the `deleteVendorRate()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await deleteVendorRate(deleteVendorRateVars); +// Variables can be defined inline as well. +const { data } = await deleteVendorRate({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await deleteVendorRate(dataConnect, deleteVendorRateVars); + +console.log(data.vendorRate_delete); + +// Or, you can use the `Promise` API. +deleteVendorRate(deleteVendorRateVars).then((response) => { + const data = response.data; + console.log(data.vendorRate_delete); +}); +``` + +### Using `DeleteVendorRate`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, deleteVendorRateRef, DeleteVendorRateVariables } from '@dataconnect/generated'; + +// The `DeleteVendorRate` mutation requires an argument of type `DeleteVendorRateVariables`: +const deleteVendorRateVars: DeleteVendorRateVariables = { + id: ..., +}; + +// Call the `deleteVendorRateRef()` function to get a reference to the mutation. +const ref = deleteVendorRateRef(deleteVendorRateVars); +// Variables can be defined inline as well. +const ref = deleteVendorRateRef({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = deleteVendorRateRef(dataConnect, deleteVendorRateVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendorRate_delete); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendorRate_delete); +}); +``` + +## CreateInvoice +You can execute the `CreateInvoice` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +createInvoice(vars: CreateInvoiceVariables): MutationPromise; + +interface CreateInvoiceRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateInvoiceVariables): MutationRef; +} +export const createInvoiceRef: CreateInvoiceRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +createInvoice(dc: DataConnect, vars: CreateInvoiceVariables): MutationPromise; + +interface CreateInvoiceRef { + ... + (dc: DataConnect, vars: CreateInvoiceVariables): MutationRef; +} +export const createInvoiceRef: CreateInvoiceRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createInvoiceRef: +```typescript +const name = createInvoiceRef.operationName; +console.log(name); +``` + +### Variables +The `CreateInvoice` mutation requires an argument of type `CreateInvoiceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface CreateInvoiceVariables { + invoiceNumber: string; + amount: number; + status: InvoiceStatus; + issueDate: TimestampString; + dueDate: TimestampString; + disputedItems?: string | null; + isAutoGenerated?: boolean | null; +} +``` +### Return Type +Recall that executing the `CreateInvoice` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `CreateInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface CreateInvoiceData { + invoice_insert: Invoice_Key; +} +``` +### Using `CreateInvoice`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, createInvoice, CreateInvoiceVariables } from '@dataconnect/generated'; + +// The `CreateInvoice` mutation requires an argument of type `CreateInvoiceVariables`: +const createInvoiceVars: CreateInvoiceVariables = { + invoiceNumber: ..., + amount: ..., + status: ..., + issueDate: ..., + dueDate: ..., + disputedItems: ..., // optional + isAutoGenerated: ..., // optional +}; + +// Call the `createInvoice()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await createInvoice(createInvoiceVars); +// Variables can be defined inline as well. +const { data } = await createInvoice({ invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await createInvoice(dataConnect, createInvoiceVars); + +console.log(data.invoice_insert); + +// Or, you can use the `Promise` API. +createInvoice(createInvoiceVars).then((response) => { + const data = response.data; + console.log(data.invoice_insert); +}); +``` + +### Using `CreateInvoice`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, createInvoiceRef, CreateInvoiceVariables } from '@dataconnect/generated'; + +// The `CreateInvoice` mutation requires an argument of type `CreateInvoiceVariables`: +const createInvoiceVars: CreateInvoiceVariables = { + invoiceNumber: ..., + amount: ..., + status: ..., + issueDate: ..., + dueDate: ..., + disputedItems: ..., // optional + isAutoGenerated: ..., // optional +}; + +// Call the `createInvoiceRef()` function to get a reference to the mutation. +const ref = createInvoiceRef(createInvoiceVars); +// Variables can be defined inline as well. +const ref = createInvoiceRef({ invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = createInvoiceRef(dataConnect, createInvoiceVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.invoice_insert); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.invoice_insert); +}); +``` + +## UpdateInvoice +You can execute the `UpdateInvoice` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +updateInvoice(vars: UpdateInvoiceVariables): MutationPromise; + +interface UpdateInvoiceRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateInvoiceVariables): MutationRef; +} +export const updateInvoiceRef: UpdateInvoiceRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +updateInvoice(dc: DataConnect, vars: UpdateInvoiceVariables): MutationPromise; + +interface UpdateInvoiceRef { + ... + (dc: DataConnect, vars: UpdateInvoiceVariables): MutationRef; +} +export const updateInvoiceRef: UpdateInvoiceRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateInvoiceRef: +```typescript +const name = updateInvoiceRef.operationName; +console.log(name); +``` + +### Variables +The `UpdateInvoice` mutation requires an argument of type `UpdateInvoiceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface UpdateInvoiceVariables { + id: UUIDString; + invoiceNumber?: string | null; + amount?: number | null; + status?: InvoiceStatus | null; + issueDate?: TimestampString | null; + dueDate?: TimestampString | null; + disputedItems?: string | null; + isAutoGenerated?: boolean | null; +} +``` +### Return Type +Recall that executing the `UpdateInvoice` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `UpdateInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface UpdateInvoiceData { + invoice_update?: Invoice_Key | null; +} +``` +### Using `UpdateInvoice`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, updateInvoice, UpdateInvoiceVariables } from '@dataconnect/generated'; + +// The `UpdateInvoice` mutation requires an argument of type `UpdateInvoiceVariables`: +const updateInvoiceVars: UpdateInvoiceVariables = { + id: ..., + invoiceNumber: ..., // optional + amount: ..., // optional + status: ..., // optional + issueDate: ..., // optional + dueDate: ..., // optional + disputedItems: ..., // optional + isAutoGenerated: ..., // optional +}; + +// Call the `updateInvoice()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await updateInvoice(updateInvoiceVars); +// Variables can be defined inline as well. +const { data } = await updateInvoice({ id: ..., invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await updateInvoice(dataConnect, updateInvoiceVars); + +console.log(data.invoice_update); + +// Or, you can use the `Promise` API. +updateInvoice(updateInvoiceVars).then((response) => { + const data = response.data; + console.log(data.invoice_update); +}); +``` + +### Using `UpdateInvoice`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, updateInvoiceRef, UpdateInvoiceVariables } from '@dataconnect/generated'; + +// The `UpdateInvoice` mutation requires an argument of type `UpdateInvoiceVariables`: +const updateInvoiceVars: UpdateInvoiceVariables = { + id: ..., + invoiceNumber: ..., // optional + amount: ..., // optional + status: ..., // optional + issueDate: ..., // optional + dueDate: ..., // optional + disputedItems: ..., // optional + isAutoGenerated: ..., // optional +}; + +// Call the `updateInvoiceRef()` function to get a reference to the mutation. +const ref = updateInvoiceRef(updateInvoiceVars); +// Variables can be defined inline as well. +const ref = updateInvoiceRef({ id: ..., invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = updateInvoiceRef(dataConnect, updateInvoiceVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.invoice_update); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.invoice_update); +}); +``` + +## DeleteInvoice +You can execute the `DeleteInvoice` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +deleteInvoice(vars: DeleteInvoiceVariables): MutationPromise; + +interface DeleteInvoiceRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteInvoiceVariables): MutationRef; +} +export const deleteInvoiceRef: DeleteInvoiceRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +deleteInvoice(dc: DataConnect, vars: DeleteInvoiceVariables): MutationPromise; + +interface DeleteInvoiceRef { + ... + (dc: DataConnect, vars: DeleteInvoiceVariables): MutationRef; +} +export const deleteInvoiceRef: DeleteInvoiceRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteInvoiceRef: +```typescript +const name = deleteInvoiceRef.operationName; +console.log(name); +``` + +### Variables +The `DeleteInvoice` mutation requires an argument of type `DeleteInvoiceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface DeleteInvoiceVariables { + id: UUIDString; +} +``` +### Return Type +Recall that executing the `DeleteInvoice` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `DeleteInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface DeleteInvoiceData { + invoice_delete?: Invoice_Key | null; +} +``` +### Using `DeleteInvoice`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, deleteInvoice, DeleteInvoiceVariables } from '@dataconnect/generated'; + +// The `DeleteInvoice` mutation requires an argument of type `DeleteInvoiceVariables`: +const deleteInvoiceVars: DeleteInvoiceVariables = { + id: ..., +}; + +// Call the `deleteInvoice()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await deleteInvoice(deleteInvoiceVars); +// Variables can be defined inline as well. +const { data } = await deleteInvoice({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await deleteInvoice(dataConnect, deleteInvoiceVars); + +console.log(data.invoice_delete); + +// Or, you can use the `Promise` API. +deleteInvoice(deleteInvoiceVars).then((response) => { + const data = response.data; + console.log(data.invoice_delete); +}); +``` + +### Using `DeleteInvoice`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, deleteInvoiceRef, DeleteInvoiceVariables } from '@dataconnect/generated'; + +// The `DeleteInvoice` mutation requires an argument of type `DeleteInvoiceVariables`: +const deleteInvoiceVars: DeleteInvoiceVariables = { + id: ..., +}; + +// Call the `deleteInvoiceRef()` function to get a reference to the mutation. +const ref = deleteInvoiceRef(deleteInvoiceVars); +// Variables can be defined inline as well. +const ref = deleteInvoiceRef({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = deleteInvoiceRef(dataConnect, deleteInvoiceVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.invoice_delete); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.invoice_delete); +}); +``` + +## CreateStaff +You can execute the `CreateStaff` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +createStaff(vars: CreateStaffVariables): MutationPromise; + +interface CreateStaffRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateStaffVariables): MutationRef; +} +export const createStaffRef: CreateStaffRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +createStaff(dc: DataConnect, vars: CreateStaffVariables): MutationPromise; + +interface CreateStaffRef { + ... + (dc: DataConnect, vars: CreateStaffVariables): MutationRef; +} +export const createStaffRef: CreateStaffRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createStaffRef: +```typescript +const name = createStaffRef.operationName; +console.log(name); +``` + +### Variables +The `CreateStaff` mutation requires an argument of type `CreateStaffVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface CreateStaffVariables { + employeeName: string; + vendorId?: UUIDString | null; + email?: string | null; + position?: string | null; + employmentType: EmploymentType; + rating?: number | null; + reliabilityScore?: number | null; + backgroundCheckStatus: BackgroundCheckStatus; + certifications?: string | null; +} +``` +### Return Type +Recall that executing the `CreateStaff` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `CreateStaffData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface CreateStaffData { + staff_insert: Staff_Key; +} +``` +### Using `CreateStaff`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, createStaff, CreateStaffVariables } from '@dataconnect/generated'; + +// The `CreateStaff` mutation requires an argument of type `CreateStaffVariables`: +const createStaffVars: CreateStaffVariables = { + employeeName: ..., + vendorId: ..., // optional + email: ..., // optional + position: ..., // optional + employmentType: ..., + rating: ..., // optional + reliabilityScore: ..., // optional + backgroundCheckStatus: ..., + certifications: ..., // 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: ..., email: ..., position: ..., employmentType: ..., rating: ..., reliabilityScore: ..., backgroundCheckStatus: ..., certifications: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await createStaff(dataConnect, createStaffVars); + +console.log(data.staff_insert); + +// Or, you can use the `Promise` API. +createStaff(createStaffVars).then((response) => { + const data = response.data; + console.log(data.staff_insert); +}); +``` + +### Using `CreateStaff`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, createStaffRef, CreateStaffVariables } from '@dataconnect/generated'; + +// The `CreateStaff` mutation requires an argument of type `CreateStaffVariables`: +const createStaffVars: CreateStaffVariables = { + employeeName: ..., + vendorId: ..., // optional + email: ..., // optional + position: ..., // optional + employmentType: ..., + rating: ..., // optional + reliabilityScore: ..., // optional + backgroundCheckStatus: ..., + certifications: ..., // 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: ..., email: ..., position: ..., employmentType: ..., rating: ..., reliabilityScore: ..., backgroundCheckStatus: ..., certifications: ..., }); + +// 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); +}); +``` + +## CreateVendor +You can execute the `CreateVendor` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +createVendor(vars: CreateVendorVariables): MutationPromise; + +interface CreateVendorRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateVendorVariables): MutationRef; +} +export const createVendorRef: CreateVendorRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +createVendor(dc: DataConnect, vars: CreateVendorVariables): MutationPromise; + +interface CreateVendorRef { + ... + (dc: DataConnect, vars: CreateVendorVariables): MutationRef; +} +export const createVendorRef: CreateVendorRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createVendorRef: +```typescript +const name = createVendorRef.operationName; +console.log(name); +``` + +### Variables +The `CreateVendor` mutation requires an argument of type `CreateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface CreateVendorVariables { + vendorNumber: string; + legalName: string; + region: VendorRegion; + platformType: VendorPlatformType; + primaryContactEmail: string; + approvalStatus: VendorApprovalStatus; + isActive?: boolean | null; +} +``` +### Return Type +Recall that executing the `CreateVendor` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `CreateVendorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface CreateVendorData { + vendor_insert: Vendor_Key; +} +``` +### Using `CreateVendor`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, createVendor, CreateVendorVariables } from '@dataconnect/generated'; + +// The `CreateVendor` mutation requires an argument of type `CreateVendorVariables`: +const createVendorVars: CreateVendorVariables = { + vendorNumber: ..., + legalName: ..., + region: ..., + platformType: ..., + primaryContactEmail: ..., + approvalStatus: ..., + isActive: ..., // optional +}; + +// Call the `createVendor()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await createVendor(createVendorVars); +// Variables can be defined inline as well. +const { data } = await createVendor({ vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await createVendor(dataConnect, createVendorVars); + +console.log(data.vendor_insert); + +// Or, you can use the `Promise` API. +createVendor(createVendorVars).then((response) => { + const data = response.data; + console.log(data.vendor_insert); +}); +``` + +### Using `CreateVendor`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, createVendorRef, CreateVendorVariables } from '@dataconnect/generated'; + +// The `CreateVendor` mutation requires an argument of type `CreateVendorVariables`: +const createVendorVars: CreateVendorVariables = { + vendorNumber: ..., + legalName: ..., + region: ..., + platformType: ..., + primaryContactEmail: ..., + approvalStatus: ..., + isActive: ..., // optional +}; + +// Call the `createVendorRef()` function to get a reference to the mutation. +const ref = createVendorRef(createVendorVars); +// Variables can be defined inline as well. +const ref = createVendorRef({ vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = createVendorRef(dataConnect, createVendorVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendor_insert); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendor_insert); +}); +``` + +## UpdateVendor +You can execute the `UpdateVendor` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +updateVendor(vars: UpdateVendorVariables): MutationPromise; + +interface UpdateVendorRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateVendorVariables): MutationRef; +} +export const updateVendorRef: UpdateVendorRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +updateVendor(dc: DataConnect, vars: UpdateVendorVariables): MutationPromise; + +interface UpdateVendorRef { + ... + (dc: DataConnect, vars: UpdateVendorVariables): MutationRef; +} +export const updateVendorRef: UpdateVendorRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateVendorRef: +```typescript +const name = updateVendorRef.operationName; +console.log(name); +``` + +### Variables +The `UpdateVendor` mutation requires an argument of type `UpdateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface UpdateVendorVariables { + id: UUIDString; + vendorNumber?: string | null; + legalName?: string | null; + region?: VendorRegion | null; + platformType?: VendorPlatformType | null; + primaryContactEmail?: string | null; + approvalStatus?: VendorApprovalStatus | null; + isActive?: boolean | null; +} +``` +### Return Type +Recall that executing the `UpdateVendor` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `UpdateVendorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface UpdateVendorData { + vendor_update?: Vendor_Key | null; +} +``` +### Using `UpdateVendor`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, updateVendor, UpdateVendorVariables } from '@dataconnect/generated'; + +// The `UpdateVendor` mutation requires an argument of type `UpdateVendorVariables`: +const updateVendorVars: UpdateVendorVariables = { + id: ..., + vendorNumber: ..., // optional + legalName: ..., // optional + region: ..., // optional + platformType: ..., // optional + primaryContactEmail: ..., // optional + approvalStatus: ..., // optional + isActive: ..., // optional +}; + +// Call the `updateVendor()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await updateVendor(updateVendorVars); +// Variables can be defined inline as well. +const { data } = await updateVendor({ id: ..., vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await updateVendor(dataConnect, updateVendorVars); + +console.log(data.vendor_update); + +// Or, you can use the `Promise` API. +updateVendor(updateVendorVars).then((response) => { + const data = response.data; + console.log(data.vendor_update); +}); +``` + +### Using `UpdateVendor`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, updateVendorRef, UpdateVendorVariables } from '@dataconnect/generated'; + +// The `UpdateVendor` mutation requires an argument of type `UpdateVendorVariables`: +const updateVendorVars: UpdateVendorVariables = { + id: ..., + vendorNumber: ..., // optional + legalName: ..., // optional + region: ..., // optional + platformType: ..., // optional + primaryContactEmail: ..., // optional + approvalStatus: ..., // optional + isActive: ..., // optional +}; + +// Call the `updateVendorRef()` function to get a reference to the mutation. +const ref = updateVendorRef(updateVendorVars); +// Variables can be defined inline as well. +const ref = updateVendorRef({ id: ..., vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = updateVendorRef(dataConnect, updateVendorVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendor_update); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendor_update); +}); +``` + +## DeleteVendor +You can execute the `DeleteVendor` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +deleteVendor(vars: DeleteVendorVariables): MutationPromise; + +interface DeleteVendorRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteVendorVariables): MutationRef; +} +export const deleteVendorRef: DeleteVendorRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +deleteVendor(dc: DataConnect, vars: DeleteVendorVariables): MutationPromise; + +interface DeleteVendorRef { + ... + (dc: DataConnect, vars: DeleteVendorVariables): MutationRef; +} +export const deleteVendorRef: DeleteVendorRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteVendorRef: +```typescript +const name = deleteVendorRef.operationName; +console.log(name); +``` + +### Variables +The `DeleteVendor` mutation requires an argument of type `DeleteVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface DeleteVendorVariables { + id: UUIDString; +} +``` +### Return Type +Recall that executing the `DeleteVendor` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `DeleteVendorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface DeleteVendorData { + vendor_delete?: Vendor_Key | null; +} +``` +### Using `DeleteVendor`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, deleteVendor, DeleteVendorVariables } from '@dataconnect/generated'; + +// The `DeleteVendor` mutation requires an argument of type `DeleteVendorVariables`: +const deleteVendorVars: DeleteVendorVariables = { + id: ..., +}; + +// Call the `deleteVendor()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await deleteVendor(deleteVendorVars); +// Variables can be defined inline as well. +const { data } = await deleteVendor({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await deleteVendor(dataConnect, deleteVendorVars); + +console.log(data.vendor_delete); + +// Or, you can use the `Promise` API. +deleteVendor(deleteVendorVars).then((response) => { + const data = response.data; + console.log(data.vendor_delete); +}); +``` + +### Using `DeleteVendor`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, deleteVendorRef, DeleteVendorVariables } from '@dataconnect/generated'; + +// The `DeleteVendor` mutation requires an argument of type `DeleteVendorVariables`: +const deleteVendorVars: DeleteVendorVariables = { + id: ..., +}; + +// Call the `deleteVendorRef()` function to get a reference to the mutation. +const ref = deleteVendorRef(deleteVendorVars); +// Variables can be defined inline as well. +const ref = deleteVendorRef({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = deleteVendorRef(dataConnect, deleteVendorVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendor_delete); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendor_delete); +}); +``` + +## CreateVendorDefaultSetting +You can execute the `CreateVendorDefaultSetting` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +createVendorDefaultSetting(vars: CreateVendorDefaultSettingVariables): MutationPromise; + +interface CreateVendorDefaultSettingRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateVendorDefaultSettingVariables): MutationRef; +} +export const createVendorDefaultSettingRef: CreateVendorDefaultSettingRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +createVendorDefaultSetting(dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationPromise; + +interface CreateVendorDefaultSettingRef { + ... + (dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationRef; +} +export const createVendorDefaultSettingRef: CreateVendorDefaultSettingRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createVendorDefaultSettingRef: +```typescript +const name = createVendorDefaultSettingRef.operationName; +console.log(name); +``` + +### Variables +The `CreateVendorDefaultSetting` mutation requires an argument of type `CreateVendorDefaultSettingVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface CreateVendorDefaultSettingVariables { + vendorName: string; + defaultMarkupPercentage: number; + defaultVendorFeePercentage: number; +} +``` +### Return Type +Recall that executing the `CreateVendorDefaultSetting` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `CreateVendorDefaultSettingData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface CreateVendorDefaultSettingData { + vendorDefaultSetting_insert: VendorDefaultSetting_Key; +} +``` +### Using `CreateVendorDefaultSetting`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, createVendorDefaultSetting, CreateVendorDefaultSettingVariables } from '@dataconnect/generated'; + +// The `CreateVendorDefaultSetting` mutation requires an argument of type `CreateVendorDefaultSettingVariables`: +const createVendorDefaultSettingVars: CreateVendorDefaultSettingVariables = { + vendorName: ..., + defaultMarkupPercentage: ..., + defaultVendorFeePercentage: ..., +}; + +// Call the `createVendorDefaultSetting()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await createVendorDefaultSetting(createVendorDefaultSettingVars); +// Variables can be defined inline as well. +const { data } = await createVendorDefaultSetting({ vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await createVendorDefaultSetting(dataConnect, createVendorDefaultSettingVars); + +console.log(data.vendorDefaultSetting_insert); + +// Or, you can use the `Promise` API. +createVendorDefaultSetting(createVendorDefaultSettingVars).then((response) => { + const data = response.data; + console.log(data.vendorDefaultSetting_insert); +}); +``` + +### Using `CreateVendorDefaultSetting`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, createVendorDefaultSettingRef, CreateVendorDefaultSettingVariables } from '@dataconnect/generated'; + +// The `CreateVendorDefaultSetting` mutation requires an argument of type `CreateVendorDefaultSettingVariables`: +const createVendorDefaultSettingVars: CreateVendorDefaultSettingVariables = { + vendorName: ..., + defaultMarkupPercentage: ..., + defaultVendorFeePercentage: ..., +}; + +// Call the `createVendorDefaultSettingRef()` function to get a reference to the mutation. +const ref = createVendorDefaultSettingRef(createVendorDefaultSettingVars); +// Variables can be defined inline as well. +const ref = createVendorDefaultSettingRef({ vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = createVendorDefaultSettingRef(dataConnect, createVendorDefaultSettingVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendorDefaultSetting_insert); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendorDefaultSetting_insert); +}); +``` + +## UpdateVendorDefaultSetting +You can execute the `UpdateVendorDefaultSetting` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +updateVendorDefaultSetting(vars: UpdateVendorDefaultSettingVariables): MutationPromise; + +interface UpdateVendorDefaultSettingRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateVendorDefaultSettingVariables): MutationRef; +} +export const updateVendorDefaultSettingRef: UpdateVendorDefaultSettingRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +updateVendorDefaultSetting(dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationPromise; + +interface UpdateVendorDefaultSettingRef { + ... + (dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationRef; +} +export const updateVendorDefaultSettingRef: UpdateVendorDefaultSettingRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateVendorDefaultSettingRef: +```typescript +const name = updateVendorDefaultSettingRef.operationName; +console.log(name); +``` + +### Variables +The `UpdateVendorDefaultSetting` mutation requires an argument of type `UpdateVendorDefaultSettingVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface UpdateVendorDefaultSettingVariables { + id: UUIDString; + vendorName?: string | null; + defaultMarkupPercentage?: number | null; + defaultVendorFeePercentage?: number | null; +} +``` +### Return Type +Recall that executing the `UpdateVendorDefaultSetting` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `UpdateVendorDefaultSettingData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface UpdateVendorDefaultSettingData { + vendorDefaultSetting_update?: VendorDefaultSetting_Key | null; +} +``` +### Using `UpdateVendorDefaultSetting`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, updateVendorDefaultSetting, UpdateVendorDefaultSettingVariables } from '@dataconnect/generated'; + +// The `UpdateVendorDefaultSetting` mutation requires an argument of type `UpdateVendorDefaultSettingVariables`: +const updateVendorDefaultSettingVars: UpdateVendorDefaultSettingVariables = { + id: ..., + vendorName: ..., // optional + defaultMarkupPercentage: ..., // optional + defaultVendorFeePercentage: ..., // optional +}; + +// Call the `updateVendorDefaultSetting()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await updateVendorDefaultSetting(updateVendorDefaultSettingVars); +// Variables can be defined inline as well. +const { data } = await updateVendorDefaultSetting({ id: ..., vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await updateVendorDefaultSetting(dataConnect, updateVendorDefaultSettingVars); + +console.log(data.vendorDefaultSetting_update); + +// Or, you can use the `Promise` API. +updateVendorDefaultSetting(updateVendorDefaultSettingVars).then((response) => { + const data = response.data; + console.log(data.vendorDefaultSetting_update); +}); +``` + +### Using `UpdateVendorDefaultSetting`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, updateVendorDefaultSettingRef, UpdateVendorDefaultSettingVariables } from '@dataconnect/generated'; + +// The `UpdateVendorDefaultSetting` mutation requires an argument of type `UpdateVendorDefaultSettingVariables`: +const updateVendorDefaultSettingVars: UpdateVendorDefaultSettingVariables = { + id: ..., + vendorName: ..., // optional + defaultMarkupPercentage: ..., // optional + defaultVendorFeePercentage: ..., // optional +}; + +// Call the `updateVendorDefaultSettingRef()` function to get a reference to the mutation. +const ref = updateVendorDefaultSettingRef(updateVendorDefaultSettingVars); +// Variables can be defined inline as well. +const ref = updateVendorDefaultSettingRef({ id: ..., vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = updateVendorDefaultSettingRef(dataConnect, updateVendorDefaultSettingVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendorDefaultSetting_update); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendorDefaultSetting_update); +}); +``` + +## DeleteVendorDefaultSetting +You can execute the `DeleteVendorDefaultSetting` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +deleteVendorDefaultSetting(vars: DeleteVendorDefaultSettingVariables): MutationPromise; + +interface DeleteVendorDefaultSettingRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteVendorDefaultSettingVariables): MutationRef; +} +export const deleteVendorDefaultSettingRef: DeleteVendorDefaultSettingRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +deleteVendorDefaultSetting(dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationPromise; + +interface DeleteVendorDefaultSettingRef { + ... + (dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationRef; +} +export const deleteVendorDefaultSettingRef: DeleteVendorDefaultSettingRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteVendorDefaultSettingRef: +```typescript +const name = deleteVendorDefaultSettingRef.operationName; +console.log(name); +``` + +### Variables +The `DeleteVendorDefaultSetting` mutation requires an argument of type `DeleteVendorDefaultSettingVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface DeleteVendorDefaultSettingVariables { + id: UUIDString; +} +``` +### Return Type +Recall that executing the `DeleteVendorDefaultSetting` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `DeleteVendorDefaultSettingData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface DeleteVendorDefaultSettingData { + vendorDefaultSetting_delete?: VendorDefaultSetting_Key | null; +} +``` +### Using `DeleteVendorDefaultSetting`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, deleteVendorDefaultSetting, DeleteVendorDefaultSettingVariables } from '@dataconnect/generated'; + +// The `DeleteVendorDefaultSetting` mutation requires an argument of type `DeleteVendorDefaultSettingVariables`: +const deleteVendorDefaultSettingVars: DeleteVendorDefaultSettingVariables = { + id: ..., +}; + +// Call the `deleteVendorDefaultSetting()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await deleteVendorDefaultSetting(deleteVendorDefaultSettingVars); +// Variables can be defined inline as well. +const { data } = await deleteVendorDefaultSetting({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await deleteVendorDefaultSetting(dataConnect, deleteVendorDefaultSettingVars); + +console.log(data.vendorDefaultSetting_delete); + +// Or, you can use the `Promise` API. +deleteVendorDefaultSetting(deleteVendorDefaultSettingVars).then((response) => { + const data = response.data; + console.log(data.vendorDefaultSetting_delete); +}); +``` + +### Using `DeleteVendorDefaultSetting`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, deleteVendorDefaultSettingRef, DeleteVendorDefaultSettingVariables } from '@dataconnect/generated'; + +// The `DeleteVendorDefaultSetting` mutation requires an argument of type `DeleteVendorDefaultSettingVariables`: +const deleteVendorDefaultSettingVars: DeleteVendorDefaultSettingVariables = { + id: ..., +}; + +// Call the `deleteVendorDefaultSettingRef()` function to get a reference to the mutation. +const ref = deleteVendorDefaultSettingRef(deleteVendorDefaultSettingVars); +// Variables can be defined inline as well. +const ref = deleteVendorDefaultSettingRef({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = deleteVendorDefaultSettingRef(dataConnect, deleteVendorDefaultSettingVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendorDefaultSetting_delete); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendorDefaultSetting_delete); +}); +``` + +## CreateBusiness +You can execute the `CreateBusiness` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +createBusiness(vars: CreateBusinessVariables): MutationPromise; + +interface CreateBusinessRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateBusinessVariables): MutationRef; +} +export const createBusinessRef: CreateBusinessRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +createBusiness(dc: DataConnect, vars: CreateBusinessVariables): MutationPromise; + +interface CreateBusinessRef { + ... + (dc: DataConnect, vars: CreateBusinessVariables): MutationRef; +} +export const createBusinessRef: CreateBusinessRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createBusinessRef: +```typescript +const name = createBusinessRef.operationName; +console.log(name); +``` + +### Variables +The `CreateBusiness` mutation requires an argument of type `CreateBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface CreateBusinessVariables { + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; +} +``` +### Return Type +Recall that executing the `CreateBusiness` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `CreateBusinessData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface CreateBusinessData { + business_insert: Business_Key; +} +``` +### Using `CreateBusiness`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, createBusiness, CreateBusinessVariables } from '@dataconnect/generated'; + +// The `CreateBusiness` mutation requires an argument of type `CreateBusinessVariables`: +const createBusinessVars: CreateBusinessVariables = { + businessName: ..., + contactName: ..., + email: ..., // optional + sector: ..., // optional + rateGroup: ..., + status: ..., // optional +}; + +// Call the `createBusiness()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await createBusiness(createBusinessVars); +// Variables can be defined inline as well. +const { data } = await createBusiness({ businessName: ..., contactName: ..., email: ..., sector: ..., rateGroup: ..., status: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await createBusiness(dataConnect, createBusinessVars); + +console.log(data.business_insert); + +// Or, you can use the `Promise` API. +createBusiness(createBusinessVars).then((response) => { + const data = response.data; + console.log(data.business_insert); +}); +``` + +### Using `CreateBusiness`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, createBusinessRef, CreateBusinessVariables } from '@dataconnect/generated'; + +// The `CreateBusiness` mutation requires an argument of type `CreateBusinessVariables`: +const createBusinessVars: CreateBusinessVariables = { + businessName: ..., + contactName: ..., + email: ..., // optional + sector: ..., // optional + rateGroup: ..., + status: ..., // optional +}; + +// Call the `createBusinessRef()` function to get a reference to the mutation. +const ref = createBusinessRef(createBusinessVars); +// Variables can be defined inline as well. +const ref = createBusinessRef({ businessName: ..., contactName: ..., email: ..., sector: ..., rateGroup: ..., status: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = createBusinessRef(dataConnect, createBusinessVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.business_insert); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.business_insert); +}); +``` + +## UpdateBusiness +You can execute the `UpdateBusiness` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +updateBusiness(vars: UpdateBusinessVariables): MutationPromise; + +interface UpdateBusinessRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateBusinessVariables): MutationRef; +} +export const updateBusinessRef: UpdateBusinessRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +updateBusiness(dc: DataConnect, vars: UpdateBusinessVariables): MutationPromise; + +interface UpdateBusinessRef { + ... + (dc: DataConnect, vars: UpdateBusinessVariables): MutationRef; +} +export const updateBusinessRef: UpdateBusinessRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateBusinessRef: +```typescript +const name = updateBusinessRef.operationName; +console.log(name); +``` + +### Variables +The `UpdateBusiness` mutation requires an argument of type `UpdateBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface UpdateBusinessVariables { + id: UUIDString; + businessName?: string | null; + contactName?: string | null; + email?: string | null; + sector?: BusinessSector | null; + rateGroup?: BusinessRateGroup | null; + status?: BusinessStatus | null; +} +``` +### Return Type +Recall that executing the `UpdateBusiness` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `UpdateBusinessData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface UpdateBusinessData { + business_update?: Business_Key | null; +} +``` +### Using `UpdateBusiness`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, updateBusiness, UpdateBusinessVariables } from '@dataconnect/generated'; + +// The `UpdateBusiness` mutation requires an argument of type `UpdateBusinessVariables`: +const updateBusinessVars: UpdateBusinessVariables = { + id: ..., + businessName: ..., // optional + contactName: ..., // optional + email: ..., // optional + sector: ..., // optional + rateGroup: ..., // optional + status: ..., // optional +}; + +// Call the `updateBusiness()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await updateBusiness(updateBusinessVars); +// Variables can be defined inline as well. +const { data } = await updateBusiness({ id: ..., businessName: ..., contactName: ..., email: ..., sector: ..., rateGroup: ..., status: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await updateBusiness(dataConnect, updateBusinessVars); + +console.log(data.business_update); + +// Or, you can use the `Promise` API. +updateBusiness(updateBusinessVars).then((response) => { + const data = response.data; + console.log(data.business_update); +}); +``` + +### Using `UpdateBusiness`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, updateBusinessRef, UpdateBusinessVariables } from '@dataconnect/generated'; + +// The `UpdateBusiness` mutation requires an argument of type `UpdateBusinessVariables`: +const updateBusinessVars: UpdateBusinessVariables = { + id: ..., + businessName: ..., // optional + contactName: ..., // optional + email: ..., // optional + sector: ..., // optional + rateGroup: ..., // optional + status: ..., // optional +}; + +// Call the `updateBusinessRef()` function to get a reference to the mutation. +const ref = updateBusinessRef(updateBusinessVars); +// Variables can be defined inline as well. +const ref = updateBusinessRef({ id: ..., businessName: ..., contactName: ..., email: ..., sector: ..., rateGroup: ..., status: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = updateBusinessRef(dataConnect, updateBusinessVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.business_update); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.business_update); +}); +``` + +## DeleteBusiness +You can execute the `DeleteBusiness` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +deleteBusiness(vars: DeleteBusinessVariables): MutationPromise; + +interface DeleteBusinessRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteBusinessVariables): MutationRef; +} +export const deleteBusinessRef: DeleteBusinessRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +deleteBusiness(dc: DataConnect, vars: DeleteBusinessVariables): MutationPromise; + +interface DeleteBusinessRef { + ... + (dc: DataConnect, vars: DeleteBusinessVariables): MutationRef; +} +export const deleteBusinessRef: DeleteBusinessRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteBusinessRef: +```typescript +const name = deleteBusinessRef.operationName; +console.log(name); +``` + +### Variables +The `DeleteBusiness` mutation requires an argument of type `DeleteBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface DeleteBusinessVariables { + id: UUIDString; +} +``` +### Return Type +Recall that executing the `DeleteBusiness` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `DeleteBusinessData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface DeleteBusinessData { + business_delete?: Business_Key | null; +} +``` +### Using `DeleteBusiness`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, deleteBusiness, DeleteBusinessVariables } from '@dataconnect/generated'; + +// The `DeleteBusiness` mutation requires an argument of type `DeleteBusinessVariables`: +const deleteBusinessVars: DeleteBusinessVariables = { + id: ..., +}; + +// Call the `deleteBusiness()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await deleteBusiness(deleteBusinessVars); +// Variables can be defined inline as well. +const { data } = await deleteBusiness({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await deleteBusiness(dataConnect, deleteBusinessVars); + +console.log(data.business_delete); + +// Or, you can use the `Promise` API. +deleteBusiness(deleteBusinessVars).then((response) => { + const data = response.data; + console.log(data.business_delete); +}); +``` + +### Using `DeleteBusiness`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, deleteBusinessRef, DeleteBusinessVariables } from '@dataconnect/generated'; + +// The `DeleteBusiness` mutation requires an argument of type `DeleteBusinessVariables`: +const deleteBusinessVars: DeleteBusinessVariables = { + id: ..., +}; + +// Call the `deleteBusinessRef()` function to get a reference to the mutation. +const ref = deleteBusinessRef(deleteBusinessVars); +// Variables can be defined inline as well. +const ref = deleteBusinessRef({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = deleteBusinessRef(dataConnect, deleteBusinessVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.business_delete); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.business_delete); +}); +``` + diff --git a/frontend-web/src/dataconnect-generated/esm/index.esm.js b/frontend-web/src/dataconnect-generated/esm/index.esm.js index a70452f4..19fba0a5 100644 --- a/frontend-web/src/dataconnect-generated/esm/index.esm.js +++ b/frontend-web/src/dataconnect-generated/esm/index.esm.js @@ -7,6 +7,28 @@ export const BackgroundCheckStatus = { EXPIRED: "EXPIRED", } +export const BusinessRateGroup = { + STANDARD: "STANDARD", + PREMIUM: "PREMIUM", + ENTERPRISE: "ENTERPRISE", + CUSTOM: "CUSTOM", +} + +export const BusinessSector = { + BON_APPETIT: "BON_APPETIT", + EUREST: "EUREST", + ARAMARK: "ARAMARK", + EPICUREAN_GROUP: "EPICUREAN_GROUP", + CHARTWELLS: "CHARTWELLS", + OTHER: "OTHER", +} + +export const BusinessStatus = { + ACTIVE: "ACTIVE", + INACTIVE: "INACTIVE", + PENDING: "PENDING", +} + export const ContractType = { W2: "W2", C1099: "C1099", @@ -93,48 +115,70 @@ export const connectorConfig = { location: 'us-central1' }; -export const listStaffRef = (dc) => { +export const listBusinessRef = (dc) => { const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'listStaff'); + return queryRef(dcInstance, 'listBusiness'); } -listStaffRef.operationName = 'listStaff'; +listBusinessRef.operationName = 'listBusiness'; -export function listStaff(dc) { - return executeQuery(listStaffRef(dc)); +export function listBusiness(dc) { + return executeQuery(listBusinessRef(dc)); } -export const createVendorRef = (dcOrVars, vars) => { +export const getBusinessByIdRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateVendor', inputVars); + return queryRef(dcInstance, 'getBusinessById', inputVars); } -createVendorRef.operationName = 'CreateVendor'; +getBusinessByIdRef.operationName = 'getBusinessById'; -export function createVendor(dcOrVars, vars) { - return executeMutation(createVendorRef(dcOrVars, vars)); +export function getBusinessById(dcOrVars, vars) { + return executeQuery(getBusinessByIdRef(dcOrVars, vars)); } -export const updateVendorRef = (dcOrVars, vars) => { +export const filterBusinessRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'filterBusiness', inputVars); +} +filterBusinessRef.operationName = 'filterBusiness'; + +export function filterBusiness(dcOrVars, vars) { + return executeQuery(filterBusinessRef(dcOrVars, vars)); +} + +export const createEventRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'UpdateVendor', inputVars); + return mutationRef(dcInstance, 'CreateEvent', inputVars); } -updateVendorRef.operationName = 'UpdateVendor'; +createEventRef.operationName = 'CreateEvent'; -export function updateVendor(dcOrVars, vars) { - return executeMutation(updateVendorRef(dcOrVars, vars)); +export function createEvent(dcOrVars, vars) { + return executeMutation(createEventRef(dcOrVars, vars)); } -export const deleteVendorRef = (dcOrVars, vars) => { +export const updateEventRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'DeleteVendor', inputVars); + return mutationRef(dcInstance, 'UpdateEvent', inputVars); } -deleteVendorRef.operationName = 'DeleteVendor'; +updateEventRef.operationName = 'UpdateEvent'; -export function deleteVendor(dcOrVars, vars) { - return executeMutation(deleteVendorRef(dcOrVars, vars)); +export function updateEvent(dcOrVars, vars) { + return executeMutation(updateEventRef(dcOrVars, vars)); +} + +export const deleteEventRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteEvent', inputVars); +} +deleteEventRef.operationName = 'DeleteEvent'; + +export function deleteEvent(dcOrVars, vars) { + return executeMutation(deleteEventRef(dcOrVars, vars)); } export const listVendorDefaultSettingsRef = (dc) => { @@ -170,149 +214,6 @@ export function filterVendorDefaultSettings(dcOrVars, vars) { return executeQuery(filterVendorDefaultSettingsRef(dcOrVars, vars)); } -export const listEventsRef = (dc) => { - const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'listEvents'); -} -listEventsRef.operationName = 'listEvents'; - -export function listEvents(dc) { - return executeQuery(listEventsRef(dc)); -} - -export const getEventByIdRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'getEventById', inputVars); -} -getEventByIdRef.operationName = 'getEventById'; - -export function getEventById(dcOrVars, vars) { - return executeQuery(getEventByIdRef(dcOrVars, vars)); -} - -export const filterEventsRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'filterEvents', inputVars); -} -filterEventsRef.operationName = 'filterEvents'; - -export function filterEvents(dcOrVars, vars) { - return executeQuery(filterEventsRef(dcOrVars, vars)); -} - -export const createInvoiceRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateInvoice', inputVars); -} -createInvoiceRef.operationName = 'CreateInvoice'; - -export function createInvoice(dcOrVars, vars) { - return executeMutation(createInvoiceRef(dcOrVars, vars)); -} - -export const updateInvoiceRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'UpdateInvoice', inputVars); -} -updateInvoiceRef.operationName = 'UpdateInvoice'; - -export function updateInvoice(dcOrVars, vars) { - return executeMutation(updateInvoiceRef(dcOrVars, vars)); -} - -export const deleteInvoiceRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'DeleteInvoice', inputVars); -} -deleteInvoiceRef.operationName = 'DeleteInvoice'; - -export function deleteInvoice(dcOrVars, vars) { - return executeMutation(deleteInvoiceRef(dcOrVars, vars)); -} - -export const createStaffRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateStaff', inputVars); -} -createStaffRef.operationName = 'CreateStaff'; - -export function createStaff(dcOrVars, vars) { - return executeMutation(createStaffRef(dcOrVars, vars)); -} - -export const listVendorRef = (dc) => { - const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'listVendor'); -} -listVendorRef.operationName = 'listVendor'; - -export function listVendor(dc) { - return executeQuery(listVendorRef(dc)); -} - -export const getVendorByIdRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'getVendorById', inputVars); -} -getVendorByIdRef.operationName = 'getVendorById'; - -export function getVendorById(dcOrVars, vars) { - return executeQuery(getVendorByIdRef(dcOrVars, vars)); -} - -export const filterVendorsRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'filterVendors', inputVars); -} -filterVendorsRef.operationName = 'filterVendors'; - -export function filterVendors(dcOrVars, vars) { - return executeQuery(filterVendorsRef(dcOrVars, vars)); -} - -export const createVendorDefaultSettingRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateVendorDefaultSetting', inputVars); -} -createVendorDefaultSettingRef.operationName = 'CreateVendorDefaultSetting'; - -export function createVendorDefaultSetting(dcOrVars, vars) { - return executeMutation(createVendorDefaultSettingRef(dcOrVars, vars)); -} - -export const updateVendorDefaultSettingRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'UpdateVendorDefaultSetting', inputVars); -} -updateVendorDefaultSettingRef.operationName = 'UpdateVendorDefaultSetting'; - -export function updateVendorDefaultSetting(dcOrVars, vars) { - return executeMutation(updateVendorDefaultSettingRef(dcOrVars, vars)); -} - -export const deleteVendorDefaultSettingRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'DeleteVendorDefaultSetting', inputVars); -} -deleteVendorDefaultSettingRef.operationName = 'DeleteVendorDefaultSetting'; - -export function deleteVendorDefaultSetting(dcOrVars, vars) { - return executeMutation(deleteVendorDefaultSettingRef(dcOrVars, vars)); -} - export const createVendorRateRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); @@ -379,37 +280,70 @@ export function filterVendorRates(dcOrVars, vars) { return executeQuery(filterVendorRatesRef(dcOrVars, vars)); } -export const createEventRef = (dcOrVars, vars) => { +export const listEventsRef = (dc) => { + const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'listEvents'); +} +listEventsRef.operationName = 'listEvents'; + +export function listEvents(dc) { + return executeQuery(listEventsRef(dc)); +} + +export const getEventByIdRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateEvent', inputVars); + return queryRef(dcInstance, 'getEventById', inputVars); } -createEventRef.operationName = 'CreateEvent'; +getEventByIdRef.operationName = 'getEventById'; -export function createEvent(dcOrVars, vars) { - return executeMutation(createEventRef(dcOrVars, vars)); +export function getEventById(dcOrVars, vars) { + return executeQuery(getEventByIdRef(dcOrVars, vars)); } -export const updateEventRef = (dcOrVars, vars) => { +export const filterEventsRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'filterEvents', inputVars); +} +filterEventsRef.operationName = 'filterEvents'; + +export function filterEvents(dcOrVars, vars) { + return executeQuery(filterEventsRef(dcOrVars, vars)); +} + +export const createInvoiceRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'UpdateEvent', inputVars); + return mutationRef(dcInstance, 'CreateInvoice', inputVars); } -updateEventRef.operationName = 'UpdateEvent'; +createInvoiceRef.operationName = 'CreateInvoice'; -export function updateEvent(dcOrVars, vars) { - return executeMutation(updateEventRef(dcOrVars, vars)); +export function createInvoice(dcOrVars, vars) { + return executeMutation(createInvoiceRef(dcOrVars, vars)); } -export const deleteEventRef = (dcOrVars, vars) => { +export const updateInvoiceRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'DeleteEvent', inputVars); + return mutationRef(dcInstance, 'UpdateInvoice', inputVars); } -deleteEventRef.operationName = 'DeleteEvent'; +updateInvoiceRef.operationName = 'UpdateInvoice'; -export function deleteEvent(dcOrVars, vars) { - return executeMutation(deleteEventRef(dcOrVars, vars)); +export function updateInvoice(dcOrVars, vars) { + return executeMutation(updateInvoiceRef(dcOrVars, vars)); +} + +export const deleteInvoiceRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteInvoice', inputVars); +} +deleteInvoiceRef.operationName = 'DeleteInvoice'; + +export function deleteInvoice(dcOrVars, vars) { + return executeMutation(deleteInvoiceRef(dcOrVars, vars)); } export const listInvoiceRef = (dc) => { @@ -445,3 +379,157 @@ export function filterInvoices(dcOrVars, vars) { return executeQuery(filterInvoicesRef(dcOrVars, vars)); } +export const createStaffRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'CreateStaff', inputVars); +} +createStaffRef.operationName = 'CreateStaff'; + +export function createStaff(dcOrVars, vars) { + return executeMutation(createStaffRef(dcOrVars, vars)); +} + +export const listStaffRef = (dc) => { + const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'listStaff'); +} +listStaffRef.operationName = 'listStaff'; + +export function listStaff(dc) { + return executeQuery(listStaffRef(dc)); +} + +export const createVendorRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'CreateVendor', inputVars); +} +createVendorRef.operationName = 'CreateVendor'; + +export function createVendor(dcOrVars, vars) { + return executeMutation(createVendorRef(dcOrVars, vars)); +} + +export const updateVendorRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'UpdateVendor', inputVars); +} +updateVendorRef.operationName = 'UpdateVendor'; + +export function updateVendor(dcOrVars, vars) { + return executeMutation(updateVendorRef(dcOrVars, vars)); +} + +export const deleteVendorRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteVendor', inputVars); +} +deleteVendorRef.operationName = 'DeleteVendor'; + +export function deleteVendor(dcOrVars, vars) { + return executeMutation(deleteVendorRef(dcOrVars, vars)); +} + +export const listVendorRef = (dc) => { + const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'listVendor'); +} +listVendorRef.operationName = 'listVendor'; + +export function listVendor(dc) { + return executeQuery(listVendorRef(dc)); +} + +export const getVendorByIdRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'getVendorById', inputVars); +} +getVendorByIdRef.operationName = 'getVendorById'; + +export function getVendorById(dcOrVars, vars) { + return executeQuery(getVendorByIdRef(dcOrVars, vars)); +} + +export const filterVendorsRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'filterVendors', inputVars); +} +filterVendorsRef.operationName = 'filterVendors'; + +export function filterVendors(dcOrVars, vars) { + return executeQuery(filterVendorsRef(dcOrVars, vars)); +} + +export const createVendorDefaultSettingRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'CreateVendorDefaultSetting', inputVars); +} +createVendorDefaultSettingRef.operationName = 'CreateVendorDefaultSetting'; + +export function createVendorDefaultSetting(dcOrVars, vars) { + return executeMutation(createVendorDefaultSettingRef(dcOrVars, vars)); +} + +export const updateVendorDefaultSettingRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'UpdateVendorDefaultSetting', inputVars); +} +updateVendorDefaultSettingRef.operationName = 'UpdateVendorDefaultSetting'; + +export function updateVendorDefaultSetting(dcOrVars, vars) { + return executeMutation(updateVendorDefaultSettingRef(dcOrVars, vars)); +} + +export const deleteVendorDefaultSettingRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteVendorDefaultSetting', inputVars); +} +deleteVendorDefaultSettingRef.operationName = 'DeleteVendorDefaultSetting'; + +export function deleteVendorDefaultSetting(dcOrVars, vars) { + return executeMutation(deleteVendorDefaultSettingRef(dcOrVars, vars)); +} + +export const createBusinessRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'CreateBusiness', inputVars); +} +createBusinessRef.operationName = 'CreateBusiness'; + +export function createBusiness(dcOrVars, vars) { + return executeMutation(createBusinessRef(dcOrVars, vars)); +} + +export const updateBusinessRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'UpdateBusiness', inputVars); +} +updateBusinessRef.operationName = 'UpdateBusiness'; + +export function updateBusiness(dcOrVars, vars) { + return executeMutation(updateBusinessRef(dcOrVars, vars)); +} + +export const deleteBusinessRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteBusiness', inputVars); +} +deleteBusinessRef.operationName = 'DeleteBusiness'; + +export function deleteBusiness(dcOrVars, vars) { + return executeMutation(deleteBusinessRef(dcOrVars, vars)); +} + diff --git a/frontend-web/src/dataconnect-generated/index.cjs.js b/frontend-web/src/dataconnect-generated/index.cjs.js index 966dc199..97caf790 100644 --- a/frontend-web/src/dataconnect-generated/index.cjs.js +++ b/frontend-web/src/dataconnect-generated/index.cjs.js @@ -8,6 +8,31 @@ const BackgroundCheckStatus = { } exports.BackgroundCheckStatus = BackgroundCheckStatus; +const BusinessRateGroup = { + STANDARD: "STANDARD", + PREMIUM: "PREMIUM", + ENTERPRISE: "ENTERPRISE", + CUSTOM: "CUSTOM", +} +exports.BusinessRateGroup = BusinessRateGroup; + +const BusinessSector = { + BON_APPETIT: "BON_APPETIT", + EUREST: "EUREST", + ARAMARK: "ARAMARK", + EPICUREAN_GROUP: "EPICUREAN_GROUP", + CHARTWELLS: "CHARTWELLS", + OTHER: "OTHER", +} +exports.BusinessSector = BusinessSector; + +const BusinessStatus = { + ACTIVE: "ACTIVE", + INACTIVE: "INACTIVE", + PENDING: "PENDING", +} +exports.BusinessStatus = BusinessStatus; + const ContractType = { W2: "W2", C1099: "C1099", @@ -104,52 +129,76 @@ const connectorConfig = { }; exports.connectorConfig = connectorConfig; -const listStaffRef = (dc) => { +const listBusinessRef = (dc) => { const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'listStaff'); + return queryRef(dcInstance, 'listBusiness'); } -listStaffRef.operationName = 'listStaff'; -exports.listStaffRef = listStaffRef; +listBusinessRef.operationName = 'listBusiness'; +exports.listBusinessRef = listBusinessRef; -exports.listStaff = function listStaff(dc) { - return executeQuery(listStaffRef(dc)); +exports.listBusiness = function listBusiness(dc) { + return executeQuery(listBusinessRef(dc)); }; -const createVendorRef = (dcOrVars, vars) => { +const getBusinessByIdRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateVendor', inputVars); + return queryRef(dcInstance, 'getBusinessById', inputVars); } -createVendorRef.operationName = 'CreateVendor'; -exports.createVendorRef = createVendorRef; +getBusinessByIdRef.operationName = 'getBusinessById'; +exports.getBusinessByIdRef = getBusinessByIdRef; -exports.createVendor = function createVendor(dcOrVars, vars) { - return executeMutation(createVendorRef(dcOrVars, vars)); +exports.getBusinessById = function getBusinessById(dcOrVars, vars) { + return executeQuery(getBusinessByIdRef(dcOrVars, vars)); }; -const updateVendorRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); +const filterBusinessRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'UpdateVendor', inputVars); + return queryRef(dcInstance, 'filterBusiness', inputVars); } -updateVendorRef.operationName = 'UpdateVendor'; -exports.updateVendorRef = updateVendorRef; +filterBusinessRef.operationName = 'filterBusiness'; +exports.filterBusinessRef = filterBusinessRef; -exports.updateVendor = function updateVendor(dcOrVars, vars) { - return executeMutation(updateVendorRef(dcOrVars, vars)); +exports.filterBusiness = function filterBusiness(dcOrVars, vars) { + return executeQuery(filterBusinessRef(dcOrVars, vars)); }; -const deleteVendorRef = (dcOrVars, vars) => { +const createEventRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'DeleteVendor', inputVars); + return mutationRef(dcInstance, 'CreateEvent', inputVars); } -deleteVendorRef.operationName = 'DeleteVendor'; -exports.deleteVendorRef = deleteVendorRef; +createEventRef.operationName = 'CreateEvent'; +exports.createEventRef = createEventRef; -exports.deleteVendor = function deleteVendor(dcOrVars, vars) { - return executeMutation(deleteVendorRef(dcOrVars, vars)); +exports.createEvent = function createEvent(dcOrVars, vars) { + return executeMutation(createEventRef(dcOrVars, vars)); +}; + +const updateEventRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'UpdateEvent', inputVars); +} +updateEventRef.operationName = 'UpdateEvent'; +exports.updateEventRef = updateEventRef; + +exports.updateEvent = function updateEvent(dcOrVars, vars) { + return executeMutation(updateEventRef(dcOrVars, vars)); +}; + +const deleteEventRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteEvent', inputVars); +} +deleteEventRef.operationName = 'DeleteEvent'; +exports.deleteEventRef = deleteEventRef; + +exports.deleteEvent = function deleteEvent(dcOrVars, vars) { + return executeMutation(deleteEventRef(dcOrVars, vars)); }; const listVendorDefaultSettingsRef = (dc) => { @@ -188,162 +237,6 @@ exports.filterVendorDefaultSettings = function filterVendorDefaultSettings(dcOrV return executeQuery(filterVendorDefaultSettingsRef(dcOrVars, vars)); }; -const listEventsRef = (dc) => { - const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'listEvents'); -} -listEventsRef.operationName = 'listEvents'; -exports.listEventsRef = listEventsRef; - -exports.listEvents = function listEvents(dc) { - return executeQuery(listEventsRef(dc)); -}; - -const getEventByIdRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'getEventById', inputVars); -} -getEventByIdRef.operationName = 'getEventById'; -exports.getEventByIdRef = getEventByIdRef; - -exports.getEventById = function getEventById(dcOrVars, vars) { - return executeQuery(getEventByIdRef(dcOrVars, vars)); -}; - -const filterEventsRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'filterEvents', inputVars); -} -filterEventsRef.operationName = 'filterEvents'; -exports.filterEventsRef = filterEventsRef; - -exports.filterEvents = function filterEvents(dcOrVars, vars) { - return executeQuery(filterEventsRef(dcOrVars, vars)); -}; - -const createInvoiceRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateInvoice', inputVars); -} -createInvoiceRef.operationName = 'CreateInvoice'; -exports.createInvoiceRef = createInvoiceRef; - -exports.createInvoice = function createInvoice(dcOrVars, vars) { - return executeMutation(createInvoiceRef(dcOrVars, vars)); -}; - -const updateInvoiceRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'UpdateInvoice', inputVars); -} -updateInvoiceRef.operationName = 'UpdateInvoice'; -exports.updateInvoiceRef = updateInvoiceRef; - -exports.updateInvoice = function updateInvoice(dcOrVars, vars) { - return executeMutation(updateInvoiceRef(dcOrVars, vars)); -}; - -const deleteInvoiceRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'DeleteInvoice', inputVars); -} -deleteInvoiceRef.operationName = 'DeleteInvoice'; -exports.deleteInvoiceRef = deleteInvoiceRef; - -exports.deleteInvoice = function deleteInvoice(dcOrVars, vars) { - return executeMutation(deleteInvoiceRef(dcOrVars, vars)); -}; - -const createStaffRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateStaff', inputVars); -} -createStaffRef.operationName = 'CreateStaff'; -exports.createStaffRef = createStaffRef; - -exports.createStaff = function createStaff(dcOrVars, vars) { - return executeMutation(createStaffRef(dcOrVars, vars)); -}; - -const listVendorRef = (dc) => { - const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'listVendor'); -} -listVendorRef.operationName = 'listVendor'; -exports.listVendorRef = listVendorRef; - -exports.listVendor = function listVendor(dc) { - return executeQuery(listVendorRef(dc)); -}; - -const getVendorByIdRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'getVendorById', inputVars); -} -getVendorByIdRef.operationName = 'getVendorById'; -exports.getVendorByIdRef = getVendorByIdRef; - -exports.getVendorById = function getVendorById(dcOrVars, vars) { - return executeQuery(getVendorByIdRef(dcOrVars, vars)); -}; - -const filterVendorsRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'filterVendors', inputVars); -} -filterVendorsRef.operationName = 'filterVendors'; -exports.filterVendorsRef = filterVendorsRef; - -exports.filterVendors = function filterVendors(dcOrVars, vars) { - return executeQuery(filterVendorsRef(dcOrVars, vars)); -}; - -const createVendorDefaultSettingRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateVendorDefaultSetting', inputVars); -} -createVendorDefaultSettingRef.operationName = 'CreateVendorDefaultSetting'; -exports.createVendorDefaultSettingRef = createVendorDefaultSettingRef; - -exports.createVendorDefaultSetting = function createVendorDefaultSetting(dcOrVars, vars) { - return executeMutation(createVendorDefaultSettingRef(dcOrVars, vars)); -}; - -const updateVendorDefaultSettingRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'UpdateVendorDefaultSetting', inputVars); -} -updateVendorDefaultSettingRef.operationName = 'UpdateVendorDefaultSetting'; -exports.updateVendorDefaultSettingRef = updateVendorDefaultSettingRef; - -exports.updateVendorDefaultSetting = function updateVendorDefaultSetting(dcOrVars, vars) { - return executeMutation(updateVendorDefaultSettingRef(dcOrVars, vars)); -}; - -const deleteVendorDefaultSettingRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'DeleteVendorDefaultSetting', inputVars); -} -deleteVendorDefaultSettingRef.operationName = 'DeleteVendorDefaultSetting'; -exports.deleteVendorDefaultSettingRef = deleteVendorDefaultSettingRef; - -exports.deleteVendorDefaultSetting = function deleteVendorDefaultSetting(dcOrVars, vars) { - return executeMutation(deleteVendorDefaultSettingRef(dcOrVars, vars)); -}; - const createVendorRateRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); @@ -416,40 +309,76 @@ exports.filterVendorRates = function filterVendorRates(dcOrVars, vars) { return executeQuery(filterVendorRatesRef(dcOrVars, vars)); }; -const createEventRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); +const listEventsRef = (dc) => { + const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateEvent', inputVars); + return queryRef(dcInstance, 'listEvents'); } -createEventRef.operationName = 'CreateEvent'; -exports.createEventRef = createEventRef; +listEventsRef.operationName = 'listEvents'; +exports.listEventsRef = listEventsRef; -exports.createEvent = function createEvent(dcOrVars, vars) { - return executeMutation(createEventRef(dcOrVars, vars)); +exports.listEvents = function listEvents(dc) { + return executeQuery(listEventsRef(dc)); }; -const updateEventRef = (dcOrVars, vars) => { +const getEventByIdRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'UpdateEvent', inputVars); + return queryRef(dcInstance, 'getEventById', inputVars); } -updateEventRef.operationName = 'UpdateEvent'; -exports.updateEventRef = updateEventRef; +getEventByIdRef.operationName = 'getEventById'; +exports.getEventByIdRef = getEventByIdRef; -exports.updateEvent = function updateEvent(dcOrVars, vars) { - return executeMutation(updateEventRef(dcOrVars, vars)); +exports.getEventById = function getEventById(dcOrVars, vars) { + return executeQuery(getEventByIdRef(dcOrVars, vars)); }; -const deleteEventRef = (dcOrVars, vars) => { +const filterEventsRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'filterEvents', inputVars); +} +filterEventsRef.operationName = 'filterEvents'; +exports.filterEventsRef = filterEventsRef; + +exports.filterEvents = function filterEvents(dcOrVars, vars) { + return executeQuery(filterEventsRef(dcOrVars, vars)); +}; + +const createInvoiceRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'DeleteEvent', inputVars); + return mutationRef(dcInstance, 'CreateInvoice', inputVars); } -deleteEventRef.operationName = 'DeleteEvent'; -exports.deleteEventRef = deleteEventRef; +createInvoiceRef.operationName = 'CreateInvoice'; +exports.createInvoiceRef = createInvoiceRef; -exports.deleteEvent = function deleteEvent(dcOrVars, vars) { - return executeMutation(deleteEventRef(dcOrVars, vars)); +exports.createInvoice = function createInvoice(dcOrVars, vars) { + return executeMutation(createInvoiceRef(dcOrVars, vars)); +}; + +const updateInvoiceRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'UpdateInvoice', inputVars); +} +updateInvoiceRef.operationName = 'UpdateInvoice'; +exports.updateInvoiceRef = updateInvoiceRef; + +exports.updateInvoice = function updateInvoice(dcOrVars, vars) { + return executeMutation(updateInvoiceRef(dcOrVars, vars)); +}; + +const deleteInvoiceRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteInvoice', inputVars); +} +deleteInvoiceRef.operationName = 'DeleteInvoice'; +exports.deleteInvoiceRef = deleteInvoiceRef; + +exports.deleteInvoice = function deleteInvoice(dcOrVars, vars) { + return executeMutation(deleteInvoiceRef(dcOrVars, vars)); }; const listInvoiceRef = (dc) => { @@ -487,3 +416,171 @@ exports.filterInvoicesRef = filterInvoicesRef; exports.filterInvoices = function filterInvoices(dcOrVars, vars) { return executeQuery(filterInvoicesRef(dcOrVars, vars)); }; + +const createStaffRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'CreateStaff', inputVars); +} +createStaffRef.operationName = 'CreateStaff'; +exports.createStaffRef = createStaffRef; + +exports.createStaff = function createStaff(dcOrVars, vars) { + return executeMutation(createStaffRef(dcOrVars, vars)); +}; + +const listStaffRef = (dc) => { + const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'listStaff'); +} +listStaffRef.operationName = 'listStaff'; +exports.listStaffRef = listStaffRef; + +exports.listStaff = function listStaff(dc) { + return executeQuery(listStaffRef(dc)); +}; + +const createVendorRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'CreateVendor', inputVars); +} +createVendorRef.operationName = 'CreateVendor'; +exports.createVendorRef = createVendorRef; + +exports.createVendor = function createVendor(dcOrVars, vars) { + return executeMutation(createVendorRef(dcOrVars, vars)); +}; + +const updateVendorRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'UpdateVendor', inputVars); +} +updateVendorRef.operationName = 'UpdateVendor'; +exports.updateVendorRef = updateVendorRef; + +exports.updateVendor = function updateVendor(dcOrVars, vars) { + return executeMutation(updateVendorRef(dcOrVars, vars)); +}; + +const deleteVendorRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteVendor', inputVars); +} +deleteVendorRef.operationName = 'DeleteVendor'; +exports.deleteVendorRef = deleteVendorRef; + +exports.deleteVendor = function deleteVendor(dcOrVars, vars) { + return executeMutation(deleteVendorRef(dcOrVars, vars)); +}; + +const listVendorRef = (dc) => { + const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'listVendor'); +} +listVendorRef.operationName = 'listVendor'; +exports.listVendorRef = listVendorRef; + +exports.listVendor = function listVendor(dc) { + return executeQuery(listVendorRef(dc)); +}; + +const getVendorByIdRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'getVendorById', inputVars); +} +getVendorByIdRef.operationName = 'getVendorById'; +exports.getVendorByIdRef = getVendorByIdRef; + +exports.getVendorById = function getVendorById(dcOrVars, vars) { + return executeQuery(getVendorByIdRef(dcOrVars, vars)); +}; + +const filterVendorsRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'filterVendors', inputVars); +} +filterVendorsRef.operationName = 'filterVendors'; +exports.filterVendorsRef = filterVendorsRef; + +exports.filterVendors = function filterVendors(dcOrVars, vars) { + return executeQuery(filterVendorsRef(dcOrVars, vars)); +}; + +const createVendorDefaultSettingRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'CreateVendorDefaultSetting', inputVars); +} +createVendorDefaultSettingRef.operationName = 'CreateVendorDefaultSetting'; +exports.createVendorDefaultSettingRef = createVendorDefaultSettingRef; + +exports.createVendorDefaultSetting = function createVendorDefaultSetting(dcOrVars, vars) { + return executeMutation(createVendorDefaultSettingRef(dcOrVars, vars)); +}; + +const updateVendorDefaultSettingRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'UpdateVendorDefaultSetting', inputVars); +} +updateVendorDefaultSettingRef.operationName = 'UpdateVendorDefaultSetting'; +exports.updateVendorDefaultSettingRef = updateVendorDefaultSettingRef; + +exports.updateVendorDefaultSetting = function updateVendorDefaultSetting(dcOrVars, vars) { + return executeMutation(updateVendorDefaultSettingRef(dcOrVars, vars)); +}; + +const deleteVendorDefaultSettingRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteVendorDefaultSetting', inputVars); +} +deleteVendorDefaultSettingRef.operationName = 'DeleteVendorDefaultSetting'; +exports.deleteVendorDefaultSettingRef = deleteVendorDefaultSettingRef; + +exports.deleteVendorDefaultSetting = function deleteVendorDefaultSetting(dcOrVars, vars) { + return executeMutation(deleteVendorDefaultSettingRef(dcOrVars, vars)); +}; + +const createBusinessRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'CreateBusiness', inputVars); +} +createBusinessRef.operationName = 'CreateBusiness'; +exports.createBusinessRef = createBusinessRef; + +exports.createBusiness = function createBusiness(dcOrVars, vars) { + return executeMutation(createBusinessRef(dcOrVars, vars)); +}; + +const updateBusinessRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'UpdateBusiness', inputVars); +} +updateBusinessRef.operationName = 'UpdateBusiness'; +exports.updateBusinessRef = updateBusinessRef; + +exports.updateBusiness = function updateBusiness(dcOrVars, vars) { + return executeMutation(updateBusinessRef(dcOrVars, vars)); +}; + +const deleteBusinessRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteBusiness', inputVars); +} +deleteBusinessRef.operationName = 'DeleteBusiness'; +exports.deleteBusinessRef = deleteBusinessRef; + +exports.deleteBusiness = function deleteBusiness(dcOrVars, vars) { + return executeMutation(deleteBusinessRef(dcOrVars, vars)); +}; diff --git a/frontend-web/src/dataconnect-generated/index.d.ts b/frontend-web/src/dataconnect-generated/index.d.ts index eb1a912d..ae0b3539 100644 --- a/frontend-web/src/dataconnect-generated/index.d.ts +++ b/frontend-web/src/dataconnect-generated/index.d.ts @@ -15,6 +15,28 @@ export enum BackgroundCheckStatus { EXPIRED = "EXPIRED", }; +export enum BusinessRateGroup { + STANDARD = "STANDARD", + PREMIUM = "PREMIUM", + ENTERPRISE = "ENTERPRISE", + CUSTOM = "CUSTOM", +}; + +export enum BusinessSector { + BON_APPETIT = "BON_APPETIT", + EUREST = "EUREST", + ARAMARK = "ARAMARK", + EPICUREAN_GROUP = "EPICUREAN_GROUP", + CHARTWELLS = "CHARTWELLS", + OTHER = "OTHER", +}; + +export enum BusinessStatus { + ACTIVE = "ACTIVE", + INACTIVE = "INACTIVE", + PENDING = "PENDING", +}; + export enum ContractType { W2 = "W2", C1099 = "C1099", @@ -97,6 +119,24 @@ export enum VendorRegion { +export interface Business_Key { + id: UUIDString; + __typename?: 'Business_Key'; +} + +export interface CreateBusinessData { + business_insert: Business_Key; +} + +export interface CreateBusinessVariables { + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; +} + export interface CreateEventData { event_insert: Event_Key; } @@ -206,6 +246,14 @@ export interface CreateVendorVariables { isActive?: boolean | null; } +export interface DeleteBusinessData { + business_delete?: Business_Key | null; +} + +export interface DeleteBusinessVariables { + id: UUIDString; +} + export interface DeleteEventData { event_delete?: Event_Key | null; } @@ -251,6 +299,26 @@ export interface Event_Key { __typename?: 'Event_Key'; } +export interface FilterBusinessData { + businesses: ({ + id: UUIDString; + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key)[]; +} + +export interface FilterBusinessVariables { + businessName?: string | null; + contactName?: string | null; + sector?: BusinessSector | null; + rateGroup?: BusinessRateGroup | null; + status?: BusinessStatus | null; +} + export interface FilterEventsData { events: ({ id: UUIDString; @@ -384,6 +452,22 @@ export interface FilterVendorsVariables { platformType?: VendorPlatformType | null; } +export interface GetBusinessByIdData { + business?: { + id: UUIDString; + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key; +} + +export interface GetBusinessByIdVariables { + id: UUIDString; +} + export interface GetEventByIdData { event?: { id: UUIDString; @@ -500,6 +584,18 @@ export interface Invoice_Key { __typename?: 'Invoice_Key'; } +export interface ListBusinessData { + businesses: ({ + id: UUIDString; + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key)[]; +} + export interface ListEventsData { events: ({ id: UUIDString; @@ -607,6 +703,20 @@ export interface Staff_Key { __typename?: 'Staff_Key'; } +export interface UpdateBusinessData { + business_update?: Business_Key | null; +} + +export interface UpdateBusinessVariables { + id: UUIDString; + businessName?: string | null; + contactName?: string | null; + email?: string | null; + sector?: BusinessSector | null; + rateGroup?: BusinessRateGroup | null; + status?: BusinessStatus | null; +} + export interface UpdateEventData { event_update?: Event_Key | null; } @@ -720,53 +830,77 @@ export interface Vendor_Key { __typename?: 'Vendor_Key'; } -interface ListStaffRef { +interface ListBusinessRef { /* Allow users to create refs without passing in DataConnect */ - (): QueryRef; + (): QueryRef; /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect): QueryRef; + (dc: DataConnect): QueryRef; operationName: string; } -export const listStaffRef: ListStaffRef; +export const listBusinessRef: ListBusinessRef; -export function listStaff(): QueryPromise; -export function listStaff(dc: DataConnect): QueryPromise; +export function listBusiness(): QueryPromise; +export function listBusiness(dc: DataConnect): QueryPromise; -interface CreateVendorRef { +interface GetBusinessByIdRef { /* Allow users to create refs without passing in DataConnect */ - (vars: CreateVendorVariables): MutationRef; + (vars: GetBusinessByIdVariables): QueryRef; /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: CreateVendorVariables): MutationRef; + (dc: DataConnect, vars: GetBusinessByIdVariables): QueryRef; operationName: string; } -export const createVendorRef: CreateVendorRef; +export const getBusinessByIdRef: GetBusinessByIdRef; -export function createVendor(vars: CreateVendorVariables): MutationPromise; -export function createVendor(dc: DataConnect, vars: CreateVendorVariables): MutationPromise; +export function getBusinessById(vars: GetBusinessByIdVariables): QueryPromise; +export function getBusinessById(dc: DataConnect, vars: GetBusinessByIdVariables): QueryPromise; -interface UpdateVendorRef { +interface FilterBusinessRef { /* Allow users to create refs without passing in DataConnect */ - (vars: UpdateVendorVariables): MutationRef; + (vars?: FilterBusinessVariables): QueryRef; /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: UpdateVendorVariables): MutationRef; + (dc: DataConnect, vars?: FilterBusinessVariables): QueryRef; operationName: string; } -export const updateVendorRef: UpdateVendorRef; +export const filterBusinessRef: FilterBusinessRef; -export function updateVendor(vars: UpdateVendorVariables): MutationPromise; -export function updateVendor(dc: DataConnect, vars: UpdateVendorVariables): MutationPromise; +export function filterBusiness(vars?: FilterBusinessVariables): QueryPromise; +export function filterBusiness(dc: DataConnect, vars?: FilterBusinessVariables): QueryPromise; -interface DeleteVendorRef { +interface CreateEventRef { /* Allow users to create refs without passing in DataConnect */ - (vars: DeleteVendorVariables): MutationRef; + (vars: CreateEventVariables): MutationRef; /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: DeleteVendorVariables): MutationRef; + (dc: DataConnect, vars: CreateEventVariables): MutationRef; operationName: string; } -export const deleteVendorRef: DeleteVendorRef; +export const createEventRef: CreateEventRef; -export function deleteVendor(vars: DeleteVendorVariables): MutationPromise; -export function deleteVendor(dc: DataConnect, vars: DeleteVendorVariables): MutationPromise; +export function createEvent(vars: CreateEventVariables): MutationPromise; +export function createEvent(dc: DataConnect, vars: CreateEventVariables): MutationPromise; + +interface UpdateEventRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateEventVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: UpdateEventVariables): MutationRef; + operationName: string; +} +export const updateEventRef: UpdateEventRef; + +export function updateEvent(vars: UpdateEventVariables): MutationPromise; +export function updateEvent(dc: DataConnect, vars: UpdateEventVariables): MutationPromise; + +interface DeleteEventRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteEventVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: DeleteEventVariables): MutationRef; + operationName: string; +} +export const deleteEventRef: DeleteEventRef; + +export function deleteEvent(vars: DeleteEventVariables): MutationPromise; +export function deleteEvent(dc: DataConnect, vars: DeleteEventVariables): MutationPromise; interface ListVendorDefaultSettingsRef { /* Allow users to create refs without passing in DataConnect */ @@ -804,162 +938,6 @@ export const filterVendorDefaultSettingsRef: FilterVendorDefaultSettingsRef; export function filterVendorDefaultSettings(vars?: FilterVendorDefaultSettingsVariables): QueryPromise; export function filterVendorDefaultSettings(dc: DataConnect, vars?: FilterVendorDefaultSettingsVariables): QueryPromise; -interface ListEventsRef { - /* Allow users to create refs without passing in DataConnect */ - (): QueryRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect): QueryRef; - operationName: string; -} -export const listEventsRef: ListEventsRef; - -export function listEvents(): QueryPromise; -export function listEvents(dc: DataConnect): QueryPromise; - -interface GetEventByIdRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: GetEventByIdVariables): QueryRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: GetEventByIdVariables): QueryRef; - operationName: string; -} -export const getEventByIdRef: GetEventByIdRef; - -export function getEventById(vars: GetEventByIdVariables): QueryPromise; -export function getEventById(dc: DataConnect, vars: GetEventByIdVariables): QueryPromise; - -interface FilterEventsRef { - /* Allow users to create refs without passing in DataConnect */ - (vars?: FilterEventsVariables): QueryRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars?: FilterEventsVariables): QueryRef; - operationName: string; -} -export const filterEventsRef: FilterEventsRef; - -export function filterEvents(vars?: FilterEventsVariables): QueryPromise; -export function filterEvents(dc: DataConnect, vars?: FilterEventsVariables): QueryPromise; - -interface CreateInvoiceRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: CreateInvoiceVariables): MutationRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: CreateInvoiceVariables): MutationRef; - operationName: string; -} -export const createInvoiceRef: CreateInvoiceRef; - -export function createInvoice(vars: CreateInvoiceVariables): MutationPromise; -export function createInvoice(dc: DataConnect, vars: CreateInvoiceVariables): MutationPromise; - -interface UpdateInvoiceRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: UpdateInvoiceVariables): MutationRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: UpdateInvoiceVariables): MutationRef; - operationName: string; -} -export const updateInvoiceRef: UpdateInvoiceRef; - -export function updateInvoice(vars: UpdateInvoiceVariables): MutationPromise; -export function updateInvoice(dc: DataConnect, vars: UpdateInvoiceVariables): MutationPromise; - -interface DeleteInvoiceRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: DeleteInvoiceVariables): MutationRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: DeleteInvoiceVariables): MutationRef; - operationName: string; -} -export const deleteInvoiceRef: DeleteInvoiceRef; - -export function deleteInvoice(vars: DeleteInvoiceVariables): MutationPromise; -export function deleteInvoice(dc: DataConnect, vars: DeleteInvoiceVariables): MutationPromise; - -interface CreateStaffRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: CreateStaffVariables): MutationRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: CreateStaffVariables): MutationRef; - operationName: string; -} -export const createStaffRef: CreateStaffRef; - -export function createStaff(vars: CreateStaffVariables): MutationPromise; -export function createStaff(dc: DataConnect, vars: CreateStaffVariables): MutationPromise; - -interface ListVendorRef { - /* Allow users to create refs without passing in DataConnect */ - (): QueryRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect): QueryRef; - operationName: string; -} -export const listVendorRef: ListVendorRef; - -export function listVendor(): QueryPromise; -export function listVendor(dc: DataConnect): QueryPromise; - -interface GetVendorByIdRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: GetVendorByIdVariables): QueryRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: GetVendorByIdVariables): QueryRef; - operationName: string; -} -export const getVendorByIdRef: GetVendorByIdRef; - -export function getVendorById(vars: GetVendorByIdVariables): QueryPromise; -export function getVendorById(dc: DataConnect, vars: GetVendorByIdVariables): QueryPromise; - -interface FilterVendorsRef { - /* Allow users to create refs without passing in DataConnect */ - (vars?: FilterVendorsVariables): QueryRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars?: FilterVendorsVariables): QueryRef; - operationName: string; -} -export const filterVendorsRef: FilterVendorsRef; - -export function filterVendors(vars?: FilterVendorsVariables): QueryPromise; -export function filterVendors(dc: DataConnect, vars?: FilterVendorsVariables): QueryPromise; - -interface CreateVendorDefaultSettingRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: CreateVendorDefaultSettingVariables): MutationRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationRef; - operationName: string; -} -export const createVendorDefaultSettingRef: CreateVendorDefaultSettingRef; - -export function createVendorDefaultSetting(vars: CreateVendorDefaultSettingVariables): MutationPromise; -export function createVendorDefaultSetting(dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationPromise; - -interface UpdateVendorDefaultSettingRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: UpdateVendorDefaultSettingVariables): MutationRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationRef; - operationName: string; -} -export const updateVendorDefaultSettingRef: UpdateVendorDefaultSettingRef; - -export function updateVendorDefaultSetting(vars: UpdateVendorDefaultSettingVariables): MutationPromise; -export function updateVendorDefaultSetting(dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationPromise; - -interface DeleteVendorDefaultSettingRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: DeleteVendorDefaultSettingVariables): MutationRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationRef; - operationName: string; -} -export const deleteVendorDefaultSettingRef: DeleteVendorDefaultSettingRef; - -export function deleteVendorDefaultSetting(vars: DeleteVendorDefaultSettingVariables): MutationPromise; -export function deleteVendorDefaultSetting(dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationPromise; - interface CreateVendorRateRef { /* Allow users to create refs without passing in DataConnect */ (vars: CreateVendorRateVariables): MutationRef; @@ -1032,41 +1010,77 @@ export const filterVendorRatesRef: FilterVendorRatesRef; export function filterVendorRates(vars?: FilterVendorRatesVariables): QueryPromise; export function filterVendorRates(dc: DataConnect, vars?: FilterVendorRatesVariables): QueryPromise; -interface CreateEventRef { +interface ListEventsRef { /* Allow users to create refs without passing in DataConnect */ - (vars: CreateEventVariables): MutationRef; + (): QueryRef; /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: CreateEventVariables): MutationRef; + (dc: DataConnect): QueryRef; operationName: string; } -export const createEventRef: CreateEventRef; +export const listEventsRef: ListEventsRef; -export function createEvent(vars: CreateEventVariables): MutationPromise; -export function createEvent(dc: DataConnect, vars: CreateEventVariables): MutationPromise; +export function listEvents(): QueryPromise; +export function listEvents(dc: DataConnect): QueryPromise; -interface UpdateEventRef { +interface GetEventByIdRef { /* Allow users to create refs without passing in DataConnect */ - (vars: UpdateEventVariables): MutationRef; + (vars: GetEventByIdVariables): QueryRef; /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: UpdateEventVariables): MutationRef; + (dc: DataConnect, vars: GetEventByIdVariables): QueryRef; operationName: string; } -export const updateEventRef: UpdateEventRef; +export const getEventByIdRef: GetEventByIdRef; -export function updateEvent(vars: UpdateEventVariables): MutationPromise; -export function updateEvent(dc: DataConnect, vars: UpdateEventVariables): MutationPromise; +export function getEventById(vars: GetEventByIdVariables): QueryPromise; +export function getEventById(dc: DataConnect, vars: GetEventByIdVariables): QueryPromise; -interface DeleteEventRef { +interface FilterEventsRef { /* Allow users to create refs without passing in DataConnect */ - (vars: DeleteEventVariables): MutationRef; + (vars?: FilterEventsVariables): QueryRef; /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: DeleteEventVariables): MutationRef; + (dc: DataConnect, vars?: FilterEventsVariables): QueryRef; operationName: string; } -export const deleteEventRef: DeleteEventRef; +export const filterEventsRef: FilterEventsRef; -export function deleteEvent(vars: DeleteEventVariables): MutationPromise; -export function deleteEvent(dc: DataConnect, vars: DeleteEventVariables): MutationPromise; +export function filterEvents(vars?: FilterEventsVariables): QueryPromise; +export function filterEvents(dc: DataConnect, vars?: FilterEventsVariables): QueryPromise; + +interface CreateInvoiceRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateInvoiceVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: CreateInvoiceVariables): MutationRef; + operationName: string; +} +export const createInvoiceRef: CreateInvoiceRef; + +export function createInvoice(vars: CreateInvoiceVariables): MutationPromise; +export function createInvoice(dc: DataConnect, vars: CreateInvoiceVariables): MutationPromise; + +interface UpdateInvoiceRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateInvoiceVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: UpdateInvoiceVariables): MutationRef; + operationName: string; +} +export const updateInvoiceRef: UpdateInvoiceRef; + +export function updateInvoice(vars: UpdateInvoiceVariables): MutationPromise; +export function updateInvoice(dc: DataConnect, vars: UpdateInvoiceVariables): MutationPromise; + +interface DeleteInvoiceRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteInvoiceVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: DeleteInvoiceVariables): MutationRef; + operationName: string; +} +export const deleteInvoiceRef: DeleteInvoiceRef; + +export function deleteInvoice(vars: DeleteInvoiceVariables): MutationPromise; +export function deleteInvoice(dc: DataConnect, vars: DeleteInvoiceVariables): MutationPromise; interface ListInvoiceRef { /* Allow users to create refs without passing in DataConnect */ @@ -1104,3 +1118,171 @@ export const filterInvoicesRef: FilterInvoicesRef; export function filterInvoices(vars?: FilterInvoicesVariables): QueryPromise; export function filterInvoices(dc: DataConnect, vars?: FilterInvoicesVariables): QueryPromise; +interface CreateStaffRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateStaffVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: CreateStaffVariables): MutationRef; + operationName: string; +} +export const createStaffRef: CreateStaffRef; + +export function createStaff(vars: CreateStaffVariables): MutationPromise; +export function createStaff(dc: DataConnect, vars: CreateStaffVariables): MutationPromise; + +interface ListStaffRef { + /* Allow users to create refs without passing in DataConnect */ + (): QueryRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect): QueryRef; + operationName: string; +} +export const listStaffRef: ListStaffRef; + +export function listStaff(): QueryPromise; +export function listStaff(dc: DataConnect): QueryPromise; + +interface CreateVendorRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateVendorVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: CreateVendorVariables): MutationRef; + operationName: string; +} +export const createVendorRef: CreateVendorRef; + +export function createVendor(vars: CreateVendorVariables): MutationPromise; +export function createVendor(dc: DataConnect, vars: CreateVendorVariables): MutationPromise; + +interface UpdateVendorRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateVendorVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: UpdateVendorVariables): MutationRef; + operationName: string; +} +export const updateVendorRef: UpdateVendorRef; + +export function updateVendor(vars: UpdateVendorVariables): MutationPromise; +export function updateVendor(dc: DataConnect, vars: UpdateVendorVariables): MutationPromise; + +interface DeleteVendorRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteVendorVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: DeleteVendorVariables): MutationRef; + operationName: string; +} +export const deleteVendorRef: DeleteVendorRef; + +export function deleteVendor(vars: DeleteVendorVariables): MutationPromise; +export function deleteVendor(dc: DataConnect, vars: DeleteVendorVariables): MutationPromise; + +interface ListVendorRef { + /* Allow users to create refs without passing in DataConnect */ + (): QueryRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect): QueryRef; + operationName: string; +} +export const listVendorRef: ListVendorRef; + +export function listVendor(): QueryPromise; +export function listVendor(dc: DataConnect): QueryPromise; + +interface GetVendorByIdRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: GetVendorByIdVariables): QueryRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: GetVendorByIdVariables): QueryRef; + operationName: string; +} +export const getVendorByIdRef: GetVendorByIdRef; + +export function getVendorById(vars: GetVendorByIdVariables): QueryPromise; +export function getVendorById(dc: DataConnect, vars: GetVendorByIdVariables): QueryPromise; + +interface FilterVendorsRef { + /* Allow users to create refs without passing in DataConnect */ + (vars?: FilterVendorsVariables): QueryRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars?: FilterVendorsVariables): QueryRef; + operationName: string; +} +export const filterVendorsRef: FilterVendorsRef; + +export function filterVendors(vars?: FilterVendorsVariables): QueryPromise; +export function filterVendors(dc: DataConnect, vars?: FilterVendorsVariables): QueryPromise; + +interface CreateVendorDefaultSettingRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateVendorDefaultSettingVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationRef; + operationName: string; +} +export const createVendorDefaultSettingRef: CreateVendorDefaultSettingRef; + +export function createVendorDefaultSetting(vars: CreateVendorDefaultSettingVariables): MutationPromise; +export function createVendorDefaultSetting(dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationPromise; + +interface UpdateVendorDefaultSettingRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateVendorDefaultSettingVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationRef; + operationName: string; +} +export const updateVendorDefaultSettingRef: UpdateVendorDefaultSettingRef; + +export function updateVendorDefaultSetting(vars: UpdateVendorDefaultSettingVariables): MutationPromise; +export function updateVendorDefaultSetting(dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationPromise; + +interface DeleteVendorDefaultSettingRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteVendorDefaultSettingVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationRef; + operationName: string; +} +export const deleteVendorDefaultSettingRef: DeleteVendorDefaultSettingRef; + +export function deleteVendorDefaultSetting(vars: DeleteVendorDefaultSettingVariables): MutationPromise; +export function deleteVendorDefaultSetting(dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationPromise; + +interface CreateBusinessRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateBusinessVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: CreateBusinessVariables): MutationRef; + operationName: string; +} +export const createBusinessRef: CreateBusinessRef; + +export function createBusiness(vars: CreateBusinessVariables): MutationPromise; +export function createBusiness(dc: DataConnect, vars: CreateBusinessVariables): MutationPromise; + +interface UpdateBusinessRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateBusinessVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: UpdateBusinessVariables): MutationRef; + operationName: string; +} +export const updateBusinessRef: UpdateBusinessRef; + +export function updateBusiness(vars: UpdateBusinessVariables): MutationPromise; +export function updateBusiness(dc: DataConnect, vars: UpdateBusinessVariables): MutationPromise; + +interface DeleteBusinessRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteBusinessVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: DeleteBusinessVariables): MutationRef; + operationName: string; +} +export const deleteBusinessRef: DeleteBusinessRef; + +export function deleteBusiness(vars: DeleteBusinessVariables): MutationPromise; +export function deleteBusiness(dc: DataConnect, vars: DeleteBusinessVariables): MutationPromise; + diff --git a/frontend-web/src/dataconnect-generated/react/README.md b/frontend-web/src/dataconnect-generated/react/README.md index de4097eb..268de00b 100644 --- a/frontend-web/src/dataconnect-generated/react/README.md +++ b/frontend-web/src/dataconnect-generated/react/README.md @@ -17,39 +17,45 @@ You can also follow the instructions from the [Data Connect documentation](https - [**Accessing the connector**](#accessing-the-connector) - [*Connecting to the local Emulator*](#connecting-to-the-local-emulator) - [**Queries**](#queries) - - [*listStaff*](#liststaff) + - [*listBusiness*](#listbusiness) + - [*getBusinessById*](#getbusinessbyid) + - [*filterBusiness*](#filterbusiness) - [*listVendorDefaultSettings*](#listvendordefaultsettings) - [*getVendorDefaultSettingById*](#getvendordefaultsettingbyid) - [*filterVendorDefaultSettings*](#filtervendordefaultsettings) - - [*listEvents*](#listevents) - - [*getEventById*](#geteventbyid) - - [*filterEvents*](#filterevents) - - [*listVendor*](#listvendor) - - [*getVendorById*](#getvendorbyid) - - [*filterVendors*](#filtervendors) - [*listVendorRate*](#listvendorrate) - [*getVendorRateById*](#getvendorratebyid) - [*filterVendorRates*](#filtervendorrates) + - [*listEvents*](#listevents) + - [*getEventById*](#geteventbyid) + - [*filterEvents*](#filterevents) - [*listInvoice*](#listinvoice) - [*getInvoiceById*](#getinvoicebyid) - [*filterInvoices*](#filterinvoices) + - [*listStaff*](#liststaff) + - [*listVendor*](#listvendor) + - [*getVendorById*](#getvendorbyid) + - [*filterVendors*](#filtervendors) - [**Mutations**](#mutations) - - [*CreateVendor*](#createvendor) - - [*UpdateVendor*](#updatevendor) - - [*DeleteVendor*](#deletevendor) + - [*CreateEvent*](#createevent) + - [*UpdateEvent*](#updateevent) + - [*DeleteEvent*](#deleteevent) + - [*CreateVendorRate*](#createvendorrate) + - [*UpdateVendorRate*](#updatevendorrate) + - [*DeleteVendorRate*](#deletevendorrate) - [*CreateInvoice*](#createinvoice) - [*UpdateInvoice*](#updateinvoice) - [*DeleteInvoice*](#deleteinvoice) - [*CreateStaff*](#createstaff) + - [*CreateVendor*](#createvendor) + - [*UpdateVendor*](#updatevendor) + - [*DeleteVendor*](#deletevendor) - [*CreateVendorDefaultSetting*](#createvendordefaultsetting) - [*UpdateVendorDefaultSetting*](#updatevendordefaultsetting) - [*DeleteVendorDefaultSetting*](#deletevendordefaultsetting) - - [*CreateVendorRate*](#createvendorrate) - - [*UpdateVendorRate*](#updatevendorrate) - - [*DeleteVendorRate*](#deletevendorrate) - - [*CreateEvent*](#createevent) - - [*UpdateEvent*](#updateevent) - - [*DeleteEvent*](#deleteevent) + - [*CreateBusiness*](#createbusiness) + - [*UpdateBusiness*](#updatebusiness) + - [*DeleteBusiness*](#deletebusiness) # TanStack Query Firebase & TanStack React Query This SDK provides [React](https://react.dev/) hooks generated specific to your application, for the operations found in the connector `krow-connector`. These hooks are generated using [TanStack Query Firebase](https://react-query-firebase.invertase.dev/) by our partners at Invertase, a library built on top of [TanStack React Query v5](https://tanstack.com/query/v5/docs/framework/react/overview). @@ -141,68 +147,65 @@ Here's a general overview of how to use the generated Query hooks in your code: Below are examples of how to use the `krow-connector` connector's generated Query hook functions to execute each Query. You can also follow the examples from the [Data Connect documentation](https://firebase.google.com/docs/data-connect/web-sdk#operations-react-angular). -## listStaff -You can execute the `listStaff` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): +## listBusiness +You can execute the `listBusiness` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): ```javascript -useListStaff(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +useListBusiness(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; ``` You can also pass in a `DataConnect` instance to the Query hook function. ```javascript -useListStaff(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +useListBusiness(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; ``` ### Variables -The `listStaff` Query has no variables. +The `listBusiness` Query has no variables. ### Return Type -Recall that calling the `listStaff` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. +Recall that calling the `listBusiness` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. -To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `listStaff` Query is of type `ListStaffData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `listBusiness` Query is of type `ListBusinessData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface ListStaffData { - staffs: ({ +export interface ListBusinessData { + businesses: ({ id: UUIDString; - employeeName: string; - vendorId?: UUIDString | null; + businessName: string; + contactName: string; email?: string | null; - position?: string | null; - employmentType: EmploymentType; - rating?: number | null; - reliabilityScore?: number | null; - backgroundCheckStatus: BackgroundCheckStatus; - certifications?: string | null; - } & Staff_Key)[]; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key)[]; } ``` To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). -### Using `listStaff`'s Query hook function +### Using `listBusiness`'s Query hook function ```javascript import { getDataConnect } from 'firebase/data-connect'; import { connectorConfig } from '@dataconnect/generated'; -import { useListStaff } from '@dataconnect/generated/react' +import { useListBusiness } from '@dataconnect/generated/react' -export default function ListStaffComponent() { +export default function ListBusinessComponent() { // You don't have to do anything to "execute" the Query. // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. - const query = useListStaff(); + const query = useListBusiness(); // You can also pass in a `DataConnect` instance to the Query hook function. const dataConnect = getDataConnect(connectorConfig); - const query = useListStaff(dataConnect); + const query = useListBusiness(dataConnect); // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. const options = { staleTime: 5 * 1000 }; - const query = useListStaff(options); + const query = useListBusiness(options); // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. const dataConnect = getDataConnect(connectorConfig); const options = { staleTime: 5 * 1000 }; - const query = useListStaff(dataConnect, options); + const query = useListBusiness(dataConnect, options); // Then, you can render your component dynamically based on the status of the Query. if (query.isPending) { @@ -215,7 +218,201 @@ export default function ListStaffComponent() { // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. if (query.isSuccess) { - console.log(query.data.staffs); + console.log(query.data.businesses); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## getBusinessById +You can execute the `getBusinessById` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useGetBusinessById(dc: DataConnect, vars: GetBusinessByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useGetBusinessById(vars: GetBusinessByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `getBusinessById` Query requires an argument of type `GetBusinessByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface GetBusinessByIdVariables { + id: UUIDString; +} +``` +### Return Type +Recall that calling the `getBusinessById` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `getBusinessById` Query is of type `GetBusinessByIdData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface GetBusinessByIdData { + business?: { + id: UUIDString; + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `getBusinessById`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, GetBusinessByIdVariables } from '@dataconnect/generated'; +import { useGetBusinessById } from '@dataconnect/generated/react' + +export default function GetBusinessByIdComponent() { + // The `useGetBusinessById` Query hook requires an argument of type `GetBusinessByIdVariables`: + const getBusinessByIdVars: GetBusinessByIdVariables = { + id: ..., + }; + + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useGetBusinessById(getBusinessByIdVars); + // Variables can be defined inline as well. + const query = useGetBusinessById({ id: ..., }); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useGetBusinessById(dataConnect, getBusinessByIdVars); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useGetBusinessById(getBusinessByIdVars, options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useGetBusinessById(dataConnect, getBusinessByIdVars, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.business); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## filterBusiness +You can execute the `filterBusiness` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useFilterBusiness(dc: DataConnect, vars?: FilterBusinessVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useFilterBusiness(vars?: FilterBusinessVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `filterBusiness` Query has an optional argument of type `FilterBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface FilterBusinessVariables { + businessName?: string | null; + contactName?: string | null; + sector?: BusinessSector | null; + rateGroup?: BusinessRateGroup | null; + status?: BusinessStatus | null; +} +``` +### Return Type +Recall that calling the `filterBusiness` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `filterBusiness` Query is of type `FilterBusinessData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface FilterBusinessData { + businesses: ({ + id: UUIDString; + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key)[]; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `filterBusiness`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, FilterBusinessVariables } from '@dataconnect/generated'; +import { useFilterBusiness } from '@dataconnect/generated/react' + +export default function FilterBusinessComponent() { + // The `useFilterBusiness` Query hook has an optional argument of type `FilterBusinessVariables`: + const filterBusinessVars: FilterBusinessVariables = { + businessName: ..., // optional + contactName: ..., // optional + sector: ..., // optional + rateGroup: ..., // optional + status: ..., // optional + }; + + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useFilterBusiness(filterBusinessVars); + // Variables can be defined inline as well. + const query = useFilterBusiness({ businessName: ..., contactName: ..., sector: ..., rateGroup: ..., status: ..., }); + // Since all variables are optional for this Query, you can omit the `FilterBusinessVariables` argument. + // (as long as you don't want to provide any `options`!) + const query = useFilterBusiness(); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useFilterBusiness(dataConnect, filterBusinessVars); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useFilterBusiness(filterBusinessVars, options); + // If you'd like to provide options without providing any variables, you must + // pass `undefined` where you would normally pass the variables. + const query = useFilterBusiness(undefined, options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useFilterBusiness(dataConnect, filterBusinessVars /** or undefined */, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.businesses); } return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; } @@ -479,6 +676,283 @@ export default function FilterVendorDefaultSettingsComponent() { } ``` +## listVendorRate +You can execute the `listVendorRate` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useListVendorRate(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useListVendorRate(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `listVendorRate` Query has no variables. +### Return Type +Recall that calling the `listVendorRate` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `listVendorRate` Query is of type `ListVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface ListVendorRateData { + vendorRates: ({ + id: UUIDString; + vendorName: string; + category: VendorRateCategory; + roleName: string; + employeeWage: number; + markupPercentage?: number | null; + vendorFeePercentage?: number | null; + clientRate: number; + } & VendorRate_Key)[]; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `listVendorRate`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig } from '@dataconnect/generated'; +import { useListVendorRate } from '@dataconnect/generated/react' + +export default function ListVendorRateComponent() { + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useListVendorRate(); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useListVendorRate(dataConnect); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useListVendorRate(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useListVendorRate(dataConnect, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.vendorRates); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## getVendorRateById +You can execute the `getVendorRateById` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useGetVendorRateById(dc: DataConnect, vars: GetVendorRateByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useGetVendorRateById(vars: GetVendorRateByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `getVendorRateById` Query requires an argument of type `GetVendorRateByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface GetVendorRateByIdVariables { + id: UUIDString; +} +``` +### Return Type +Recall that calling the `getVendorRateById` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `getVendorRateById` Query is of type `GetVendorRateByIdData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +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; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `getVendorRateById`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, GetVendorRateByIdVariables } from '@dataconnect/generated'; +import { useGetVendorRateById } from '@dataconnect/generated/react' + +export default function GetVendorRateByIdComponent() { + // The `useGetVendorRateById` Query hook requires an argument of type `GetVendorRateByIdVariables`: + const getVendorRateByIdVars: GetVendorRateByIdVariables = { + id: ..., + }; + + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useGetVendorRateById(getVendorRateByIdVars); + // Variables can be defined inline as well. + const query = useGetVendorRateById({ id: ..., }); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useGetVendorRateById(dataConnect, getVendorRateByIdVars); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useGetVendorRateById(getVendorRateByIdVars, options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useGetVendorRateById(dataConnect, getVendorRateByIdVars, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.vendorRate); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## filterVendorRates +You can execute the `filterVendorRates` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useFilterVendorRates(dc: DataConnect, vars?: FilterVendorRatesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useFilterVendorRates(vars?: FilterVendorRatesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `filterVendorRates` Query has an optional argument of type `FilterVendorRatesVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface FilterVendorRatesVariables { + vendorName?: string | null; + category?: VendorRateCategory | null; + roleName?: string | null; + minClientRate?: number | null; + maxClientRate?: number | null; +} +``` +### Return Type +Recall that calling the `filterVendorRates` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `filterVendorRates` Query is of type `FilterVendorRatesData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface FilterVendorRatesData { + vendorRates: ({ + id: UUIDString; + vendorName: string; + category: VendorRateCategory; + roleName: string; + employeeWage: number; + markupPercentage?: number | null; + vendorFeePercentage?: number | null; + clientRate: number; + } & VendorRate_Key)[]; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `filterVendorRates`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, FilterVendorRatesVariables } from '@dataconnect/generated'; +import { useFilterVendorRates } from '@dataconnect/generated/react' + +export default function FilterVendorRatesComponent() { + // The `useFilterVendorRates` Query hook has an optional argument of type `FilterVendorRatesVariables`: + const filterVendorRatesVars: FilterVendorRatesVariables = { + vendorName: ..., // optional + category: ..., // optional + roleName: ..., // optional + minClientRate: ..., // optional + maxClientRate: ..., // optional + }; + + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useFilterVendorRates(filterVendorRatesVars); + // Variables can be defined inline as well. + const query = useFilterVendorRates({ vendorName: ..., category: ..., roleName: ..., minClientRate: ..., maxClientRate: ..., }); + // Since all variables are optional for this Query, you can omit the `FilterVendorRatesVariables` argument. + // (as long as you don't want to provide any `options`!) + const query = useFilterVendorRates(); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useFilterVendorRates(dataConnect, filterVendorRatesVars); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useFilterVendorRates(filterVendorRatesVars, options); + // If you'd like to provide options without providing any variables, you must + // pass `undefined` where you would normally pass the variables. + const query = useFilterVendorRates(undefined, options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useFilterVendorRates(dataConnect, filterVendorRatesVars /** or undefined */, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.vendorRates); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + ## listEvents You can execute the `listEvents` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): @@ -848,6 +1322,356 @@ export default function FilterEventsComponent() { } ``` +## listInvoice +You can execute the `listInvoice` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useListInvoice(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useListInvoice(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `listInvoice` Query has no variables. +### Return Type +Recall that calling the `listInvoice` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `listInvoice` Query is of type `ListInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface ListInvoiceData { + invoices: ({ + id: UUIDString; + invoiceNumber: string; + amount: number; + status: InvoiceStatus; + issueDate: TimestampString; + dueDate: TimestampString; + isAutoGenerated?: boolean | null; + } & Invoice_Key)[]; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `listInvoice`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig } from '@dataconnect/generated'; +import { useListInvoice } from '@dataconnect/generated/react' + +export default function ListInvoiceComponent() { + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useListInvoice(); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useListInvoice(dataConnect); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useListInvoice(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useListInvoice(dataConnect, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.invoices); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## getInvoiceById +You can execute the `getInvoiceById` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useGetInvoiceById(dc: DataConnect, vars: GetInvoiceByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useGetInvoiceById(vars: GetInvoiceByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `getInvoiceById` Query requires an argument of type `GetInvoiceByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface GetInvoiceByIdVariables { + id: UUIDString; +} +``` +### Return Type +Recall that calling the `getInvoiceById` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `getInvoiceById` Query is of type `GetInvoiceByIdData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface GetInvoiceByIdData { + invoice?: { + id: UUIDString; + invoiceNumber: string; + amount: number; + status: InvoiceStatus; + issueDate: TimestampString; + dueDate: TimestampString; + disputedItems?: string | null; + isAutoGenerated?: boolean | null; + } & Invoice_Key; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `getInvoiceById`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, GetInvoiceByIdVariables } from '@dataconnect/generated'; +import { useGetInvoiceById } from '@dataconnect/generated/react' + +export default function GetInvoiceByIdComponent() { + // The `useGetInvoiceById` Query hook requires an argument of type `GetInvoiceByIdVariables`: + const getInvoiceByIdVars: GetInvoiceByIdVariables = { + id: ..., + }; + + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useGetInvoiceById(getInvoiceByIdVars); + // Variables can be defined inline as well. + const query = useGetInvoiceById({ id: ..., }); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useGetInvoiceById(dataConnect, getInvoiceByIdVars); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useGetInvoiceById(getInvoiceByIdVars, options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useGetInvoiceById(dataConnect, getInvoiceByIdVars, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.invoice); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## filterInvoices +You can execute the `filterInvoices` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useFilterInvoices(dc: DataConnect, vars?: FilterInvoicesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useFilterInvoices(vars?: FilterInvoicesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `filterInvoices` Query has an optional argument of type `FilterInvoicesVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface FilterInvoicesVariables { + invoiceNumber?: string | null; + status?: InvoiceStatus | null; + isAutoGenerated?: boolean | null; + amount?: number | null; +} +``` +### Return Type +Recall that calling the `filterInvoices` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `filterInvoices` Query is of type `FilterInvoicesData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface FilterInvoicesData { + invoices: ({ + id: UUIDString; + invoiceNumber: string; + amount: number; + status: InvoiceStatus; + issueDate: TimestampString; + dueDate: TimestampString; + isAutoGenerated?: boolean | null; + } & Invoice_Key)[]; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `filterInvoices`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, FilterInvoicesVariables } from '@dataconnect/generated'; +import { useFilterInvoices } from '@dataconnect/generated/react' + +export default function FilterInvoicesComponent() { + // The `useFilterInvoices` Query hook has an optional argument of type `FilterInvoicesVariables`: + const filterInvoicesVars: FilterInvoicesVariables = { + invoiceNumber: ..., // optional + status: ..., // optional + isAutoGenerated: ..., // optional + amount: ..., // optional + }; + + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useFilterInvoices(filterInvoicesVars); + // Variables can be defined inline as well. + const query = useFilterInvoices({ invoiceNumber: ..., status: ..., isAutoGenerated: ..., amount: ..., }); + // Since all variables are optional for this Query, you can omit the `FilterInvoicesVariables` argument. + // (as long as you don't want to provide any `options`!) + const query = useFilterInvoices(); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useFilterInvoices(dataConnect, filterInvoicesVars); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useFilterInvoices(filterInvoicesVars, options); + // If you'd like to provide options without providing any variables, you must + // pass `undefined` where you would normally pass the variables. + const query = useFilterInvoices(undefined, options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useFilterInvoices(dataConnect, filterInvoicesVars /** or undefined */, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.invoices); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## listStaff +You can execute the `listStaff` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useListStaff(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useListStaff(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `listStaff` Query has no variables. +### Return Type +Recall that calling the `listStaff` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `listStaff` Query is of type `ListStaffData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface ListStaffData { + staffs: ({ + id: UUIDString; + employeeName: string; + vendorId?: UUIDString | null; + email?: string | null; + position?: string | null; + employmentType: EmploymentType; + rating?: number | null; + reliabilityScore?: number | null; + backgroundCheckStatus: BackgroundCheckStatus; + certifications?: string | null; + } & Staff_Key)[]; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `listStaff`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig } from '@dataconnect/generated'; +import { useListStaff } from '@dataconnect/generated/react' + +export default function ListStaffComponent() { + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useListStaff(); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useListStaff(dataConnect); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useListStaff(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useListStaff(dataConnect, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.staffs); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + ## listVendor You can execute the `listVendor` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): @@ -1126,553 +1950,6 @@ export default function FilterVendorsComponent() { } ``` -## listVendorRate -You can execute the `listVendorRate` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): - -```javascript -useListVendorRate(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` -You can also pass in a `DataConnect` instance to the Query hook function. -```javascript -useListVendorRate(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` - -### Variables -The `listVendorRate` Query has no variables. -### Return Type -Recall that calling the `listVendorRate` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. - -To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. - -To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `listVendorRate` Query is of type `ListVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface ListVendorRateData { - vendorRates: ({ - id: UUIDString; - vendorName: string; - category: VendorRateCategory; - roleName: string; - employeeWage: number; - markupPercentage?: number | null; - vendorFeePercentage?: number | null; - clientRate: number; - } & VendorRate_Key)[]; -} -``` - -To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). - -### Using `listVendorRate`'s Query hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig } from '@dataconnect/generated'; -import { useListVendorRate } from '@dataconnect/generated/react' - -export default function ListVendorRateComponent() { - // You don't have to do anything to "execute" the Query. - // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. - const query = useListVendorRate(); - - // You can also pass in a `DataConnect` instance to the Query hook function. - const dataConnect = getDataConnect(connectorConfig); - const query = useListVendorRate(dataConnect); - - // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. - const options = { staleTime: 5 * 1000 }; - const query = useListVendorRate(options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { staleTime: 5 * 1000 }; - const query = useListVendorRate(dataConnect, options); - - // Then, you can render your component dynamically based on the status of the Query. - if (query.isPending) { - return
Loading...
; - } - - if (query.isError) { - return
Error: {query.error.message}
; - } - - // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. - if (query.isSuccess) { - console.log(query.data.vendorRates); - } - return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## getVendorRateById -You can execute the `getVendorRateById` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): - -```javascript -useGetVendorRateById(dc: DataConnect, vars: GetVendorRateByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` -You can also pass in a `DataConnect` instance to the Query hook function. -```javascript -useGetVendorRateById(vars: GetVendorRateByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` - -### Variables -The `getVendorRateById` Query requires an argument of type `GetVendorRateByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: - -```javascript -export interface GetVendorRateByIdVariables { - id: UUIDString; -} -``` -### Return Type -Recall that calling the `getVendorRateById` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. - -To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. - -To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `getVendorRateById` Query is of type `GetVendorRateByIdData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -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; -} -``` - -To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). - -### Using `getVendorRateById`'s Query hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, GetVendorRateByIdVariables } from '@dataconnect/generated'; -import { useGetVendorRateById } from '@dataconnect/generated/react' - -export default function GetVendorRateByIdComponent() { - // The `useGetVendorRateById` Query hook requires an argument of type `GetVendorRateByIdVariables`: - const getVendorRateByIdVars: GetVendorRateByIdVariables = { - id: ..., - }; - - // You don't have to do anything to "execute" the Query. - // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. - const query = useGetVendorRateById(getVendorRateByIdVars); - // Variables can be defined inline as well. - const query = useGetVendorRateById({ id: ..., }); - - // You can also pass in a `DataConnect` instance to the Query hook function. - const dataConnect = getDataConnect(connectorConfig); - const query = useGetVendorRateById(dataConnect, getVendorRateByIdVars); - - // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. - const options = { staleTime: 5 * 1000 }; - const query = useGetVendorRateById(getVendorRateByIdVars, options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { staleTime: 5 * 1000 }; - const query = useGetVendorRateById(dataConnect, getVendorRateByIdVars, options); - - // Then, you can render your component dynamically based on the status of the Query. - if (query.isPending) { - return
Loading...
; - } - - if (query.isError) { - return
Error: {query.error.message}
; - } - - // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. - if (query.isSuccess) { - console.log(query.data.vendorRate); - } - return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## filterVendorRates -You can execute the `filterVendorRates` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): - -```javascript -useFilterVendorRates(dc: DataConnect, vars?: FilterVendorRatesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` -You can also pass in a `DataConnect` instance to the Query hook function. -```javascript -useFilterVendorRates(vars?: FilterVendorRatesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` - -### Variables -The `filterVendorRates` Query has an optional argument of type `FilterVendorRatesVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: - -```javascript -export interface FilterVendorRatesVariables { - vendorName?: string | null; - category?: VendorRateCategory | null; - roleName?: string | null; - minClientRate?: number | null; - maxClientRate?: number | null; -} -``` -### Return Type -Recall that calling the `filterVendorRates` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. - -To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. - -To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `filterVendorRates` Query is of type `FilterVendorRatesData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface FilterVendorRatesData { - vendorRates: ({ - id: UUIDString; - vendorName: string; - category: VendorRateCategory; - roleName: string; - employeeWage: number; - markupPercentage?: number | null; - vendorFeePercentage?: number | null; - clientRate: number; - } & VendorRate_Key)[]; -} -``` - -To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). - -### Using `filterVendorRates`'s Query hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, FilterVendorRatesVariables } from '@dataconnect/generated'; -import { useFilterVendorRates } from '@dataconnect/generated/react' - -export default function FilterVendorRatesComponent() { - // The `useFilterVendorRates` Query hook has an optional argument of type `FilterVendorRatesVariables`: - const filterVendorRatesVars: FilterVendorRatesVariables = { - vendorName: ..., // optional - category: ..., // optional - roleName: ..., // optional - minClientRate: ..., // optional - maxClientRate: ..., // optional - }; - - // You don't have to do anything to "execute" the Query. - // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. - const query = useFilterVendorRates(filterVendorRatesVars); - // Variables can be defined inline as well. - const query = useFilterVendorRates({ vendorName: ..., category: ..., roleName: ..., minClientRate: ..., maxClientRate: ..., }); - // Since all variables are optional for this Query, you can omit the `FilterVendorRatesVariables` argument. - // (as long as you don't want to provide any `options`!) - const query = useFilterVendorRates(); - - // You can also pass in a `DataConnect` instance to the Query hook function. - const dataConnect = getDataConnect(connectorConfig); - const query = useFilterVendorRates(dataConnect, filterVendorRatesVars); - - // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. - const options = { staleTime: 5 * 1000 }; - const query = useFilterVendorRates(filterVendorRatesVars, options); - // If you'd like to provide options without providing any variables, you must - // pass `undefined` where you would normally pass the variables. - const query = useFilterVendorRates(undefined, options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { staleTime: 5 * 1000 }; - const query = useFilterVendorRates(dataConnect, filterVendorRatesVars /** or undefined */, options); - - // Then, you can render your component dynamically based on the status of the Query. - if (query.isPending) { - return
Loading...
; - } - - if (query.isError) { - return
Error: {query.error.message}
; - } - - // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. - if (query.isSuccess) { - console.log(query.data.vendorRates); - } - return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## listInvoice -You can execute the `listInvoice` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): - -```javascript -useListInvoice(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` -You can also pass in a `DataConnect` instance to the Query hook function. -```javascript -useListInvoice(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` - -### Variables -The `listInvoice` Query has no variables. -### Return Type -Recall that calling the `listInvoice` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. - -To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. - -To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `listInvoice` Query is of type `ListInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface ListInvoiceData { - invoices: ({ - id: UUIDString; - invoiceNumber: string; - amount: number; - status: InvoiceStatus; - issueDate: TimestampString; - dueDate: TimestampString; - isAutoGenerated?: boolean | null; - } & Invoice_Key)[]; -} -``` - -To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). - -### Using `listInvoice`'s Query hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig } from '@dataconnect/generated'; -import { useListInvoice } from '@dataconnect/generated/react' - -export default function ListInvoiceComponent() { - // You don't have to do anything to "execute" the Query. - // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. - const query = useListInvoice(); - - // You can also pass in a `DataConnect` instance to the Query hook function. - const dataConnect = getDataConnect(connectorConfig); - const query = useListInvoice(dataConnect); - - // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. - const options = { staleTime: 5 * 1000 }; - const query = useListInvoice(options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { staleTime: 5 * 1000 }; - const query = useListInvoice(dataConnect, options); - - // Then, you can render your component dynamically based on the status of the Query. - if (query.isPending) { - return
Loading...
; - } - - if (query.isError) { - return
Error: {query.error.message}
; - } - - // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. - if (query.isSuccess) { - console.log(query.data.invoices); - } - return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## getInvoiceById -You can execute the `getInvoiceById` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): - -```javascript -useGetInvoiceById(dc: DataConnect, vars: GetInvoiceByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` -You can also pass in a `DataConnect` instance to the Query hook function. -```javascript -useGetInvoiceById(vars: GetInvoiceByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` - -### Variables -The `getInvoiceById` Query requires an argument of type `GetInvoiceByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: - -```javascript -export interface GetInvoiceByIdVariables { - id: UUIDString; -} -``` -### Return Type -Recall that calling the `getInvoiceById` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. - -To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. - -To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `getInvoiceById` Query is of type `GetInvoiceByIdData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface GetInvoiceByIdData { - invoice?: { - id: UUIDString; - invoiceNumber: string; - amount: number; - status: InvoiceStatus; - issueDate: TimestampString; - dueDate: TimestampString; - disputedItems?: string | null; - isAutoGenerated?: boolean | null; - } & Invoice_Key; -} -``` - -To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). - -### Using `getInvoiceById`'s Query hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, GetInvoiceByIdVariables } from '@dataconnect/generated'; -import { useGetInvoiceById } from '@dataconnect/generated/react' - -export default function GetInvoiceByIdComponent() { - // The `useGetInvoiceById` Query hook requires an argument of type `GetInvoiceByIdVariables`: - const getInvoiceByIdVars: GetInvoiceByIdVariables = { - id: ..., - }; - - // You don't have to do anything to "execute" the Query. - // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. - const query = useGetInvoiceById(getInvoiceByIdVars); - // Variables can be defined inline as well. - const query = useGetInvoiceById({ id: ..., }); - - // You can also pass in a `DataConnect` instance to the Query hook function. - const dataConnect = getDataConnect(connectorConfig); - const query = useGetInvoiceById(dataConnect, getInvoiceByIdVars); - - // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. - const options = { staleTime: 5 * 1000 }; - const query = useGetInvoiceById(getInvoiceByIdVars, options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { staleTime: 5 * 1000 }; - const query = useGetInvoiceById(dataConnect, getInvoiceByIdVars, options); - - // Then, you can render your component dynamically based on the status of the Query. - if (query.isPending) { - return
Loading...
; - } - - if (query.isError) { - return
Error: {query.error.message}
; - } - - // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. - if (query.isSuccess) { - console.log(query.data.invoice); - } - return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## filterInvoices -You can execute the `filterInvoices` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): - -```javascript -useFilterInvoices(dc: DataConnect, vars?: FilterInvoicesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` -You can also pass in a `DataConnect` instance to the Query hook function. -```javascript -useFilterInvoices(vars?: FilterInvoicesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` - -### Variables -The `filterInvoices` Query has an optional argument of type `FilterInvoicesVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: - -```javascript -export interface FilterInvoicesVariables { - invoiceNumber?: string | null; - status?: InvoiceStatus | null; - isAutoGenerated?: boolean | null; - amount?: number | null; -} -``` -### Return Type -Recall that calling the `filterInvoices` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. - -To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. - -To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `filterInvoices` Query is of type `FilterInvoicesData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface FilterInvoicesData { - invoices: ({ - id: UUIDString; - invoiceNumber: string; - amount: number; - status: InvoiceStatus; - issueDate: TimestampString; - dueDate: TimestampString; - isAutoGenerated?: boolean | null; - } & Invoice_Key)[]; -} -``` - -To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). - -### Using `filterInvoices`'s Query hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, FilterInvoicesVariables } from '@dataconnect/generated'; -import { useFilterInvoices } from '@dataconnect/generated/react' - -export default function FilterInvoicesComponent() { - // The `useFilterInvoices` Query hook has an optional argument of type `FilterInvoicesVariables`: - const filterInvoicesVars: FilterInvoicesVariables = { - invoiceNumber: ..., // optional - status: ..., // optional - isAutoGenerated: ..., // optional - amount: ..., // optional - }; - - // You don't have to do anything to "execute" the Query. - // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. - const query = useFilterInvoices(filterInvoicesVars); - // Variables can be defined inline as well. - const query = useFilterInvoices({ invoiceNumber: ..., status: ..., isAutoGenerated: ..., amount: ..., }); - // Since all variables are optional for this Query, you can omit the `FilterInvoicesVariables` argument. - // (as long as you don't want to provide any `options`!) - const query = useFilterInvoices(); - - // You can also pass in a `DataConnect` instance to the Query hook function. - const dataConnect = getDataConnect(connectorConfig); - const query = useFilterInvoices(dataConnect, filterInvoicesVars); - - // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. - const options = { staleTime: 5 * 1000 }; - const query = useFilterInvoices(filterInvoicesVars, options); - // If you'd like to provide options without providing any variables, you must - // pass `undefined` where you would normally pass the variables. - const query = useFilterInvoices(undefined, options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { staleTime: 5 * 1000 }; - const query = useFilterInvoices(dataConnect, filterInvoicesVars /** or undefined */, options); - - // Then, you can render your component dynamically based on the status of the Query. - if (query.isPending) { - return
Loading...
; - } - - if (query.isError) { - return
Error: {query.error.message}
; - } - - // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. - if (query.isSuccess) { - console.log(query.data.invoices); - } - return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; -} -``` - # Mutations The React generated SDK provides Mutations hook functions that call and return [`useDataConnectMutation`](https://react-query-firebase.invertase.dev/react/data-connect/mutations) hooks from TanStack Query Firebase. @@ -1698,94 +1975,148 @@ Here's a general overview of how to use the generated Mutation hooks in your cod Below are examples of how to use the `krow-connector` connector's generated Mutation hook functions to execute each Mutation. You can also follow the examples from the [Data Connect documentation](https://firebase.google.com/docs/data-connect/web-sdk#operations-react-angular). -## CreateVendor -You can execute the `CreateVendor` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +## CreateEvent +You can execute the `CreateEvent` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): ```javascript -useCreateVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useCreateEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` You can also pass in a `DataConnect` instance to the Mutation hook function. ```javascript -useCreateVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useCreateEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` ### Variables -The `CreateVendor` Mutation requires an argument of type `CreateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +The `CreateEvent` Mutation requires an argument of type `CreateEventVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface CreateVendorVariables { - vendorNumber: string; - legalName: string; - region: VendorRegion; - platformType: VendorPlatformType; - primaryContactEmail: string; - approvalStatus: VendorApprovalStatus; - isActive?: boolean | null; +export interface CreateEventVariables { + eventName: string; + isRapid?: boolean | null; + isRecurring?: boolean | null; + isMultiDay?: boolean | null; + recurrenceType?: RecurrenceType | null; + recurrenceStartDate?: TimestampString | null; + recurrenceEndDate?: TimestampString | null; + scatterDates?: string | null; + multiDayStartDate?: TimestampString | null; + multiDayEndDate?: TimestampString | null; + bufferTimeBefore?: number | null; + bufferTimeAfter?: number | null; + conflictDetectionEnabled?: boolean | null; + detectedConflicts?: string | null; + businessId: UUIDString; + businessName?: string | null; + vendorId?: UUIDString | null; + vendorName?: string | null; + hub?: string | null; + eventLocation?: string | null; + contractType?: ContractType | null; + poReference?: string | null; + status: EventStatus; + date: TimestampString; + shifts?: string | null; + addons?: string | null; + total?: number | null; + clientName?: string | null; + clientEmail?: string | null; + clientPhone?: string | null; + invoiceId?: UUIDString | null; + notes?: string | null; + requested?: number | null; + assignedStaff?: string | null; } ``` ### Return Type -Recall that calling the `CreateVendor` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. +Recall that calling the `CreateEvent` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `CreateVendor` Mutation is of type `CreateVendorData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `CreateEvent` Mutation is of type `CreateEventData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface CreateVendorData { - vendor_insert: Vendor_Key; +export interface CreateEventData { + event_insert: Event_Key; } ``` To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). -### Using `CreateVendor`'s Mutation hook function +### Using `CreateEvent`'s Mutation hook function ```javascript import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, CreateVendorVariables } from '@dataconnect/generated'; -import { useCreateVendor } from '@dataconnect/generated/react' +import { connectorConfig, CreateEventVariables } from '@dataconnect/generated'; +import { useCreateEvent } from '@dataconnect/generated/react' -export default function CreateVendorComponent() { +export default function CreateEventComponent() { // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useCreateVendor(); + const mutation = useCreateEvent(); // You can also pass in a `DataConnect` instance to the Mutation hook function. const dataConnect = getDataConnect(connectorConfig); - const mutation = useCreateVendor(dataConnect); + const mutation = useCreateEvent(dataConnect); // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useCreateVendor(options); + const mutation = useCreateEvent(options); // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. const dataConnect = getDataConnect(connectorConfig); const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useCreateVendor(dataConnect, options); + const mutation = useCreateEvent(dataConnect, options); // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useCreateVendor` Mutation requires an argument of type `CreateVendorVariables`: - const createVendorVars: CreateVendorVariables = { - vendorNumber: ..., - legalName: ..., - region: ..., - platformType: ..., - primaryContactEmail: ..., - approvalStatus: ..., - isActive: ..., // optional + // The `useCreateEvent` 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 }; - mutation.mutate(createVendorVars); + mutation.mutate(createEventVars); // Variables can be defined inline as well. - mutation.mutate({ vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); + mutation.mutate({ 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: ..., }); // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - mutation.mutate(createVendorVars, options); + mutation.mutate(createEventVars, options); // Then, you can render your component dynamically based on the status of the Mutation. if (mutation.isPending) { @@ -1798,102 +2129,156 @@ export default function CreateVendorComponent() { // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. if (mutation.isSuccess) { - console.log(mutation.data.vendor_insert); + console.log(mutation.data.event_insert); } return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; } ``` -## UpdateVendor -You can execute the `UpdateVendor` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +## UpdateEvent +You can execute the `UpdateEvent` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): ```javascript -useUpdateVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useUpdateEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` You can also pass in a `DataConnect` instance to the Mutation hook function. ```javascript -useUpdateVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useUpdateEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` ### Variables -The `UpdateVendor` Mutation requires an argument of type `UpdateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +The `UpdateEvent` Mutation requires an argument of type `UpdateEventVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface UpdateVendorVariables { +export interface UpdateEventVariables { id: UUIDString; - vendorNumber?: string | null; - legalName?: string | null; - region?: VendorRegion | null; - platformType?: VendorPlatformType | null; - primaryContactEmail?: string | null; - approvalStatus?: VendorApprovalStatus | null; - isActive?: boolean | null; + eventName?: string | null; + isRapid?: boolean | null; + isRecurring?: boolean | null; + isMultiDay?: boolean | null; + recurrenceType?: RecurrenceType | null; + recurrenceStartDate?: TimestampString | null; + recurrenceEndDate?: TimestampString | null; + scatterDates?: string | null; + multiDayStartDate?: TimestampString | null; + multiDayEndDate?: TimestampString | null; + bufferTimeBefore?: number | null; + bufferTimeAfter?: number | null; + conflictDetectionEnabled?: boolean | null; + detectedConflicts?: string | null; + businessId?: UUIDString | null; + businessName?: string | null; + vendorId?: UUIDString | null; + vendorName?: string | null; + hub?: string | null; + eventLocation?: string | null; + contractType?: ContractType | null; + poReference?: string | null; + status?: EventStatus | null; + date?: TimestampString | null; + shifts?: string | null; + addons?: string | null; + total?: number | null; + clientName?: string | null; + clientEmail?: string | null; + clientPhone?: string | null; + invoiceId?: UUIDString | null; + notes?: string | null; + requested?: number | null; + assignedStaff?: string | null; } ``` ### Return Type -Recall that calling the `UpdateVendor` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. +Recall that calling the `UpdateEvent` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `UpdateVendor` Mutation is of type `UpdateVendorData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `UpdateEvent` Mutation is of type `UpdateEventData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface UpdateVendorData { - vendor_update?: Vendor_Key | null; +export interface UpdateEventData { + event_update?: Event_Key | null; } ``` To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). -### Using `UpdateVendor`'s Mutation hook function +### Using `UpdateEvent`'s Mutation hook function ```javascript import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, UpdateVendorVariables } from '@dataconnect/generated'; -import { useUpdateVendor } from '@dataconnect/generated/react' +import { connectorConfig, UpdateEventVariables } from '@dataconnect/generated'; +import { useUpdateEvent } from '@dataconnect/generated/react' -export default function UpdateVendorComponent() { +export default function UpdateEventComponent() { // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useUpdateVendor(); + const mutation = useUpdateEvent(); // You can also pass in a `DataConnect` instance to the Mutation hook function. const dataConnect = getDataConnect(connectorConfig); - const mutation = useUpdateVendor(dataConnect); + const mutation = useUpdateEvent(dataConnect); // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useUpdateVendor(options); + const mutation = useUpdateEvent(options); // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. const dataConnect = getDataConnect(connectorConfig); const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useUpdateVendor(dataConnect, options); + const mutation = useUpdateEvent(dataConnect, options); // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useUpdateVendor` Mutation requires an argument of type `UpdateVendorVariables`: - const updateVendorVars: UpdateVendorVariables = { + // The `useUpdateEvent` Mutation requires an argument of type `UpdateEventVariables`: + const updateEventVars: UpdateEventVariables = { id: ..., - vendorNumber: ..., // optional - legalName: ..., // optional - region: ..., // optional - platformType: ..., // optional - primaryContactEmail: ..., // optional - approvalStatus: ..., // optional - isActive: ..., // optional + 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 + assignedStaff: ..., // optional }; - mutation.mutate(updateVendorVars); + mutation.mutate(updateEventVars); // Variables can be defined inline as well. - mutation.mutate({ id: ..., vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); + mutation.mutate({ 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: ..., assignedStaff: ..., }); // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - mutation.mutate(updateVendorVars, options); + mutation.mutate(updateEventVars, options); // Then, you can render your component dynamically based on the status of the Mutation. if (mutation.isPending) { @@ -1906,80 +2291,80 @@ export default function UpdateVendorComponent() { // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. if (mutation.isSuccess) { - console.log(mutation.data.vendor_update); + console.log(mutation.data.event_update); } return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; } ``` -## DeleteVendor -You can execute the `DeleteVendor` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +## DeleteEvent +You can execute the `DeleteEvent` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): ```javascript -useDeleteVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useDeleteEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` You can also pass in a `DataConnect` instance to the Mutation hook function. ```javascript -useDeleteVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useDeleteEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` ### Variables -The `DeleteVendor` Mutation requires an argument of type `DeleteVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +The `DeleteEvent` Mutation requires an argument of type `DeleteEventVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface DeleteVendorVariables { +export interface DeleteEventVariables { id: UUIDString; } ``` ### Return Type -Recall that calling the `DeleteVendor` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. +Recall that calling the `DeleteEvent` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `DeleteVendor` Mutation is of type `DeleteVendorData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `DeleteEvent` Mutation is of type `DeleteEventData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface DeleteVendorData { - vendor_delete?: Vendor_Key | null; +export interface DeleteEventData { + event_delete?: Event_Key | null; } ``` To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). -### Using `DeleteVendor`'s Mutation hook function +### Using `DeleteEvent`'s Mutation hook function ```javascript import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, DeleteVendorVariables } from '@dataconnect/generated'; -import { useDeleteVendor } from '@dataconnect/generated/react' +import { connectorConfig, DeleteEventVariables } from '@dataconnect/generated'; +import { useDeleteEvent } from '@dataconnect/generated/react' -export default function DeleteVendorComponent() { +export default function DeleteEventComponent() { // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useDeleteVendor(); + const mutation = useDeleteEvent(); // You can also pass in a `DataConnect` instance to the Mutation hook function. const dataConnect = getDataConnect(connectorConfig); - const mutation = useDeleteVendor(dataConnect); + const mutation = useDeleteEvent(dataConnect); // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useDeleteVendor(options); + const mutation = useDeleteEvent(options); // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. const dataConnect = getDataConnect(connectorConfig); const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useDeleteVendor(dataConnect, options); + const mutation = useDeleteEvent(dataConnect, options); // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useDeleteVendor` Mutation requires an argument of type `DeleteVendorVariables`: - const deleteVendorVars: DeleteVendorVariables = { + // The `useDeleteEvent` Mutation requires an argument of type `DeleteEventVariables`: + const deleteEventVars: DeleteEventVariables = { id: ..., }; - mutation.mutate(deleteVendorVars); + mutation.mutate(deleteEventVars); // Variables can be defined inline as well. mutation.mutate({ id: ..., }); @@ -1987,7 +2372,7 @@ export default function DeleteVendorComponent() { const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - mutation.mutate(deleteVendorVars, options); + mutation.mutate(deleteEventVars, options); // Then, you can render your component dynamically based on the status of the Mutation. if (mutation.isPending) { @@ -2000,7 +2385,315 @@ export default function DeleteVendorComponent() { // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. if (mutation.isSuccess) { - console.log(mutation.data.vendor_delete); + console.log(mutation.data.event_delete); + } + return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## CreateVendorRate +You can execute the `CreateVendorRate` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +```javascript +useCreateVendorRate(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` +You can also pass in a `DataConnect` instance to the Mutation hook function. +```javascript +useCreateVendorRate(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` + +### Variables +The `CreateVendorRate` Mutation requires an argument of type `CreateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface CreateVendorRateVariables { + vendorName: string; + category: VendorRateCategory; + roleName: string; + employeeWage: number; + markupPercentage?: number | null; + vendorFeePercentage?: number | null; + clientRate: number; +} +``` +### Return Type +Recall that calling the `CreateVendorRate` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. + +To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. + +To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. + +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `CreateVendorRate` Mutation is of type `CreateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface CreateVendorRateData { + vendorRate_insert: VendorRate_Key; +} +``` + +To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). + +### Using `CreateVendorRate`'s Mutation hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, CreateVendorRateVariables } from '@dataconnect/generated'; +import { useCreateVendorRate } from '@dataconnect/generated/react' + +export default function CreateVendorRateComponent() { + // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. + const mutation = useCreateVendorRate(); + + // You can also pass in a `DataConnect` instance to the Mutation hook function. + const dataConnect = getDataConnect(connectorConfig); + const mutation = useCreateVendorRate(dataConnect); + + // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useCreateVendorRate(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useCreateVendorRate(dataConnect, options); + + // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. + // The `useCreateVendorRate` Mutation requires an argument of type `CreateVendorRateVariables`: + const createVendorRateVars: CreateVendorRateVariables = { + vendorName: ..., + category: ..., + roleName: ..., + employeeWage: ..., + markupPercentage: ..., // optional + vendorFeePercentage: ..., // optional + clientRate: ..., + }; + mutation.mutate(createVendorRateVars); + // Variables can be defined inline as well. + mutation.mutate({ vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); + + // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + mutation.mutate(createVendorRateVars, options); + + // Then, you can render your component dynamically based on the status of the Mutation. + if (mutation.isPending) { + return
Loading...
; + } + + if (mutation.isError) { + return
Error: {mutation.error.message}
; + } + + // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. + if (mutation.isSuccess) { + console.log(mutation.data.vendorRate_insert); + } + return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## UpdateVendorRate +You can execute the `UpdateVendorRate` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +```javascript +useUpdateVendorRate(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` +You can also pass in a `DataConnect` instance to the Mutation hook function. +```javascript +useUpdateVendorRate(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` + +### Variables +The `UpdateVendorRate` Mutation requires an argument of type `UpdateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +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 calling the `UpdateVendorRate` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. + +To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. + +To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. + +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `UpdateVendorRate` Mutation is of type `UpdateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface UpdateVendorRateData { + vendorRate_update?: VendorRate_Key | null; +} +``` + +To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). + +### Using `UpdateVendorRate`'s Mutation hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, UpdateVendorRateVariables } from '@dataconnect/generated'; +import { useUpdateVendorRate } from '@dataconnect/generated/react' + +export default function UpdateVendorRateComponent() { + // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. + const mutation = useUpdateVendorRate(); + + // You can also pass in a `DataConnect` instance to the Mutation hook function. + const dataConnect = getDataConnect(connectorConfig); + const mutation = useUpdateVendorRate(dataConnect); + + // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useUpdateVendorRate(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useUpdateVendorRate(dataConnect, options); + + // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. + // The `useUpdateVendorRate` 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 + }; + mutation.mutate(updateVendorRateVars); + // Variables can be defined inline as well. + mutation.mutate({ id: ..., vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); + + // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + mutation.mutate(updateVendorRateVars, options); + + // Then, you can render your component dynamically based on the status of the Mutation. + if (mutation.isPending) { + return
Loading...
; + } + + if (mutation.isError) { + return
Error: {mutation.error.message}
; + } + + // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. + if (mutation.isSuccess) { + console.log(mutation.data.vendorRate_update); + } + return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## DeleteVendorRate +You can execute the `DeleteVendorRate` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +```javascript +useDeleteVendorRate(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` +You can also pass in a `DataConnect` instance to the Mutation hook function. +```javascript +useDeleteVendorRate(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` + +### Variables +The `DeleteVendorRate` Mutation requires an argument of type `DeleteVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface DeleteVendorRateVariables { + id: UUIDString; +} +``` +### Return Type +Recall that calling the `DeleteVendorRate` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. + +To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. + +To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. + +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `DeleteVendorRate` Mutation is of type `DeleteVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface DeleteVendorRateData { + vendorRate_delete?: VendorRate_Key | null; +} +``` + +To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). + +### Using `DeleteVendorRate`'s Mutation hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, DeleteVendorRateVariables } from '@dataconnect/generated'; +import { useDeleteVendorRate } from '@dataconnect/generated/react' + +export default function DeleteVendorRateComponent() { + // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. + const mutation = useDeleteVendorRate(); + + // You can also pass in a `DataConnect` instance to the Mutation hook function. + const dataConnect = getDataConnect(connectorConfig); + const mutation = useDeleteVendorRate(dataConnect); + + // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useDeleteVendorRate(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useDeleteVendorRate(dataConnect, options); + + // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. + // The `useDeleteVendorRate` Mutation requires an argument of type `DeleteVendorRateVariables`: + const deleteVendorRateVars: DeleteVendorRateVariables = { + id: ..., + }; + mutation.mutate(deleteVendorRateVars); + // Variables can be defined inline as well. + mutation.mutate({ id: ..., }); + + // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + mutation.mutate(deleteVendorRateVars, options); + + // Then, you can render your component dynamically based on the status of the Mutation. + if (mutation.isPending) { + return
Loading...
; + } + + if (mutation.isError) { + return
Error: {mutation.error.message}
; + } + + // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. + if (mutation.isSuccess) { + console.log(mutation.data.vendorRate_delete); } return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; } @@ -2424,6 +3117,314 @@ export default function CreateStaffComponent() { } ``` +## CreateVendor +You can execute the `CreateVendor` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +```javascript +useCreateVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` +You can also pass in a `DataConnect` instance to the Mutation hook function. +```javascript +useCreateVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` + +### Variables +The `CreateVendor` Mutation requires an argument of type `CreateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface CreateVendorVariables { + vendorNumber: string; + legalName: string; + region: VendorRegion; + platformType: VendorPlatformType; + primaryContactEmail: string; + approvalStatus: VendorApprovalStatus; + isActive?: boolean | null; +} +``` +### Return Type +Recall that calling the `CreateVendor` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. + +To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. + +To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. + +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `CreateVendor` Mutation is of type `CreateVendorData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface CreateVendorData { + vendor_insert: Vendor_Key; +} +``` + +To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). + +### Using `CreateVendor`'s Mutation hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, CreateVendorVariables } from '@dataconnect/generated'; +import { useCreateVendor } from '@dataconnect/generated/react' + +export default function CreateVendorComponent() { + // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. + const mutation = useCreateVendor(); + + // You can also pass in a `DataConnect` instance to the Mutation hook function. + const dataConnect = getDataConnect(connectorConfig); + const mutation = useCreateVendor(dataConnect); + + // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useCreateVendor(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useCreateVendor(dataConnect, options); + + // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. + // The `useCreateVendor` Mutation requires an argument of type `CreateVendorVariables`: + const createVendorVars: CreateVendorVariables = { + vendorNumber: ..., + legalName: ..., + region: ..., + platformType: ..., + primaryContactEmail: ..., + approvalStatus: ..., + isActive: ..., // optional + }; + mutation.mutate(createVendorVars); + // Variables can be defined inline as well. + mutation.mutate({ vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); + + // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + mutation.mutate(createVendorVars, options); + + // Then, you can render your component dynamically based on the status of the Mutation. + if (mutation.isPending) { + return
Loading...
; + } + + if (mutation.isError) { + return
Error: {mutation.error.message}
; + } + + // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. + if (mutation.isSuccess) { + console.log(mutation.data.vendor_insert); + } + return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## UpdateVendor +You can execute the `UpdateVendor` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +```javascript +useUpdateVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` +You can also pass in a `DataConnect` instance to the Mutation hook function. +```javascript +useUpdateVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` + +### Variables +The `UpdateVendor` Mutation requires an argument of type `UpdateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +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 calling the `UpdateVendor` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. + +To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. + +To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. + +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `UpdateVendor` Mutation is of type `UpdateVendorData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface UpdateVendorData { + vendor_update?: Vendor_Key | null; +} +``` + +To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). + +### Using `UpdateVendor`'s Mutation hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, UpdateVendorVariables } from '@dataconnect/generated'; +import { useUpdateVendor } from '@dataconnect/generated/react' + +export default function UpdateVendorComponent() { + // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. + const mutation = useUpdateVendor(); + + // You can also pass in a `DataConnect` instance to the Mutation hook function. + const dataConnect = getDataConnect(connectorConfig); + const mutation = useUpdateVendor(dataConnect); + + // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useUpdateVendor(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useUpdateVendor(dataConnect, options); + + // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. + // The `useUpdateVendor` 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 + }; + mutation.mutate(updateVendorVars); + // Variables can be defined inline as well. + mutation.mutate({ id: ..., vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); + + // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + mutation.mutate(updateVendorVars, options); + + // Then, you can render your component dynamically based on the status of the Mutation. + if (mutation.isPending) { + return
Loading...
; + } + + if (mutation.isError) { + return
Error: {mutation.error.message}
; + } + + // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. + if (mutation.isSuccess) { + console.log(mutation.data.vendor_update); + } + return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## DeleteVendor +You can execute the `DeleteVendor` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +```javascript +useDeleteVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` +You can also pass in a `DataConnect` instance to the Mutation hook function. +```javascript +useDeleteVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` + +### Variables +The `DeleteVendor` Mutation requires an argument of type `DeleteVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface DeleteVendorVariables { + id: UUIDString; +} +``` +### Return Type +Recall that calling the `DeleteVendor` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. + +To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. + +To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. + +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `DeleteVendor` Mutation is of type `DeleteVendorData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface DeleteVendorData { + vendor_delete?: Vendor_Key | null; +} +``` + +To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). + +### Using `DeleteVendor`'s Mutation hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, DeleteVendorVariables } from '@dataconnect/generated'; +import { useDeleteVendor } from '@dataconnect/generated/react' + +export default function DeleteVendorComponent() { + // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. + const mutation = useDeleteVendor(); + + // You can also pass in a `DataConnect` instance to the Mutation hook function. + const dataConnect = getDataConnect(connectorConfig); + const mutation = useDeleteVendor(dataConnect); + + // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useDeleteVendor(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useDeleteVendor(dataConnect, options); + + // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. + // The `useDeleteVendor` Mutation requires an argument of type `DeleteVendorVariables`: + const deleteVendorVars: DeleteVendorVariables = { + id: ..., + }; + mutation.mutate(deleteVendorVars); + // Variables can be defined inline as well. + mutation.mutate({ id: ..., }); + + // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + mutation.mutate(deleteVendorVars, options); + + // Then, you can render your component dynamically based on the status of the Mutation. + if (mutation.isPending) { + return
Loading...
; + } + + if (mutation.isError) { + return
Error: {mutation.error.message}
; + } + + // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. + if (mutation.isSuccess) { + console.log(mutation.data.vendor_delete); + } + return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; +} +``` + ## CreateVendorDefaultSetting You can execute the `CreateVendorDefaultSetting` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): ```javascript @@ -2716,618 +3717,92 @@ export default function DeleteVendorDefaultSettingComponent() { } ``` -## CreateVendorRate -You can execute the `CreateVendorRate` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +## CreateBusiness +You can execute the `CreateBusiness` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): ```javascript -useCreateVendorRate(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useCreateBusiness(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` You can also pass in a `DataConnect` instance to the Mutation hook function. ```javascript -useCreateVendorRate(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useCreateBusiness(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` ### Variables -The `CreateVendorRate` Mutation requires an argument of type `CreateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +The `CreateBusiness` Mutation requires an argument of type `CreateBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface CreateVendorRateVariables { - vendorName: string; - category: VendorRateCategory; - roleName: string; - employeeWage: number; - markupPercentage?: number | null; - vendorFeePercentage?: number | null; - clientRate: number; +export interface CreateBusinessVariables { + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; } ``` ### Return Type -Recall that calling the `CreateVendorRate` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. +Recall that calling the `CreateBusiness` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `CreateVendorRate` Mutation is of type `CreateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `CreateBusiness` Mutation is of type `CreateBusinessData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface CreateVendorRateData { - vendorRate_insert: VendorRate_Key; +export interface CreateBusinessData { + business_insert: Business_Key; } ``` To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). -### Using `CreateVendorRate`'s Mutation hook function +### Using `CreateBusiness`'s Mutation hook function ```javascript import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, CreateVendorRateVariables } from '@dataconnect/generated'; -import { useCreateVendorRate } from '@dataconnect/generated/react' +import { connectorConfig, CreateBusinessVariables } from '@dataconnect/generated'; +import { useCreateBusiness } from '@dataconnect/generated/react' -export default function CreateVendorRateComponent() { +export default function CreateBusinessComponent() { // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useCreateVendorRate(); + const mutation = useCreateBusiness(); // You can also pass in a `DataConnect` instance to the Mutation hook function. const dataConnect = getDataConnect(connectorConfig); - const mutation = useCreateVendorRate(dataConnect); + const mutation = useCreateBusiness(dataConnect); // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useCreateVendorRate(options); + const mutation = useCreateBusiness(options); // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. const dataConnect = getDataConnect(connectorConfig); const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useCreateVendorRate(dataConnect, options); + const mutation = useCreateBusiness(dataConnect, options); // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useCreateVendorRate` Mutation requires an argument of type `CreateVendorRateVariables`: - const createVendorRateVars: CreateVendorRateVariables = { - vendorName: ..., - category: ..., - roleName: ..., - employeeWage: ..., - markupPercentage: ..., // optional - vendorFeePercentage: ..., // optional - clientRate: ..., - }; - mutation.mutate(createVendorRateVars); - // Variables can be defined inline as well. - mutation.mutate({ vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); - - // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - mutation.mutate(createVendorRateVars, options); - - // Then, you can render your component dynamically based on the status of the Mutation. - if (mutation.isPending) { - return
Loading...
; - } - - if (mutation.isError) { - return
Error: {mutation.error.message}
; - } - - // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. - if (mutation.isSuccess) { - console.log(mutation.data.vendorRate_insert); - } - return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## UpdateVendorRate -You can execute the `UpdateVendorRate` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): -```javascript -useUpdateVendorRate(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -``` -You can also pass in a `DataConnect` instance to the Mutation hook function. -```javascript -useUpdateVendorRate(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -``` - -### Variables -The `UpdateVendorRate` Mutation requires an argument of type `UpdateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: - -```javascript -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 calling the `UpdateVendorRate` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. - -To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. - -To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. - -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `UpdateVendorRate` Mutation is of type `UpdateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface UpdateVendorRateData { - vendorRate_update?: VendorRate_Key | null; -} -``` - -To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). - -### Using `UpdateVendorRate`'s Mutation hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, UpdateVendorRateVariables } from '@dataconnect/generated'; -import { useUpdateVendorRate } from '@dataconnect/generated/react' - -export default function UpdateVendorRateComponent() { - // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useUpdateVendorRate(); - - // You can also pass in a `DataConnect` instance to the Mutation hook function. - const dataConnect = getDataConnect(connectorConfig); - const mutation = useUpdateVendorRate(dataConnect); - - // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - const mutation = useUpdateVendorRate(options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - const mutation = useUpdateVendorRate(dataConnect, options); - - // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useUpdateVendorRate` 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 - }; - mutation.mutate(updateVendorRateVars); - // Variables can be defined inline as well. - mutation.mutate({ id: ..., vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); - - // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - mutation.mutate(updateVendorRateVars, options); - - // Then, you can render your component dynamically based on the status of the Mutation. - if (mutation.isPending) { - return
Loading...
; - } - - if (mutation.isError) { - return
Error: {mutation.error.message}
; - } - - // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. - if (mutation.isSuccess) { - console.log(mutation.data.vendorRate_update); - } - return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## DeleteVendorRate -You can execute the `DeleteVendorRate` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): -```javascript -useDeleteVendorRate(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -``` -You can also pass in a `DataConnect` instance to the Mutation hook function. -```javascript -useDeleteVendorRate(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -``` - -### Variables -The `DeleteVendorRate` Mutation requires an argument of type `DeleteVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: - -```javascript -export interface DeleteVendorRateVariables { - id: UUIDString; -} -``` -### Return Type -Recall that calling the `DeleteVendorRate` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. - -To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. - -To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. - -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `DeleteVendorRate` Mutation is of type `DeleteVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface DeleteVendorRateData { - vendorRate_delete?: VendorRate_Key | null; -} -``` - -To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). - -### Using `DeleteVendorRate`'s Mutation hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, DeleteVendorRateVariables } from '@dataconnect/generated'; -import { useDeleteVendorRate } from '@dataconnect/generated/react' - -export default function DeleteVendorRateComponent() { - // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useDeleteVendorRate(); - - // You can also pass in a `DataConnect` instance to the Mutation hook function. - const dataConnect = getDataConnect(connectorConfig); - const mutation = useDeleteVendorRate(dataConnect); - - // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - const mutation = useDeleteVendorRate(options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - const mutation = useDeleteVendorRate(dataConnect, options); - - // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useDeleteVendorRate` Mutation requires an argument of type `DeleteVendorRateVariables`: - const deleteVendorRateVars: DeleteVendorRateVariables = { - id: ..., - }; - mutation.mutate(deleteVendorRateVars); - // Variables can be defined inline as well. - mutation.mutate({ id: ..., }); - - // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - mutation.mutate(deleteVendorRateVars, options); - - // Then, you can render your component dynamically based on the status of the Mutation. - if (mutation.isPending) { - return
Loading...
; - } - - if (mutation.isError) { - return
Error: {mutation.error.message}
; - } - - // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. - if (mutation.isSuccess) { - console.log(mutation.data.vendorRate_delete); - } - return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## CreateEvent -You can execute the `CreateEvent` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): -```javascript -useCreateEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -``` -You can also pass in a `DataConnect` instance to the Mutation hook function. -```javascript -useCreateEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -``` - -### Variables -The `CreateEvent` Mutation requires an argument of type `CreateEventVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: - -```javascript -export interface CreateEventVariables { - eventName: string; - isRapid?: boolean | null; - isRecurring?: boolean | null; - isMultiDay?: boolean | null; - recurrenceType?: RecurrenceType | null; - recurrenceStartDate?: TimestampString | null; - recurrenceEndDate?: TimestampString | null; - scatterDates?: string | null; - multiDayStartDate?: TimestampString | null; - multiDayEndDate?: TimestampString | null; - bufferTimeBefore?: number | null; - bufferTimeAfter?: number | null; - conflictDetectionEnabled?: boolean | null; - detectedConflicts?: string | null; - businessId: UUIDString; - businessName?: string | null; - vendorId?: UUIDString | null; - vendorName?: string | null; - hub?: string | null; - eventLocation?: string | null; - contractType?: ContractType | null; - poReference?: string | null; - status: EventStatus; - date: TimestampString; - shifts?: string | null; - addons?: string | null; - total?: number | null; - clientName?: string | null; - clientEmail?: string | null; - clientPhone?: string | null; - invoiceId?: UUIDString | null; - notes?: string | null; - requested?: number | null; - assignedStaff?: string | null; -} -``` -### Return Type -Recall that calling the `CreateEvent` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. - -To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. - -To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. - -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `CreateEvent` Mutation is of type `CreateEventData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface CreateEventData { - event_insert: Event_Key; -} -``` - -To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). - -### Using `CreateEvent`'s Mutation hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, CreateEventVariables } from '@dataconnect/generated'; -import { useCreateEvent } from '@dataconnect/generated/react' - -export default function CreateEventComponent() { - // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useCreateEvent(); - - // You can also pass in a `DataConnect` instance to the Mutation hook function. - const dataConnect = getDataConnect(connectorConfig); - const mutation = useCreateEvent(dataConnect); - - // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - const mutation = useCreateEvent(options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - const mutation = useCreateEvent(dataConnect, options); - - // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useCreateEvent` 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 - }; - mutation.mutate(createEventVars); - // Variables can be defined inline as well. - mutation.mutate({ 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: ..., }); - - // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - mutation.mutate(createEventVars, options); - - // Then, you can render your component dynamically based on the status of the Mutation. - if (mutation.isPending) { - return
Loading...
; - } - - if (mutation.isError) { - return
Error: {mutation.error.message}
; - } - - // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. - if (mutation.isSuccess) { - console.log(mutation.data.event_insert); - } - return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## UpdateEvent -You can execute the `UpdateEvent` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): -```javascript -useUpdateEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -``` -You can also pass in a `DataConnect` instance to the Mutation hook function. -```javascript -useUpdateEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -``` - -### Variables -The `UpdateEvent` Mutation requires an argument of type `UpdateEventVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: - -```javascript -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?: string | null; - multiDayStartDate?: TimestampString | null; - multiDayEndDate?: TimestampString | null; - bufferTimeBefore?: number | null; - bufferTimeAfter?: number | null; - conflictDetectionEnabled?: boolean | null; - detectedConflicts?: string | null; - businessId?: UUIDString | null; - businessName?: string | null; - vendorId?: UUIDString | null; - vendorName?: string | null; - hub?: string | null; - eventLocation?: string | null; - contractType?: ContractType | null; - poReference?: string | null; - status?: EventStatus | null; - date?: TimestampString | null; - shifts?: string | null; - addons?: string | null; - total?: number | null; - clientName?: string | null; - clientEmail?: string | null; - clientPhone?: string | null; - invoiceId?: UUIDString | null; - notes?: string | null; - requested?: number | null; - assignedStaff?: string | null; -} -``` -### Return Type -Recall that calling the `UpdateEvent` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. - -To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. - -To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. - -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `UpdateEvent` Mutation is of type `UpdateEventData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface UpdateEventData { - event_update?: Event_Key | null; -} -``` - -To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). - -### Using `UpdateEvent`'s Mutation hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, UpdateEventVariables } from '@dataconnect/generated'; -import { useUpdateEvent } from '@dataconnect/generated/react' - -export default function UpdateEventComponent() { - // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useUpdateEvent(); - - // You can also pass in a `DataConnect` instance to the Mutation hook function. - const dataConnect = getDataConnect(connectorConfig); - const mutation = useUpdateEvent(dataConnect); - - // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - const mutation = useUpdateEvent(options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - const mutation = useUpdateEvent(dataConnect, options); - - // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useUpdateEvent` 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 + // The `useCreateBusiness` Mutation requires an argument of type `CreateBusinessVariables`: + const createBusinessVars: CreateBusinessVariables = { + businessName: ..., + contactName: ..., + email: ..., // optional + sector: ..., // optional + rateGroup: ..., status: ..., // optional - date: ..., // optional - shifts: ..., // optional - addons: ..., // optional - total: ..., // optional - clientName: ..., // optional - clientEmail: ..., // optional - clientPhone: ..., // optional - invoiceId: ..., // optional - notes: ..., // optional - requested: ..., // optional - assignedStaff: ..., // optional }; - mutation.mutate(updateEventVars); + mutation.mutate(createBusinessVars); // Variables can be defined inline as well. - mutation.mutate({ 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: ..., assignedStaff: ..., }); + mutation.mutate({ businessName: ..., contactName: ..., email: ..., sector: ..., rateGroup: ..., status: ..., }); // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - mutation.mutate(updateEventVars, options); + mutation.mutate(createBusinessVars, options); // Then, you can render your component dynamically based on the status of the Mutation. if (mutation.isPending) { @@ -3340,80 +3815,186 @@ export default function UpdateEventComponent() { // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. if (mutation.isSuccess) { - console.log(mutation.data.event_update); + console.log(mutation.data.business_insert); } return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; } ``` -## DeleteEvent -You can execute the `DeleteEvent` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +## UpdateBusiness +You can execute the `UpdateBusiness` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): ```javascript -useDeleteEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useUpdateBusiness(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` You can also pass in a `DataConnect` instance to the Mutation hook function. ```javascript -useDeleteEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useUpdateBusiness(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` ### Variables -The `DeleteEvent` Mutation requires an argument of type `DeleteEventVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +The `UpdateBusiness` Mutation requires an argument of type `UpdateBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface DeleteEventVariables { +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 calling the `DeleteEvent` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. +Recall that calling the `UpdateBusiness` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `DeleteEvent` Mutation is of type `DeleteEventData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `UpdateBusiness` Mutation is of type `UpdateBusinessData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface DeleteEventData { - event_delete?: Event_Key | null; +export interface UpdateBusinessData { + business_update?: Business_Key | null; } ``` To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). -### Using `DeleteEvent`'s Mutation hook function +### Using `UpdateBusiness`'s Mutation hook function ```javascript import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, DeleteEventVariables } from '@dataconnect/generated'; -import { useDeleteEvent } from '@dataconnect/generated/react' +import { connectorConfig, UpdateBusinessVariables } from '@dataconnect/generated'; +import { useUpdateBusiness } from '@dataconnect/generated/react' -export default function DeleteEventComponent() { +export default function UpdateBusinessComponent() { // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useDeleteEvent(); + const mutation = useUpdateBusiness(); // You can also pass in a `DataConnect` instance to the Mutation hook function. const dataConnect = getDataConnect(connectorConfig); - const mutation = useDeleteEvent(dataConnect); + const mutation = useUpdateBusiness(dataConnect); // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useDeleteEvent(options); + const mutation = useUpdateBusiness(options); // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. const dataConnect = getDataConnect(connectorConfig); const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useDeleteEvent(dataConnect, options); + const mutation = useUpdateBusiness(dataConnect, options); // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useDeleteEvent` Mutation requires an argument of type `DeleteEventVariables`: - const deleteEventVars: DeleteEventVariables = { + // The `useUpdateBusiness` Mutation requires an argument of type `UpdateBusinessVariables`: + const updateBusinessVars: UpdateBusinessVariables = { + id: ..., + businessName: ..., // optional + contactName: ..., // optional + email: ..., // optional + sector: ..., // optional + rateGroup: ..., // optional + status: ..., // optional + }; + mutation.mutate(updateBusinessVars); + // Variables can be defined inline as well. + mutation.mutate({ id: ..., businessName: ..., contactName: ..., email: ..., sector: ..., rateGroup: ..., status: ..., }); + + // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + mutation.mutate(updateBusinessVars, options); + + // Then, you can render your component dynamically based on the status of the Mutation. + if (mutation.isPending) { + return
Loading...
; + } + + if (mutation.isError) { + return
Error: {mutation.error.message}
; + } + + // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. + if (mutation.isSuccess) { + console.log(mutation.data.business_update); + } + return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## DeleteBusiness +You can execute the `DeleteBusiness` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +```javascript +useDeleteBusiness(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` +You can also pass in a `DataConnect` instance to the Mutation hook function. +```javascript +useDeleteBusiness(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` + +### Variables +The `DeleteBusiness` Mutation requires an argument of type `DeleteBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface DeleteBusinessVariables { + id: UUIDString; +} +``` +### Return Type +Recall that calling the `DeleteBusiness` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. + +To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. + +To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. + +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `DeleteBusiness` Mutation is of type `DeleteBusinessData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface DeleteBusinessData { + business_delete?: Business_Key | null; +} +``` + +To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). + +### Using `DeleteBusiness`'s Mutation hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, DeleteBusinessVariables } from '@dataconnect/generated'; +import { useDeleteBusiness } from '@dataconnect/generated/react' + +export default function DeleteBusinessComponent() { + // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. + const mutation = useDeleteBusiness(); + + // You can also pass in a `DataConnect` instance to the Mutation hook function. + const dataConnect = getDataConnect(connectorConfig); + const mutation = useDeleteBusiness(dataConnect); + + // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useDeleteBusiness(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useDeleteBusiness(dataConnect, options); + + // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. + // The `useDeleteBusiness` Mutation requires an argument of type `DeleteBusinessVariables`: + const deleteBusinessVars: DeleteBusinessVariables = { id: ..., }; - mutation.mutate(deleteEventVars); + mutation.mutate(deleteBusinessVars); // Variables can be defined inline as well. mutation.mutate({ id: ..., }); @@ -3421,7 +4002,7 @@ export default function DeleteEventComponent() { const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - mutation.mutate(deleteEventVars, options); + mutation.mutate(deleteBusinessVars, options); // Then, you can render your component dynamically based on the status of the Mutation. if (mutation.isPending) { @@ -3434,7 +4015,7 @@ export default function DeleteEventComponent() { // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. if (mutation.isSuccess) { - console.log(mutation.data.event_delete); + console.log(mutation.data.business_delete); } return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; } diff --git a/frontend-web/src/dataconnect-generated/react/esm/index.esm.js b/frontend-web/src/dataconnect-generated/react/esm/index.esm.js index a007882e..8fcd37c9 100644 --- a/frontend-web/src/dataconnect-generated/react/esm/index.esm.js +++ b/frontend-web/src/dataconnect-generated/react/esm/index.esm.js @@ -1,33 +1,45 @@ -import { listStaffRef, createVendorRef, updateVendorRef, deleteVendorRef, listVendorDefaultSettingsRef, getVendorDefaultSettingByIdRef, filterVendorDefaultSettingsRef, listEventsRef, getEventByIdRef, filterEventsRef, createInvoiceRef, updateInvoiceRef, deleteInvoiceRef, createStaffRef, listVendorRef, getVendorByIdRef, filterVendorsRef, createVendorDefaultSettingRef, updateVendorDefaultSettingRef, deleteVendorDefaultSettingRef, createVendorRateRef, updateVendorRateRef, deleteVendorRateRef, listVendorRateRef, getVendorRateByIdRef, filterVendorRatesRef, createEventRef, updateEventRef, deleteEventRef, listInvoiceRef, getInvoiceByIdRef, filterInvoicesRef, connectorConfig } from '../../esm/index.esm.js'; +import { listBusinessRef, getBusinessByIdRef, filterBusinessRef, createEventRef, updateEventRef, deleteEventRef, listVendorDefaultSettingsRef, getVendorDefaultSettingByIdRef, filterVendorDefaultSettingsRef, createVendorRateRef, updateVendorRateRef, deleteVendorRateRef, listVendorRateRef, getVendorRateByIdRef, filterVendorRatesRef, listEventsRef, getEventByIdRef, filterEventsRef, createInvoiceRef, updateInvoiceRef, deleteInvoiceRef, listInvoiceRef, getInvoiceByIdRef, filterInvoicesRef, createStaffRef, listStaffRef, createVendorRef, updateVendorRef, deleteVendorRef, listVendorRef, getVendorByIdRef, filterVendorsRef, createVendorDefaultSettingRef, updateVendorDefaultSettingRef, deleteVendorDefaultSettingRef, createBusinessRef, updateBusinessRef, deleteBusinessRef, connectorConfig } from '../../esm/index.esm.js'; import { validateArgs, CallerSdkTypeEnum } from 'firebase/data-connect'; import { useDataConnectQuery, useDataConnectMutation, validateReactArgs } from '@tanstack-query-firebase/react/data-connect'; -export function useListStaff(dcOrOptions, options) { +export function useListBusiness(dcOrOptions, options) { const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); - const ref = listStaffRef(dcInstance); + const ref = listBusinessRef(dcInstance); return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -export function useCreateVendor(dcOrOptions, options) { + +export function useGetBusinessById(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); + const ref = getBusinessByIdRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useFilterBusiness(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); + const ref = filterBusinessRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} +export function useCreateEvent(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return createVendorRef(dcInstance, vars); + return createEventRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -export function useUpdateVendor(dcOrOptions, options) { +export function useUpdateEvent(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return updateVendorRef(dcInstance, vars); + return updateEventRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -export function useDeleteVendor(dcOrOptions, options) { +export function useDeleteEvent(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return deleteVendorRef(dcInstance, vars); + return deleteEventRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } @@ -50,6 +62,48 @@ export function useFilterVendorDefaultSettings(dcOrVars, varsOrOptions, options) const ref = filterVendorDefaultSettingsRef(dcInstance, inputVars); return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); } +export function useCreateVendorRate(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return createVendorRateRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useUpdateVendorRate(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return updateVendorRateRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useDeleteVendorRate(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return deleteVendorRateRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + + +export function useListVendorRate(dcOrOptions, options) { + const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); + const ref = listVendorRateRef(dcInstance); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useGetVendorRateById(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); + const ref = getVendorRateByIdRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useFilterVendorRates(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); + const ref = filterVendorRatesRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} export function useListEvents(dcOrOptions, options) { const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); @@ -92,6 +146,24 @@ export function useDeleteInvoice(dcOrOptions, options) { return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } + +export function useListInvoice(dcOrOptions, options) { + const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); + const ref = listInvoiceRef(dcInstance); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useGetInvoiceById(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); + const ref = getInvoiceByIdRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useFilterInvoices(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); + const ref = filterInvoicesRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} export function useCreateStaff(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { @@ -101,6 +173,36 @@ export function useCreateStaff(dcOrOptions, options) { } +export function useListStaff(dcOrOptions, options) { + const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); + const ref = listStaffRef(dcInstance); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} +export function useCreateVendor(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return createVendorRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useUpdateVendor(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return updateVendorRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useDeleteVendor(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return deleteVendorRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + + export function useListVendor(dcOrOptions, options) { const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); const ref = listVendorRef(dcInstance); @@ -142,87 +244,26 @@ export function useDeleteVendorDefaultSetting(dcOrOptions, options) { return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -export function useCreateVendorRate(dcOrOptions, options) { +export function useCreateBusiness(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return createVendorRateRef(dcInstance, vars); + return createBusinessRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -export function useUpdateVendorRate(dcOrOptions, options) { +export function useUpdateBusiness(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return updateVendorRateRef(dcInstance, vars); + return updateBusinessRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -export function useDeleteVendorRate(dcOrOptions, options) { +export function useDeleteBusiness(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return deleteVendorRateRef(dcInstance, vars); + return deleteBusinessRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } - - -export function useListVendorRate(dcOrOptions, options) { - const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); - const ref = listVendorRateRef(dcInstance); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -export function useGetVendorRateById(dcOrVars, varsOrOptions, options) { - const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); - const ref = getVendorRateByIdRef(dcInstance, inputVars); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -export function useFilterVendorRates(dcOrVars, varsOrOptions, options) { - const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); - const ref = filterVendorRatesRef(dcInstance, inputVars); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} -export function useCreateEvent(dcOrOptions, options) { - const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); - function refFactory(vars) { - return createEventRef(dcInstance, vars); - } - return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -export function useUpdateEvent(dcOrOptions, options) { - const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); - function refFactory(vars) { - return updateEventRef(dcInstance, vars); - } - return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -export function useDeleteEvent(dcOrOptions, options) { - const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); - function refFactory(vars) { - return deleteEventRef(dcInstance, vars); - } - return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - - -export function useListInvoice(dcOrOptions, options) { - const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); - const ref = listInvoiceRef(dcInstance); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -export function useGetInvoiceById(dcOrVars, varsOrOptions, options) { - const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); - const ref = getInvoiceByIdRef(dcInstance, inputVars); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -export function useFilterInvoices(dcOrVars, varsOrOptions, options) { - const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); - const ref = filterInvoicesRef(dcInstance, inputVars); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} \ No newline at end of file diff --git a/frontend-web/src/dataconnect-generated/react/index.cjs.js b/frontend-web/src/dataconnect-generated/react/index.cjs.js index d7deeadc..3ecd5152 100644 --- a/frontend-web/src/dataconnect-generated/react/index.cjs.js +++ b/frontend-web/src/dataconnect-generated/react/index.cjs.js @@ -1,33 +1,45 @@ -const { listStaffRef, createVendorRef, updateVendorRef, deleteVendorRef, listVendorDefaultSettingsRef, getVendorDefaultSettingByIdRef, filterVendorDefaultSettingsRef, listEventsRef, getEventByIdRef, filterEventsRef, createInvoiceRef, updateInvoiceRef, deleteInvoiceRef, createStaffRef, listVendorRef, getVendorByIdRef, filterVendorsRef, createVendorDefaultSettingRef, updateVendorDefaultSettingRef, deleteVendorDefaultSettingRef, createVendorRateRef, updateVendorRateRef, deleteVendorRateRef, listVendorRateRef, getVendorRateByIdRef, filterVendorRatesRef, createEventRef, updateEventRef, deleteEventRef, listInvoiceRef, getInvoiceByIdRef, filterInvoicesRef, connectorConfig } = require('../index.cjs.js'); +const { listBusinessRef, getBusinessByIdRef, filterBusinessRef, createEventRef, updateEventRef, deleteEventRef, listVendorDefaultSettingsRef, getVendorDefaultSettingByIdRef, filterVendorDefaultSettingsRef, createVendorRateRef, updateVendorRateRef, deleteVendorRateRef, listVendorRateRef, getVendorRateByIdRef, filterVendorRatesRef, listEventsRef, getEventByIdRef, filterEventsRef, createInvoiceRef, updateInvoiceRef, deleteInvoiceRef, listInvoiceRef, getInvoiceByIdRef, filterInvoicesRef, createStaffRef, listStaffRef, createVendorRef, updateVendorRef, deleteVendorRef, listVendorRef, getVendorByIdRef, filterVendorsRef, createVendorDefaultSettingRef, updateVendorDefaultSettingRef, deleteVendorDefaultSettingRef, createBusinessRef, updateBusinessRef, deleteBusinessRef, connectorConfig } = require('../index.cjs.js'); const { validateArgs, CallerSdkTypeEnum } = require('firebase/data-connect'); const { useDataConnectQuery, useDataConnectMutation, validateReactArgs } = require('@tanstack-query-firebase/react/data-connect'); -exports.useListStaff = function useListStaff(dcOrOptions, options) { +exports.useListBusiness = function useListBusiness(dcOrOptions, options) { const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); - const ref = listStaffRef(dcInstance); + const ref = listBusinessRef(dcInstance); return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -exports.useCreateVendor = function useCreateVendor(dcOrOptions, options) { + +exports.useGetBusinessById = function useGetBusinessById(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); + const ref = getBusinessByIdRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useFilterBusiness = function useFilterBusiness(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); + const ref = filterBusinessRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} +exports.useCreateEvent = function useCreateEvent(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return createVendorRef(dcInstance, vars); + return createEventRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -exports.useUpdateVendor = function useUpdateVendor(dcOrOptions, options) { +exports.useUpdateEvent = function useUpdateEvent(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return updateVendorRef(dcInstance, vars); + return updateEventRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -exports.useDeleteVendor = function useDeleteVendor(dcOrOptions, options) { +exports.useDeleteEvent = function useDeleteEvent(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return deleteVendorRef(dcInstance, vars); + return deleteEventRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } @@ -50,6 +62,48 @@ exports.useFilterVendorDefaultSettings = function useFilterVendorDefaultSettings const ref = filterVendorDefaultSettingsRef(dcInstance, inputVars); return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); } +exports.useCreateVendorRate = function useCreateVendorRate(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return createVendorRateRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useUpdateVendorRate = function useUpdateVendorRate(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return updateVendorRateRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useDeleteVendorRate = function useDeleteVendorRate(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return deleteVendorRateRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + + +exports.useListVendorRate = function useListVendorRate(dcOrOptions, options) { + const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); + const ref = listVendorRateRef(dcInstance); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useGetVendorRateById = function useGetVendorRateById(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); + const ref = getVendorRateByIdRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useFilterVendorRates = function useFilterVendorRates(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); + const ref = filterVendorRatesRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} exports.useListEvents = function useListEvents(dcOrOptions, options) { const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); @@ -92,6 +146,24 @@ exports.useDeleteInvoice = function useDeleteInvoice(dcOrOptions, options) { return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } + +exports.useListInvoice = function useListInvoice(dcOrOptions, options) { + const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); + const ref = listInvoiceRef(dcInstance); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useGetInvoiceById = function useGetInvoiceById(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); + const ref = getInvoiceByIdRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useFilterInvoices = function useFilterInvoices(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); + const ref = filterInvoicesRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} exports.useCreateStaff = function useCreateStaff(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { @@ -101,6 +173,36 @@ exports.useCreateStaff = function useCreateStaff(dcOrOptions, options) { } +exports.useListStaff = function useListStaff(dcOrOptions, options) { + const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); + const ref = listStaffRef(dcInstance); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} +exports.useCreateVendor = function useCreateVendor(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return createVendorRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useUpdateVendor = function useUpdateVendor(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return updateVendorRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useDeleteVendor = function useDeleteVendor(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return deleteVendorRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + + exports.useListVendor = function useListVendor(dcOrOptions, options) { const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); const ref = listVendorRef(dcInstance); @@ -142,87 +244,26 @@ exports.useDeleteVendorDefaultSetting = function useDeleteVendorDefaultSetting(d return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -exports.useCreateVendorRate = function useCreateVendorRate(dcOrOptions, options) { +exports.useCreateBusiness = function useCreateBusiness(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return createVendorRateRef(dcInstance, vars); + return createBusinessRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -exports.useUpdateVendorRate = function useUpdateVendorRate(dcOrOptions, options) { +exports.useUpdateBusiness = function useUpdateBusiness(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return updateVendorRateRef(dcInstance, vars); + return updateBusinessRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -exports.useDeleteVendorRate = function useDeleteVendorRate(dcOrOptions, options) { +exports.useDeleteBusiness = function useDeleteBusiness(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return deleteVendorRateRef(dcInstance, vars); + return deleteBusinessRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } - - -exports.useListVendorRate = function useListVendorRate(dcOrOptions, options) { - const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); - const ref = listVendorRateRef(dcInstance); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -exports.useGetVendorRateById = function useGetVendorRateById(dcOrVars, varsOrOptions, options) { - const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); - const ref = getVendorRateByIdRef(dcInstance, inputVars); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -exports.useFilterVendorRates = function useFilterVendorRates(dcOrVars, varsOrOptions, options) { - const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); - const ref = filterVendorRatesRef(dcInstance, inputVars); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} -exports.useCreateEvent = function useCreateEvent(dcOrOptions, options) { - const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); - function refFactory(vars) { - return createEventRef(dcInstance, vars); - } - return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -exports.useUpdateEvent = function useUpdateEvent(dcOrOptions, options) { - const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); - function refFactory(vars) { - return updateEventRef(dcInstance, vars); - } - return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -exports.useDeleteEvent = function useDeleteEvent(dcOrOptions, options) { - const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); - function refFactory(vars) { - return deleteEventRef(dcInstance, vars); - } - return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - - -exports.useListInvoice = function useListInvoice(dcOrOptions, options) { - const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); - const ref = listInvoiceRef(dcInstance); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -exports.useGetInvoiceById = function useGetInvoiceById(dcOrVars, varsOrOptions, options) { - const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); - const ref = getInvoiceByIdRef(dcInstance, inputVars); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -exports.useFilterInvoices = function useFilterInvoices(dcOrVars, varsOrOptions, options) { - const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); - const ref = filterInvoicesRef(dcInstance, inputVars); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} \ No newline at end of file diff --git a/frontend-web/src/dataconnect-generated/react/index.d.ts b/frontend-web/src/dataconnect-generated/react/index.d.ts index e5957f90..18a7afb1 100644 --- a/frontend-web/src/dataconnect-generated/react/index.d.ts +++ b/frontend-web/src/dataconnect-generated/react/index.d.ts @@ -1,21 +1,27 @@ -import { ListStaffData, CreateVendorData, CreateVendorVariables, UpdateVendorData, UpdateVendorVariables, DeleteVendorData, DeleteVendorVariables, ListVendorDefaultSettingsData, GetVendorDefaultSettingByIdData, GetVendorDefaultSettingByIdVariables, FilterVendorDefaultSettingsData, FilterVendorDefaultSettingsVariables, ListEventsData, GetEventByIdData, GetEventByIdVariables, FilterEventsData, FilterEventsVariables, CreateInvoiceData, CreateInvoiceVariables, UpdateInvoiceData, UpdateInvoiceVariables, DeleteInvoiceData, DeleteInvoiceVariables, CreateStaffData, CreateStaffVariables, ListVendorData, GetVendorByIdData, GetVendorByIdVariables, FilterVendorsData, FilterVendorsVariables, CreateVendorDefaultSettingData, CreateVendorDefaultSettingVariables, UpdateVendorDefaultSettingData, UpdateVendorDefaultSettingVariables, DeleteVendorDefaultSettingData, DeleteVendorDefaultSettingVariables, CreateVendorRateData, CreateVendorRateVariables, UpdateVendorRateData, UpdateVendorRateVariables, DeleteVendorRateData, DeleteVendorRateVariables, ListVendorRateData, GetVendorRateByIdData, GetVendorRateByIdVariables, FilterVendorRatesData, FilterVendorRatesVariables, CreateEventData, CreateEventVariables, UpdateEventData, UpdateEventVariables, DeleteEventData, DeleteEventVariables, ListInvoiceData, GetInvoiceByIdData, GetInvoiceByIdVariables, FilterInvoicesData, FilterInvoicesVariables } from '../'; +import { ListBusinessData, GetBusinessByIdData, GetBusinessByIdVariables, FilterBusinessData, FilterBusinessVariables, CreateEventData, CreateEventVariables, UpdateEventData, UpdateEventVariables, DeleteEventData, DeleteEventVariables, ListVendorDefaultSettingsData, GetVendorDefaultSettingByIdData, GetVendorDefaultSettingByIdVariables, FilterVendorDefaultSettingsData, FilterVendorDefaultSettingsVariables, CreateVendorRateData, CreateVendorRateVariables, UpdateVendorRateData, UpdateVendorRateVariables, DeleteVendorRateData, DeleteVendorRateVariables, ListVendorRateData, GetVendorRateByIdData, GetVendorRateByIdVariables, FilterVendorRatesData, FilterVendorRatesVariables, ListEventsData, GetEventByIdData, GetEventByIdVariables, FilterEventsData, FilterEventsVariables, CreateInvoiceData, CreateInvoiceVariables, UpdateInvoiceData, UpdateInvoiceVariables, DeleteInvoiceData, DeleteInvoiceVariables, ListInvoiceData, GetInvoiceByIdData, GetInvoiceByIdVariables, FilterInvoicesData, FilterInvoicesVariables, CreateStaffData, CreateStaffVariables, ListStaffData, CreateVendorData, CreateVendorVariables, UpdateVendorData, UpdateVendorVariables, DeleteVendorData, DeleteVendorVariables, ListVendorData, GetVendorByIdData, GetVendorByIdVariables, FilterVendorsData, FilterVendorsVariables, CreateVendorDefaultSettingData, CreateVendorDefaultSettingVariables, UpdateVendorDefaultSettingData, UpdateVendorDefaultSettingVariables, DeleteVendorDefaultSettingData, DeleteVendorDefaultSettingVariables, CreateBusinessData, CreateBusinessVariables, UpdateBusinessData, UpdateBusinessVariables, DeleteBusinessData, DeleteBusinessVariables } from '../'; import { UseDataConnectQueryResult, useDataConnectQueryOptions, UseDataConnectMutationResult, useDataConnectMutationOptions} from '@tanstack-query-firebase/react/data-connect'; import { UseQueryResult, UseMutationResult} from '@tanstack/react-query'; import { DataConnect } from 'firebase/data-connect'; import { FirebaseError } from 'firebase/app'; -export function useListStaff(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useListStaff(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useListBusiness(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useListBusiness(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useCreateVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useCreateVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useGetBusinessById(vars: GetBusinessByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useGetBusinessById(dc: DataConnect, vars: GetBusinessByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useUpdateVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useUpdateVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useFilterBusiness(vars?: FilterBusinessVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useFilterBusiness(dc: DataConnect, vars?: FilterBusinessVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useDeleteVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useDeleteVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useCreateEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useCreateEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useUpdateEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useUpdateEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useDeleteEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useDeleteEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; export function useListVendorDefaultSettings(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; export function useListVendorDefaultSettings(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; @@ -26,45 +32,6 @@ export function useGetVendorDefaultSettingById(dc: DataConnect, vars: GetVendorD export function useFilterVendorDefaultSettings(vars?: FilterVendorDefaultSettingsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; export function useFilterVendorDefaultSettings(dc: DataConnect, vars?: FilterVendorDefaultSettingsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useListEvents(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useListEvents(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; - -export function useGetEventById(vars: GetEventByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useGetEventById(dc: DataConnect, vars: GetEventByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; - -export function useFilterEvents(vars?: FilterEventsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useFilterEvents(dc: DataConnect, vars?: FilterEventsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; - -export function useCreateInvoice(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useCreateInvoice(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; - -export function useUpdateInvoice(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useUpdateInvoice(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; - -export function useDeleteInvoice(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useDeleteInvoice(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; - -export function useCreateStaff(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useCreateStaff(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; - -export function useListVendor(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useListVendor(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; - -export function useGetVendorById(vars: GetVendorByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useGetVendorById(dc: DataConnect, vars: GetVendorByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; - -export function useFilterVendors(vars?: FilterVendorsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useFilterVendors(dc: DataConnect, vars?: FilterVendorsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; - -export function useCreateVendorDefaultSetting(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useCreateVendorDefaultSetting(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; - -export function useUpdateVendorDefaultSetting(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useUpdateVendorDefaultSetting(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; - -export function useDeleteVendorDefaultSetting(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useDeleteVendorDefaultSetting(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; - export function useCreateVendorRate(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; export function useCreateVendorRate(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; @@ -83,14 +50,23 @@ export function useGetVendorRateById(dc: DataConnect, vars: GetVendorRateByIdVar export function useFilterVendorRates(vars?: FilterVendorRatesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; export function useFilterVendorRates(dc: DataConnect, vars?: FilterVendorRatesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useCreateEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useCreateEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useListEvents(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useListEvents(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useUpdateEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useUpdateEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useGetEventById(vars: GetEventByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useGetEventById(dc: DataConnect, vars: GetEventByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useDeleteEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useDeleteEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useFilterEvents(vars?: FilterEventsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useFilterEvents(dc: DataConnect, vars?: FilterEventsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; + +export function useCreateInvoice(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useCreateInvoice(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useUpdateInvoice(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useUpdateInvoice(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useDeleteInvoice(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useDeleteInvoice(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; export function useListInvoice(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; export function useListInvoice(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; @@ -100,3 +76,45 @@ export function useGetInvoiceById(dc: DataConnect, vars: GetInvoiceByIdVariables export function useFilterInvoices(vars?: FilterInvoicesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; export function useFilterInvoices(dc: DataConnect, vars?: FilterInvoicesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; + +export function useCreateStaff(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useCreateStaff(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useListStaff(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useListStaff(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; + +export function useCreateVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useCreateVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useUpdateVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useUpdateVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useDeleteVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useDeleteVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useListVendor(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useListVendor(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; + +export function useGetVendorById(vars: GetVendorByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useGetVendorById(dc: DataConnect, vars: GetVendorByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; + +export function useFilterVendors(vars?: FilterVendorsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useFilterVendors(dc: DataConnect, vars?: FilterVendorsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; + +export function useCreateVendorDefaultSetting(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useCreateVendorDefaultSetting(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useUpdateVendorDefaultSetting(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useUpdateVendorDefaultSetting(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useDeleteVendorDefaultSetting(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useDeleteVendorDefaultSetting(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useCreateBusiness(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useCreateBusiness(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useUpdateBusiness(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useUpdateBusiness(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useDeleteBusiness(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useDeleteBusiness(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; diff --git a/internal-api-harness/src/dataconnect-generated/.guides/usage.md b/internal-api-harness/src/dataconnect-generated/.guides/usage.md index 29b57da6..76991bc0 100644 --- a/internal-api-harness/src/dataconnect-generated/.guides/usage.md +++ b/internal-api-harness/src/dataconnect-generated/.guides/usage.md @@ -12,16 +12,20 @@ For each operation, there is a wrapper hook that can be used to call the operati Here are all of the hooks that get generated: ```ts -import { useListStaff, useCreateVendor, useUpdateVendor, useDeleteVendor, useListVendorDefaultSettings, useGetVendorDefaultSettingById, useFilterVendorDefaultSettings, useListEvents, useGetEventById, useFilterEvents } from '@dataconnect/generated/react'; +import { useListBusiness, useGetBusinessById, useFilterBusiness, useCreateEvent, useUpdateEvent, useDeleteEvent, useListVendorDefaultSettings, useGetVendorDefaultSettingById, useFilterVendorDefaultSettings, useCreateVendorRate } from '@dataconnect/generated/react'; // The types of these hooks are available in react/index.d.ts -const { data, isPending, isSuccess, isError, error } = useListStaff(); +const { data, isPending, isSuccess, isError, error } = useListBusiness(); -const { data, isPending, isSuccess, isError, error } = useCreateVendor(createVendorVars); +const { data, isPending, isSuccess, isError, error } = useGetBusinessById(getBusinessByIdVars); -const { data, isPending, isSuccess, isError, error } = useUpdateVendor(updateVendorVars); +const { data, isPending, isSuccess, isError, error } = useFilterBusiness(filterBusinessVars); -const { data, isPending, isSuccess, isError, error } = useDeleteVendor(deleteVendorVars); +const { data, isPending, isSuccess, isError, error } = useCreateEvent(createEventVars); + +const { data, isPending, isSuccess, isError, error } = useUpdateEvent(updateEventVars); + +const { data, isPending, isSuccess, isError, error } = useDeleteEvent(deleteEventVars); const { data, isPending, isSuccess, isError, error } = useListVendorDefaultSettings(); @@ -29,11 +33,7 @@ const { data, isPending, isSuccess, isError, error } = useGetVendorDefaultSettin const { data, isPending, isSuccess, isError, error } = useFilterVendorDefaultSettings(filterVendorDefaultSettingsVars); -const { data, isPending, isSuccess, isError, error } = useListEvents(); - -const { data, isPending, isSuccess, isError, error } = useGetEventById(getEventByIdVars); - -const { data, isPending, isSuccess, isError, error } = useFilterEvents(filterEventsVars); +const { data, isPending, isSuccess, isError, error } = useCreateVendorRate(createVendorRateVars); ``` @@ -72,20 +72,26 @@ If a user is not using a supported framework, they can use the generated SDK dir Here's an example of how to use it with the first 5 operations: ```js -import { listStaff, createVendor, updateVendor, deleteVendor, listVendorDefaultSettings, getVendorDefaultSettingById, filterVendorDefaultSettings, listEvents, getEventById, filterEvents } from '@dataconnect/generated'; +import { listBusiness, getBusinessById, filterBusiness, createEvent, updateEvent, deleteEvent, listVendorDefaultSettings, getVendorDefaultSettingById, filterVendorDefaultSettings, createVendorRate } from '@dataconnect/generated'; -// Operation listStaff: -const { data } = await ListStaff(dataConnect); +// Operation listBusiness: +const { data } = await ListBusiness(dataConnect); -// Operation CreateVendor: For variables, look at type CreateVendorVars in ../index.d.ts -const { data } = await CreateVendor(dataConnect, createVendorVars); +// Operation getBusinessById: For variables, look at type GetBusinessByIdVars in ../index.d.ts +const { data } = await GetBusinessById(dataConnect, getBusinessByIdVars); -// Operation UpdateVendor: For variables, look at type UpdateVendorVars in ../index.d.ts -const { data } = await UpdateVendor(dataConnect, updateVendorVars); +// Operation filterBusiness: For variables, look at type FilterBusinessVars in ../index.d.ts +const { data } = await FilterBusiness(dataConnect, filterBusinessVars); -// Operation DeleteVendor: For variables, look at type DeleteVendorVars in ../index.d.ts -const { data } = await DeleteVendor(dataConnect, deleteVendorVars); +// Operation CreateEvent: For variables, look at type CreateEventVars in ../index.d.ts +const { data } = await CreateEvent(dataConnect, createEventVars); + +// Operation UpdateEvent: For variables, look at type UpdateEventVars in ../index.d.ts +const { data } = await UpdateEvent(dataConnect, updateEventVars); + +// Operation DeleteEvent: For variables, look at type DeleteEventVars in ../index.d.ts +const { data } = await DeleteEvent(dataConnect, deleteEventVars); // Operation listVendorDefaultSettings: const { data } = await ListVendorDefaultSettings(dataConnect); @@ -96,14 +102,8 @@ const { data } = await GetVendorDefaultSettingById(dataConnect, getVendorDefault // Operation filterVendorDefaultSettings: For variables, look at type FilterVendorDefaultSettingsVars in ../index.d.ts const { data } = await FilterVendorDefaultSettings(dataConnect, filterVendorDefaultSettingsVars); -// Operation listEvents: -const { data } = await ListEvents(dataConnect); - -// Operation getEventById: For variables, look at type GetEventByIdVars in ../index.d.ts -const { data } = await GetEventById(dataConnect, getEventByIdVars); - -// Operation filterEvents: For variables, look at type FilterEventsVars in ../index.d.ts -const { data } = await FilterEvents(dataConnect, filterEventsVars); +// Operation CreateVendorRate: For variables, look at type CreateVendorRateVars in ../index.d.ts +const { data } = await CreateVendorRate(dataConnect, createVendorRateVars); ``` \ No newline at end of file diff --git a/internal-api-harness/src/dataconnect-generated/README.md b/internal-api-harness/src/dataconnect-generated/README.md index 3035cccb..165ef7f8 100644 --- a/internal-api-harness/src/dataconnect-generated/README.md +++ b/internal-api-harness/src/dataconnect-generated/README.md @@ -10,39 +10,45 @@ This README will guide you through the process of using the generated JavaScript - [**Accessing the connector**](#accessing-the-connector) - [*Connecting to the local Emulator*](#connecting-to-the-local-emulator) - [**Queries**](#queries) - - [*listStaff*](#liststaff) + - [*listBusiness*](#listbusiness) + - [*getBusinessById*](#getbusinessbyid) + - [*filterBusiness*](#filterbusiness) - [*listVendorDefaultSettings*](#listvendordefaultsettings) - [*getVendorDefaultSettingById*](#getvendordefaultsettingbyid) - [*filterVendorDefaultSettings*](#filtervendordefaultsettings) - - [*listEvents*](#listevents) - - [*getEventById*](#geteventbyid) - - [*filterEvents*](#filterevents) - - [*listVendor*](#listvendor) - - [*getVendorById*](#getvendorbyid) - - [*filterVendors*](#filtervendors) - [*listVendorRate*](#listvendorrate) - [*getVendorRateById*](#getvendorratebyid) - [*filterVendorRates*](#filtervendorrates) + - [*listEvents*](#listevents) + - [*getEventById*](#geteventbyid) + - [*filterEvents*](#filterevents) - [*listInvoice*](#listinvoice) - [*getInvoiceById*](#getinvoicebyid) - [*filterInvoices*](#filterinvoices) + - [*listStaff*](#liststaff) + - [*listVendor*](#listvendor) + - [*getVendorById*](#getvendorbyid) + - [*filterVendors*](#filtervendors) - [**Mutations**](#mutations) - - [*CreateVendor*](#createvendor) - - [*UpdateVendor*](#updatevendor) - - [*DeleteVendor*](#deletevendor) + - [*CreateEvent*](#createevent) + - [*UpdateEvent*](#updateevent) + - [*DeleteEvent*](#deleteevent) + - [*CreateVendorRate*](#createvendorrate) + - [*UpdateVendorRate*](#updatevendorrate) + - [*DeleteVendorRate*](#deletevendorrate) - [*CreateInvoice*](#createinvoice) - [*UpdateInvoice*](#updateinvoice) - [*DeleteInvoice*](#deleteinvoice) - [*CreateStaff*](#createstaff) + - [*CreateVendor*](#createvendor) + - [*UpdateVendor*](#updatevendor) + - [*DeleteVendor*](#deletevendor) - [*CreateVendorDefaultSetting*](#createvendordefaultsetting) - [*UpdateVendorDefaultSetting*](#updatevendordefaultsetting) - [*DeleteVendorDefaultSetting*](#deletevendordefaultsetting) - - [*CreateVendorRate*](#createvendorrate) - - [*UpdateVendorRate*](#updatevendorrate) - - [*DeleteVendorRate*](#deletevendorrate) - - [*CreateEvent*](#createevent) - - [*UpdateEvent*](#updateevent) - - [*DeleteEvent*](#deleteevent) + - [*CreateBusiness*](#createbusiness) + - [*UpdateBusiness*](#updatebusiness) + - [*DeleteBusiness*](#deletebusiness) # Accessing the connector A connector is a collection of Queries and Mutations. One SDK is generated for each connector - this SDK is generated for the connector `krow-connector`. You can find more information about connectors in the [Data Connect documentation](https://firebase.google.com/docs/data-connect#how-does). @@ -89,105 +95,352 @@ The following is true for both the action shortcut function and the `QueryRef` f Below are examples of how to use the `krow-connector` connector's generated functions to execute each query. You can also follow the examples from the [Data Connect documentation](https://firebase.google.com/docs/data-connect/web-sdk#using-queries). -## listStaff -You can execute the `listStaff` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +## listBusiness +You can execute the `listBusiness` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): ```typescript -listStaff(): QueryPromise; +listBusiness(): QueryPromise; -interface ListStaffRef { +interface ListBusinessRef { ... /* Allow users to create refs without passing in DataConnect */ - (): QueryRef; + (): QueryRef; } -export const listStaffRef: ListStaffRef; +export const listBusinessRef: ListBusinessRef; ``` You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. ```typescript -listStaff(dc: DataConnect): QueryPromise; +listBusiness(dc: DataConnect): QueryPromise; -interface ListStaffRef { +interface ListBusinessRef { ... - (dc: DataConnect): QueryRef; + (dc: DataConnect): QueryRef; } -export const listStaffRef: ListStaffRef; +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 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 listBusinessRef: ```typescript -const name = listStaffRef.operationName; +const name = listBusinessRef.operationName; console.log(name); ``` ### Variables -The `listStaff` query has no variables. +The `listBusiness` query has no variables. ### Return Type -Recall that executing the `listStaff` query returns a `QueryPromise` that resolves to an object with a `data` property. +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 `ListStaffData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +The `data` property is an object of type `ListBusinessData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: ```typescript -export interface ListStaffData { - staffs: ({ +export interface ListBusinessData { + businesses: ({ id: UUIDString; - employeeName: string; - vendorId?: UUIDString | null; + businessName: string; + contactName: string; email?: string | null; - position?: string | null; - employmentType: EmploymentType; - rating?: number | null; - reliabilityScore?: number | null; - backgroundCheckStatus: BackgroundCheckStatus; - certifications?: string | null; - } & Staff_Key)[]; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key)[]; } ``` -### Using `listStaff`'s action shortcut function +### Using `listBusiness`'s action shortcut function ```typescript import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, listStaff } from '@dataconnect/generated'; +import { connectorConfig, listBusiness } from '@dataconnect/generated'; -// Call the `listStaff()` function to execute the query. +// Call the `listBusiness()` function to execute the query. // You can use the `await` keyword to wait for the promise to resolve. -const { data } = await listStaff(); +const { data } = await listBusiness(); // You can also pass in a `DataConnect` instance to the action shortcut function. const dataConnect = getDataConnect(connectorConfig); -const { data } = await listStaff(dataConnect); +const { data } = await listBusiness(dataConnect); -console.log(data.staffs); +console.log(data.businesses); // Or, you can use the `Promise` API. -listStaff().then((response) => { +listBusiness().then((response) => { const data = response.data; - console.log(data.staffs); + console.log(data.businesses); }); ``` -### Using `listStaff`'s `QueryRef` function +### Using `listBusiness`'s `QueryRef` function ```typescript import { getDataConnect, executeQuery } from 'firebase/data-connect'; -import { connectorConfig, listStaffRef } from '@dataconnect/generated'; +import { connectorConfig, listBusinessRef } from '@dataconnect/generated'; -// Call the `listStaffRef()` function to get a reference to the query. -const ref = listStaffRef(); +// 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 = listStaffRef(dataConnect); +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.staffs); +console.log(data.businesses); // Or, you can use the `Promise` API. executeQuery(ref).then((response) => { const data = response.data; - console.log(data.staffs); + console.log(data.businesses); +}); +``` + +## getBusinessById +You can execute the `getBusinessById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +getBusinessById(vars: GetBusinessByIdVariables): QueryPromise; + +interface GetBusinessByIdRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: GetBusinessByIdVariables): QueryRef; +} +export const getBusinessByIdRef: GetBusinessByIdRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +getBusinessById(dc: DataConnect, vars: GetBusinessByIdVariables): QueryPromise; + +interface GetBusinessByIdRef { + ... + (dc: DataConnect, vars: GetBusinessByIdVariables): QueryRef; +} +export const getBusinessByIdRef: GetBusinessByIdRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getBusinessByIdRef: +```typescript +const name = getBusinessByIdRef.operationName; +console.log(name); +``` + +### Variables +The `getBusinessById` query requires an argument of type `GetBusinessByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface GetBusinessByIdVariables { + id: UUIDString; +} +``` +### Return Type +Recall that executing the `getBusinessById` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `GetBusinessByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface GetBusinessByIdData { + business?: { + id: UUIDString; + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key; +} +``` +### Using `getBusinessById`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, getBusinessById, GetBusinessByIdVariables } from '@dataconnect/generated'; + +// The `getBusinessById` query requires an argument of type `GetBusinessByIdVariables`: +const getBusinessByIdVars: GetBusinessByIdVariables = { + id: ..., +}; + +// Call the `getBusinessById()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await getBusinessById(getBusinessByIdVars); +// Variables can be defined inline as well. +const { data } = await getBusinessById({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await getBusinessById(dataConnect, getBusinessByIdVars); + +console.log(data.business); + +// Or, you can use the `Promise` API. +getBusinessById(getBusinessByIdVars).then((response) => { + const data = response.data; + console.log(data.business); +}); +``` + +### Using `getBusinessById`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, getBusinessByIdRef, GetBusinessByIdVariables } from '@dataconnect/generated'; + +// The `getBusinessById` query requires an argument of type `GetBusinessByIdVariables`: +const getBusinessByIdVars: GetBusinessByIdVariables = { + id: ..., +}; + +// Call the `getBusinessByIdRef()` function to get a reference to the query. +const ref = getBusinessByIdRef(getBusinessByIdVars); +// Variables can be defined inline as well. +const ref = getBusinessByIdRef({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = getBusinessByIdRef(dataConnect, getBusinessByIdVars); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.business); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.business); +}); +``` + +## filterBusiness +You can execute the `filterBusiness` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +filterBusiness(vars?: FilterBusinessVariables): QueryPromise; + +interface FilterBusinessRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars?: FilterBusinessVariables): QueryRef; +} +export const filterBusinessRef: FilterBusinessRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +filterBusiness(dc: DataConnect, vars?: FilterBusinessVariables): QueryPromise; + +interface FilterBusinessRef { + ... + (dc: DataConnect, vars?: FilterBusinessVariables): QueryRef; +} +export const filterBusinessRef: FilterBusinessRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterBusinessRef: +```typescript +const name = filterBusinessRef.operationName; +console.log(name); +``` + +### Variables +The `filterBusiness` query has an optional argument of type `FilterBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface FilterBusinessVariables { + businessName?: string | null; + contactName?: string | null; + sector?: BusinessSector | null; + rateGroup?: BusinessRateGroup | null; + status?: BusinessStatus | null; +} +``` +### Return Type +Recall that executing the `filterBusiness` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `FilterBusinessData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface FilterBusinessData { + businesses: ({ + id: UUIDString; + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key)[]; +} +``` +### Using `filterBusiness`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, filterBusiness, FilterBusinessVariables } from '@dataconnect/generated'; + +// The `filterBusiness` query has an optional argument of type `FilterBusinessVariables`: +const filterBusinessVars: FilterBusinessVariables = { + businessName: ..., // optional + contactName: ..., // optional + sector: ..., // optional + rateGroup: ..., // optional + status: ..., // optional +}; + +// Call the `filterBusiness()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await filterBusiness(filterBusinessVars); +// Variables can be defined inline as well. +const { data } = await filterBusiness({ businessName: ..., contactName: ..., sector: ..., rateGroup: ..., status: ..., }); +// Since all variables are optional for this query, you can omit the `FilterBusinessVariables` argument. +const { data } = await filterBusiness(); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await filterBusiness(dataConnect, filterBusinessVars); + +console.log(data.businesses); + +// Or, you can use the `Promise` API. +filterBusiness(filterBusinessVars).then((response) => { + const data = response.data; + console.log(data.businesses); +}); +``` + +### Using `filterBusiness`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, filterBusinessRef, FilterBusinessVariables } from '@dataconnect/generated'; + +// The `filterBusiness` query has an optional argument of type `FilterBusinessVariables`: +const filterBusinessVars: FilterBusinessVariables = { + businessName: ..., // optional + contactName: ..., // optional + sector: ..., // optional + rateGroup: ..., // optional + status: ..., // optional +}; + +// Call the `filterBusinessRef()` function to get a reference to the query. +const ref = filterBusinessRef(filterBusinessVars); +// Variables can be defined inline as well. +const ref = filterBusinessRef({ businessName: ..., contactName: ..., sector: ..., rateGroup: ..., status: ..., }); +// Since all variables are optional for this query, you can omit the `FilterBusinessVariables` argument. +const ref = filterBusinessRef(); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = filterBusinessRef(dataConnect, filterBusinessVars); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.businesses); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.businesses); }); ``` @@ -525,6 +778,361 @@ executeQuery(ref).then((response) => { }); ``` +## listVendorRate +You can execute the `listVendorRate` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +listVendorRate(): QueryPromise; + +interface ListVendorRateRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (): QueryRef; +} +export const listVendorRateRef: ListVendorRateRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +listVendorRate(dc: DataConnect): QueryPromise; + +interface ListVendorRateRef { + ... + (dc: DataConnect): QueryRef; +} +export const listVendorRateRef: ListVendorRateRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listVendorRateRef: +```typescript +const name = listVendorRateRef.operationName; +console.log(name); +``` + +### Variables +The `listVendorRate` query has no variables. +### Return Type +Recall that executing the `listVendorRate` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `ListVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface ListVendorRateData { + vendorRates: ({ + id: UUIDString; + vendorName: string; + category: VendorRateCategory; + roleName: string; + employeeWage: number; + markupPercentage?: number | null; + vendorFeePercentage?: number | null; + clientRate: number; + } & VendorRate_Key)[]; +} +``` +### Using `listVendorRate`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, listVendorRate } from '@dataconnect/generated'; + + +// Call the `listVendorRate()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await listVendorRate(); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await listVendorRate(dataConnect); + +console.log(data.vendorRates); + +// Or, you can use the `Promise` API. +listVendorRate().then((response) => { + const data = response.data; + console.log(data.vendorRates); +}); +``` + +### Using `listVendorRate`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, listVendorRateRef } from '@dataconnect/generated'; + + +// Call the `listVendorRateRef()` function to get a reference to the query. +const ref = listVendorRateRef(); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = listVendorRateRef(dataConnect); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.vendorRates); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.vendorRates); +}); +``` + +## getVendorRateById +You can execute the `getVendorRateById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +getVendorRateById(vars: GetVendorRateByIdVariables): QueryPromise; + +interface GetVendorRateByIdRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: GetVendorRateByIdVariables): QueryRef; +} +export const getVendorRateByIdRef: GetVendorRateByIdRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +getVendorRateById(dc: DataConnect, vars: GetVendorRateByIdVariables): QueryPromise; + +interface GetVendorRateByIdRef { + ... + (dc: DataConnect, vars: GetVendorRateByIdVariables): QueryRef; +} +export const getVendorRateByIdRef: GetVendorRateByIdRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getVendorRateByIdRef: +```typescript +const name = getVendorRateByIdRef.operationName; +console.log(name); +``` + +### Variables +The `getVendorRateById` query requires an argument of type `GetVendorRateByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface GetVendorRateByIdVariables { + id: UUIDString; +} +``` +### Return Type +Recall that executing the `getVendorRateById` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `GetVendorRateByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface GetVendorRateByIdData { + vendorRate?: { + id: UUIDString; + vendorName: string; + category: VendorRateCategory; + roleName: string; + employeeWage: number; + markupPercentage?: number | null; + vendorFeePercentage?: number | null; + clientRate: number; + createdDate?: TimestampString | null; + updatedDate?: TimestampString | null; + createdBy?: string | null; + } & VendorRate_Key; +} +``` +### Using `getVendorRateById`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, getVendorRateById, GetVendorRateByIdVariables } from '@dataconnect/generated'; + +// The `getVendorRateById` query requires an argument of type `GetVendorRateByIdVariables`: +const getVendorRateByIdVars: GetVendorRateByIdVariables = { + id: ..., +}; + +// Call the `getVendorRateById()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await getVendorRateById(getVendorRateByIdVars); +// Variables can be defined inline as well. +const { data } = await getVendorRateById({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await getVendorRateById(dataConnect, getVendorRateByIdVars); + +console.log(data.vendorRate); + +// Or, you can use the `Promise` API. +getVendorRateById(getVendorRateByIdVars).then((response) => { + const data = response.data; + console.log(data.vendorRate); +}); +``` + +### Using `getVendorRateById`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, getVendorRateByIdRef, GetVendorRateByIdVariables } from '@dataconnect/generated'; + +// The `getVendorRateById` query requires an argument of type `GetVendorRateByIdVariables`: +const getVendorRateByIdVars: GetVendorRateByIdVariables = { + id: ..., +}; + +// Call the `getVendorRateByIdRef()` function to get a reference to the query. +const ref = getVendorRateByIdRef(getVendorRateByIdVars); +// Variables can be defined inline as well. +const ref = getVendorRateByIdRef({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = getVendorRateByIdRef(dataConnect, getVendorRateByIdVars); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.vendorRate); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.vendorRate); +}); +``` + +## filterVendorRates +You can execute the `filterVendorRates` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +filterVendorRates(vars?: FilterVendorRatesVariables): QueryPromise; + +interface FilterVendorRatesRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars?: FilterVendorRatesVariables): QueryRef; +} +export const filterVendorRatesRef: FilterVendorRatesRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +filterVendorRates(dc: DataConnect, vars?: FilterVendorRatesVariables): QueryPromise; + +interface FilterVendorRatesRef { + ... + (dc: DataConnect, vars?: FilterVendorRatesVariables): QueryRef; +} +export const filterVendorRatesRef: FilterVendorRatesRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterVendorRatesRef: +```typescript +const name = filterVendorRatesRef.operationName; +console.log(name); +``` + +### Variables +The `filterVendorRates` query has an optional argument of type `FilterVendorRatesVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface FilterVendorRatesVariables { + vendorName?: string | null; + category?: VendorRateCategory | null; + roleName?: string | null; + minClientRate?: number | null; + maxClientRate?: number | null; +} +``` +### Return Type +Recall that executing the `filterVendorRates` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `FilterVendorRatesData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface FilterVendorRatesData { + vendorRates: ({ + id: UUIDString; + vendorName: string; + category: VendorRateCategory; + roleName: string; + employeeWage: number; + markupPercentage?: number | null; + vendorFeePercentage?: number | null; + clientRate: number; + } & VendorRate_Key)[]; +} +``` +### Using `filterVendorRates`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, filterVendorRates, FilterVendorRatesVariables } from '@dataconnect/generated'; + +// The `filterVendorRates` query has an optional argument of type `FilterVendorRatesVariables`: +const filterVendorRatesVars: FilterVendorRatesVariables = { + vendorName: ..., // optional + category: ..., // optional + roleName: ..., // optional + minClientRate: ..., // optional + maxClientRate: ..., // optional +}; + +// Call the `filterVendorRates()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await filterVendorRates(filterVendorRatesVars); +// Variables can be defined inline as well. +const { data } = await filterVendorRates({ vendorName: ..., category: ..., roleName: ..., minClientRate: ..., maxClientRate: ..., }); +// Since all variables are optional for this query, you can omit the `FilterVendorRatesVariables` argument. +const { data } = await filterVendorRates(); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await filterVendorRates(dataConnect, filterVendorRatesVars); + +console.log(data.vendorRates); + +// Or, you can use the `Promise` API. +filterVendorRates(filterVendorRatesVars).then((response) => { + const data = response.data; + console.log(data.vendorRates); +}); +``` + +### Using `filterVendorRates`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, filterVendorRatesRef, FilterVendorRatesVariables } from '@dataconnect/generated'; + +// The `filterVendorRates` query has an optional argument of type `FilterVendorRatesVariables`: +const filterVendorRatesVars: FilterVendorRatesVariables = { + vendorName: ..., // optional + category: ..., // optional + roleName: ..., // optional + minClientRate: ..., // optional + maxClientRate: ..., // optional +}; + +// Call the `filterVendorRatesRef()` function to get a reference to the query. +const ref = filterVendorRatesRef(filterVendorRatesVars); +// Variables can be defined inline as well. +const ref = filterVendorRatesRef({ vendorName: ..., category: ..., roleName: ..., minClientRate: ..., maxClientRate: ..., }); +// Since all variables are optional for this query, you can omit the `FilterVendorRatesVariables` argument. +const ref = filterVendorRatesRef(); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = filterVendorRatesRef(dataConnect, filterVendorRatesVars); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.vendorRates); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.vendorRates); +}); +``` + ## listEvents You can execute the `listEvents` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): ```typescript @@ -979,6 +1587,455 @@ executeQuery(ref).then((response) => { }); ``` +## listInvoice +You can execute the `listInvoice` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +listInvoice(): QueryPromise; + +interface ListInvoiceRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (): QueryRef; +} +export const listInvoiceRef: ListInvoiceRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +listInvoice(dc: DataConnect): QueryPromise; + +interface ListInvoiceRef { + ... + (dc: DataConnect): QueryRef; +} +export const listInvoiceRef: ListInvoiceRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listInvoiceRef: +```typescript +const name = listInvoiceRef.operationName; +console.log(name); +``` + +### Variables +The `listInvoice` query has no variables. +### Return Type +Recall that executing the `listInvoice` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `ListInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface ListInvoiceData { + invoices: ({ + id: UUIDString; + invoiceNumber: string; + amount: number; + status: InvoiceStatus; + issueDate: TimestampString; + dueDate: TimestampString; + isAutoGenerated?: boolean | null; + } & Invoice_Key)[]; +} +``` +### Using `listInvoice`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, listInvoice } from '@dataconnect/generated'; + + +// Call the `listInvoice()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await listInvoice(); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await listInvoice(dataConnect); + +console.log(data.invoices); + +// Or, you can use the `Promise` API. +listInvoice().then((response) => { + const data = response.data; + console.log(data.invoices); +}); +``` + +### Using `listInvoice`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, listInvoiceRef } from '@dataconnect/generated'; + + +// Call the `listInvoiceRef()` function to get a reference to the query. +const ref = listInvoiceRef(); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = listInvoiceRef(dataConnect); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.invoices); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.invoices); +}); +``` + +## getInvoiceById +You can execute the `getInvoiceById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +getInvoiceById(vars: GetInvoiceByIdVariables): QueryPromise; + +interface GetInvoiceByIdRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: GetInvoiceByIdVariables): QueryRef; +} +export const getInvoiceByIdRef: GetInvoiceByIdRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +getInvoiceById(dc: DataConnect, vars: GetInvoiceByIdVariables): QueryPromise; + +interface GetInvoiceByIdRef { + ... + (dc: DataConnect, vars: GetInvoiceByIdVariables): QueryRef; +} +export const getInvoiceByIdRef: GetInvoiceByIdRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getInvoiceByIdRef: +```typescript +const name = getInvoiceByIdRef.operationName; +console.log(name); +``` + +### Variables +The `getInvoiceById` query requires an argument of type `GetInvoiceByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface GetInvoiceByIdVariables { + id: UUIDString; +} +``` +### Return Type +Recall that executing the `getInvoiceById` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `GetInvoiceByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface GetInvoiceByIdData { + invoice?: { + id: UUIDString; + invoiceNumber: string; + amount: number; + status: InvoiceStatus; + issueDate: TimestampString; + dueDate: TimestampString; + disputedItems?: string | null; + isAutoGenerated?: boolean | null; + } & Invoice_Key; +} +``` +### Using `getInvoiceById`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, getInvoiceById, GetInvoiceByIdVariables } from '@dataconnect/generated'; + +// The `getInvoiceById` query requires an argument of type `GetInvoiceByIdVariables`: +const getInvoiceByIdVars: GetInvoiceByIdVariables = { + id: ..., +}; + +// Call the `getInvoiceById()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await getInvoiceById(getInvoiceByIdVars); +// Variables can be defined inline as well. +const { data } = await getInvoiceById({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await getInvoiceById(dataConnect, getInvoiceByIdVars); + +console.log(data.invoice); + +// Or, you can use the `Promise` API. +getInvoiceById(getInvoiceByIdVars).then((response) => { + const data = response.data; + console.log(data.invoice); +}); +``` + +### Using `getInvoiceById`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, getInvoiceByIdRef, GetInvoiceByIdVariables } from '@dataconnect/generated'; + +// The `getInvoiceById` query requires an argument of type `GetInvoiceByIdVariables`: +const getInvoiceByIdVars: GetInvoiceByIdVariables = { + id: ..., +}; + +// Call the `getInvoiceByIdRef()` function to get a reference to the query. +const ref = getInvoiceByIdRef(getInvoiceByIdVars); +// Variables can be defined inline as well. +const ref = getInvoiceByIdRef({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = getInvoiceByIdRef(dataConnect, getInvoiceByIdVars); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.invoice); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.invoice); +}); +``` + +## filterInvoices +You can execute the `filterInvoices` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +filterInvoices(vars?: FilterInvoicesVariables): QueryPromise; + +interface FilterInvoicesRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars?: FilterInvoicesVariables): QueryRef; +} +export const filterInvoicesRef: FilterInvoicesRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +filterInvoices(dc: DataConnect, vars?: FilterInvoicesVariables): QueryPromise; + +interface FilterInvoicesRef { + ... + (dc: DataConnect, vars?: FilterInvoicesVariables): QueryRef; +} +export const filterInvoicesRef: FilterInvoicesRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterInvoicesRef: +```typescript +const name = filterInvoicesRef.operationName; +console.log(name); +``` + +### Variables +The `filterInvoices` query has an optional argument of type `FilterInvoicesVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface FilterInvoicesVariables { + invoiceNumber?: string | null; + status?: InvoiceStatus | null; + isAutoGenerated?: boolean | null; + amount?: number | null; +} +``` +### Return Type +Recall that executing the `filterInvoices` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `FilterInvoicesData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface FilterInvoicesData { + invoices: ({ + id: UUIDString; + invoiceNumber: string; + amount: number; + status: InvoiceStatus; + issueDate: TimestampString; + dueDate: TimestampString; + isAutoGenerated?: boolean | null; + } & Invoice_Key)[]; +} +``` +### Using `filterInvoices`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, filterInvoices, FilterInvoicesVariables } from '@dataconnect/generated'; + +// The `filterInvoices` query has an optional argument of type `FilterInvoicesVariables`: +const filterInvoicesVars: FilterInvoicesVariables = { + invoiceNumber: ..., // optional + status: ..., // optional + isAutoGenerated: ..., // optional + amount: ..., // optional +}; + +// Call the `filterInvoices()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await filterInvoices(filterInvoicesVars); +// Variables can be defined inline as well. +const { data } = await filterInvoices({ invoiceNumber: ..., status: ..., isAutoGenerated: ..., amount: ..., }); +// Since all variables are optional for this query, you can omit the `FilterInvoicesVariables` argument. +const { data } = await filterInvoices(); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await filterInvoices(dataConnect, filterInvoicesVars); + +console.log(data.invoices); + +// Or, you can use the `Promise` API. +filterInvoices(filterInvoicesVars).then((response) => { + const data = response.data; + console.log(data.invoices); +}); +``` + +### Using `filterInvoices`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, filterInvoicesRef, FilterInvoicesVariables } from '@dataconnect/generated'; + +// The `filterInvoices` query has an optional argument of type `FilterInvoicesVariables`: +const filterInvoicesVars: FilterInvoicesVariables = { + invoiceNumber: ..., // optional + status: ..., // optional + isAutoGenerated: ..., // optional + amount: ..., // optional +}; + +// Call the `filterInvoicesRef()` function to get a reference to the query. +const ref = filterInvoicesRef(filterInvoicesVars); +// Variables can be defined inline as well. +const ref = filterInvoicesRef({ invoiceNumber: ..., status: ..., isAutoGenerated: ..., amount: ..., }); +// Since all variables are optional for this query, you can omit the `FilterInvoicesVariables` argument. +const ref = filterInvoicesRef(); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = filterInvoicesRef(dataConnect, filterInvoicesVars); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.invoices); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.invoices); +}); +``` + +## listStaff +You can execute the `listStaff` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +listStaff(): QueryPromise; + +interface ListStaffRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (): QueryRef; +} +export const listStaffRef: ListStaffRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. +```typescript +listStaff(dc: DataConnect): QueryPromise; + +interface ListStaffRef { + ... + (dc: DataConnect): QueryRef; +} +export const listStaffRef: ListStaffRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listStaffRef: +```typescript +const name = listStaffRef.operationName; +console.log(name); +``` + +### Variables +The `listStaff` query has no variables. +### Return Type +Recall that executing the `listStaff` query returns a `QueryPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `ListStaffData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface ListStaffData { + staffs: ({ + id: UUIDString; + employeeName: string; + vendorId?: UUIDString | null; + email?: string | null; + position?: string | null; + employmentType: EmploymentType; + rating?: number | null; + reliabilityScore?: number | null; + backgroundCheckStatus: BackgroundCheckStatus; + certifications?: string | null; + } & Staff_Key)[]; +} +``` +### Using `listStaff`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, listStaff } from '@dataconnect/generated'; + + +// Call the `listStaff()` function to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await listStaff(); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await listStaff(dataConnect); + +console.log(data.staffs); + +// Or, you can use the `Promise` API. +listStaff().then((response) => { + const data = response.data; + console.log(data.staffs); +}); +``` + +### Using `listStaff`'s `QueryRef` function + +```typescript +import { getDataConnect, executeQuery } from 'firebase/data-connect'; +import { connectorConfig, listStaffRef } from '@dataconnect/generated'; + + +// Call the `listStaffRef()` function to get a reference to the query. +const ref = listStaffRef(); + +// You can also pass in a `DataConnect` instance to the `QueryRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = listStaffRef(dataConnect); + +// Call `executeQuery()` on the reference to execute the query. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeQuery(ref); + +console.log(data.staffs); + +// Or, you can use the `Promise` API. +executeQuery(ref).then((response) => { + const data = response.data; + console.log(data.staffs); +}); +``` + ## listVendor You can execute the `listVendor` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): ```typescript @@ -1337,708 +2394,6 @@ executeQuery(ref).then((response) => { }); ``` -## listVendorRate -You can execute the `listVendorRate` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -listVendorRate(): QueryPromise; - -interface ListVendorRateRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (): QueryRef; -} -export const listVendorRateRef: ListVendorRateRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. -```typescript -listVendorRate(dc: DataConnect): QueryPromise; - -interface ListVendorRateRef { - ... - (dc: DataConnect): QueryRef; -} -export const listVendorRateRef: ListVendorRateRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listVendorRateRef: -```typescript -const name = listVendorRateRef.operationName; -console.log(name); -``` - -### Variables -The `listVendorRate` query has no variables. -### Return Type -Recall that executing the `listVendorRate` query returns a `QueryPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `ListVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface ListVendorRateData { - vendorRates: ({ - id: UUIDString; - vendorName: string; - category: VendorRateCategory; - roleName: string; - employeeWage: number; - markupPercentage?: number | null; - vendorFeePercentage?: number | null; - clientRate: number; - } & VendorRate_Key)[]; -} -``` -### Using `listVendorRate`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, listVendorRate } from '@dataconnect/generated'; - - -// Call the `listVendorRate()` function to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await listVendorRate(); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await listVendorRate(dataConnect); - -console.log(data.vendorRates); - -// Or, you can use the `Promise` API. -listVendorRate().then((response) => { - const data = response.data; - console.log(data.vendorRates); -}); -``` - -### Using `listVendorRate`'s `QueryRef` function - -```typescript -import { getDataConnect, executeQuery } from 'firebase/data-connect'; -import { connectorConfig, listVendorRateRef } from '@dataconnect/generated'; - - -// Call the `listVendorRateRef()` function to get a reference to the query. -const ref = listVendorRateRef(); - -// You can also pass in a `DataConnect` instance to the `QueryRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = listVendorRateRef(dataConnect); - -// Call `executeQuery()` on the reference to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeQuery(ref); - -console.log(data.vendorRates); - -// Or, you can use the `Promise` API. -executeQuery(ref).then((response) => { - const data = response.data; - console.log(data.vendorRates); -}); -``` - -## getVendorRateById -You can execute the `getVendorRateById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -getVendorRateById(vars: GetVendorRateByIdVariables): QueryPromise; - -interface GetVendorRateByIdRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: GetVendorRateByIdVariables): QueryRef; -} -export const getVendorRateByIdRef: GetVendorRateByIdRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. -```typescript -getVendorRateById(dc: DataConnect, vars: GetVendorRateByIdVariables): QueryPromise; - -interface GetVendorRateByIdRef { - ... - (dc: DataConnect, vars: GetVendorRateByIdVariables): QueryRef; -} -export const getVendorRateByIdRef: GetVendorRateByIdRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getVendorRateByIdRef: -```typescript -const name = getVendorRateByIdRef.operationName; -console.log(name); -``` - -### Variables -The `getVendorRateById` query requires an argument of type `GetVendorRateByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface GetVendorRateByIdVariables { - id: UUIDString; -} -``` -### Return Type -Recall that executing the `getVendorRateById` query returns a `QueryPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `GetVendorRateByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface GetVendorRateByIdData { - vendorRate?: { - id: UUIDString; - vendorName: string; - category: VendorRateCategory; - roleName: string; - employeeWage: number; - markupPercentage?: number | null; - vendorFeePercentage?: number | null; - clientRate: number; - createdDate?: TimestampString | null; - updatedDate?: TimestampString | null; - createdBy?: string | null; - } & VendorRate_Key; -} -``` -### Using `getVendorRateById`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, getVendorRateById, GetVendorRateByIdVariables } from '@dataconnect/generated'; - -// The `getVendorRateById` query requires an argument of type `GetVendorRateByIdVariables`: -const getVendorRateByIdVars: GetVendorRateByIdVariables = { - id: ..., -}; - -// Call the `getVendorRateById()` function to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await getVendorRateById(getVendorRateByIdVars); -// Variables can be defined inline as well. -const { data } = await getVendorRateById({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await getVendorRateById(dataConnect, getVendorRateByIdVars); - -console.log(data.vendorRate); - -// Or, you can use the `Promise` API. -getVendorRateById(getVendorRateByIdVars).then((response) => { - const data = response.data; - console.log(data.vendorRate); -}); -``` - -### Using `getVendorRateById`'s `QueryRef` function - -```typescript -import { getDataConnect, executeQuery } from 'firebase/data-connect'; -import { connectorConfig, getVendorRateByIdRef, GetVendorRateByIdVariables } from '@dataconnect/generated'; - -// The `getVendorRateById` query requires an argument of type `GetVendorRateByIdVariables`: -const getVendorRateByIdVars: GetVendorRateByIdVariables = { - id: ..., -}; - -// Call the `getVendorRateByIdRef()` function to get a reference to the query. -const ref = getVendorRateByIdRef(getVendorRateByIdVars); -// Variables can be defined inline as well. -const ref = getVendorRateByIdRef({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the `QueryRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = getVendorRateByIdRef(dataConnect, getVendorRateByIdVars); - -// Call `executeQuery()` on the reference to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeQuery(ref); - -console.log(data.vendorRate); - -// Or, you can use the `Promise` API. -executeQuery(ref).then((response) => { - const data = response.data; - console.log(data.vendorRate); -}); -``` - -## filterVendorRates -You can execute the `filterVendorRates` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -filterVendorRates(vars?: FilterVendorRatesVariables): QueryPromise; - -interface FilterVendorRatesRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars?: FilterVendorRatesVariables): QueryRef; -} -export const filterVendorRatesRef: FilterVendorRatesRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. -```typescript -filterVendorRates(dc: DataConnect, vars?: FilterVendorRatesVariables): QueryPromise; - -interface FilterVendorRatesRef { - ... - (dc: DataConnect, vars?: FilterVendorRatesVariables): QueryRef; -} -export const filterVendorRatesRef: FilterVendorRatesRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterVendorRatesRef: -```typescript -const name = filterVendorRatesRef.operationName; -console.log(name); -``` - -### Variables -The `filterVendorRates` query has an optional argument of type `FilterVendorRatesVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface FilterVendorRatesVariables { - vendorName?: string | null; - category?: VendorRateCategory | null; - roleName?: string | null; - minClientRate?: number | null; - maxClientRate?: number | null; -} -``` -### Return Type -Recall that executing the `filterVendorRates` query returns a `QueryPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `FilterVendorRatesData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface FilterVendorRatesData { - vendorRates: ({ - id: UUIDString; - vendorName: string; - category: VendorRateCategory; - roleName: string; - employeeWage: number; - markupPercentage?: number | null; - vendorFeePercentage?: number | null; - clientRate: number; - } & VendorRate_Key)[]; -} -``` -### Using `filterVendorRates`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, filterVendorRates, FilterVendorRatesVariables } from '@dataconnect/generated'; - -// The `filterVendorRates` query has an optional argument of type `FilterVendorRatesVariables`: -const filterVendorRatesVars: FilterVendorRatesVariables = { - vendorName: ..., // optional - category: ..., // optional - roleName: ..., // optional - minClientRate: ..., // optional - maxClientRate: ..., // optional -}; - -// Call the `filterVendorRates()` function to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await filterVendorRates(filterVendorRatesVars); -// Variables can be defined inline as well. -const { data } = await filterVendorRates({ vendorName: ..., category: ..., roleName: ..., minClientRate: ..., maxClientRate: ..., }); -// Since all variables are optional for this query, you can omit the `FilterVendorRatesVariables` argument. -const { data } = await filterVendorRates(); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await filterVendorRates(dataConnect, filterVendorRatesVars); - -console.log(data.vendorRates); - -// Or, you can use the `Promise` API. -filterVendorRates(filterVendorRatesVars).then((response) => { - const data = response.data; - console.log(data.vendorRates); -}); -``` - -### Using `filterVendorRates`'s `QueryRef` function - -```typescript -import { getDataConnect, executeQuery } from 'firebase/data-connect'; -import { connectorConfig, filterVendorRatesRef, FilterVendorRatesVariables } from '@dataconnect/generated'; - -// The `filterVendorRates` query has an optional argument of type `FilterVendorRatesVariables`: -const filterVendorRatesVars: FilterVendorRatesVariables = { - vendorName: ..., // optional - category: ..., // optional - roleName: ..., // optional - minClientRate: ..., // optional - maxClientRate: ..., // optional -}; - -// Call the `filterVendorRatesRef()` function to get a reference to the query. -const ref = filterVendorRatesRef(filterVendorRatesVars); -// Variables can be defined inline as well. -const ref = filterVendorRatesRef({ vendorName: ..., category: ..., roleName: ..., minClientRate: ..., maxClientRate: ..., }); -// Since all variables are optional for this query, you can omit the `FilterVendorRatesVariables` argument. -const ref = filterVendorRatesRef(); - -// You can also pass in a `DataConnect` instance to the `QueryRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = filterVendorRatesRef(dataConnect, filterVendorRatesVars); - -// Call `executeQuery()` on the reference to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeQuery(ref); - -console.log(data.vendorRates); - -// Or, you can use the `Promise` API. -executeQuery(ref).then((response) => { - const data = response.data; - console.log(data.vendorRates); -}); -``` - -## listInvoice -You can execute the `listInvoice` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -listInvoice(): QueryPromise; - -interface ListInvoiceRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (): QueryRef; -} -export const listInvoiceRef: ListInvoiceRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. -```typescript -listInvoice(dc: DataConnect): QueryPromise; - -interface ListInvoiceRef { - ... - (dc: DataConnect): QueryRef; -} -export const listInvoiceRef: ListInvoiceRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the listInvoiceRef: -```typescript -const name = listInvoiceRef.operationName; -console.log(name); -``` - -### Variables -The `listInvoice` query has no variables. -### Return Type -Recall that executing the `listInvoice` query returns a `QueryPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `ListInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface ListInvoiceData { - invoices: ({ - id: UUIDString; - invoiceNumber: string; - amount: number; - status: InvoiceStatus; - issueDate: TimestampString; - dueDate: TimestampString; - isAutoGenerated?: boolean | null; - } & Invoice_Key)[]; -} -``` -### Using `listInvoice`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, listInvoice } from '@dataconnect/generated'; - - -// Call the `listInvoice()` function to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await listInvoice(); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await listInvoice(dataConnect); - -console.log(data.invoices); - -// Or, you can use the `Promise` API. -listInvoice().then((response) => { - const data = response.data; - console.log(data.invoices); -}); -``` - -### Using `listInvoice`'s `QueryRef` function - -```typescript -import { getDataConnect, executeQuery } from 'firebase/data-connect'; -import { connectorConfig, listInvoiceRef } from '@dataconnect/generated'; - - -// Call the `listInvoiceRef()` function to get a reference to the query. -const ref = listInvoiceRef(); - -// You can also pass in a `DataConnect` instance to the `QueryRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = listInvoiceRef(dataConnect); - -// Call `executeQuery()` on the reference to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeQuery(ref); - -console.log(data.invoices); - -// Or, you can use the `Promise` API. -executeQuery(ref).then((response) => { - const data = response.data; - console.log(data.invoices); -}); -``` - -## getInvoiceById -You can execute the `getInvoiceById` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -getInvoiceById(vars: GetInvoiceByIdVariables): QueryPromise; - -interface GetInvoiceByIdRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: GetInvoiceByIdVariables): QueryRef; -} -export const getInvoiceByIdRef: GetInvoiceByIdRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. -```typescript -getInvoiceById(dc: DataConnect, vars: GetInvoiceByIdVariables): QueryPromise; - -interface GetInvoiceByIdRef { - ... - (dc: DataConnect, vars: GetInvoiceByIdVariables): QueryRef; -} -export const getInvoiceByIdRef: GetInvoiceByIdRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the getInvoiceByIdRef: -```typescript -const name = getInvoiceByIdRef.operationName; -console.log(name); -``` - -### Variables -The `getInvoiceById` query requires an argument of type `GetInvoiceByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface GetInvoiceByIdVariables { - id: UUIDString; -} -``` -### Return Type -Recall that executing the `getInvoiceById` query returns a `QueryPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `GetInvoiceByIdData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface GetInvoiceByIdData { - invoice?: { - id: UUIDString; - invoiceNumber: string; - amount: number; - status: InvoiceStatus; - issueDate: TimestampString; - dueDate: TimestampString; - disputedItems?: string | null; - isAutoGenerated?: boolean | null; - } & Invoice_Key; -} -``` -### Using `getInvoiceById`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, getInvoiceById, GetInvoiceByIdVariables } from '@dataconnect/generated'; - -// The `getInvoiceById` query requires an argument of type `GetInvoiceByIdVariables`: -const getInvoiceByIdVars: GetInvoiceByIdVariables = { - id: ..., -}; - -// Call the `getInvoiceById()` function to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await getInvoiceById(getInvoiceByIdVars); -// Variables can be defined inline as well. -const { data } = await getInvoiceById({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await getInvoiceById(dataConnect, getInvoiceByIdVars); - -console.log(data.invoice); - -// Or, you can use the `Promise` API. -getInvoiceById(getInvoiceByIdVars).then((response) => { - const data = response.data; - console.log(data.invoice); -}); -``` - -### Using `getInvoiceById`'s `QueryRef` function - -```typescript -import { getDataConnect, executeQuery } from 'firebase/data-connect'; -import { connectorConfig, getInvoiceByIdRef, GetInvoiceByIdVariables } from '@dataconnect/generated'; - -// The `getInvoiceById` query requires an argument of type `GetInvoiceByIdVariables`: -const getInvoiceByIdVars: GetInvoiceByIdVariables = { - id: ..., -}; - -// Call the `getInvoiceByIdRef()` function to get a reference to the query. -const ref = getInvoiceByIdRef(getInvoiceByIdVars); -// Variables can be defined inline as well. -const ref = getInvoiceByIdRef({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the `QueryRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = getInvoiceByIdRef(dataConnect, getInvoiceByIdVars); - -// Call `executeQuery()` on the reference to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeQuery(ref); - -console.log(data.invoice); - -// Or, you can use the `Promise` API. -executeQuery(ref).then((response) => { - const data = response.data; - console.log(data.invoice); -}); -``` - -## filterInvoices -You can execute the `filterInvoices` query using the following action shortcut function, or by calling `executeQuery()` after calling the following `QueryRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -filterInvoices(vars?: FilterInvoicesVariables): QueryPromise; - -interface FilterInvoicesRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars?: FilterInvoicesVariables): QueryRef; -} -export const filterInvoicesRef: FilterInvoicesRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `QueryRef` function. -```typescript -filterInvoices(dc: DataConnect, vars?: FilterInvoicesVariables): QueryPromise; - -interface FilterInvoicesRef { - ... - (dc: DataConnect, vars?: FilterInvoicesVariables): QueryRef; -} -export const filterInvoicesRef: FilterInvoicesRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the filterInvoicesRef: -```typescript -const name = filterInvoicesRef.operationName; -console.log(name); -``` - -### Variables -The `filterInvoices` query has an optional argument of type `FilterInvoicesVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface FilterInvoicesVariables { - invoiceNumber?: string | null; - status?: InvoiceStatus | null; - isAutoGenerated?: boolean | null; - amount?: number | null; -} -``` -### Return Type -Recall that executing the `filterInvoices` query returns a `QueryPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `FilterInvoicesData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface FilterInvoicesData { - invoices: ({ - id: UUIDString; - invoiceNumber: string; - amount: number; - status: InvoiceStatus; - issueDate: TimestampString; - dueDate: TimestampString; - isAutoGenerated?: boolean | null; - } & Invoice_Key)[]; -} -``` -### Using `filterInvoices`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, filterInvoices, FilterInvoicesVariables } from '@dataconnect/generated'; - -// The `filterInvoices` query has an optional argument of type `FilterInvoicesVariables`: -const filterInvoicesVars: FilterInvoicesVariables = { - invoiceNumber: ..., // optional - status: ..., // optional - isAutoGenerated: ..., // optional - amount: ..., // optional -}; - -// Call the `filterInvoices()` function to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await filterInvoices(filterInvoicesVars); -// Variables can be defined inline as well. -const { data } = await filterInvoices({ invoiceNumber: ..., status: ..., isAutoGenerated: ..., amount: ..., }); -// Since all variables are optional for this query, you can omit the `FilterInvoicesVariables` argument. -const { data } = await filterInvoices(); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await filterInvoices(dataConnect, filterInvoicesVars); - -console.log(data.invoices); - -// Or, you can use the `Promise` API. -filterInvoices(filterInvoicesVars).then((response) => { - const data = response.data; - console.log(data.invoices); -}); -``` - -### Using `filterInvoices`'s `QueryRef` function - -```typescript -import { getDataConnect, executeQuery } from 'firebase/data-connect'; -import { connectorConfig, filterInvoicesRef, FilterInvoicesVariables } from '@dataconnect/generated'; - -// The `filterInvoices` query has an optional argument of type `FilterInvoicesVariables`: -const filterInvoicesVars: FilterInvoicesVariables = { - invoiceNumber: ..., // optional - status: ..., // optional - isAutoGenerated: ..., // optional - amount: ..., // optional -}; - -// Call the `filterInvoicesRef()` function to get a reference to the query. -const ref = filterInvoicesRef(filterInvoicesVars); -// Variables can be defined inline as well. -const ref = filterInvoicesRef({ invoiceNumber: ..., status: ..., isAutoGenerated: ..., amount: ..., }); -// Since all variables are optional for this query, you can omit the `FilterInvoicesVariables` argument. -const ref = filterInvoicesRef(); - -// You can also pass in a `DataConnect` instance to the `QueryRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = filterInvoicesRef(dataConnect, filterInvoicesVars); - -// Call `executeQuery()` on the reference to execute the query. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeQuery(ref); - -console.log(data.invoices); - -// Or, you can use the `Promise` API. -executeQuery(ref).then((response) => { - const data = response.data; - console.log(data.invoices); -}); -``` - # Mutations There are two ways to execute a Data Connect Mutation using the generated Web SDK: @@ -2054,1579 +2409,6 @@ The following is true for both the action shortcut function and the `MutationRef Below are examples of how to use the `krow-connector` connector's generated functions to execute each mutation. You can also follow the examples from the [Data Connect documentation](https://firebase.google.com/docs/data-connect/web-sdk#using-mutations). -## CreateVendor -You can execute the `CreateVendor` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -createVendor(vars: CreateVendorVariables): MutationPromise; - -interface CreateVendorRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: CreateVendorVariables): MutationRef; -} -export const createVendorRef: CreateVendorRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -createVendor(dc: DataConnect, vars: CreateVendorVariables): MutationPromise; - -interface CreateVendorRef { - ... - (dc: DataConnect, vars: CreateVendorVariables): MutationRef; -} -export const createVendorRef: CreateVendorRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createVendorRef: -```typescript -const name = createVendorRef.operationName; -console.log(name); -``` - -### Variables -The `CreateVendor` mutation requires an argument of type `CreateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface CreateVendorVariables { - vendorNumber: string; - legalName: string; - region: VendorRegion; - platformType: VendorPlatformType; - primaryContactEmail: string; - approvalStatus: VendorApprovalStatus; - isActive?: boolean | null; -} -``` -### Return Type -Recall that executing the `CreateVendor` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `CreateVendorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface CreateVendorData { - vendor_insert: Vendor_Key; -} -``` -### Using `CreateVendor`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, createVendor, CreateVendorVariables } from '@dataconnect/generated'; - -// The `CreateVendor` mutation requires an argument of type `CreateVendorVariables`: -const createVendorVars: CreateVendorVariables = { - vendorNumber: ..., - legalName: ..., - region: ..., - platformType: ..., - primaryContactEmail: ..., - approvalStatus: ..., - isActive: ..., // optional -}; - -// Call the `createVendor()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await createVendor(createVendorVars); -// Variables can be defined inline as well. -const { data } = await createVendor({ vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await createVendor(dataConnect, createVendorVars); - -console.log(data.vendor_insert); - -// Or, you can use the `Promise` API. -createVendor(createVendorVars).then((response) => { - const data = response.data; - console.log(data.vendor_insert); -}); -``` - -### Using `CreateVendor`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, createVendorRef, CreateVendorVariables } from '@dataconnect/generated'; - -// The `CreateVendor` mutation requires an argument of type `CreateVendorVariables`: -const createVendorVars: CreateVendorVariables = { - vendorNumber: ..., - legalName: ..., - region: ..., - platformType: ..., - primaryContactEmail: ..., - approvalStatus: ..., - isActive: ..., // optional -}; - -// Call the `createVendorRef()` function to get a reference to the mutation. -const ref = createVendorRef(createVendorVars); -// Variables can be defined inline as well. -const ref = createVendorRef({ vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = createVendorRef(dataConnect, createVendorVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendor_insert); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendor_insert); -}); -``` - -## UpdateVendor -You can execute the `UpdateVendor` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -updateVendor(vars: UpdateVendorVariables): MutationPromise; - -interface UpdateVendorRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: UpdateVendorVariables): MutationRef; -} -export const updateVendorRef: UpdateVendorRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -updateVendor(dc: DataConnect, vars: UpdateVendorVariables): MutationPromise; - -interface UpdateVendorRef { - ... - (dc: DataConnect, vars: UpdateVendorVariables): MutationRef; -} -export const updateVendorRef: UpdateVendorRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateVendorRef: -```typescript -const name = updateVendorRef.operationName; -console.log(name); -``` - -### Variables -The `UpdateVendor` mutation requires an argument of type `UpdateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface UpdateVendorVariables { - id: UUIDString; - vendorNumber?: string | null; - legalName?: string | null; - region?: VendorRegion | null; - platformType?: VendorPlatformType | null; - primaryContactEmail?: string | null; - approvalStatus?: VendorApprovalStatus | null; - isActive?: boolean | null; -} -``` -### Return Type -Recall that executing the `UpdateVendor` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `UpdateVendorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface UpdateVendorData { - vendor_update?: Vendor_Key | null; -} -``` -### Using `UpdateVendor`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, updateVendor, UpdateVendorVariables } from '@dataconnect/generated'; - -// The `UpdateVendor` mutation requires an argument of type `UpdateVendorVariables`: -const updateVendorVars: UpdateVendorVariables = { - id: ..., - vendorNumber: ..., // optional - legalName: ..., // optional - region: ..., // optional - platformType: ..., // optional - primaryContactEmail: ..., // optional - approvalStatus: ..., // optional - isActive: ..., // optional -}; - -// Call the `updateVendor()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await updateVendor(updateVendorVars); -// Variables can be defined inline as well. -const { data } = await updateVendor({ id: ..., vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await updateVendor(dataConnect, updateVendorVars); - -console.log(data.vendor_update); - -// Or, you can use the `Promise` API. -updateVendor(updateVendorVars).then((response) => { - const data = response.data; - console.log(data.vendor_update); -}); -``` - -### Using `UpdateVendor`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, updateVendorRef, UpdateVendorVariables } from '@dataconnect/generated'; - -// The `UpdateVendor` mutation requires an argument of type `UpdateVendorVariables`: -const updateVendorVars: UpdateVendorVariables = { - id: ..., - vendorNumber: ..., // optional - legalName: ..., // optional - region: ..., // optional - platformType: ..., // optional - primaryContactEmail: ..., // optional - approvalStatus: ..., // optional - isActive: ..., // optional -}; - -// Call the `updateVendorRef()` function to get a reference to the mutation. -const ref = updateVendorRef(updateVendorVars); -// Variables can be defined inline as well. -const ref = updateVendorRef({ id: ..., vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = updateVendorRef(dataConnect, updateVendorVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendor_update); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendor_update); -}); -``` - -## DeleteVendor -You can execute the `DeleteVendor` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -deleteVendor(vars: DeleteVendorVariables): MutationPromise; - -interface DeleteVendorRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: DeleteVendorVariables): MutationRef; -} -export const deleteVendorRef: DeleteVendorRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -deleteVendor(dc: DataConnect, vars: DeleteVendorVariables): MutationPromise; - -interface DeleteVendorRef { - ... - (dc: DataConnect, vars: DeleteVendorVariables): MutationRef; -} -export const deleteVendorRef: DeleteVendorRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteVendorRef: -```typescript -const name = deleteVendorRef.operationName; -console.log(name); -``` - -### Variables -The `DeleteVendor` mutation requires an argument of type `DeleteVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface DeleteVendorVariables { - id: UUIDString; -} -``` -### Return Type -Recall that executing the `DeleteVendor` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `DeleteVendorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface DeleteVendorData { - vendor_delete?: Vendor_Key | null; -} -``` -### Using `DeleteVendor`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, deleteVendor, DeleteVendorVariables } from '@dataconnect/generated'; - -// The `DeleteVendor` mutation requires an argument of type `DeleteVendorVariables`: -const deleteVendorVars: DeleteVendorVariables = { - id: ..., -}; - -// Call the `deleteVendor()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await deleteVendor(deleteVendorVars); -// Variables can be defined inline as well. -const { data } = await deleteVendor({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await deleteVendor(dataConnect, deleteVendorVars); - -console.log(data.vendor_delete); - -// Or, you can use the `Promise` API. -deleteVendor(deleteVendorVars).then((response) => { - const data = response.data; - console.log(data.vendor_delete); -}); -``` - -### Using `DeleteVendor`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, deleteVendorRef, DeleteVendorVariables } from '@dataconnect/generated'; - -// The `DeleteVendor` mutation requires an argument of type `DeleteVendorVariables`: -const deleteVendorVars: DeleteVendorVariables = { - id: ..., -}; - -// Call the `deleteVendorRef()` function to get a reference to the mutation. -const ref = deleteVendorRef(deleteVendorVars); -// Variables can be defined inline as well. -const ref = deleteVendorRef({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = deleteVendorRef(dataConnect, deleteVendorVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendor_delete); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendor_delete); -}); -``` - -## CreateInvoice -You can execute the `CreateInvoice` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -createInvoice(vars: CreateInvoiceVariables): MutationPromise; - -interface CreateInvoiceRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: CreateInvoiceVariables): MutationRef; -} -export const createInvoiceRef: CreateInvoiceRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -createInvoice(dc: DataConnect, vars: CreateInvoiceVariables): MutationPromise; - -interface CreateInvoiceRef { - ... - (dc: DataConnect, vars: CreateInvoiceVariables): MutationRef; -} -export const createInvoiceRef: CreateInvoiceRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createInvoiceRef: -```typescript -const name = createInvoiceRef.operationName; -console.log(name); -``` - -### Variables -The `CreateInvoice` mutation requires an argument of type `CreateInvoiceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface CreateInvoiceVariables { - invoiceNumber: string; - amount: number; - status: InvoiceStatus; - issueDate: TimestampString; - dueDate: TimestampString; - disputedItems?: string | null; - isAutoGenerated?: boolean | null; -} -``` -### Return Type -Recall that executing the `CreateInvoice` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `CreateInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface CreateInvoiceData { - invoice_insert: Invoice_Key; -} -``` -### Using `CreateInvoice`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, createInvoice, CreateInvoiceVariables } from '@dataconnect/generated'; - -// The `CreateInvoice` mutation requires an argument of type `CreateInvoiceVariables`: -const createInvoiceVars: CreateInvoiceVariables = { - invoiceNumber: ..., - amount: ..., - status: ..., - issueDate: ..., - dueDate: ..., - disputedItems: ..., // optional - isAutoGenerated: ..., // optional -}; - -// Call the `createInvoice()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await createInvoice(createInvoiceVars); -// Variables can be defined inline as well. -const { data } = await createInvoice({ invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await createInvoice(dataConnect, createInvoiceVars); - -console.log(data.invoice_insert); - -// Or, you can use the `Promise` API. -createInvoice(createInvoiceVars).then((response) => { - const data = response.data; - console.log(data.invoice_insert); -}); -``` - -### Using `CreateInvoice`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, createInvoiceRef, CreateInvoiceVariables } from '@dataconnect/generated'; - -// The `CreateInvoice` mutation requires an argument of type `CreateInvoiceVariables`: -const createInvoiceVars: CreateInvoiceVariables = { - invoiceNumber: ..., - amount: ..., - status: ..., - issueDate: ..., - dueDate: ..., - disputedItems: ..., // optional - isAutoGenerated: ..., // optional -}; - -// Call the `createInvoiceRef()` function to get a reference to the mutation. -const ref = createInvoiceRef(createInvoiceVars); -// Variables can be defined inline as well. -const ref = createInvoiceRef({ invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = createInvoiceRef(dataConnect, createInvoiceVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.invoice_insert); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.invoice_insert); -}); -``` - -## UpdateInvoice -You can execute the `UpdateInvoice` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -updateInvoice(vars: UpdateInvoiceVariables): MutationPromise; - -interface UpdateInvoiceRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: UpdateInvoiceVariables): MutationRef; -} -export const updateInvoiceRef: UpdateInvoiceRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -updateInvoice(dc: DataConnect, vars: UpdateInvoiceVariables): MutationPromise; - -interface UpdateInvoiceRef { - ... - (dc: DataConnect, vars: UpdateInvoiceVariables): MutationRef; -} -export const updateInvoiceRef: UpdateInvoiceRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateInvoiceRef: -```typescript -const name = updateInvoiceRef.operationName; -console.log(name); -``` - -### Variables -The `UpdateInvoice` mutation requires an argument of type `UpdateInvoiceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface UpdateInvoiceVariables { - id: UUIDString; - invoiceNumber?: string | null; - amount?: number | null; - status?: InvoiceStatus | null; - issueDate?: TimestampString | null; - dueDate?: TimestampString | null; - disputedItems?: string | null; - isAutoGenerated?: boolean | null; -} -``` -### Return Type -Recall that executing the `UpdateInvoice` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `UpdateInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface UpdateInvoiceData { - invoice_update?: Invoice_Key | null; -} -``` -### Using `UpdateInvoice`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, updateInvoice, UpdateInvoiceVariables } from '@dataconnect/generated'; - -// The `UpdateInvoice` mutation requires an argument of type `UpdateInvoiceVariables`: -const updateInvoiceVars: UpdateInvoiceVariables = { - id: ..., - invoiceNumber: ..., // optional - amount: ..., // optional - status: ..., // optional - issueDate: ..., // optional - dueDate: ..., // optional - disputedItems: ..., // optional - isAutoGenerated: ..., // optional -}; - -// Call the `updateInvoice()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await updateInvoice(updateInvoiceVars); -// Variables can be defined inline as well. -const { data } = await updateInvoice({ id: ..., invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await updateInvoice(dataConnect, updateInvoiceVars); - -console.log(data.invoice_update); - -// Or, you can use the `Promise` API. -updateInvoice(updateInvoiceVars).then((response) => { - const data = response.data; - console.log(data.invoice_update); -}); -``` - -### Using `UpdateInvoice`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, updateInvoiceRef, UpdateInvoiceVariables } from '@dataconnect/generated'; - -// The `UpdateInvoice` mutation requires an argument of type `UpdateInvoiceVariables`: -const updateInvoiceVars: UpdateInvoiceVariables = { - id: ..., - invoiceNumber: ..., // optional - amount: ..., // optional - status: ..., // optional - issueDate: ..., // optional - dueDate: ..., // optional - disputedItems: ..., // optional - isAutoGenerated: ..., // optional -}; - -// Call the `updateInvoiceRef()` function to get a reference to the mutation. -const ref = updateInvoiceRef(updateInvoiceVars); -// Variables can be defined inline as well. -const ref = updateInvoiceRef({ id: ..., invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = updateInvoiceRef(dataConnect, updateInvoiceVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.invoice_update); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.invoice_update); -}); -``` - -## DeleteInvoice -You can execute the `DeleteInvoice` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -deleteInvoice(vars: DeleteInvoiceVariables): MutationPromise; - -interface DeleteInvoiceRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: DeleteInvoiceVariables): MutationRef; -} -export const deleteInvoiceRef: DeleteInvoiceRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -deleteInvoice(dc: DataConnect, vars: DeleteInvoiceVariables): MutationPromise; - -interface DeleteInvoiceRef { - ... - (dc: DataConnect, vars: DeleteInvoiceVariables): MutationRef; -} -export const deleteInvoiceRef: DeleteInvoiceRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteInvoiceRef: -```typescript -const name = deleteInvoiceRef.operationName; -console.log(name); -``` - -### Variables -The `DeleteInvoice` mutation requires an argument of type `DeleteInvoiceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface DeleteInvoiceVariables { - id: UUIDString; -} -``` -### Return Type -Recall that executing the `DeleteInvoice` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `DeleteInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface DeleteInvoiceData { - invoice_delete?: Invoice_Key | null; -} -``` -### Using `DeleteInvoice`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, deleteInvoice, DeleteInvoiceVariables } from '@dataconnect/generated'; - -// The `DeleteInvoice` mutation requires an argument of type `DeleteInvoiceVariables`: -const deleteInvoiceVars: DeleteInvoiceVariables = { - id: ..., -}; - -// Call the `deleteInvoice()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await deleteInvoice(deleteInvoiceVars); -// Variables can be defined inline as well. -const { data } = await deleteInvoice({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await deleteInvoice(dataConnect, deleteInvoiceVars); - -console.log(data.invoice_delete); - -// Or, you can use the `Promise` API. -deleteInvoice(deleteInvoiceVars).then((response) => { - const data = response.data; - console.log(data.invoice_delete); -}); -``` - -### Using `DeleteInvoice`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, deleteInvoiceRef, DeleteInvoiceVariables } from '@dataconnect/generated'; - -// The `DeleteInvoice` mutation requires an argument of type `DeleteInvoiceVariables`: -const deleteInvoiceVars: DeleteInvoiceVariables = { - id: ..., -}; - -// Call the `deleteInvoiceRef()` function to get a reference to the mutation. -const ref = deleteInvoiceRef(deleteInvoiceVars); -// Variables can be defined inline as well. -const ref = deleteInvoiceRef({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = deleteInvoiceRef(dataConnect, deleteInvoiceVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.invoice_delete); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.invoice_delete); -}); -``` - -## CreateStaff -You can execute the `CreateStaff` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -createStaff(vars: CreateStaffVariables): MutationPromise; - -interface CreateStaffRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: CreateStaffVariables): MutationRef; -} -export const createStaffRef: CreateStaffRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -createStaff(dc: DataConnect, vars: CreateStaffVariables): MutationPromise; - -interface CreateStaffRef { - ... - (dc: DataConnect, vars: CreateStaffVariables): MutationRef; -} -export const createStaffRef: CreateStaffRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createStaffRef: -```typescript -const name = createStaffRef.operationName; -console.log(name); -``` - -### Variables -The `CreateStaff` mutation requires an argument of type `CreateStaffVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface CreateStaffVariables { - employeeName: string; - vendorId?: UUIDString | null; - email?: string | null; - position?: string | null; - employmentType: EmploymentType; - rating?: number | null; - reliabilityScore?: number | null; - backgroundCheckStatus: BackgroundCheckStatus; - certifications?: string | null; -} -``` -### Return Type -Recall that executing the `CreateStaff` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `CreateStaffData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface CreateStaffData { - staff_insert: Staff_Key; -} -``` -### Using `CreateStaff`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, createStaff, CreateStaffVariables } from '@dataconnect/generated'; - -// The `CreateStaff` mutation requires an argument of type `CreateStaffVariables`: -const createStaffVars: CreateStaffVariables = { - employeeName: ..., - vendorId: ..., // optional - email: ..., // optional - position: ..., // optional - employmentType: ..., - rating: ..., // optional - reliabilityScore: ..., // optional - backgroundCheckStatus: ..., - certifications: ..., // 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: ..., email: ..., position: ..., employmentType: ..., rating: ..., reliabilityScore: ..., backgroundCheckStatus: ..., certifications: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await createStaff(dataConnect, createStaffVars); - -console.log(data.staff_insert); - -// Or, you can use the `Promise` API. -createStaff(createStaffVars).then((response) => { - const data = response.data; - console.log(data.staff_insert); -}); -``` - -### Using `CreateStaff`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, createStaffRef, CreateStaffVariables } from '@dataconnect/generated'; - -// The `CreateStaff` mutation requires an argument of type `CreateStaffVariables`: -const createStaffVars: CreateStaffVariables = { - employeeName: ..., - vendorId: ..., // optional - email: ..., // optional - position: ..., // optional - employmentType: ..., - rating: ..., // optional - reliabilityScore: ..., // optional - backgroundCheckStatus: ..., - certifications: ..., // 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: ..., email: ..., position: ..., employmentType: ..., rating: ..., reliabilityScore: ..., backgroundCheckStatus: ..., certifications: ..., }); - -// 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); -}); -``` - -## CreateVendorDefaultSetting -You can execute the `CreateVendorDefaultSetting` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -createVendorDefaultSetting(vars: CreateVendorDefaultSettingVariables): MutationPromise; - -interface CreateVendorDefaultSettingRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: CreateVendorDefaultSettingVariables): MutationRef; -} -export const createVendorDefaultSettingRef: CreateVendorDefaultSettingRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -createVendorDefaultSetting(dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationPromise; - -interface CreateVendorDefaultSettingRef { - ... - (dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationRef; -} -export const createVendorDefaultSettingRef: CreateVendorDefaultSettingRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createVendorDefaultSettingRef: -```typescript -const name = createVendorDefaultSettingRef.operationName; -console.log(name); -``` - -### Variables -The `CreateVendorDefaultSetting` mutation requires an argument of type `CreateVendorDefaultSettingVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface CreateVendorDefaultSettingVariables { - vendorName: string; - defaultMarkupPercentage: number; - defaultVendorFeePercentage: number; -} -``` -### Return Type -Recall that executing the `CreateVendorDefaultSetting` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `CreateVendorDefaultSettingData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface CreateVendorDefaultSettingData { - vendorDefaultSetting_insert: VendorDefaultSetting_Key; -} -``` -### Using `CreateVendorDefaultSetting`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, createVendorDefaultSetting, CreateVendorDefaultSettingVariables } from '@dataconnect/generated'; - -// The `CreateVendorDefaultSetting` mutation requires an argument of type `CreateVendorDefaultSettingVariables`: -const createVendorDefaultSettingVars: CreateVendorDefaultSettingVariables = { - vendorName: ..., - defaultMarkupPercentage: ..., - defaultVendorFeePercentage: ..., -}; - -// Call the `createVendorDefaultSetting()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await createVendorDefaultSetting(createVendorDefaultSettingVars); -// Variables can be defined inline as well. -const { data } = await createVendorDefaultSetting({ vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await createVendorDefaultSetting(dataConnect, createVendorDefaultSettingVars); - -console.log(data.vendorDefaultSetting_insert); - -// Or, you can use the `Promise` API. -createVendorDefaultSetting(createVendorDefaultSettingVars).then((response) => { - const data = response.data; - console.log(data.vendorDefaultSetting_insert); -}); -``` - -### Using `CreateVendorDefaultSetting`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, createVendorDefaultSettingRef, CreateVendorDefaultSettingVariables } from '@dataconnect/generated'; - -// The `CreateVendorDefaultSetting` mutation requires an argument of type `CreateVendorDefaultSettingVariables`: -const createVendorDefaultSettingVars: CreateVendorDefaultSettingVariables = { - vendorName: ..., - defaultMarkupPercentage: ..., - defaultVendorFeePercentage: ..., -}; - -// Call the `createVendorDefaultSettingRef()` function to get a reference to the mutation. -const ref = createVendorDefaultSettingRef(createVendorDefaultSettingVars); -// Variables can be defined inline as well. -const ref = createVendorDefaultSettingRef({ vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = createVendorDefaultSettingRef(dataConnect, createVendorDefaultSettingVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendorDefaultSetting_insert); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendorDefaultSetting_insert); -}); -``` - -## UpdateVendorDefaultSetting -You can execute the `UpdateVendorDefaultSetting` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -updateVendorDefaultSetting(vars: UpdateVendorDefaultSettingVariables): MutationPromise; - -interface UpdateVendorDefaultSettingRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: UpdateVendorDefaultSettingVariables): MutationRef; -} -export const updateVendorDefaultSettingRef: UpdateVendorDefaultSettingRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -updateVendorDefaultSetting(dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationPromise; - -interface UpdateVendorDefaultSettingRef { - ... - (dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationRef; -} -export const updateVendorDefaultSettingRef: UpdateVendorDefaultSettingRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateVendorDefaultSettingRef: -```typescript -const name = updateVendorDefaultSettingRef.operationName; -console.log(name); -``` - -### Variables -The `UpdateVendorDefaultSetting` mutation requires an argument of type `UpdateVendorDefaultSettingVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface UpdateVendorDefaultSettingVariables { - id: UUIDString; - vendorName?: string | null; - defaultMarkupPercentage?: number | null; - defaultVendorFeePercentage?: number | null; -} -``` -### Return Type -Recall that executing the `UpdateVendorDefaultSetting` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `UpdateVendorDefaultSettingData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface UpdateVendorDefaultSettingData { - vendorDefaultSetting_update?: VendorDefaultSetting_Key | null; -} -``` -### Using `UpdateVendorDefaultSetting`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, updateVendorDefaultSetting, UpdateVendorDefaultSettingVariables } from '@dataconnect/generated'; - -// The `UpdateVendorDefaultSetting` mutation requires an argument of type `UpdateVendorDefaultSettingVariables`: -const updateVendorDefaultSettingVars: UpdateVendorDefaultSettingVariables = { - id: ..., - vendorName: ..., // optional - defaultMarkupPercentage: ..., // optional - defaultVendorFeePercentage: ..., // optional -}; - -// Call the `updateVendorDefaultSetting()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await updateVendorDefaultSetting(updateVendorDefaultSettingVars); -// Variables can be defined inline as well. -const { data } = await updateVendorDefaultSetting({ id: ..., vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await updateVendorDefaultSetting(dataConnect, updateVendorDefaultSettingVars); - -console.log(data.vendorDefaultSetting_update); - -// Or, you can use the `Promise` API. -updateVendorDefaultSetting(updateVendorDefaultSettingVars).then((response) => { - const data = response.data; - console.log(data.vendorDefaultSetting_update); -}); -``` - -### Using `UpdateVendorDefaultSetting`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, updateVendorDefaultSettingRef, UpdateVendorDefaultSettingVariables } from '@dataconnect/generated'; - -// The `UpdateVendorDefaultSetting` mutation requires an argument of type `UpdateVendorDefaultSettingVariables`: -const updateVendorDefaultSettingVars: UpdateVendorDefaultSettingVariables = { - id: ..., - vendorName: ..., // optional - defaultMarkupPercentage: ..., // optional - defaultVendorFeePercentage: ..., // optional -}; - -// Call the `updateVendorDefaultSettingRef()` function to get a reference to the mutation. -const ref = updateVendorDefaultSettingRef(updateVendorDefaultSettingVars); -// Variables can be defined inline as well. -const ref = updateVendorDefaultSettingRef({ id: ..., vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = updateVendorDefaultSettingRef(dataConnect, updateVendorDefaultSettingVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendorDefaultSetting_update); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendorDefaultSetting_update); -}); -``` - -## DeleteVendorDefaultSetting -You can execute the `DeleteVendorDefaultSetting` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -deleteVendorDefaultSetting(vars: DeleteVendorDefaultSettingVariables): MutationPromise; - -interface DeleteVendorDefaultSettingRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: DeleteVendorDefaultSettingVariables): MutationRef; -} -export const deleteVendorDefaultSettingRef: DeleteVendorDefaultSettingRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -deleteVendorDefaultSetting(dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationPromise; - -interface DeleteVendorDefaultSettingRef { - ... - (dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationRef; -} -export const deleteVendorDefaultSettingRef: DeleteVendorDefaultSettingRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteVendorDefaultSettingRef: -```typescript -const name = deleteVendorDefaultSettingRef.operationName; -console.log(name); -``` - -### Variables -The `DeleteVendorDefaultSetting` mutation requires an argument of type `DeleteVendorDefaultSettingVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface DeleteVendorDefaultSettingVariables { - id: UUIDString; -} -``` -### Return Type -Recall that executing the `DeleteVendorDefaultSetting` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `DeleteVendorDefaultSettingData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface DeleteVendorDefaultSettingData { - vendorDefaultSetting_delete?: VendorDefaultSetting_Key | null; -} -``` -### Using `DeleteVendorDefaultSetting`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, deleteVendorDefaultSetting, DeleteVendorDefaultSettingVariables } from '@dataconnect/generated'; - -// The `DeleteVendorDefaultSetting` mutation requires an argument of type `DeleteVendorDefaultSettingVariables`: -const deleteVendorDefaultSettingVars: DeleteVendorDefaultSettingVariables = { - id: ..., -}; - -// Call the `deleteVendorDefaultSetting()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await deleteVendorDefaultSetting(deleteVendorDefaultSettingVars); -// Variables can be defined inline as well. -const { data } = await deleteVendorDefaultSetting({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await deleteVendorDefaultSetting(dataConnect, deleteVendorDefaultSettingVars); - -console.log(data.vendorDefaultSetting_delete); - -// Or, you can use the `Promise` API. -deleteVendorDefaultSetting(deleteVendorDefaultSettingVars).then((response) => { - const data = response.data; - console.log(data.vendorDefaultSetting_delete); -}); -``` - -### Using `DeleteVendorDefaultSetting`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, deleteVendorDefaultSettingRef, DeleteVendorDefaultSettingVariables } from '@dataconnect/generated'; - -// The `DeleteVendorDefaultSetting` mutation requires an argument of type `DeleteVendorDefaultSettingVariables`: -const deleteVendorDefaultSettingVars: DeleteVendorDefaultSettingVariables = { - id: ..., -}; - -// Call the `deleteVendorDefaultSettingRef()` function to get a reference to the mutation. -const ref = deleteVendorDefaultSettingRef(deleteVendorDefaultSettingVars); -// Variables can be defined inline as well. -const ref = deleteVendorDefaultSettingRef({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = deleteVendorDefaultSettingRef(dataConnect, deleteVendorDefaultSettingVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendorDefaultSetting_delete); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendorDefaultSetting_delete); -}); -``` - -## CreateVendorRate -You can execute the `CreateVendorRate` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -createVendorRate(vars: CreateVendorRateVariables): MutationPromise; - -interface CreateVendorRateRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: CreateVendorRateVariables): MutationRef; -} -export const createVendorRateRef: CreateVendorRateRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -createVendorRate(dc: DataConnect, vars: CreateVendorRateVariables): MutationPromise; - -interface CreateVendorRateRef { - ... - (dc: DataConnect, vars: CreateVendorRateVariables): MutationRef; -} -export const createVendorRateRef: CreateVendorRateRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createVendorRateRef: -```typescript -const name = createVendorRateRef.operationName; -console.log(name); -``` - -### Variables -The `CreateVendorRate` mutation requires an argument of type `CreateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface CreateVendorRateVariables { - vendorName: string; - category: VendorRateCategory; - roleName: string; - employeeWage: number; - markupPercentage?: number | null; - vendorFeePercentage?: number | null; - clientRate: number; -} -``` -### Return Type -Recall that executing the `CreateVendorRate` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `CreateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface CreateVendorRateData { - vendorRate_insert: VendorRate_Key; -} -``` -### Using `CreateVendorRate`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, createVendorRate, CreateVendorRateVariables } from '@dataconnect/generated'; - -// The `CreateVendorRate` mutation requires an argument of type `CreateVendorRateVariables`: -const createVendorRateVars: CreateVendorRateVariables = { - vendorName: ..., - category: ..., - roleName: ..., - employeeWage: ..., - markupPercentage: ..., // optional - vendorFeePercentage: ..., // optional - clientRate: ..., -}; - -// Call the `createVendorRate()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await createVendorRate(createVendorRateVars); -// Variables can be defined inline as well. -const { data } = await createVendorRate({ vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await createVendorRate(dataConnect, createVendorRateVars); - -console.log(data.vendorRate_insert); - -// Or, you can use the `Promise` API. -createVendorRate(createVendorRateVars).then((response) => { - const data = response.data; - console.log(data.vendorRate_insert); -}); -``` - -### Using `CreateVendorRate`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, createVendorRateRef, CreateVendorRateVariables } from '@dataconnect/generated'; - -// The `CreateVendorRate` mutation requires an argument of type `CreateVendorRateVariables`: -const createVendorRateVars: CreateVendorRateVariables = { - vendorName: ..., - category: ..., - roleName: ..., - employeeWage: ..., - markupPercentage: ..., // optional - vendorFeePercentage: ..., // optional - clientRate: ..., -}; - -// Call the `createVendorRateRef()` function to get a reference to the mutation. -const ref = createVendorRateRef(createVendorRateVars); -// Variables can be defined inline as well. -const ref = createVendorRateRef({ vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = createVendorRateRef(dataConnect, createVendorRateVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendorRate_insert); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendorRate_insert); -}); -``` - -## UpdateVendorRate -You can execute the `UpdateVendorRate` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -updateVendorRate(vars: UpdateVendorRateVariables): MutationPromise; - -interface UpdateVendorRateRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: UpdateVendorRateVariables): MutationRef; -} -export const updateVendorRateRef: UpdateVendorRateRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -updateVendorRate(dc: DataConnect, vars: UpdateVendorRateVariables): MutationPromise; - -interface UpdateVendorRateRef { - ... - (dc: DataConnect, vars: UpdateVendorRateVariables): MutationRef; -} -export const updateVendorRateRef: UpdateVendorRateRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateVendorRateRef: -```typescript -const name = updateVendorRateRef.operationName; -console.log(name); -``` - -### Variables -The `UpdateVendorRate` mutation requires an argument of type `UpdateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface UpdateVendorRateVariables { - id: UUIDString; - vendorName?: string | null; - category?: VendorRateCategory | null; - roleName?: string | null; - employeeWage?: number | null; - markupPercentage?: number | null; - vendorFeePercentage?: number | null; - clientRate?: number | null; -} -``` -### Return Type -Recall that executing the `UpdateVendorRate` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `UpdateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface UpdateVendorRateData { - vendorRate_update?: VendorRate_Key | null; -} -``` -### Using `UpdateVendorRate`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, updateVendorRate, UpdateVendorRateVariables } from '@dataconnect/generated'; - -// The `UpdateVendorRate` mutation requires an argument of type `UpdateVendorRateVariables`: -const updateVendorRateVars: UpdateVendorRateVariables = { - id: ..., - vendorName: ..., // optional - category: ..., // optional - roleName: ..., // optional - employeeWage: ..., // optional - markupPercentage: ..., // optional - vendorFeePercentage: ..., // optional - clientRate: ..., // optional -}; - -// Call the `updateVendorRate()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await updateVendorRate(updateVendorRateVars); -// Variables can be defined inline as well. -const { data } = await updateVendorRate({ id: ..., vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await updateVendorRate(dataConnect, updateVendorRateVars); - -console.log(data.vendorRate_update); - -// Or, you can use the `Promise` API. -updateVendorRate(updateVendorRateVars).then((response) => { - const data = response.data; - console.log(data.vendorRate_update); -}); -``` - -### Using `UpdateVendorRate`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, updateVendorRateRef, UpdateVendorRateVariables } from '@dataconnect/generated'; - -// The `UpdateVendorRate` mutation requires an argument of type `UpdateVendorRateVariables`: -const updateVendorRateVars: UpdateVendorRateVariables = { - id: ..., - vendorName: ..., // optional - category: ..., // optional - roleName: ..., // optional - employeeWage: ..., // optional - markupPercentage: ..., // optional - vendorFeePercentage: ..., // optional - clientRate: ..., // optional -}; - -// Call the `updateVendorRateRef()` function to get a reference to the mutation. -const ref = updateVendorRateRef(updateVendorRateVars); -// Variables can be defined inline as well. -const ref = updateVendorRateRef({ id: ..., vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = updateVendorRateRef(dataConnect, updateVendorRateVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendorRate_update); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendorRate_update); -}); -``` - -## DeleteVendorRate -You can execute the `DeleteVendorRate` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): -```typescript -deleteVendorRate(vars: DeleteVendorRateVariables): MutationPromise; - -interface DeleteVendorRateRef { - ... - /* Allow users to create refs without passing in DataConnect */ - (vars: DeleteVendorRateVariables): MutationRef; -} -export const deleteVendorRateRef: DeleteVendorRateRef; -``` -You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. -```typescript -deleteVendorRate(dc: DataConnect, vars: DeleteVendorRateVariables): MutationPromise; - -interface DeleteVendorRateRef { - ... - (dc: DataConnect, vars: DeleteVendorRateVariables): MutationRef; -} -export const deleteVendorRateRef: DeleteVendorRateRef; -``` - -If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteVendorRateRef: -```typescript -const name = deleteVendorRateRef.operationName; -console.log(name); -``` - -### Variables -The `DeleteVendorRate` mutation requires an argument of type `DeleteVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: - -```typescript -export interface DeleteVendorRateVariables { - id: UUIDString; -} -``` -### Return Type -Recall that executing the `DeleteVendorRate` mutation returns a `MutationPromise` that resolves to an object with a `data` property. - -The `data` property is an object of type `DeleteVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: -```typescript -export interface DeleteVendorRateData { - vendorRate_delete?: VendorRate_Key | null; -} -``` -### Using `DeleteVendorRate`'s action shortcut function - -```typescript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, deleteVendorRate, DeleteVendorRateVariables } from '@dataconnect/generated'; - -// The `DeleteVendorRate` mutation requires an argument of type `DeleteVendorRateVariables`: -const deleteVendorRateVars: DeleteVendorRateVariables = { - id: ..., -}; - -// Call the `deleteVendorRate()` function to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await deleteVendorRate(deleteVendorRateVars); -// Variables can be defined inline as well. -const { data } = await deleteVendorRate({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the action shortcut function. -const dataConnect = getDataConnect(connectorConfig); -const { data } = await deleteVendorRate(dataConnect, deleteVendorRateVars); - -console.log(data.vendorRate_delete); - -// Or, you can use the `Promise` API. -deleteVendorRate(deleteVendorRateVars).then((response) => { - const data = response.data; - console.log(data.vendorRate_delete); -}); -``` - -### Using `DeleteVendorRate`'s `MutationRef` function - -```typescript -import { getDataConnect, executeMutation } from 'firebase/data-connect'; -import { connectorConfig, deleteVendorRateRef, DeleteVendorRateVariables } from '@dataconnect/generated'; - -// The `DeleteVendorRate` mutation requires an argument of type `DeleteVendorRateVariables`: -const deleteVendorRateVars: DeleteVendorRateVariables = { - id: ..., -}; - -// Call the `deleteVendorRateRef()` function to get a reference to the mutation. -const ref = deleteVendorRateRef(deleteVendorRateVars); -// Variables can be defined inline as well. -const ref = deleteVendorRateRef({ id: ..., }); - -// You can also pass in a `DataConnect` instance to the `MutationRef` function. -const dataConnect = getDataConnect(connectorConfig); -const ref = deleteVendorRateRef(dataConnect, deleteVendorRateVars); - -// Call `executeMutation()` on the reference to execute the mutation. -// You can use the `await` keyword to wait for the promise to resolve. -const { data } = await executeMutation(ref); - -console.log(data.vendorRate_delete); - -// Or, you can use the `Promise` API. -executeMutation(ref).then((response) => { - const data = response.data; - console.log(data.vendorRate_delete); -}); -``` - ## CreateEvent You can execute the `CreateEvent` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): ```typescript @@ -4155,3 +2937,1936 @@ executeMutation(ref).then((response) => { }); ``` +## CreateVendorRate +You can execute the `CreateVendorRate` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +createVendorRate(vars: CreateVendorRateVariables): MutationPromise; + +interface CreateVendorRateRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateVendorRateVariables): MutationRef; +} +export const createVendorRateRef: CreateVendorRateRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +createVendorRate(dc: DataConnect, vars: CreateVendorRateVariables): MutationPromise; + +interface CreateVendorRateRef { + ... + (dc: DataConnect, vars: CreateVendorRateVariables): MutationRef; +} +export const createVendorRateRef: CreateVendorRateRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createVendorRateRef: +```typescript +const name = createVendorRateRef.operationName; +console.log(name); +``` + +### Variables +The `CreateVendorRate` mutation requires an argument of type `CreateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface CreateVendorRateVariables { + vendorName: string; + category: VendorRateCategory; + roleName: string; + employeeWage: number; + markupPercentage?: number | null; + vendorFeePercentage?: number | null; + clientRate: number; +} +``` +### Return Type +Recall that executing the `CreateVendorRate` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `CreateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface CreateVendorRateData { + vendorRate_insert: VendorRate_Key; +} +``` +### Using `CreateVendorRate`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, createVendorRate, CreateVendorRateVariables } from '@dataconnect/generated'; + +// The `CreateVendorRate` mutation requires an argument of type `CreateVendorRateVariables`: +const createVendorRateVars: CreateVendorRateVariables = { + vendorName: ..., + category: ..., + roleName: ..., + employeeWage: ..., + markupPercentage: ..., // optional + vendorFeePercentage: ..., // optional + clientRate: ..., +}; + +// Call the `createVendorRate()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await createVendorRate(createVendorRateVars); +// Variables can be defined inline as well. +const { data } = await createVendorRate({ vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await createVendorRate(dataConnect, createVendorRateVars); + +console.log(data.vendorRate_insert); + +// Or, you can use the `Promise` API. +createVendorRate(createVendorRateVars).then((response) => { + const data = response.data; + console.log(data.vendorRate_insert); +}); +``` + +### Using `CreateVendorRate`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, createVendorRateRef, CreateVendorRateVariables } from '@dataconnect/generated'; + +// The `CreateVendorRate` mutation requires an argument of type `CreateVendorRateVariables`: +const createVendorRateVars: CreateVendorRateVariables = { + vendorName: ..., + category: ..., + roleName: ..., + employeeWage: ..., + markupPercentage: ..., // optional + vendorFeePercentage: ..., // optional + clientRate: ..., +}; + +// Call the `createVendorRateRef()` function to get a reference to the mutation. +const ref = createVendorRateRef(createVendorRateVars); +// Variables can be defined inline as well. +const ref = createVendorRateRef({ vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = createVendorRateRef(dataConnect, createVendorRateVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendorRate_insert); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendorRate_insert); +}); +``` + +## UpdateVendorRate +You can execute the `UpdateVendorRate` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +updateVendorRate(vars: UpdateVendorRateVariables): MutationPromise; + +interface UpdateVendorRateRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateVendorRateVariables): MutationRef; +} +export const updateVendorRateRef: UpdateVendorRateRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +updateVendorRate(dc: DataConnect, vars: UpdateVendorRateVariables): MutationPromise; + +interface UpdateVendorRateRef { + ... + (dc: DataConnect, vars: UpdateVendorRateVariables): MutationRef; +} +export const updateVendorRateRef: UpdateVendorRateRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateVendorRateRef: +```typescript +const name = updateVendorRateRef.operationName; +console.log(name); +``` + +### Variables +The `UpdateVendorRate` mutation requires an argument of type `UpdateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface UpdateVendorRateVariables { + id: UUIDString; + vendorName?: string | null; + category?: VendorRateCategory | null; + roleName?: string | null; + employeeWage?: number | null; + markupPercentage?: number | null; + vendorFeePercentage?: number | null; + clientRate?: number | null; +} +``` +### Return Type +Recall that executing the `UpdateVendorRate` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `UpdateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface UpdateVendorRateData { + vendorRate_update?: VendorRate_Key | null; +} +``` +### Using `UpdateVendorRate`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, updateVendorRate, UpdateVendorRateVariables } from '@dataconnect/generated'; + +// The `UpdateVendorRate` mutation requires an argument of type `UpdateVendorRateVariables`: +const updateVendorRateVars: UpdateVendorRateVariables = { + id: ..., + vendorName: ..., // optional + category: ..., // optional + roleName: ..., // optional + employeeWage: ..., // optional + markupPercentage: ..., // optional + vendorFeePercentage: ..., // optional + clientRate: ..., // optional +}; + +// Call the `updateVendorRate()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await updateVendorRate(updateVendorRateVars); +// Variables can be defined inline as well. +const { data } = await updateVendorRate({ id: ..., vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await updateVendorRate(dataConnect, updateVendorRateVars); + +console.log(data.vendorRate_update); + +// Or, you can use the `Promise` API. +updateVendorRate(updateVendorRateVars).then((response) => { + const data = response.data; + console.log(data.vendorRate_update); +}); +``` + +### Using `UpdateVendorRate`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, updateVendorRateRef, UpdateVendorRateVariables } from '@dataconnect/generated'; + +// The `UpdateVendorRate` mutation requires an argument of type `UpdateVendorRateVariables`: +const updateVendorRateVars: UpdateVendorRateVariables = { + id: ..., + vendorName: ..., // optional + category: ..., // optional + roleName: ..., // optional + employeeWage: ..., // optional + markupPercentage: ..., // optional + vendorFeePercentage: ..., // optional + clientRate: ..., // optional +}; + +// Call the `updateVendorRateRef()` function to get a reference to the mutation. +const ref = updateVendorRateRef(updateVendorRateVars); +// Variables can be defined inline as well. +const ref = updateVendorRateRef({ id: ..., vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = updateVendorRateRef(dataConnect, updateVendorRateVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendorRate_update); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendorRate_update); +}); +``` + +## DeleteVendorRate +You can execute the `DeleteVendorRate` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +deleteVendorRate(vars: DeleteVendorRateVariables): MutationPromise; + +interface DeleteVendorRateRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteVendorRateVariables): MutationRef; +} +export const deleteVendorRateRef: DeleteVendorRateRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +deleteVendorRate(dc: DataConnect, vars: DeleteVendorRateVariables): MutationPromise; + +interface DeleteVendorRateRef { + ... + (dc: DataConnect, vars: DeleteVendorRateVariables): MutationRef; +} +export const deleteVendorRateRef: DeleteVendorRateRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteVendorRateRef: +```typescript +const name = deleteVendorRateRef.operationName; +console.log(name); +``` + +### Variables +The `DeleteVendorRate` mutation requires an argument of type `DeleteVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface DeleteVendorRateVariables { + id: UUIDString; +} +``` +### Return Type +Recall that executing the `DeleteVendorRate` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `DeleteVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface DeleteVendorRateData { + vendorRate_delete?: VendorRate_Key | null; +} +``` +### Using `DeleteVendorRate`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, deleteVendorRate, DeleteVendorRateVariables } from '@dataconnect/generated'; + +// The `DeleteVendorRate` mutation requires an argument of type `DeleteVendorRateVariables`: +const deleteVendorRateVars: DeleteVendorRateVariables = { + id: ..., +}; + +// Call the `deleteVendorRate()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await deleteVendorRate(deleteVendorRateVars); +// Variables can be defined inline as well. +const { data } = await deleteVendorRate({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await deleteVendorRate(dataConnect, deleteVendorRateVars); + +console.log(data.vendorRate_delete); + +// Or, you can use the `Promise` API. +deleteVendorRate(deleteVendorRateVars).then((response) => { + const data = response.data; + console.log(data.vendorRate_delete); +}); +``` + +### Using `DeleteVendorRate`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, deleteVendorRateRef, DeleteVendorRateVariables } from '@dataconnect/generated'; + +// The `DeleteVendorRate` mutation requires an argument of type `DeleteVendorRateVariables`: +const deleteVendorRateVars: DeleteVendorRateVariables = { + id: ..., +}; + +// Call the `deleteVendorRateRef()` function to get a reference to the mutation. +const ref = deleteVendorRateRef(deleteVendorRateVars); +// Variables can be defined inline as well. +const ref = deleteVendorRateRef({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = deleteVendorRateRef(dataConnect, deleteVendorRateVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendorRate_delete); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendorRate_delete); +}); +``` + +## CreateInvoice +You can execute the `CreateInvoice` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +createInvoice(vars: CreateInvoiceVariables): MutationPromise; + +interface CreateInvoiceRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateInvoiceVariables): MutationRef; +} +export const createInvoiceRef: CreateInvoiceRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +createInvoice(dc: DataConnect, vars: CreateInvoiceVariables): MutationPromise; + +interface CreateInvoiceRef { + ... + (dc: DataConnect, vars: CreateInvoiceVariables): MutationRef; +} +export const createInvoiceRef: CreateInvoiceRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createInvoiceRef: +```typescript +const name = createInvoiceRef.operationName; +console.log(name); +``` + +### Variables +The `CreateInvoice` mutation requires an argument of type `CreateInvoiceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface CreateInvoiceVariables { + invoiceNumber: string; + amount: number; + status: InvoiceStatus; + issueDate: TimestampString; + dueDate: TimestampString; + disputedItems?: string | null; + isAutoGenerated?: boolean | null; +} +``` +### Return Type +Recall that executing the `CreateInvoice` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `CreateInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface CreateInvoiceData { + invoice_insert: Invoice_Key; +} +``` +### Using `CreateInvoice`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, createInvoice, CreateInvoiceVariables } from '@dataconnect/generated'; + +// The `CreateInvoice` mutation requires an argument of type `CreateInvoiceVariables`: +const createInvoiceVars: CreateInvoiceVariables = { + invoiceNumber: ..., + amount: ..., + status: ..., + issueDate: ..., + dueDate: ..., + disputedItems: ..., // optional + isAutoGenerated: ..., // optional +}; + +// Call the `createInvoice()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await createInvoice(createInvoiceVars); +// Variables can be defined inline as well. +const { data } = await createInvoice({ invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await createInvoice(dataConnect, createInvoiceVars); + +console.log(data.invoice_insert); + +// Or, you can use the `Promise` API. +createInvoice(createInvoiceVars).then((response) => { + const data = response.data; + console.log(data.invoice_insert); +}); +``` + +### Using `CreateInvoice`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, createInvoiceRef, CreateInvoiceVariables } from '@dataconnect/generated'; + +// The `CreateInvoice` mutation requires an argument of type `CreateInvoiceVariables`: +const createInvoiceVars: CreateInvoiceVariables = { + invoiceNumber: ..., + amount: ..., + status: ..., + issueDate: ..., + dueDate: ..., + disputedItems: ..., // optional + isAutoGenerated: ..., // optional +}; + +// Call the `createInvoiceRef()` function to get a reference to the mutation. +const ref = createInvoiceRef(createInvoiceVars); +// Variables can be defined inline as well. +const ref = createInvoiceRef({ invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = createInvoiceRef(dataConnect, createInvoiceVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.invoice_insert); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.invoice_insert); +}); +``` + +## UpdateInvoice +You can execute the `UpdateInvoice` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +updateInvoice(vars: UpdateInvoiceVariables): MutationPromise; + +interface UpdateInvoiceRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateInvoiceVariables): MutationRef; +} +export const updateInvoiceRef: UpdateInvoiceRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +updateInvoice(dc: DataConnect, vars: UpdateInvoiceVariables): MutationPromise; + +interface UpdateInvoiceRef { + ... + (dc: DataConnect, vars: UpdateInvoiceVariables): MutationRef; +} +export const updateInvoiceRef: UpdateInvoiceRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateInvoiceRef: +```typescript +const name = updateInvoiceRef.operationName; +console.log(name); +``` + +### Variables +The `UpdateInvoice` mutation requires an argument of type `UpdateInvoiceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface UpdateInvoiceVariables { + id: UUIDString; + invoiceNumber?: string | null; + amount?: number | null; + status?: InvoiceStatus | null; + issueDate?: TimestampString | null; + dueDate?: TimestampString | null; + disputedItems?: string | null; + isAutoGenerated?: boolean | null; +} +``` +### Return Type +Recall that executing the `UpdateInvoice` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `UpdateInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface UpdateInvoiceData { + invoice_update?: Invoice_Key | null; +} +``` +### Using `UpdateInvoice`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, updateInvoice, UpdateInvoiceVariables } from '@dataconnect/generated'; + +// The `UpdateInvoice` mutation requires an argument of type `UpdateInvoiceVariables`: +const updateInvoiceVars: UpdateInvoiceVariables = { + id: ..., + invoiceNumber: ..., // optional + amount: ..., // optional + status: ..., // optional + issueDate: ..., // optional + dueDate: ..., // optional + disputedItems: ..., // optional + isAutoGenerated: ..., // optional +}; + +// Call the `updateInvoice()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await updateInvoice(updateInvoiceVars); +// Variables can be defined inline as well. +const { data } = await updateInvoice({ id: ..., invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await updateInvoice(dataConnect, updateInvoiceVars); + +console.log(data.invoice_update); + +// Or, you can use the `Promise` API. +updateInvoice(updateInvoiceVars).then((response) => { + const data = response.data; + console.log(data.invoice_update); +}); +``` + +### Using `UpdateInvoice`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, updateInvoiceRef, UpdateInvoiceVariables } from '@dataconnect/generated'; + +// The `UpdateInvoice` mutation requires an argument of type `UpdateInvoiceVariables`: +const updateInvoiceVars: UpdateInvoiceVariables = { + id: ..., + invoiceNumber: ..., // optional + amount: ..., // optional + status: ..., // optional + issueDate: ..., // optional + dueDate: ..., // optional + disputedItems: ..., // optional + isAutoGenerated: ..., // optional +}; + +// Call the `updateInvoiceRef()` function to get a reference to the mutation. +const ref = updateInvoiceRef(updateInvoiceVars); +// Variables can be defined inline as well. +const ref = updateInvoiceRef({ id: ..., invoiceNumber: ..., amount: ..., status: ..., issueDate: ..., dueDate: ..., disputedItems: ..., isAutoGenerated: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = updateInvoiceRef(dataConnect, updateInvoiceVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.invoice_update); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.invoice_update); +}); +``` + +## DeleteInvoice +You can execute the `DeleteInvoice` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +deleteInvoice(vars: DeleteInvoiceVariables): MutationPromise; + +interface DeleteInvoiceRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteInvoiceVariables): MutationRef; +} +export const deleteInvoiceRef: DeleteInvoiceRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +deleteInvoice(dc: DataConnect, vars: DeleteInvoiceVariables): MutationPromise; + +interface DeleteInvoiceRef { + ... + (dc: DataConnect, vars: DeleteInvoiceVariables): MutationRef; +} +export const deleteInvoiceRef: DeleteInvoiceRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteInvoiceRef: +```typescript +const name = deleteInvoiceRef.operationName; +console.log(name); +``` + +### Variables +The `DeleteInvoice` mutation requires an argument of type `DeleteInvoiceVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface DeleteInvoiceVariables { + id: UUIDString; +} +``` +### Return Type +Recall that executing the `DeleteInvoice` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `DeleteInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface DeleteInvoiceData { + invoice_delete?: Invoice_Key | null; +} +``` +### Using `DeleteInvoice`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, deleteInvoice, DeleteInvoiceVariables } from '@dataconnect/generated'; + +// The `DeleteInvoice` mutation requires an argument of type `DeleteInvoiceVariables`: +const deleteInvoiceVars: DeleteInvoiceVariables = { + id: ..., +}; + +// Call the `deleteInvoice()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await deleteInvoice(deleteInvoiceVars); +// Variables can be defined inline as well. +const { data } = await deleteInvoice({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await deleteInvoice(dataConnect, deleteInvoiceVars); + +console.log(data.invoice_delete); + +// Or, you can use the `Promise` API. +deleteInvoice(deleteInvoiceVars).then((response) => { + const data = response.data; + console.log(data.invoice_delete); +}); +``` + +### Using `DeleteInvoice`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, deleteInvoiceRef, DeleteInvoiceVariables } from '@dataconnect/generated'; + +// The `DeleteInvoice` mutation requires an argument of type `DeleteInvoiceVariables`: +const deleteInvoiceVars: DeleteInvoiceVariables = { + id: ..., +}; + +// Call the `deleteInvoiceRef()` function to get a reference to the mutation. +const ref = deleteInvoiceRef(deleteInvoiceVars); +// Variables can be defined inline as well. +const ref = deleteInvoiceRef({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = deleteInvoiceRef(dataConnect, deleteInvoiceVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.invoice_delete); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.invoice_delete); +}); +``` + +## CreateStaff +You can execute the `CreateStaff` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +createStaff(vars: CreateStaffVariables): MutationPromise; + +interface CreateStaffRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateStaffVariables): MutationRef; +} +export const createStaffRef: CreateStaffRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +createStaff(dc: DataConnect, vars: CreateStaffVariables): MutationPromise; + +interface CreateStaffRef { + ... + (dc: DataConnect, vars: CreateStaffVariables): MutationRef; +} +export const createStaffRef: CreateStaffRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createStaffRef: +```typescript +const name = createStaffRef.operationName; +console.log(name); +``` + +### Variables +The `CreateStaff` mutation requires an argument of type `CreateStaffVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface CreateStaffVariables { + employeeName: string; + vendorId?: UUIDString | null; + email?: string | null; + position?: string | null; + employmentType: EmploymentType; + rating?: number | null; + reliabilityScore?: number | null; + backgroundCheckStatus: BackgroundCheckStatus; + certifications?: string | null; +} +``` +### Return Type +Recall that executing the `CreateStaff` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `CreateStaffData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface CreateStaffData { + staff_insert: Staff_Key; +} +``` +### Using `CreateStaff`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, createStaff, CreateStaffVariables } from '@dataconnect/generated'; + +// The `CreateStaff` mutation requires an argument of type `CreateStaffVariables`: +const createStaffVars: CreateStaffVariables = { + employeeName: ..., + vendorId: ..., // optional + email: ..., // optional + position: ..., // optional + employmentType: ..., + rating: ..., // optional + reliabilityScore: ..., // optional + backgroundCheckStatus: ..., + certifications: ..., // 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: ..., email: ..., position: ..., employmentType: ..., rating: ..., reliabilityScore: ..., backgroundCheckStatus: ..., certifications: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await createStaff(dataConnect, createStaffVars); + +console.log(data.staff_insert); + +// Or, you can use the `Promise` API. +createStaff(createStaffVars).then((response) => { + const data = response.data; + console.log(data.staff_insert); +}); +``` + +### Using `CreateStaff`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, createStaffRef, CreateStaffVariables } from '@dataconnect/generated'; + +// The `CreateStaff` mutation requires an argument of type `CreateStaffVariables`: +const createStaffVars: CreateStaffVariables = { + employeeName: ..., + vendorId: ..., // optional + email: ..., // optional + position: ..., // optional + employmentType: ..., + rating: ..., // optional + reliabilityScore: ..., // optional + backgroundCheckStatus: ..., + certifications: ..., // 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: ..., email: ..., position: ..., employmentType: ..., rating: ..., reliabilityScore: ..., backgroundCheckStatus: ..., certifications: ..., }); + +// 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); +}); +``` + +## CreateVendor +You can execute the `CreateVendor` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +createVendor(vars: CreateVendorVariables): MutationPromise; + +interface CreateVendorRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateVendorVariables): MutationRef; +} +export const createVendorRef: CreateVendorRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +createVendor(dc: DataConnect, vars: CreateVendorVariables): MutationPromise; + +interface CreateVendorRef { + ... + (dc: DataConnect, vars: CreateVendorVariables): MutationRef; +} +export const createVendorRef: CreateVendorRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createVendorRef: +```typescript +const name = createVendorRef.operationName; +console.log(name); +``` + +### Variables +The `CreateVendor` mutation requires an argument of type `CreateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface CreateVendorVariables { + vendorNumber: string; + legalName: string; + region: VendorRegion; + platformType: VendorPlatformType; + primaryContactEmail: string; + approvalStatus: VendorApprovalStatus; + isActive?: boolean | null; +} +``` +### Return Type +Recall that executing the `CreateVendor` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `CreateVendorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface CreateVendorData { + vendor_insert: Vendor_Key; +} +``` +### Using `CreateVendor`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, createVendor, CreateVendorVariables } from '@dataconnect/generated'; + +// The `CreateVendor` mutation requires an argument of type `CreateVendorVariables`: +const createVendorVars: CreateVendorVariables = { + vendorNumber: ..., + legalName: ..., + region: ..., + platformType: ..., + primaryContactEmail: ..., + approvalStatus: ..., + isActive: ..., // optional +}; + +// Call the `createVendor()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await createVendor(createVendorVars); +// Variables can be defined inline as well. +const { data } = await createVendor({ vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await createVendor(dataConnect, createVendorVars); + +console.log(data.vendor_insert); + +// Or, you can use the `Promise` API. +createVendor(createVendorVars).then((response) => { + const data = response.data; + console.log(data.vendor_insert); +}); +``` + +### Using `CreateVendor`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, createVendorRef, CreateVendorVariables } from '@dataconnect/generated'; + +// The `CreateVendor` mutation requires an argument of type `CreateVendorVariables`: +const createVendorVars: CreateVendorVariables = { + vendorNumber: ..., + legalName: ..., + region: ..., + platformType: ..., + primaryContactEmail: ..., + approvalStatus: ..., + isActive: ..., // optional +}; + +// Call the `createVendorRef()` function to get a reference to the mutation. +const ref = createVendorRef(createVendorVars); +// Variables can be defined inline as well. +const ref = createVendorRef({ vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = createVendorRef(dataConnect, createVendorVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendor_insert); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendor_insert); +}); +``` + +## UpdateVendor +You can execute the `UpdateVendor` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +updateVendor(vars: UpdateVendorVariables): MutationPromise; + +interface UpdateVendorRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateVendorVariables): MutationRef; +} +export const updateVendorRef: UpdateVendorRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +updateVendor(dc: DataConnect, vars: UpdateVendorVariables): MutationPromise; + +interface UpdateVendorRef { + ... + (dc: DataConnect, vars: UpdateVendorVariables): MutationRef; +} +export const updateVendorRef: UpdateVendorRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateVendorRef: +```typescript +const name = updateVendorRef.operationName; +console.log(name); +``` + +### Variables +The `UpdateVendor` mutation requires an argument of type `UpdateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface UpdateVendorVariables { + id: UUIDString; + vendorNumber?: string | null; + legalName?: string | null; + region?: VendorRegion | null; + platformType?: VendorPlatformType | null; + primaryContactEmail?: string | null; + approvalStatus?: VendorApprovalStatus | null; + isActive?: boolean | null; +} +``` +### Return Type +Recall that executing the `UpdateVendor` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `UpdateVendorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface UpdateVendorData { + vendor_update?: Vendor_Key | null; +} +``` +### Using `UpdateVendor`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, updateVendor, UpdateVendorVariables } from '@dataconnect/generated'; + +// The `UpdateVendor` mutation requires an argument of type `UpdateVendorVariables`: +const updateVendorVars: UpdateVendorVariables = { + id: ..., + vendorNumber: ..., // optional + legalName: ..., // optional + region: ..., // optional + platformType: ..., // optional + primaryContactEmail: ..., // optional + approvalStatus: ..., // optional + isActive: ..., // optional +}; + +// Call the `updateVendor()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await updateVendor(updateVendorVars); +// Variables can be defined inline as well. +const { data } = await updateVendor({ id: ..., vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await updateVendor(dataConnect, updateVendorVars); + +console.log(data.vendor_update); + +// Or, you can use the `Promise` API. +updateVendor(updateVendorVars).then((response) => { + const data = response.data; + console.log(data.vendor_update); +}); +``` + +### Using `UpdateVendor`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, updateVendorRef, UpdateVendorVariables } from '@dataconnect/generated'; + +// The `UpdateVendor` mutation requires an argument of type `UpdateVendorVariables`: +const updateVendorVars: UpdateVendorVariables = { + id: ..., + vendorNumber: ..., // optional + legalName: ..., // optional + region: ..., // optional + platformType: ..., // optional + primaryContactEmail: ..., // optional + approvalStatus: ..., // optional + isActive: ..., // optional +}; + +// Call the `updateVendorRef()` function to get a reference to the mutation. +const ref = updateVendorRef(updateVendorVars); +// Variables can be defined inline as well. +const ref = updateVendorRef({ id: ..., vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = updateVendorRef(dataConnect, updateVendorVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendor_update); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendor_update); +}); +``` + +## DeleteVendor +You can execute the `DeleteVendor` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +deleteVendor(vars: DeleteVendorVariables): MutationPromise; + +interface DeleteVendorRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteVendorVariables): MutationRef; +} +export const deleteVendorRef: DeleteVendorRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +deleteVendor(dc: DataConnect, vars: DeleteVendorVariables): MutationPromise; + +interface DeleteVendorRef { + ... + (dc: DataConnect, vars: DeleteVendorVariables): MutationRef; +} +export const deleteVendorRef: DeleteVendorRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteVendorRef: +```typescript +const name = deleteVendorRef.operationName; +console.log(name); +``` + +### Variables +The `DeleteVendor` mutation requires an argument of type `DeleteVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface DeleteVendorVariables { + id: UUIDString; +} +``` +### Return Type +Recall that executing the `DeleteVendor` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `DeleteVendorData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface DeleteVendorData { + vendor_delete?: Vendor_Key | null; +} +``` +### Using `DeleteVendor`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, deleteVendor, DeleteVendorVariables } from '@dataconnect/generated'; + +// The `DeleteVendor` mutation requires an argument of type `DeleteVendorVariables`: +const deleteVendorVars: DeleteVendorVariables = { + id: ..., +}; + +// Call the `deleteVendor()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await deleteVendor(deleteVendorVars); +// Variables can be defined inline as well. +const { data } = await deleteVendor({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await deleteVendor(dataConnect, deleteVendorVars); + +console.log(data.vendor_delete); + +// Or, you can use the `Promise` API. +deleteVendor(deleteVendorVars).then((response) => { + const data = response.data; + console.log(data.vendor_delete); +}); +``` + +### Using `DeleteVendor`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, deleteVendorRef, DeleteVendorVariables } from '@dataconnect/generated'; + +// The `DeleteVendor` mutation requires an argument of type `DeleteVendorVariables`: +const deleteVendorVars: DeleteVendorVariables = { + id: ..., +}; + +// Call the `deleteVendorRef()` function to get a reference to the mutation. +const ref = deleteVendorRef(deleteVendorVars); +// Variables can be defined inline as well. +const ref = deleteVendorRef({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = deleteVendorRef(dataConnect, deleteVendorVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendor_delete); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendor_delete); +}); +``` + +## CreateVendorDefaultSetting +You can execute the `CreateVendorDefaultSetting` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +createVendorDefaultSetting(vars: CreateVendorDefaultSettingVariables): MutationPromise; + +interface CreateVendorDefaultSettingRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateVendorDefaultSettingVariables): MutationRef; +} +export const createVendorDefaultSettingRef: CreateVendorDefaultSettingRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +createVendorDefaultSetting(dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationPromise; + +interface CreateVendorDefaultSettingRef { + ... + (dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationRef; +} +export const createVendorDefaultSettingRef: CreateVendorDefaultSettingRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createVendorDefaultSettingRef: +```typescript +const name = createVendorDefaultSettingRef.operationName; +console.log(name); +``` + +### Variables +The `CreateVendorDefaultSetting` mutation requires an argument of type `CreateVendorDefaultSettingVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface CreateVendorDefaultSettingVariables { + vendorName: string; + defaultMarkupPercentage: number; + defaultVendorFeePercentage: number; +} +``` +### Return Type +Recall that executing the `CreateVendorDefaultSetting` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `CreateVendorDefaultSettingData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface CreateVendorDefaultSettingData { + vendorDefaultSetting_insert: VendorDefaultSetting_Key; +} +``` +### Using `CreateVendorDefaultSetting`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, createVendorDefaultSetting, CreateVendorDefaultSettingVariables } from '@dataconnect/generated'; + +// The `CreateVendorDefaultSetting` mutation requires an argument of type `CreateVendorDefaultSettingVariables`: +const createVendorDefaultSettingVars: CreateVendorDefaultSettingVariables = { + vendorName: ..., + defaultMarkupPercentage: ..., + defaultVendorFeePercentage: ..., +}; + +// Call the `createVendorDefaultSetting()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await createVendorDefaultSetting(createVendorDefaultSettingVars); +// Variables can be defined inline as well. +const { data } = await createVendorDefaultSetting({ vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await createVendorDefaultSetting(dataConnect, createVendorDefaultSettingVars); + +console.log(data.vendorDefaultSetting_insert); + +// Or, you can use the `Promise` API. +createVendorDefaultSetting(createVendorDefaultSettingVars).then((response) => { + const data = response.data; + console.log(data.vendorDefaultSetting_insert); +}); +``` + +### Using `CreateVendorDefaultSetting`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, createVendorDefaultSettingRef, CreateVendorDefaultSettingVariables } from '@dataconnect/generated'; + +// The `CreateVendorDefaultSetting` mutation requires an argument of type `CreateVendorDefaultSettingVariables`: +const createVendorDefaultSettingVars: CreateVendorDefaultSettingVariables = { + vendorName: ..., + defaultMarkupPercentage: ..., + defaultVendorFeePercentage: ..., +}; + +// Call the `createVendorDefaultSettingRef()` function to get a reference to the mutation. +const ref = createVendorDefaultSettingRef(createVendorDefaultSettingVars); +// Variables can be defined inline as well. +const ref = createVendorDefaultSettingRef({ vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = createVendorDefaultSettingRef(dataConnect, createVendorDefaultSettingVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendorDefaultSetting_insert); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendorDefaultSetting_insert); +}); +``` + +## UpdateVendorDefaultSetting +You can execute the `UpdateVendorDefaultSetting` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +updateVendorDefaultSetting(vars: UpdateVendorDefaultSettingVariables): MutationPromise; + +interface UpdateVendorDefaultSettingRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateVendorDefaultSettingVariables): MutationRef; +} +export const updateVendorDefaultSettingRef: UpdateVendorDefaultSettingRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +updateVendorDefaultSetting(dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationPromise; + +interface UpdateVendorDefaultSettingRef { + ... + (dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationRef; +} +export const updateVendorDefaultSettingRef: UpdateVendorDefaultSettingRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateVendorDefaultSettingRef: +```typescript +const name = updateVendorDefaultSettingRef.operationName; +console.log(name); +``` + +### Variables +The `UpdateVendorDefaultSetting` mutation requires an argument of type `UpdateVendorDefaultSettingVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface UpdateVendorDefaultSettingVariables { + id: UUIDString; + vendorName?: string | null; + defaultMarkupPercentage?: number | null; + defaultVendorFeePercentage?: number | null; +} +``` +### Return Type +Recall that executing the `UpdateVendorDefaultSetting` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `UpdateVendorDefaultSettingData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface UpdateVendorDefaultSettingData { + vendorDefaultSetting_update?: VendorDefaultSetting_Key | null; +} +``` +### Using `UpdateVendorDefaultSetting`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, updateVendorDefaultSetting, UpdateVendorDefaultSettingVariables } from '@dataconnect/generated'; + +// The `UpdateVendorDefaultSetting` mutation requires an argument of type `UpdateVendorDefaultSettingVariables`: +const updateVendorDefaultSettingVars: UpdateVendorDefaultSettingVariables = { + id: ..., + vendorName: ..., // optional + defaultMarkupPercentage: ..., // optional + defaultVendorFeePercentage: ..., // optional +}; + +// Call the `updateVendorDefaultSetting()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await updateVendorDefaultSetting(updateVendorDefaultSettingVars); +// Variables can be defined inline as well. +const { data } = await updateVendorDefaultSetting({ id: ..., vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await updateVendorDefaultSetting(dataConnect, updateVendorDefaultSettingVars); + +console.log(data.vendorDefaultSetting_update); + +// Or, you can use the `Promise` API. +updateVendorDefaultSetting(updateVendorDefaultSettingVars).then((response) => { + const data = response.data; + console.log(data.vendorDefaultSetting_update); +}); +``` + +### Using `UpdateVendorDefaultSetting`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, updateVendorDefaultSettingRef, UpdateVendorDefaultSettingVariables } from '@dataconnect/generated'; + +// The `UpdateVendorDefaultSetting` mutation requires an argument of type `UpdateVendorDefaultSettingVariables`: +const updateVendorDefaultSettingVars: UpdateVendorDefaultSettingVariables = { + id: ..., + vendorName: ..., // optional + defaultMarkupPercentage: ..., // optional + defaultVendorFeePercentage: ..., // optional +}; + +// Call the `updateVendorDefaultSettingRef()` function to get a reference to the mutation. +const ref = updateVendorDefaultSettingRef(updateVendorDefaultSettingVars); +// Variables can be defined inline as well. +const ref = updateVendorDefaultSettingRef({ id: ..., vendorName: ..., defaultMarkupPercentage: ..., defaultVendorFeePercentage: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = updateVendorDefaultSettingRef(dataConnect, updateVendorDefaultSettingVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendorDefaultSetting_update); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendorDefaultSetting_update); +}); +``` + +## DeleteVendorDefaultSetting +You can execute the `DeleteVendorDefaultSetting` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +deleteVendorDefaultSetting(vars: DeleteVendorDefaultSettingVariables): MutationPromise; + +interface DeleteVendorDefaultSettingRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteVendorDefaultSettingVariables): MutationRef; +} +export const deleteVendorDefaultSettingRef: DeleteVendorDefaultSettingRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +deleteVendorDefaultSetting(dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationPromise; + +interface DeleteVendorDefaultSettingRef { + ... + (dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationRef; +} +export const deleteVendorDefaultSettingRef: DeleteVendorDefaultSettingRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteVendorDefaultSettingRef: +```typescript +const name = deleteVendorDefaultSettingRef.operationName; +console.log(name); +``` + +### Variables +The `DeleteVendorDefaultSetting` mutation requires an argument of type `DeleteVendorDefaultSettingVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface DeleteVendorDefaultSettingVariables { + id: UUIDString; +} +``` +### Return Type +Recall that executing the `DeleteVendorDefaultSetting` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `DeleteVendorDefaultSettingData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface DeleteVendorDefaultSettingData { + vendorDefaultSetting_delete?: VendorDefaultSetting_Key | null; +} +``` +### Using `DeleteVendorDefaultSetting`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, deleteVendorDefaultSetting, DeleteVendorDefaultSettingVariables } from '@dataconnect/generated'; + +// The `DeleteVendorDefaultSetting` mutation requires an argument of type `DeleteVendorDefaultSettingVariables`: +const deleteVendorDefaultSettingVars: DeleteVendorDefaultSettingVariables = { + id: ..., +}; + +// Call the `deleteVendorDefaultSetting()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await deleteVendorDefaultSetting(deleteVendorDefaultSettingVars); +// Variables can be defined inline as well. +const { data } = await deleteVendorDefaultSetting({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await deleteVendorDefaultSetting(dataConnect, deleteVendorDefaultSettingVars); + +console.log(data.vendorDefaultSetting_delete); + +// Or, you can use the `Promise` API. +deleteVendorDefaultSetting(deleteVendorDefaultSettingVars).then((response) => { + const data = response.data; + console.log(data.vendorDefaultSetting_delete); +}); +``` + +### Using `DeleteVendorDefaultSetting`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, deleteVendorDefaultSettingRef, DeleteVendorDefaultSettingVariables } from '@dataconnect/generated'; + +// The `DeleteVendorDefaultSetting` mutation requires an argument of type `DeleteVendorDefaultSettingVariables`: +const deleteVendorDefaultSettingVars: DeleteVendorDefaultSettingVariables = { + id: ..., +}; + +// Call the `deleteVendorDefaultSettingRef()` function to get a reference to the mutation. +const ref = deleteVendorDefaultSettingRef(deleteVendorDefaultSettingVars); +// Variables can be defined inline as well. +const ref = deleteVendorDefaultSettingRef({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = deleteVendorDefaultSettingRef(dataConnect, deleteVendorDefaultSettingVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.vendorDefaultSetting_delete); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.vendorDefaultSetting_delete); +}); +``` + +## CreateBusiness +You can execute the `CreateBusiness` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +createBusiness(vars: CreateBusinessVariables): MutationPromise; + +interface CreateBusinessRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateBusinessVariables): MutationRef; +} +export const createBusinessRef: CreateBusinessRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +createBusiness(dc: DataConnect, vars: CreateBusinessVariables): MutationPromise; + +interface CreateBusinessRef { + ... + (dc: DataConnect, vars: CreateBusinessVariables): MutationRef; +} +export const createBusinessRef: CreateBusinessRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the createBusinessRef: +```typescript +const name = createBusinessRef.operationName; +console.log(name); +``` + +### Variables +The `CreateBusiness` mutation requires an argument of type `CreateBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface CreateBusinessVariables { + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; +} +``` +### Return Type +Recall that executing the `CreateBusiness` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `CreateBusinessData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface CreateBusinessData { + business_insert: Business_Key; +} +``` +### Using `CreateBusiness`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, createBusiness, CreateBusinessVariables } from '@dataconnect/generated'; + +// The `CreateBusiness` mutation requires an argument of type `CreateBusinessVariables`: +const createBusinessVars: CreateBusinessVariables = { + businessName: ..., + contactName: ..., + email: ..., // optional + sector: ..., // optional + rateGroup: ..., + status: ..., // optional +}; + +// Call the `createBusiness()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await createBusiness(createBusinessVars); +// Variables can be defined inline as well. +const { data } = await createBusiness({ businessName: ..., contactName: ..., email: ..., sector: ..., rateGroup: ..., status: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await createBusiness(dataConnect, createBusinessVars); + +console.log(data.business_insert); + +// Or, you can use the `Promise` API. +createBusiness(createBusinessVars).then((response) => { + const data = response.data; + console.log(data.business_insert); +}); +``` + +### Using `CreateBusiness`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, createBusinessRef, CreateBusinessVariables } from '@dataconnect/generated'; + +// The `CreateBusiness` mutation requires an argument of type `CreateBusinessVariables`: +const createBusinessVars: CreateBusinessVariables = { + businessName: ..., + contactName: ..., + email: ..., // optional + sector: ..., // optional + rateGroup: ..., + status: ..., // optional +}; + +// Call the `createBusinessRef()` function to get a reference to the mutation. +const ref = createBusinessRef(createBusinessVars); +// Variables can be defined inline as well. +const ref = createBusinessRef({ businessName: ..., contactName: ..., email: ..., sector: ..., rateGroup: ..., status: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = createBusinessRef(dataConnect, createBusinessVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.business_insert); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.business_insert); +}); +``` + +## UpdateBusiness +You can execute the `UpdateBusiness` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +updateBusiness(vars: UpdateBusinessVariables): MutationPromise; + +interface UpdateBusinessRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateBusinessVariables): MutationRef; +} +export const updateBusinessRef: UpdateBusinessRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +updateBusiness(dc: DataConnect, vars: UpdateBusinessVariables): MutationPromise; + +interface UpdateBusinessRef { + ... + (dc: DataConnect, vars: UpdateBusinessVariables): MutationRef; +} +export const updateBusinessRef: UpdateBusinessRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the updateBusinessRef: +```typescript +const name = updateBusinessRef.operationName; +console.log(name); +``` + +### Variables +The `UpdateBusiness` mutation requires an argument of type `UpdateBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface UpdateBusinessVariables { + id: UUIDString; + businessName?: string | null; + contactName?: string | null; + email?: string | null; + sector?: BusinessSector | null; + rateGroup?: BusinessRateGroup | null; + status?: BusinessStatus | null; +} +``` +### Return Type +Recall that executing the `UpdateBusiness` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `UpdateBusinessData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface UpdateBusinessData { + business_update?: Business_Key | null; +} +``` +### Using `UpdateBusiness`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, updateBusiness, UpdateBusinessVariables } from '@dataconnect/generated'; + +// The `UpdateBusiness` mutation requires an argument of type `UpdateBusinessVariables`: +const updateBusinessVars: UpdateBusinessVariables = { + id: ..., + businessName: ..., // optional + contactName: ..., // optional + email: ..., // optional + sector: ..., // optional + rateGroup: ..., // optional + status: ..., // optional +}; + +// Call the `updateBusiness()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await updateBusiness(updateBusinessVars); +// Variables can be defined inline as well. +const { data } = await updateBusiness({ id: ..., businessName: ..., contactName: ..., email: ..., sector: ..., rateGroup: ..., status: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await updateBusiness(dataConnect, updateBusinessVars); + +console.log(data.business_update); + +// Or, you can use the `Promise` API. +updateBusiness(updateBusinessVars).then((response) => { + const data = response.data; + console.log(data.business_update); +}); +``` + +### Using `UpdateBusiness`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, updateBusinessRef, UpdateBusinessVariables } from '@dataconnect/generated'; + +// The `UpdateBusiness` mutation requires an argument of type `UpdateBusinessVariables`: +const updateBusinessVars: UpdateBusinessVariables = { + id: ..., + businessName: ..., // optional + contactName: ..., // optional + email: ..., // optional + sector: ..., // optional + rateGroup: ..., // optional + status: ..., // optional +}; + +// Call the `updateBusinessRef()` function to get a reference to the mutation. +const ref = updateBusinessRef(updateBusinessVars); +// Variables can be defined inline as well. +const ref = updateBusinessRef({ id: ..., businessName: ..., contactName: ..., email: ..., sector: ..., rateGroup: ..., status: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = updateBusinessRef(dataConnect, updateBusinessVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.business_update); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.business_update); +}); +``` + +## DeleteBusiness +You can execute the `DeleteBusiness` mutation using the following action shortcut function, or by calling `executeMutation()` after calling the following `MutationRef` function, both of which are defined in [dataconnect-generated/index.d.ts](./index.d.ts): +```typescript +deleteBusiness(vars: DeleteBusinessVariables): MutationPromise; + +interface DeleteBusinessRef { + ... + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteBusinessVariables): MutationRef; +} +export const deleteBusinessRef: DeleteBusinessRef; +``` +You can also pass in a `DataConnect` instance to the action shortcut function or `MutationRef` function. +```typescript +deleteBusiness(dc: DataConnect, vars: DeleteBusinessVariables): MutationPromise; + +interface DeleteBusinessRef { + ... + (dc: DataConnect, vars: DeleteBusinessVariables): MutationRef; +} +export const deleteBusinessRef: DeleteBusinessRef; +``` + +If you need the name of the operation without creating a ref, you can retrieve the operation name by calling the `operationName` property on the deleteBusinessRef: +```typescript +const name = deleteBusinessRef.operationName; +console.log(name); +``` + +### Variables +The `DeleteBusiness` mutation requires an argument of type `DeleteBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: + +```typescript +export interface DeleteBusinessVariables { + id: UUIDString; +} +``` +### Return Type +Recall that executing the `DeleteBusiness` mutation returns a `MutationPromise` that resolves to an object with a `data` property. + +The `data` property is an object of type `DeleteBusinessData`, which is defined in [dataconnect-generated/index.d.ts](./index.d.ts). It has the following fields: +```typescript +export interface DeleteBusinessData { + business_delete?: Business_Key | null; +} +``` +### Using `DeleteBusiness`'s action shortcut function + +```typescript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, deleteBusiness, DeleteBusinessVariables } from '@dataconnect/generated'; + +// The `DeleteBusiness` mutation requires an argument of type `DeleteBusinessVariables`: +const deleteBusinessVars: DeleteBusinessVariables = { + id: ..., +}; + +// Call the `deleteBusiness()` function to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await deleteBusiness(deleteBusinessVars); +// Variables can be defined inline as well. +const { data } = await deleteBusiness({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the action shortcut function. +const dataConnect = getDataConnect(connectorConfig); +const { data } = await deleteBusiness(dataConnect, deleteBusinessVars); + +console.log(data.business_delete); + +// Or, you can use the `Promise` API. +deleteBusiness(deleteBusinessVars).then((response) => { + const data = response.data; + console.log(data.business_delete); +}); +``` + +### Using `DeleteBusiness`'s `MutationRef` function + +```typescript +import { getDataConnect, executeMutation } from 'firebase/data-connect'; +import { connectorConfig, deleteBusinessRef, DeleteBusinessVariables } from '@dataconnect/generated'; + +// The `DeleteBusiness` mutation requires an argument of type `DeleteBusinessVariables`: +const deleteBusinessVars: DeleteBusinessVariables = { + id: ..., +}; + +// Call the `deleteBusinessRef()` function to get a reference to the mutation. +const ref = deleteBusinessRef(deleteBusinessVars); +// Variables can be defined inline as well. +const ref = deleteBusinessRef({ id: ..., }); + +// You can also pass in a `DataConnect` instance to the `MutationRef` function. +const dataConnect = getDataConnect(connectorConfig); +const ref = deleteBusinessRef(dataConnect, deleteBusinessVars); + +// Call `executeMutation()` on the reference to execute the mutation. +// You can use the `await` keyword to wait for the promise to resolve. +const { data } = await executeMutation(ref); + +console.log(data.business_delete); + +// Or, you can use the `Promise` API. +executeMutation(ref).then((response) => { + const data = response.data; + console.log(data.business_delete); +}); +``` + diff --git a/internal-api-harness/src/dataconnect-generated/esm/index.esm.js b/internal-api-harness/src/dataconnect-generated/esm/index.esm.js index a70452f4..19fba0a5 100644 --- a/internal-api-harness/src/dataconnect-generated/esm/index.esm.js +++ b/internal-api-harness/src/dataconnect-generated/esm/index.esm.js @@ -7,6 +7,28 @@ export const BackgroundCheckStatus = { EXPIRED: "EXPIRED", } +export const BusinessRateGroup = { + STANDARD: "STANDARD", + PREMIUM: "PREMIUM", + ENTERPRISE: "ENTERPRISE", + CUSTOM: "CUSTOM", +} + +export const BusinessSector = { + BON_APPETIT: "BON_APPETIT", + EUREST: "EUREST", + ARAMARK: "ARAMARK", + EPICUREAN_GROUP: "EPICUREAN_GROUP", + CHARTWELLS: "CHARTWELLS", + OTHER: "OTHER", +} + +export const BusinessStatus = { + ACTIVE: "ACTIVE", + INACTIVE: "INACTIVE", + PENDING: "PENDING", +} + export const ContractType = { W2: "W2", C1099: "C1099", @@ -93,48 +115,70 @@ export const connectorConfig = { location: 'us-central1' }; -export const listStaffRef = (dc) => { +export const listBusinessRef = (dc) => { const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'listStaff'); + return queryRef(dcInstance, 'listBusiness'); } -listStaffRef.operationName = 'listStaff'; +listBusinessRef.operationName = 'listBusiness'; -export function listStaff(dc) { - return executeQuery(listStaffRef(dc)); +export function listBusiness(dc) { + return executeQuery(listBusinessRef(dc)); } -export const createVendorRef = (dcOrVars, vars) => { +export const getBusinessByIdRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateVendor', inputVars); + return queryRef(dcInstance, 'getBusinessById', inputVars); } -createVendorRef.operationName = 'CreateVendor'; +getBusinessByIdRef.operationName = 'getBusinessById'; -export function createVendor(dcOrVars, vars) { - return executeMutation(createVendorRef(dcOrVars, vars)); +export function getBusinessById(dcOrVars, vars) { + return executeQuery(getBusinessByIdRef(dcOrVars, vars)); } -export const updateVendorRef = (dcOrVars, vars) => { +export const filterBusinessRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'filterBusiness', inputVars); +} +filterBusinessRef.operationName = 'filterBusiness'; + +export function filterBusiness(dcOrVars, vars) { + return executeQuery(filterBusinessRef(dcOrVars, vars)); +} + +export const createEventRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'UpdateVendor', inputVars); + return mutationRef(dcInstance, 'CreateEvent', inputVars); } -updateVendorRef.operationName = 'UpdateVendor'; +createEventRef.operationName = 'CreateEvent'; -export function updateVendor(dcOrVars, vars) { - return executeMutation(updateVendorRef(dcOrVars, vars)); +export function createEvent(dcOrVars, vars) { + return executeMutation(createEventRef(dcOrVars, vars)); } -export const deleteVendorRef = (dcOrVars, vars) => { +export const updateEventRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'DeleteVendor', inputVars); + return mutationRef(dcInstance, 'UpdateEvent', inputVars); } -deleteVendorRef.operationName = 'DeleteVendor'; +updateEventRef.operationName = 'UpdateEvent'; -export function deleteVendor(dcOrVars, vars) { - return executeMutation(deleteVendorRef(dcOrVars, vars)); +export function updateEvent(dcOrVars, vars) { + return executeMutation(updateEventRef(dcOrVars, vars)); +} + +export const deleteEventRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteEvent', inputVars); +} +deleteEventRef.operationName = 'DeleteEvent'; + +export function deleteEvent(dcOrVars, vars) { + return executeMutation(deleteEventRef(dcOrVars, vars)); } export const listVendorDefaultSettingsRef = (dc) => { @@ -170,149 +214,6 @@ export function filterVendorDefaultSettings(dcOrVars, vars) { return executeQuery(filterVendorDefaultSettingsRef(dcOrVars, vars)); } -export const listEventsRef = (dc) => { - const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'listEvents'); -} -listEventsRef.operationName = 'listEvents'; - -export function listEvents(dc) { - return executeQuery(listEventsRef(dc)); -} - -export const getEventByIdRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'getEventById', inputVars); -} -getEventByIdRef.operationName = 'getEventById'; - -export function getEventById(dcOrVars, vars) { - return executeQuery(getEventByIdRef(dcOrVars, vars)); -} - -export const filterEventsRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'filterEvents', inputVars); -} -filterEventsRef.operationName = 'filterEvents'; - -export function filterEvents(dcOrVars, vars) { - return executeQuery(filterEventsRef(dcOrVars, vars)); -} - -export const createInvoiceRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateInvoice', inputVars); -} -createInvoiceRef.operationName = 'CreateInvoice'; - -export function createInvoice(dcOrVars, vars) { - return executeMutation(createInvoiceRef(dcOrVars, vars)); -} - -export const updateInvoiceRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'UpdateInvoice', inputVars); -} -updateInvoiceRef.operationName = 'UpdateInvoice'; - -export function updateInvoice(dcOrVars, vars) { - return executeMutation(updateInvoiceRef(dcOrVars, vars)); -} - -export const deleteInvoiceRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'DeleteInvoice', inputVars); -} -deleteInvoiceRef.operationName = 'DeleteInvoice'; - -export function deleteInvoice(dcOrVars, vars) { - return executeMutation(deleteInvoiceRef(dcOrVars, vars)); -} - -export const createStaffRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateStaff', inputVars); -} -createStaffRef.operationName = 'CreateStaff'; - -export function createStaff(dcOrVars, vars) { - return executeMutation(createStaffRef(dcOrVars, vars)); -} - -export const listVendorRef = (dc) => { - const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'listVendor'); -} -listVendorRef.operationName = 'listVendor'; - -export function listVendor(dc) { - return executeQuery(listVendorRef(dc)); -} - -export const getVendorByIdRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'getVendorById', inputVars); -} -getVendorByIdRef.operationName = 'getVendorById'; - -export function getVendorById(dcOrVars, vars) { - return executeQuery(getVendorByIdRef(dcOrVars, vars)); -} - -export const filterVendorsRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'filterVendors', inputVars); -} -filterVendorsRef.operationName = 'filterVendors'; - -export function filterVendors(dcOrVars, vars) { - return executeQuery(filterVendorsRef(dcOrVars, vars)); -} - -export const createVendorDefaultSettingRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateVendorDefaultSetting', inputVars); -} -createVendorDefaultSettingRef.operationName = 'CreateVendorDefaultSetting'; - -export function createVendorDefaultSetting(dcOrVars, vars) { - return executeMutation(createVendorDefaultSettingRef(dcOrVars, vars)); -} - -export const updateVendorDefaultSettingRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'UpdateVendorDefaultSetting', inputVars); -} -updateVendorDefaultSettingRef.operationName = 'UpdateVendorDefaultSetting'; - -export function updateVendorDefaultSetting(dcOrVars, vars) { - return executeMutation(updateVendorDefaultSettingRef(dcOrVars, vars)); -} - -export const deleteVendorDefaultSettingRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'DeleteVendorDefaultSetting', inputVars); -} -deleteVendorDefaultSettingRef.operationName = 'DeleteVendorDefaultSetting'; - -export function deleteVendorDefaultSetting(dcOrVars, vars) { - return executeMutation(deleteVendorDefaultSettingRef(dcOrVars, vars)); -} - export const createVendorRateRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); @@ -379,37 +280,70 @@ export function filterVendorRates(dcOrVars, vars) { return executeQuery(filterVendorRatesRef(dcOrVars, vars)); } -export const createEventRef = (dcOrVars, vars) => { +export const listEventsRef = (dc) => { + const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'listEvents'); +} +listEventsRef.operationName = 'listEvents'; + +export function listEvents(dc) { + return executeQuery(listEventsRef(dc)); +} + +export const getEventByIdRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateEvent', inputVars); + return queryRef(dcInstance, 'getEventById', inputVars); } -createEventRef.operationName = 'CreateEvent'; +getEventByIdRef.operationName = 'getEventById'; -export function createEvent(dcOrVars, vars) { - return executeMutation(createEventRef(dcOrVars, vars)); +export function getEventById(dcOrVars, vars) { + return executeQuery(getEventByIdRef(dcOrVars, vars)); } -export const updateEventRef = (dcOrVars, vars) => { +export const filterEventsRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'filterEvents', inputVars); +} +filterEventsRef.operationName = 'filterEvents'; + +export function filterEvents(dcOrVars, vars) { + return executeQuery(filterEventsRef(dcOrVars, vars)); +} + +export const createInvoiceRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'UpdateEvent', inputVars); + return mutationRef(dcInstance, 'CreateInvoice', inputVars); } -updateEventRef.operationName = 'UpdateEvent'; +createInvoiceRef.operationName = 'CreateInvoice'; -export function updateEvent(dcOrVars, vars) { - return executeMutation(updateEventRef(dcOrVars, vars)); +export function createInvoice(dcOrVars, vars) { + return executeMutation(createInvoiceRef(dcOrVars, vars)); } -export const deleteEventRef = (dcOrVars, vars) => { +export const updateInvoiceRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'DeleteEvent', inputVars); + return mutationRef(dcInstance, 'UpdateInvoice', inputVars); } -deleteEventRef.operationName = 'DeleteEvent'; +updateInvoiceRef.operationName = 'UpdateInvoice'; -export function deleteEvent(dcOrVars, vars) { - return executeMutation(deleteEventRef(dcOrVars, vars)); +export function updateInvoice(dcOrVars, vars) { + return executeMutation(updateInvoiceRef(dcOrVars, vars)); +} + +export const deleteInvoiceRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteInvoice', inputVars); +} +deleteInvoiceRef.operationName = 'DeleteInvoice'; + +export function deleteInvoice(dcOrVars, vars) { + return executeMutation(deleteInvoiceRef(dcOrVars, vars)); } export const listInvoiceRef = (dc) => { @@ -445,3 +379,157 @@ export function filterInvoices(dcOrVars, vars) { return executeQuery(filterInvoicesRef(dcOrVars, vars)); } +export const createStaffRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'CreateStaff', inputVars); +} +createStaffRef.operationName = 'CreateStaff'; + +export function createStaff(dcOrVars, vars) { + return executeMutation(createStaffRef(dcOrVars, vars)); +} + +export const listStaffRef = (dc) => { + const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'listStaff'); +} +listStaffRef.operationName = 'listStaff'; + +export function listStaff(dc) { + return executeQuery(listStaffRef(dc)); +} + +export const createVendorRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'CreateVendor', inputVars); +} +createVendorRef.operationName = 'CreateVendor'; + +export function createVendor(dcOrVars, vars) { + return executeMutation(createVendorRef(dcOrVars, vars)); +} + +export const updateVendorRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'UpdateVendor', inputVars); +} +updateVendorRef.operationName = 'UpdateVendor'; + +export function updateVendor(dcOrVars, vars) { + return executeMutation(updateVendorRef(dcOrVars, vars)); +} + +export const deleteVendorRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteVendor', inputVars); +} +deleteVendorRef.operationName = 'DeleteVendor'; + +export function deleteVendor(dcOrVars, vars) { + return executeMutation(deleteVendorRef(dcOrVars, vars)); +} + +export const listVendorRef = (dc) => { + const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'listVendor'); +} +listVendorRef.operationName = 'listVendor'; + +export function listVendor(dc) { + return executeQuery(listVendorRef(dc)); +} + +export const getVendorByIdRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'getVendorById', inputVars); +} +getVendorByIdRef.operationName = 'getVendorById'; + +export function getVendorById(dcOrVars, vars) { + return executeQuery(getVendorByIdRef(dcOrVars, vars)); +} + +export const filterVendorsRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'filterVendors', inputVars); +} +filterVendorsRef.operationName = 'filterVendors'; + +export function filterVendors(dcOrVars, vars) { + return executeQuery(filterVendorsRef(dcOrVars, vars)); +} + +export const createVendorDefaultSettingRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'CreateVendorDefaultSetting', inputVars); +} +createVendorDefaultSettingRef.operationName = 'CreateVendorDefaultSetting'; + +export function createVendorDefaultSetting(dcOrVars, vars) { + return executeMutation(createVendorDefaultSettingRef(dcOrVars, vars)); +} + +export const updateVendorDefaultSettingRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'UpdateVendorDefaultSetting', inputVars); +} +updateVendorDefaultSettingRef.operationName = 'UpdateVendorDefaultSetting'; + +export function updateVendorDefaultSetting(dcOrVars, vars) { + return executeMutation(updateVendorDefaultSettingRef(dcOrVars, vars)); +} + +export const deleteVendorDefaultSettingRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteVendorDefaultSetting', inputVars); +} +deleteVendorDefaultSettingRef.operationName = 'DeleteVendorDefaultSetting'; + +export function deleteVendorDefaultSetting(dcOrVars, vars) { + return executeMutation(deleteVendorDefaultSettingRef(dcOrVars, vars)); +} + +export const createBusinessRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'CreateBusiness', inputVars); +} +createBusinessRef.operationName = 'CreateBusiness'; + +export function createBusiness(dcOrVars, vars) { + return executeMutation(createBusinessRef(dcOrVars, vars)); +} + +export const updateBusinessRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'UpdateBusiness', inputVars); +} +updateBusinessRef.operationName = 'UpdateBusiness'; + +export function updateBusiness(dcOrVars, vars) { + return executeMutation(updateBusinessRef(dcOrVars, vars)); +} + +export const deleteBusinessRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteBusiness', inputVars); +} +deleteBusinessRef.operationName = 'DeleteBusiness'; + +export function deleteBusiness(dcOrVars, vars) { + return executeMutation(deleteBusinessRef(dcOrVars, vars)); +} + diff --git a/internal-api-harness/src/dataconnect-generated/index.cjs.js b/internal-api-harness/src/dataconnect-generated/index.cjs.js index 966dc199..97caf790 100644 --- a/internal-api-harness/src/dataconnect-generated/index.cjs.js +++ b/internal-api-harness/src/dataconnect-generated/index.cjs.js @@ -8,6 +8,31 @@ const BackgroundCheckStatus = { } exports.BackgroundCheckStatus = BackgroundCheckStatus; +const BusinessRateGroup = { + STANDARD: "STANDARD", + PREMIUM: "PREMIUM", + ENTERPRISE: "ENTERPRISE", + CUSTOM: "CUSTOM", +} +exports.BusinessRateGroup = BusinessRateGroup; + +const BusinessSector = { + BON_APPETIT: "BON_APPETIT", + EUREST: "EUREST", + ARAMARK: "ARAMARK", + EPICUREAN_GROUP: "EPICUREAN_GROUP", + CHARTWELLS: "CHARTWELLS", + OTHER: "OTHER", +} +exports.BusinessSector = BusinessSector; + +const BusinessStatus = { + ACTIVE: "ACTIVE", + INACTIVE: "INACTIVE", + PENDING: "PENDING", +} +exports.BusinessStatus = BusinessStatus; + const ContractType = { W2: "W2", C1099: "C1099", @@ -104,52 +129,76 @@ const connectorConfig = { }; exports.connectorConfig = connectorConfig; -const listStaffRef = (dc) => { +const listBusinessRef = (dc) => { const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'listStaff'); + return queryRef(dcInstance, 'listBusiness'); } -listStaffRef.operationName = 'listStaff'; -exports.listStaffRef = listStaffRef; +listBusinessRef.operationName = 'listBusiness'; +exports.listBusinessRef = listBusinessRef; -exports.listStaff = function listStaff(dc) { - return executeQuery(listStaffRef(dc)); +exports.listBusiness = function listBusiness(dc) { + return executeQuery(listBusinessRef(dc)); }; -const createVendorRef = (dcOrVars, vars) => { +const getBusinessByIdRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateVendor', inputVars); + return queryRef(dcInstance, 'getBusinessById', inputVars); } -createVendorRef.operationName = 'CreateVendor'; -exports.createVendorRef = createVendorRef; +getBusinessByIdRef.operationName = 'getBusinessById'; +exports.getBusinessByIdRef = getBusinessByIdRef; -exports.createVendor = function createVendor(dcOrVars, vars) { - return executeMutation(createVendorRef(dcOrVars, vars)); +exports.getBusinessById = function getBusinessById(dcOrVars, vars) { + return executeQuery(getBusinessByIdRef(dcOrVars, vars)); }; -const updateVendorRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); +const filterBusinessRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'UpdateVendor', inputVars); + return queryRef(dcInstance, 'filterBusiness', inputVars); } -updateVendorRef.operationName = 'UpdateVendor'; -exports.updateVendorRef = updateVendorRef; +filterBusinessRef.operationName = 'filterBusiness'; +exports.filterBusinessRef = filterBusinessRef; -exports.updateVendor = function updateVendor(dcOrVars, vars) { - return executeMutation(updateVendorRef(dcOrVars, vars)); +exports.filterBusiness = function filterBusiness(dcOrVars, vars) { + return executeQuery(filterBusinessRef(dcOrVars, vars)); }; -const deleteVendorRef = (dcOrVars, vars) => { +const createEventRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'DeleteVendor', inputVars); + return mutationRef(dcInstance, 'CreateEvent', inputVars); } -deleteVendorRef.operationName = 'DeleteVendor'; -exports.deleteVendorRef = deleteVendorRef; +createEventRef.operationName = 'CreateEvent'; +exports.createEventRef = createEventRef; -exports.deleteVendor = function deleteVendor(dcOrVars, vars) { - return executeMutation(deleteVendorRef(dcOrVars, vars)); +exports.createEvent = function createEvent(dcOrVars, vars) { + return executeMutation(createEventRef(dcOrVars, vars)); +}; + +const updateEventRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'UpdateEvent', inputVars); +} +updateEventRef.operationName = 'UpdateEvent'; +exports.updateEventRef = updateEventRef; + +exports.updateEvent = function updateEvent(dcOrVars, vars) { + return executeMutation(updateEventRef(dcOrVars, vars)); +}; + +const deleteEventRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteEvent', inputVars); +} +deleteEventRef.operationName = 'DeleteEvent'; +exports.deleteEventRef = deleteEventRef; + +exports.deleteEvent = function deleteEvent(dcOrVars, vars) { + return executeMutation(deleteEventRef(dcOrVars, vars)); }; const listVendorDefaultSettingsRef = (dc) => { @@ -188,162 +237,6 @@ exports.filterVendorDefaultSettings = function filterVendorDefaultSettings(dcOrV return executeQuery(filterVendorDefaultSettingsRef(dcOrVars, vars)); }; -const listEventsRef = (dc) => { - const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'listEvents'); -} -listEventsRef.operationName = 'listEvents'; -exports.listEventsRef = listEventsRef; - -exports.listEvents = function listEvents(dc) { - return executeQuery(listEventsRef(dc)); -}; - -const getEventByIdRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'getEventById', inputVars); -} -getEventByIdRef.operationName = 'getEventById'; -exports.getEventByIdRef = getEventByIdRef; - -exports.getEventById = function getEventById(dcOrVars, vars) { - return executeQuery(getEventByIdRef(dcOrVars, vars)); -}; - -const filterEventsRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'filterEvents', inputVars); -} -filterEventsRef.operationName = 'filterEvents'; -exports.filterEventsRef = filterEventsRef; - -exports.filterEvents = function filterEvents(dcOrVars, vars) { - return executeQuery(filterEventsRef(dcOrVars, vars)); -}; - -const createInvoiceRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateInvoice', inputVars); -} -createInvoiceRef.operationName = 'CreateInvoice'; -exports.createInvoiceRef = createInvoiceRef; - -exports.createInvoice = function createInvoice(dcOrVars, vars) { - return executeMutation(createInvoiceRef(dcOrVars, vars)); -}; - -const updateInvoiceRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'UpdateInvoice', inputVars); -} -updateInvoiceRef.operationName = 'UpdateInvoice'; -exports.updateInvoiceRef = updateInvoiceRef; - -exports.updateInvoice = function updateInvoice(dcOrVars, vars) { - return executeMutation(updateInvoiceRef(dcOrVars, vars)); -}; - -const deleteInvoiceRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'DeleteInvoice', inputVars); -} -deleteInvoiceRef.operationName = 'DeleteInvoice'; -exports.deleteInvoiceRef = deleteInvoiceRef; - -exports.deleteInvoice = function deleteInvoice(dcOrVars, vars) { - return executeMutation(deleteInvoiceRef(dcOrVars, vars)); -}; - -const createStaffRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateStaff', inputVars); -} -createStaffRef.operationName = 'CreateStaff'; -exports.createStaffRef = createStaffRef; - -exports.createStaff = function createStaff(dcOrVars, vars) { - return executeMutation(createStaffRef(dcOrVars, vars)); -}; - -const listVendorRef = (dc) => { - const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'listVendor'); -} -listVendorRef.operationName = 'listVendor'; -exports.listVendorRef = listVendorRef; - -exports.listVendor = function listVendor(dc) { - return executeQuery(listVendorRef(dc)); -}; - -const getVendorByIdRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'getVendorById', inputVars); -} -getVendorByIdRef.operationName = 'getVendorById'; -exports.getVendorByIdRef = getVendorByIdRef; - -exports.getVendorById = function getVendorById(dcOrVars, vars) { - return executeQuery(getVendorByIdRef(dcOrVars, vars)); -}; - -const filterVendorsRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); - dcInstance._useGeneratedSdk(); - return queryRef(dcInstance, 'filterVendors', inputVars); -} -filterVendorsRef.operationName = 'filterVendors'; -exports.filterVendorsRef = filterVendorsRef; - -exports.filterVendors = function filterVendors(dcOrVars, vars) { - return executeQuery(filterVendorsRef(dcOrVars, vars)); -}; - -const createVendorDefaultSettingRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateVendorDefaultSetting', inputVars); -} -createVendorDefaultSettingRef.operationName = 'CreateVendorDefaultSetting'; -exports.createVendorDefaultSettingRef = createVendorDefaultSettingRef; - -exports.createVendorDefaultSetting = function createVendorDefaultSetting(dcOrVars, vars) { - return executeMutation(createVendorDefaultSettingRef(dcOrVars, vars)); -}; - -const updateVendorDefaultSettingRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'UpdateVendorDefaultSetting', inputVars); -} -updateVendorDefaultSettingRef.operationName = 'UpdateVendorDefaultSetting'; -exports.updateVendorDefaultSettingRef = updateVendorDefaultSettingRef; - -exports.updateVendorDefaultSetting = function updateVendorDefaultSetting(dcOrVars, vars) { - return executeMutation(updateVendorDefaultSettingRef(dcOrVars, vars)); -}; - -const deleteVendorDefaultSettingRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); - dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'DeleteVendorDefaultSetting', inputVars); -} -deleteVendorDefaultSettingRef.operationName = 'DeleteVendorDefaultSetting'; -exports.deleteVendorDefaultSettingRef = deleteVendorDefaultSettingRef; - -exports.deleteVendorDefaultSetting = function deleteVendorDefaultSetting(dcOrVars, vars) { - return executeMutation(deleteVendorDefaultSettingRef(dcOrVars, vars)); -}; - const createVendorRateRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); @@ -416,40 +309,76 @@ exports.filterVendorRates = function filterVendorRates(dcOrVars, vars) { return executeQuery(filterVendorRatesRef(dcOrVars, vars)); }; -const createEventRef = (dcOrVars, vars) => { - const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); +const listEventsRef = (dc) => { + const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'CreateEvent', inputVars); + return queryRef(dcInstance, 'listEvents'); } -createEventRef.operationName = 'CreateEvent'; -exports.createEventRef = createEventRef; +listEventsRef.operationName = 'listEvents'; +exports.listEventsRef = listEventsRef; -exports.createEvent = function createEvent(dcOrVars, vars) { - return executeMutation(createEventRef(dcOrVars, vars)); +exports.listEvents = function listEvents(dc) { + return executeQuery(listEventsRef(dc)); }; -const updateEventRef = (dcOrVars, vars) => { +const getEventByIdRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'UpdateEvent', inputVars); + return queryRef(dcInstance, 'getEventById', inputVars); } -updateEventRef.operationName = 'UpdateEvent'; -exports.updateEventRef = updateEventRef; +getEventByIdRef.operationName = 'getEventById'; +exports.getEventByIdRef = getEventByIdRef; -exports.updateEvent = function updateEvent(dcOrVars, vars) { - return executeMutation(updateEventRef(dcOrVars, vars)); +exports.getEventById = function getEventById(dcOrVars, vars) { + return executeQuery(getEventByIdRef(dcOrVars, vars)); }; -const deleteEventRef = (dcOrVars, vars) => { +const filterEventsRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'filterEvents', inputVars); +} +filterEventsRef.operationName = 'filterEvents'; +exports.filterEventsRef = filterEventsRef; + +exports.filterEvents = function filterEvents(dcOrVars, vars) { + return executeQuery(filterEventsRef(dcOrVars, vars)); +}; + +const createInvoiceRef = (dcOrVars, vars) => { const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); dcInstance._useGeneratedSdk(); - return mutationRef(dcInstance, 'DeleteEvent', inputVars); + return mutationRef(dcInstance, 'CreateInvoice', inputVars); } -deleteEventRef.operationName = 'DeleteEvent'; -exports.deleteEventRef = deleteEventRef; +createInvoiceRef.operationName = 'CreateInvoice'; +exports.createInvoiceRef = createInvoiceRef; -exports.deleteEvent = function deleteEvent(dcOrVars, vars) { - return executeMutation(deleteEventRef(dcOrVars, vars)); +exports.createInvoice = function createInvoice(dcOrVars, vars) { + return executeMutation(createInvoiceRef(dcOrVars, vars)); +}; + +const updateInvoiceRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'UpdateInvoice', inputVars); +} +updateInvoiceRef.operationName = 'UpdateInvoice'; +exports.updateInvoiceRef = updateInvoiceRef; + +exports.updateInvoice = function updateInvoice(dcOrVars, vars) { + return executeMutation(updateInvoiceRef(dcOrVars, vars)); +}; + +const deleteInvoiceRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteInvoice', inputVars); +} +deleteInvoiceRef.operationName = 'DeleteInvoice'; +exports.deleteInvoiceRef = deleteInvoiceRef; + +exports.deleteInvoice = function deleteInvoice(dcOrVars, vars) { + return executeMutation(deleteInvoiceRef(dcOrVars, vars)); }; const listInvoiceRef = (dc) => { @@ -487,3 +416,171 @@ exports.filterInvoicesRef = filterInvoicesRef; exports.filterInvoices = function filterInvoices(dcOrVars, vars) { return executeQuery(filterInvoicesRef(dcOrVars, vars)); }; + +const createStaffRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'CreateStaff', inputVars); +} +createStaffRef.operationName = 'CreateStaff'; +exports.createStaffRef = createStaffRef; + +exports.createStaff = function createStaff(dcOrVars, vars) { + return executeMutation(createStaffRef(dcOrVars, vars)); +}; + +const listStaffRef = (dc) => { + const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'listStaff'); +} +listStaffRef.operationName = 'listStaff'; +exports.listStaffRef = listStaffRef; + +exports.listStaff = function listStaff(dc) { + return executeQuery(listStaffRef(dc)); +}; + +const createVendorRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'CreateVendor', inputVars); +} +createVendorRef.operationName = 'CreateVendor'; +exports.createVendorRef = createVendorRef; + +exports.createVendor = function createVendor(dcOrVars, vars) { + return executeMutation(createVendorRef(dcOrVars, vars)); +}; + +const updateVendorRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'UpdateVendor', inputVars); +} +updateVendorRef.operationName = 'UpdateVendor'; +exports.updateVendorRef = updateVendorRef; + +exports.updateVendor = function updateVendor(dcOrVars, vars) { + return executeMutation(updateVendorRef(dcOrVars, vars)); +}; + +const deleteVendorRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteVendor', inputVars); +} +deleteVendorRef.operationName = 'DeleteVendor'; +exports.deleteVendorRef = deleteVendorRef; + +exports.deleteVendor = function deleteVendor(dcOrVars, vars) { + return executeMutation(deleteVendorRef(dcOrVars, vars)); +}; + +const listVendorRef = (dc) => { + const { dc: dcInstance} = validateArgs(connectorConfig, dc, undefined); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'listVendor'); +} +listVendorRef.operationName = 'listVendor'; +exports.listVendorRef = listVendorRef; + +exports.listVendor = function listVendor(dc) { + return executeQuery(listVendorRef(dc)); +}; + +const getVendorByIdRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'getVendorById', inputVars); +} +getVendorByIdRef.operationName = 'getVendorById'; +exports.getVendorByIdRef = getVendorByIdRef; + +exports.getVendorById = function getVendorById(dcOrVars, vars) { + return executeQuery(getVendorByIdRef(dcOrVars, vars)); +}; + +const filterVendorsRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars); + dcInstance._useGeneratedSdk(); + return queryRef(dcInstance, 'filterVendors', inputVars); +} +filterVendorsRef.operationName = 'filterVendors'; +exports.filterVendorsRef = filterVendorsRef; + +exports.filterVendors = function filterVendors(dcOrVars, vars) { + return executeQuery(filterVendorsRef(dcOrVars, vars)); +}; + +const createVendorDefaultSettingRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'CreateVendorDefaultSetting', inputVars); +} +createVendorDefaultSettingRef.operationName = 'CreateVendorDefaultSetting'; +exports.createVendorDefaultSettingRef = createVendorDefaultSettingRef; + +exports.createVendorDefaultSetting = function createVendorDefaultSetting(dcOrVars, vars) { + return executeMutation(createVendorDefaultSettingRef(dcOrVars, vars)); +}; + +const updateVendorDefaultSettingRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'UpdateVendorDefaultSetting', inputVars); +} +updateVendorDefaultSettingRef.operationName = 'UpdateVendorDefaultSetting'; +exports.updateVendorDefaultSettingRef = updateVendorDefaultSettingRef; + +exports.updateVendorDefaultSetting = function updateVendorDefaultSetting(dcOrVars, vars) { + return executeMutation(updateVendorDefaultSettingRef(dcOrVars, vars)); +}; + +const deleteVendorDefaultSettingRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteVendorDefaultSetting', inputVars); +} +deleteVendorDefaultSettingRef.operationName = 'DeleteVendorDefaultSetting'; +exports.deleteVendorDefaultSettingRef = deleteVendorDefaultSettingRef; + +exports.deleteVendorDefaultSetting = function deleteVendorDefaultSetting(dcOrVars, vars) { + return executeMutation(deleteVendorDefaultSettingRef(dcOrVars, vars)); +}; + +const createBusinessRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'CreateBusiness', inputVars); +} +createBusinessRef.operationName = 'CreateBusiness'; +exports.createBusinessRef = createBusinessRef; + +exports.createBusiness = function createBusiness(dcOrVars, vars) { + return executeMutation(createBusinessRef(dcOrVars, vars)); +}; + +const updateBusinessRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'UpdateBusiness', inputVars); +} +updateBusinessRef.operationName = 'UpdateBusiness'; +exports.updateBusinessRef = updateBusinessRef; + +exports.updateBusiness = function updateBusiness(dcOrVars, vars) { + return executeMutation(updateBusinessRef(dcOrVars, vars)); +}; + +const deleteBusinessRef = (dcOrVars, vars) => { + const { dc: dcInstance, vars: inputVars} = validateArgs(connectorConfig, dcOrVars, vars, true); + dcInstance._useGeneratedSdk(); + return mutationRef(dcInstance, 'DeleteBusiness', inputVars); +} +deleteBusinessRef.operationName = 'DeleteBusiness'; +exports.deleteBusinessRef = deleteBusinessRef; + +exports.deleteBusiness = function deleteBusiness(dcOrVars, vars) { + return executeMutation(deleteBusinessRef(dcOrVars, vars)); +}; diff --git a/internal-api-harness/src/dataconnect-generated/index.d.ts b/internal-api-harness/src/dataconnect-generated/index.d.ts index eb1a912d..ae0b3539 100644 --- a/internal-api-harness/src/dataconnect-generated/index.d.ts +++ b/internal-api-harness/src/dataconnect-generated/index.d.ts @@ -15,6 +15,28 @@ export enum BackgroundCheckStatus { EXPIRED = "EXPIRED", }; +export enum BusinessRateGroup { + STANDARD = "STANDARD", + PREMIUM = "PREMIUM", + ENTERPRISE = "ENTERPRISE", + CUSTOM = "CUSTOM", +}; + +export enum BusinessSector { + BON_APPETIT = "BON_APPETIT", + EUREST = "EUREST", + ARAMARK = "ARAMARK", + EPICUREAN_GROUP = "EPICUREAN_GROUP", + CHARTWELLS = "CHARTWELLS", + OTHER = "OTHER", +}; + +export enum BusinessStatus { + ACTIVE = "ACTIVE", + INACTIVE = "INACTIVE", + PENDING = "PENDING", +}; + export enum ContractType { W2 = "W2", C1099 = "C1099", @@ -97,6 +119,24 @@ export enum VendorRegion { +export interface Business_Key { + id: UUIDString; + __typename?: 'Business_Key'; +} + +export interface CreateBusinessData { + business_insert: Business_Key; +} + +export interface CreateBusinessVariables { + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; +} + export interface CreateEventData { event_insert: Event_Key; } @@ -206,6 +246,14 @@ export interface CreateVendorVariables { isActive?: boolean | null; } +export interface DeleteBusinessData { + business_delete?: Business_Key | null; +} + +export interface DeleteBusinessVariables { + id: UUIDString; +} + export interface DeleteEventData { event_delete?: Event_Key | null; } @@ -251,6 +299,26 @@ export interface Event_Key { __typename?: 'Event_Key'; } +export interface FilterBusinessData { + businesses: ({ + id: UUIDString; + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key)[]; +} + +export interface FilterBusinessVariables { + businessName?: string | null; + contactName?: string | null; + sector?: BusinessSector | null; + rateGroup?: BusinessRateGroup | null; + status?: BusinessStatus | null; +} + export interface FilterEventsData { events: ({ id: UUIDString; @@ -384,6 +452,22 @@ export interface FilterVendorsVariables { platformType?: VendorPlatformType | null; } +export interface GetBusinessByIdData { + business?: { + id: UUIDString; + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key; +} + +export interface GetBusinessByIdVariables { + id: UUIDString; +} + export interface GetEventByIdData { event?: { id: UUIDString; @@ -500,6 +584,18 @@ export interface Invoice_Key { __typename?: 'Invoice_Key'; } +export interface ListBusinessData { + businesses: ({ + id: UUIDString; + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key)[]; +} + export interface ListEventsData { events: ({ id: UUIDString; @@ -607,6 +703,20 @@ export interface Staff_Key { __typename?: 'Staff_Key'; } +export interface UpdateBusinessData { + business_update?: Business_Key | null; +} + +export interface UpdateBusinessVariables { + id: UUIDString; + businessName?: string | null; + contactName?: string | null; + email?: string | null; + sector?: BusinessSector | null; + rateGroup?: BusinessRateGroup | null; + status?: BusinessStatus | null; +} + export interface UpdateEventData { event_update?: Event_Key | null; } @@ -720,53 +830,77 @@ export interface Vendor_Key { __typename?: 'Vendor_Key'; } -interface ListStaffRef { +interface ListBusinessRef { /* Allow users to create refs without passing in DataConnect */ - (): QueryRef; + (): QueryRef; /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect): QueryRef; + (dc: DataConnect): QueryRef; operationName: string; } -export const listStaffRef: ListStaffRef; +export const listBusinessRef: ListBusinessRef; -export function listStaff(): QueryPromise; -export function listStaff(dc: DataConnect): QueryPromise; +export function listBusiness(): QueryPromise; +export function listBusiness(dc: DataConnect): QueryPromise; -interface CreateVendorRef { +interface GetBusinessByIdRef { /* Allow users to create refs without passing in DataConnect */ - (vars: CreateVendorVariables): MutationRef; + (vars: GetBusinessByIdVariables): QueryRef; /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: CreateVendorVariables): MutationRef; + (dc: DataConnect, vars: GetBusinessByIdVariables): QueryRef; operationName: string; } -export const createVendorRef: CreateVendorRef; +export const getBusinessByIdRef: GetBusinessByIdRef; -export function createVendor(vars: CreateVendorVariables): MutationPromise; -export function createVendor(dc: DataConnect, vars: CreateVendorVariables): MutationPromise; +export function getBusinessById(vars: GetBusinessByIdVariables): QueryPromise; +export function getBusinessById(dc: DataConnect, vars: GetBusinessByIdVariables): QueryPromise; -interface UpdateVendorRef { +interface FilterBusinessRef { /* Allow users to create refs without passing in DataConnect */ - (vars: UpdateVendorVariables): MutationRef; + (vars?: FilterBusinessVariables): QueryRef; /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: UpdateVendorVariables): MutationRef; + (dc: DataConnect, vars?: FilterBusinessVariables): QueryRef; operationName: string; } -export const updateVendorRef: UpdateVendorRef; +export const filterBusinessRef: FilterBusinessRef; -export function updateVendor(vars: UpdateVendorVariables): MutationPromise; -export function updateVendor(dc: DataConnect, vars: UpdateVendorVariables): MutationPromise; +export function filterBusiness(vars?: FilterBusinessVariables): QueryPromise; +export function filterBusiness(dc: DataConnect, vars?: FilterBusinessVariables): QueryPromise; -interface DeleteVendorRef { +interface CreateEventRef { /* Allow users to create refs without passing in DataConnect */ - (vars: DeleteVendorVariables): MutationRef; + (vars: CreateEventVariables): MutationRef; /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: DeleteVendorVariables): MutationRef; + (dc: DataConnect, vars: CreateEventVariables): MutationRef; operationName: string; } -export const deleteVendorRef: DeleteVendorRef; +export const createEventRef: CreateEventRef; -export function deleteVendor(vars: DeleteVendorVariables): MutationPromise; -export function deleteVendor(dc: DataConnect, vars: DeleteVendorVariables): MutationPromise; +export function createEvent(vars: CreateEventVariables): MutationPromise; +export function createEvent(dc: DataConnect, vars: CreateEventVariables): MutationPromise; + +interface UpdateEventRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateEventVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: UpdateEventVariables): MutationRef; + operationName: string; +} +export const updateEventRef: UpdateEventRef; + +export function updateEvent(vars: UpdateEventVariables): MutationPromise; +export function updateEvent(dc: DataConnect, vars: UpdateEventVariables): MutationPromise; + +interface DeleteEventRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteEventVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: DeleteEventVariables): MutationRef; + operationName: string; +} +export const deleteEventRef: DeleteEventRef; + +export function deleteEvent(vars: DeleteEventVariables): MutationPromise; +export function deleteEvent(dc: DataConnect, vars: DeleteEventVariables): MutationPromise; interface ListVendorDefaultSettingsRef { /* Allow users to create refs without passing in DataConnect */ @@ -804,162 +938,6 @@ export const filterVendorDefaultSettingsRef: FilterVendorDefaultSettingsRef; export function filterVendorDefaultSettings(vars?: FilterVendorDefaultSettingsVariables): QueryPromise; export function filterVendorDefaultSettings(dc: DataConnect, vars?: FilterVendorDefaultSettingsVariables): QueryPromise; -interface ListEventsRef { - /* Allow users to create refs without passing in DataConnect */ - (): QueryRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect): QueryRef; - operationName: string; -} -export const listEventsRef: ListEventsRef; - -export function listEvents(): QueryPromise; -export function listEvents(dc: DataConnect): QueryPromise; - -interface GetEventByIdRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: GetEventByIdVariables): QueryRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: GetEventByIdVariables): QueryRef; - operationName: string; -} -export const getEventByIdRef: GetEventByIdRef; - -export function getEventById(vars: GetEventByIdVariables): QueryPromise; -export function getEventById(dc: DataConnect, vars: GetEventByIdVariables): QueryPromise; - -interface FilterEventsRef { - /* Allow users to create refs without passing in DataConnect */ - (vars?: FilterEventsVariables): QueryRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars?: FilterEventsVariables): QueryRef; - operationName: string; -} -export const filterEventsRef: FilterEventsRef; - -export function filterEvents(vars?: FilterEventsVariables): QueryPromise; -export function filterEvents(dc: DataConnect, vars?: FilterEventsVariables): QueryPromise; - -interface CreateInvoiceRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: CreateInvoiceVariables): MutationRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: CreateInvoiceVariables): MutationRef; - operationName: string; -} -export const createInvoiceRef: CreateInvoiceRef; - -export function createInvoice(vars: CreateInvoiceVariables): MutationPromise; -export function createInvoice(dc: DataConnect, vars: CreateInvoiceVariables): MutationPromise; - -interface UpdateInvoiceRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: UpdateInvoiceVariables): MutationRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: UpdateInvoiceVariables): MutationRef; - operationName: string; -} -export const updateInvoiceRef: UpdateInvoiceRef; - -export function updateInvoice(vars: UpdateInvoiceVariables): MutationPromise; -export function updateInvoice(dc: DataConnect, vars: UpdateInvoiceVariables): MutationPromise; - -interface DeleteInvoiceRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: DeleteInvoiceVariables): MutationRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: DeleteInvoiceVariables): MutationRef; - operationName: string; -} -export const deleteInvoiceRef: DeleteInvoiceRef; - -export function deleteInvoice(vars: DeleteInvoiceVariables): MutationPromise; -export function deleteInvoice(dc: DataConnect, vars: DeleteInvoiceVariables): MutationPromise; - -interface CreateStaffRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: CreateStaffVariables): MutationRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: CreateStaffVariables): MutationRef; - operationName: string; -} -export const createStaffRef: CreateStaffRef; - -export function createStaff(vars: CreateStaffVariables): MutationPromise; -export function createStaff(dc: DataConnect, vars: CreateStaffVariables): MutationPromise; - -interface ListVendorRef { - /* Allow users to create refs without passing in DataConnect */ - (): QueryRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect): QueryRef; - operationName: string; -} -export const listVendorRef: ListVendorRef; - -export function listVendor(): QueryPromise; -export function listVendor(dc: DataConnect): QueryPromise; - -interface GetVendorByIdRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: GetVendorByIdVariables): QueryRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: GetVendorByIdVariables): QueryRef; - operationName: string; -} -export const getVendorByIdRef: GetVendorByIdRef; - -export function getVendorById(vars: GetVendorByIdVariables): QueryPromise; -export function getVendorById(dc: DataConnect, vars: GetVendorByIdVariables): QueryPromise; - -interface FilterVendorsRef { - /* Allow users to create refs without passing in DataConnect */ - (vars?: FilterVendorsVariables): QueryRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars?: FilterVendorsVariables): QueryRef; - operationName: string; -} -export const filterVendorsRef: FilterVendorsRef; - -export function filterVendors(vars?: FilterVendorsVariables): QueryPromise; -export function filterVendors(dc: DataConnect, vars?: FilterVendorsVariables): QueryPromise; - -interface CreateVendorDefaultSettingRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: CreateVendorDefaultSettingVariables): MutationRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationRef; - operationName: string; -} -export const createVendorDefaultSettingRef: CreateVendorDefaultSettingRef; - -export function createVendorDefaultSetting(vars: CreateVendorDefaultSettingVariables): MutationPromise; -export function createVendorDefaultSetting(dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationPromise; - -interface UpdateVendorDefaultSettingRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: UpdateVendorDefaultSettingVariables): MutationRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationRef; - operationName: string; -} -export const updateVendorDefaultSettingRef: UpdateVendorDefaultSettingRef; - -export function updateVendorDefaultSetting(vars: UpdateVendorDefaultSettingVariables): MutationPromise; -export function updateVendorDefaultSetting(dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationPromise; - -interface DeleteVendorDefaultSettingRef { - /* Allow users to create refs without passing in DataConnect */ - (vars: DeleteVendorDefaultSettingVariables): MutationRef; - /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationRef; - operationName: string; -} -export const deleteVendorDefaultSettingRef: DeleteVendorDefaultSettingRef; - -export function deleteVendorDefaultSetting(vars: DeleteVendorDefaultSettingVariables): MutationPromise; -export function deleteVendorDefaultSetting(dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationPromise; - interface CreateVendorRateRef { /* Allow users to create refs without passing in DataConnect */ (vars: CreateVendorRateVariables): MutationRef; @@ -1032,41 +1010,77 @@ export const filterVendorRatesRef: FilterVendorRatesRef; export function filterVendorRates(vars?: FilterVendorRatesVariables): QueryPromise; export function filterVendorRates(dc: DataConnect, vars?: FilterVendorRatesVariables): QueryPromise; -interface CreateEventRef { +interface ListEventsRef { /* Allow users to create refs without passing in DataConnect */ - (vars: CreateEventVariables): MutationRef; + (): QueryRef; /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: CreateEventVariables): MutationRef; + (dc: DataConnect): QueryRef; operationName: string; } -export const createEventRef: CreateEventRef; +export const listEventsRef: ListEventsRef; -export function createEvent(vars: CreateEventVariables): MutationPromise; -export function createEvent(dc: DataConnect, vars: CreateEventVariables): MutationPromise; +export function listEvents(): QueryPromise; +export function listEvents(dc: DataConnect): QueryPromise; -interface UpdateEventRef { +interface GetEventByIdRef { /* Allow users to create refs without passing in DataConnect */ - (vars: UpdateEventVariables): MutationRef; + (vars: GetEventByIdVariables): QueryRef; /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: UpdateEventVariables): MutationRef; + (dc: DataConnect, vars: GetEventByIdVariables): QueryRef; operationName: string; } -export const updateEventRef: UpdateEventRef; +export const getEventByIdRef: GetEventByIdRef; -export function updateEvent(vars: UpdateEventVariables): MutationPromise; -export function updateEvent(dc: DataConnect, vars: UpdateEventVariables): MutationPromise; +export function getEventById(vars: GetEventByIdVariables): QueryPromise; +export function getEventById(dc: DataConnect, vars: GetEventByIdVariables): QueryPromise; -interface DeleteEventRef { +interface FilterEventsRef { /* Allow users to create refs without passing in DataConnect */ - (vars: DeleteEventVariables): MutationRef; + (vars?: FilterEventsVariables): QueryRef; /* Allow users to pass in custom DataConnect instances */ - (dc: DataConnect, vars: DeleteEventVariables): MutationRef; + (dc: DataConnect, vars?: FilterEventsVariables): QueryRef; operationName: string; } -export const deleteEventRef: DeleteEventRef; +export const filterEventsRef: FilterEventsRef; -export function deleteEvent(vars: DeleteEventVariables): MutationPromise; -export function deleteEvent(dc: DataConnect, vars: DeleteEventVariables): MutationPromise; +export function filterEvents(vars?: FilterEventsVariables): QueryPromise; +export function filterEvents(dc: DataConnect, vars?: FilterEventsVariables): QueryPromise; + +interface CreateInvoiceRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateInvoiceVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: CreateInvoiceVariables): MutationRef; + operationName: string; +} +export const createInvoiceRef: CreateInvoiceRef; + +export function createInvoice(vars: CreateInvoiceVariables): MutationPromise; +export function createInvoice(dc: DataConnect, vars: CreateInvoiceVariables): MutationPromise; + +interface UpdateInvoiceRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateInvoiceVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: UpdateInvoiceVariables): MutationRef; + operationName: string; +} +export const updateInvoiceRef: UpdateInvoiceRef; + +export function updateInvoice(vars: UpdateInvoiceVariables): MutationPromise; +export function updateInvoice(dc: DataConnect, vars: UpdateInvoiceVariables): MutationPromise; + +interface DeleteInvoiceRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteInvoiceVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: DeleteInvoiceVariables): MutationRef; + operationName: string; +} +export const deleteInvoiceRef: DeleteInvoiceRef; + +export function deleteInvoice(vars: DeleteInvoiceVariables): MutationPromise; +export function deleteInvoice(dc: DataConnect, vars: DeleteInvoiceVariables): MutationPromise; interface ListInvoiceRef { /* Allow users to create refs without passing in DataConnect */ @@ -1104,3 +1118,171 @@ export const filterInvoicesRef: FilterInvoicesRef; export function filterInvoices(vars?: FilterInvoicesVariables): QueryPromise; export function filterInvoices(dc: DataConnect, vars?: FilterInvoicesVariables): QueryPromise; +interface CreateStaffRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateStaffVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: CreateStaffVariables): MutationRef; + operationName: string; +} +export const createStaffRef: CreateStaffRef; + +export function createStaff(vars: CreateStaffVariables): MutationPromise; +export function createStaff(dc: DataConnect, vars: CreateStaffVariables): MutationPromise; + +interface ListStaffRef { + /* Allow users to create refs without passing in DataConnect */ + (): QueryRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect): QueryRef; + operationName: string; +} +export const listStaffRef: ListStaffRef; + +export function listStaff(): QueryPromise; +export function listStaff(dc: DataConnect): QueryPromise; + +interface CreateVendorRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateVendorVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: CreateVendorVariables): MutationRef; + operationName: string; +} +export const createVendorRef: CreateVendorRef; + +export function createVendor(vars: CreateVendorVariables): MutationPromise; +export function createVendor(dc: DataConnect, vars: CreateVendorVariables): MutationPromise; + +interface UpdateVendorRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateVendorVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: UpdateVendorVariables): MutationRef; + operationName: string; +} +export const updateVendorRef: UpdateVendorRef; + +export function updateVendor(vars: UpdateVendorVariables): MutationPromise; +export function updateVendor(dc: DataConnect, vars: UpdateVendorVariables): MutationPromise; + +interface DeleteVendorRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteVendorVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: DeleteVendorVariables): MutationRef; + operationName: string; +} +export const deleteVendorRef: DeleteVendorRef; + +export function deleteVendor(vars: DeleteVendorVariables): MutationPromise; +export function deleteVendor(dc: DataConnect, vars: DeleteVendorVariables): MutationPromise; + +interface ListVendorRef { + /* Allow users to create refs without passing in DataConnect */ + (): QueryRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect): QueryRef; + operationName: string; +} +export const listVendorRef: ListVendorRef; + +export function listVendor(): QueryPromise; +export function listVendor(dc: DataConnect): QueryPromise; + +interface GetVendorByIdRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: GetVendorByIdVariables): QueryRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: GetVendorByIdVariables): QueryRef; + operationName: string; +} +export const getVendorByIdRef: GetVendorByIdRef; + +export function getVendorById(vars: GetVendorByIdVariables): QueryPromise; +export function getVendorById(dc: DataConnect, vars: GetVendorByIdVariables): QueryPromise; + +interface FilterVendorsRef { + /* Allow users to create refs without passing in DataConnect */ + (vars?: FilterVendorsVariables): QueryRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars?: FilterVendorsVariables): QueryRef; + operationName: string; +} +export const filterVendorsRef: FilterVendorsRef; + +export function filterVendors(vars?: FilterVendorsVariables): QueryPromise; +export function filterVendors(dc: DataConnect, vars?: FilterVendorsVariables): QueryPromise; + +interface CreateVendorDefaultSettingRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateVendorDefaultSettingVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationRef; + operationName: string; +} +export const createVendorDefaultSettingRef: CreateVendorDefaultSettingRef; + +export function createVendorDefaultSetting(vars: CreateVendorDefaultSettingVariables): MutationPromise; +export function createVendorDefaultSetting(dc: DataConnect, vars: CreateVendorDefaultSettingVariables): MutationPromise; + +interface UpdateVendorDefaultSettingRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateVendorDefaultSettingVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationRef; + operationName: string; +} +export const updateVendorDefaultSettingRef: UpdateVendorDefaultSettingRef; + +export function updateVendorDefaultSetting(vars: UpdateVendorDefaultSettingVariables): MutationPromise; +export function updateVendorDefaultSetting(dc: DataConnect, vars: UpdateVendorDefaultSettingVariables): MutationPromise; + +interface DeleteVendorDefaultSettingRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteVendorDefaultSettingVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationRef; + operationName: string; +} +export const deleteVendorDefaultSettingRef: DeleteVendorDefaultSettingRef; + +export function deleteVendorDefaultSetting(vars: DeleteVendorDefaultSettingVariables): MutationPromise; +export function deleteVendorDefaultSetting(dc: DataConnect, vars: DeleteVendorDefaultSettingVariables): MutationPromise; + +interface CreateBusinessRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: CreateBusinessVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: CreateBusinessVariables): MutationRef; + operationName: string; +} +export const createBusinessRef: CreateBusinessRef; + +export function createBusiness(vars: CreateBusinessVariables): MutationPromise; +export function createBusiness(dc: DataConnect, vars: CreateBusinessVariables): MutationPromise; + +interface UpdateBusinessRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: UpdateBusinessVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: UpdateBusinessVariables): MutationRef; + operationName: string; +} +export const updateBusinessRef: UpdateBusinessRef; + +export function updateBusiness(vars: UpdateBusinessVariables): MutationPromise; +export function updateBusiness(dc: DataConnect, vars: UpdateBusinessVariables): MutationPromise; + +interface DeleteBusinessRef { + /* Allow users to create refs without passing in DataConnect */ + (vars: DeleteBusinessVariables): MutationRef; + /* Allow users to pass in custom DataConnect instances */ + (dc: DataConnect, vars: DeleteBusinessVariables): MutationRef; + operationName: string; +} +export const deleteBusinessRef: DeleteBusinessRef; + +export function deleteBusiness(vars: DeleteBusinessVariables): MutationPromise; +export function deleteBusiness(dc: DataConnect, vars: DeleteBusinessVariables): MutationPromise; + diff --git a/internal-api-harness/src/dataconnect-generated/react/README.md b/internal-api-harness/src/dataconnect-generated/react/README.md index de4097eb..268de00b 100644 --- a/internal-api-harness/src/dataconnect-generated/react/README.md +++ b/internal-api-harness/src/dataconnect-generated/react/README.md @@ -17,39 +17,45 @@ You can also follow the instructions from the [Data Connect documentation](https - [**Accessing the connector**](#accessing-the-connector) - [*Connecting to the local Emulator*](#connecting-to-the-local-emulator) - [**Queries**](#queries) - - [*listStaff*](#liststaff) + - [*listBusiness*](#listbusiness) + - [*getBusinessById*](#getbusinessbyid) + - [*filterBusiness*](#filterbusiness) - [*listVendorDefaultSettings*](#listvendordefaultsettings) - [*getVendorDefaultSettingById*](#getvendordefaultsettingbyid) - [*filterVendorDefaultSettings*](#filtervendordefaultsettings) - - [*listEvents*](#listevents) - - [*getEventById*](#geteventbyid) - - [*filterEvents*](#filterevents) - - [*listVendor*](#listvendor) - - [*getVendorById*](#getvendorbyid) - - [*filterVendors*](#filtervendors) - [*listVendorRate*](#listvendorrate) - [*getVendorRateById*](#getvendorratebyid) - [*filterVendorRates*](#filtervendorrates) + - [*listEvents*](#listevents) + - [*getEventById*](#geteventbyid) + - [*filterEvents*](#filterevents) - [*listInvoice*](#listinvoice) - [*getInvoiceById*](#getinvoicebyid) - [*filterInvoices*](#filterinvoices) + - [*listStaff*](#liststaff) + - [*listVendor*](#listvendor) + - [*getVendorById*](#getvendorbyid) + - [*filterVendors*](#filtervendors) - [**Mutations**](#mutations) - - [*CreateVendor*](#createvendor) - - [*UpdateVendor*](#updatevendor) - - [*DeleteVendor*](#deletevendor) + - [*CreateEvent*](#createevent) + - [*UpdateEvent*](#updateevent) + - [*DeleteEvent*](#deleteevent) + - [*CreateVendorRate*](#createvendorrate) + - [*UpdateVendorRate*](#updatevendorrate) + - [*DeleteVendorRate*](#deletevendorrate) - [*CreateInvoice*](#createinvoice) - [*UpdateInvoice*](#updateinvoice) - [*DeleteInvoice*](#deleteinvoice) - [*CreateStaff*](#createstaff) + - [*CreateVendor*](#createvendor) + - [*UpdateVendor*](#updatevendor) + - [*DeleteVendor*](#deletevendor) - [*CreateVendorDefaultSetting*](#createvendordefaultsetting) - [*UpdateVendorDefaultSetting*](#updatevendordefaultsetting) - [*DeleteVendorDefaultSetting*](#deletevendordefaultsetting) - - [*CreateVendorRate*](#createvendorrate) - - [*UpdateVendorRate*](#updatevendorrate) - - [*DeleteVendorRate*](#deletevendorrate) - - [*CreateEvent*](#createevent) - - [*UpdateEvent*](#updateevent) - - [*DeleteEvent*](#deleteevent) + - [*CreateBusiness*](#createbusiness) + - [*UpdateBusiness*](#updatebusiness) + - [*DeleteBusiness*](#deletebusiness) # TanStack Query Firebase & TanStack React Query This SDK provides [React](https://react.dev/) hooks generated specific to your application, for the operations found in the connector `krow-connector`. These hooks are generated using [TanStack Query Firebase](https://react-query-firebase.invertase.dev/) by our partners at Invertase, a library built on top of [TanStack React Query v5](https://tanstack.com/query/v5/docs/framework/react/overview). @@ -141,68 +147,65 @@ Here's a general overview of how to use the generated Query hooks in your code: Below are examples of how to use the `krow-connector` connector's generated Query hook functions to execute each Query. You can also follow the examples from the [Data Connect documentation](https://firebase.google.com/docs/data-connect/web-sdk#operations-react-angular). -## listStaff -You can execute the `listStaff` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): +## listBusiness +You can execute the `listBusiness` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): ```javascript -useListStaff(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +useListBusiness(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; ``` You can also pass in a `DataConnect` instance to the Query hook function. ```javascript -useListStaff(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +useListBusiness(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; ``` ### Variables -The `listStaff` Query has no variables. +The `listBusiness` Query has no variables. ### Return Type -Recall that calling the `listStaff` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. +Recall that calling the `listBusiness` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. -To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `listStaff` Query is of type `ListStaffData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `listBusiness` Query is of type `ListBusinessData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface ListStaffData { - staffs: ({ +export interface ListBusinessData { + businesses: ({ id: UUIDString; - employeeName: string; - vendorId?: UUIDString | null; + businessName: string; + contactName: string; email?: string | null; - position?: string | null; - employmentType: EmploymentType; - rating?: number | null; - reliabilityScore?: number | null; - backgroundCheckStatus: BackgroundCheckStatus; - certifications?: string | null; - } & Staff_Key)[]; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key)[]; } ``` To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). -### Using `listStaff`'s Query hook function +### Using `listBusiness`'s Query hook function ```javascript import { getDataConnect } from 'firebase/data-connect'; import { connectorConfig } from '@dataconnect/generated'; -import { useListStaff } from '@dataconnect/generated/react' +import { useListBusiness } from '@dataconnect/generated/react' -export default function ListStaffComponent() { +export default function ListBusinessComponent() { // You don't have to do anything to "execute" the Query. // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. - const query = useListStaff(); + const query = useListBusiness(); // You can also pass in a `DataConnect` instance to the Query hook function. const dataConnect = getDataConnect(connectorConfig); - const query = useListStaff(dataConnect); + const query = useListBusiness(dataConnect); // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. const options = { staleTime: 5 * 1000 }; - const query = useListStaff(options); + const query = useListBusiness(options); // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. const dataConnect = getDataConnect(connectorConfig); const options = { staleTime: 5 * 1000 }; - const query = useListStaff(dataConnect, options); + const query = useListBusiness(dataConnect, options); // Then, you can render your component dynamically based on the status of the Query. if (query.isPending) { @@ -215,7 +218,201 @@ export default function ListStaffComponent() { // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. if (query.isSuccess) { - console.log(query.data.staffs); + console.log(query.data.businesses); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## getBusinessById +You can execute the `getBusinessById` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useGetBusinessById(dc: DataConnect, vars: GetBusinessByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useGetBusinessById(vars: GetBusinessByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `getBusinessById` Query requires an argument of type `GetBusinessByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface GetBusinessByIdVariables { + id: UUIDString; +} +``` +### Return Type +Recall that calling the `getBusinessById` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `getBusinessById` Query is of type `GetBusinessByIdData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface GetBusinessByIdData { + business?: { + id: UUIDString; + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `getBusinessById`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, GetBusinessByIdVariables } from '@dataconnect/generated'; +import { useGetBusinessById } from '@dataconnect/generated/react' + +export default function GetBusinessByIdComponent() { + // The `useGetBusinessById` Query hook requires an argument of type `GetBusinessByIdVariables`: + const getBusinessByIdVars: GetBusinessByIdVariables = { + id: ..., + }; + + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useGetBusinessById(getBusinessByIdVars); + // Variables can be defined inline as well. + const query = useGetBusinessById({ id: ..., }); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useGetBusinessById(dataConnect, getBusinessByIdVars); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useGetBusinessById(getBusinessByIdVars, options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useGetBusinessById(dataConnect, getBusinessByIdVars, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.business); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## filterBusiness +You can execute the `filterBusiness` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useFilterBusiness(dc: DataConnect, vars?: FilterBusinessVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useFilterBusiness(vars?: FilterBusinessVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `filterBusiness` Query has an optional argument of type `FilterBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface FilterBusinessVariables { + businessName?: string | null; + contactName?: string | null; + sector?: BusinessSector | null; + rateGroup?: BusinessRateGroup | null; + status?: BusinessStatus | null; +} +``` +### Return Type +Recall that calling the `filterBusiness` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `filterBusiness` Query is of type `FilterBusinessData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface FilterBusinessData { + businesses: ({ + id: UUIDString; + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; + } & Business_Key)[]; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `filterBusiness`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, FilterBusinessVariables } from '@dataconnect/generated'; +import { useFilterBusiness } from '@dataconnect/generated/react' + +export default function FilterBusinessComponent() { + // The `useFilterBusiness` Query hook has an optional argument of type `FilterBusinessVariables`: + const filterBusinessVars: FilterBusinessVariables = { + businessName: ..., // optional + contactName: ..., // optional + sector: ..., // optional + rateGroup: ..., // optional + status: ..., // optional + }; + + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useFilterBusiness(filterBusinessVars); + // Variables can be defined inline as well. + const query = useFilterBusiness({ businessName: ..., contactName: ..., sector: ..., rateGroup: ..., status: ..., }); + // Since all variables are optional for this Query, you can omit the `FilterBusinessVariables` argument. + // (as long as you don't want to provide any `options`!) + const query = useFilterBusiness(); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useFilterBusiness(dataConnect, filterBusinessVars); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useFilterBusiness(filterBusinessVars, options); + // If you'd like to provide options without providing any variables, you must + // pass `undefined` where you would normally pass the variables. + const query = useFilterBusiness(undefined, options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useFilterBusiness(dataConnect, filterBusinessVars /** or undefined */, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.businesses); } return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; } @@ -479,6 +676,283 @@ export default function FilterVendorDefaultSettingsComponent() { } ``` +## listVendorRate +You can execute the `listVendorRate` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useListVendorRate(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useListVendorRate(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `listVendorRate` Query has no variables. +### Return Type +Recall that calling the `listVendorRate` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `listVendorRate` Query is of type `ListVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface ListVendorRateData { + vendorRates: ({ + id: UUIDString; + vendorName: string; + category: VendorRateCategory; + roleName: string; + employeeWage: number; + markupPercentage?: number | null; + vendorFeePercentage?: number | null; + clientRate: number; + } & VendorRate_Key)[]; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `listVendorRate`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig } from '@dataconnect/generated'; +import { useListVendorRate } from '@dataconnect/generated/react' + +export default function ListVendorRateComponent() { + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useListVendorRate(); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useListVendorRate(dataConnect); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useListVendorRate(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useListVendorRate(dataConnect, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.vendorRates); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## getVendorRateById +You can execute the `getVendorRateById` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useGetVendorRateById(dc: DataConnect, vars: GetVendorRateByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useGetVendorRateById(vars: GetVendorRateByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `getVendorRateById` Query requires an argument of type `GetVendorRateByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface GetVendorRateByIdVariables { + id: UUIDString; +} +``` +### Return Type +Recall that calling the `getVendorRateById` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `getVendorRateById` Query is of type `GetVendorRateByIdData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +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; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `getVendorRateById`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, GetVendorRateByIdVariables } from '@dataconnect/generated'; +import { useGetVendorRateById } from '@dataconnect/generated/react' + +export default function GetVendorRateByIdComponent() { + // The `useGetVendorRateById` Query hook requires an argument of type `GetVendorRateByIdVariables`: + const getVendorRateByIdVars: GetVendorRateByIdVariables = { + id: ..., + }; + + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useGetVendorRateById(getVendorRateByIdVars); + // Variables can be defined inline as well. + const query = useGetVendorRateById({ id: ..., }); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useGetVendorRateById(dataConnect, getVendorRateByIdVars); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useGetVendorRateById(getVendorRateByIdVars, options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useGetVendorRateById(dataConnect, getVendorRateByIdVars, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.vendorRate); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## filterVendorRates +You can execute the `filterVendorRates` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useFilterVendorRates(dc: DataConnect, vars?: FilterVendorRatesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useFilterVendorRates(vars?: FilterVendorRatesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `filterVendorRates` Query has an optional argument of type `FilterVendorRatesVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface FilterVendorRatesVariables { + vendorName?: string | null; + category?: VendorRateCategory | null; + roleName?: string | null; + minClientRate?: number | null; + maxClientRate?: number | null; +} +``` +### Return Type +Recall that calling the `filterVendorRates` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `filterVendorRates` Query is of type `FilterVendorRatesData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface FilterVendorRatesData { + vendorRates: ({ + id: UUIDString; + vendorName: string; + category: VendorRateCategory; + roleName: string; + employeeWage: number; + markupPercentage?: number | null; + vendorFeePercentage?: number | null; + clientRate: number; + } & VendorRate_Key)[]; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `filterVendorRates`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, FilterVendorRatesVariables } from '@dataconnect/generated'; +import { useFilterVendorRates } from '@dataconnect/generated/react' + +export default function FilterVendorRatesComponent() { + // The `useFilterVendorRates` Query hook has an optional argument of type `FilterVendorRatesVariables`: + const filterVendorRatesVars: FilterVendorRatesVariables = { + vendorName: ..., // optional + category: ..., // optional + roleName: ..., // optional + minClientRate: ..., // optional + maxClientRate: ..., // optional + }; + + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useFilterVendorRates(filterVendorRatesVars); + // Variables can be defined inline as well. + const query = useFilterVendorRates({ vendorName: ..., category: ..., roleName: ..., minClientRate: ..., maxClientRate: ..., }); + // Since all variables are optional for this Query, you can omit the `FilterVendorRatesVariables` argument. + // (as long as you don't want to provide any `options`!) + const query = useFilterVendorRates(); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useFilterVendorRates(dataConnect, filterVendorRatesVars); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useFilterVendorRates(filterVendorRatesVars, options); + // If you'd like to provide options without providing any variables, you must + // pass `undefined` where you would normally pass the variables. + const query = useFilterVendorRates(undefined, options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useFilterVendorRates(dataConnect, filterVendorRatesVars /** or undefined */, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.vendorRates); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + ## listEvents You can execute the `listEvents` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): @@ -848,6 +1322,356 @@ export default function FilterEventsComponent() { } ``` +## listInvoice +You can execute the `listInvoice` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useListInvoice(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useListInvoice(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `listInvoice` Query has no variables. +### Return Type +Recall that calling the `listInvoice` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `listInvoice` Query is of type `ListInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface ListInvoiceData { + invoices: ({ + id: UUIDString; + invoiceNumber: string; + amount: number; + status: InvoiceStatus; + issueDate: TimestampString; + dueDate: TimestampString; + isAutoGenerated?: boolean | null; + } & Invoice_Key)[]; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `listInvoice`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig } from '@dataconnect/generated'; +import { useListInvoice } from '@dataconnect/generated/react' + +export default function ListInvoiceComponent() { + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useListInvoice(); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useListInvoice(dataConnect); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useListInvoice(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useListInvoice(dataConnect, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.invoices); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## getInvoiceById +You can execute the `getInvoiceById` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useGetInvoiceById(dc: DataConnect, vars: GetInvoiceByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useGetInvoiceById(vars: GetInvoiceByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `getInvoiceById` Query requires an argument of type `GetInvoiceByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface GetInvoiceByIdVariables { + id: UUIDString; +} +``` +### Return Type +Recall that calling the `getInvoiceById` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `getInvoiceById` Query is of type `GetInvoiceByIdData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface GetInvoiceByIdData { + invoice?: { + id: UUIDString; + invoiceNumber: string; + amount: number; + status: InvoiceStatus; + issueDate: TimestampString; + dueDate: TimestampString; + disputedItems?: string | null; + isAutoGenerated?: boolean | null; + } & Invoice_Key; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `getInvoiceById`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, GetInvoiceByIdVariables } from '@dataconnect/generated'; +import { useGetInvoiceById } from '@dataconnect/generated/react' + +export default function GetInvoiceByIdComponent() { + // The `useGetInvoiceById` Query hook requires an argument of type `GetInvoiceByIdVariables`: + const getInvoiceByIdVars: GetInvoiceByIdVariables = { + id: ..., + }; + + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useGetInvoiceById(getInvoiceByIdVars); + // Variables can be defined inline as well. + const query = useGetInvoiceById({ id: ..., }); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useGetInvoiceById(dataConnect, getInvoiceByIdVars); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useGetInvoiceById(getInvoiceByIdVars, options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useGetInvoiceById(dataConnect, getInvoiceByIdVars, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.invoice); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## filterInvoices +You can execute the `filterInvoices` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useFilterInvoices(dc: DataConnect, vars?: FilterInvoicesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useFilterInvoices(vars?: FilterInvoicesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `filterInvoices` Query has an optional argument of type `FilterInvoicesVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface FilterInvoicesVariables { + invoiceNumber?: string | null; + status?: InvoiceStatus | null; + isAutoGenerated?: boolean | null; + amount?: number | null; +} +``` +### Return Type +Recall that calling the `filterInvoices` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `filterInvoices` Query is of type `FilterInvoicesData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface FilterInvoicesData { + invoices: ({ + id: UUIDString; + invoiceNumber: string; + amount: number; + status: InvoiceStatus; + issueDate: TimestampString; + dueDate: TimestampString; + isAutoGenerated?: boolean | null; + } & Invoice_Key)[]; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `filterInvoices`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, FilterInvoicesVariables } from '@dataconnect/generated'; +import { useFilterInvoices } from '@dataconnect/generated/react' + +export default function FilterInvoicesComponent() { + // The `useFilterInvoices` Query hook has an optional argument of type `FilterInvoicesVariables`: + const filterInvoicesVars: FilterInvoicesVariables = { + invoiceNumber: ..., // optional + status: ..., // optional + isAutoGenerated: ..., // optional + amount: ..., // optional + }; + + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useFilterInvoices(filterInvoicesVars); + // Variables can be defined inline as well. + const query = useFilterInvoices({ invoiceNumber: ..., status: ..., isAutoGenerated: ..., amount: ..., }); + // Since all variables are optional for this Query, you can omit the `FilterInvoicesVariables` argument. + // (as long as you don't want to provide any `options`!) + const query = useFilterInvoices(); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useFilterInvoices(dataConnect, filterInvoicesVars); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useFilterInvoices(filterInvoicesVars, options); + // If you'd like to provide options without providing any variables, you must + // pass `undefined` where you would normally pass the variables. + const query = useFilterInvoices(undefined, options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useFilterInvoices(dataConnect, filterInvoicesVars /** or undefined */, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.invoices); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## listStaff +You can execute the `listStaff` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): + +```javascript +useListStaff(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` +You can also pass in a `DataConnect` instance to the Query hook function. +```javascript +useListStaff(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +``` + +### Variables +The `listStaff` Query has no variables. +### Return Type +Recall that calling the `listStaff` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. + +To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. + +To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `listStaff` Query is of type `ListStaffData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface ListStaffData { + staffs: ({ + id: UUIDString; + employeeName: string; + vendorId?: UUIDString | null; + email?: string | null; + position?: string | null; + employmentType: EmploymentType; + rating?: number | null; + reliabilityScore?: number | null; + backgroundCheckStatus: BackgroundCheckStatus; + certifications?: string | null; + } & Staff_Key)[]; +} +``` + +To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). + +### Using `listStaff`'s Query hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig } from '@dataconnect/generated'; +import { useListStaff } from '@dataconnect/generated/react' + +export default function ListStaffComponent() { + // You don't have to do anything to "execute" the Query. + // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. + const query = useListStaff(); + + // You can also pass in a `DataConnect` instance to the Query hook function. + const dataConnect = getDataConnect(connectorConfig); + const query = useListStaff(dataConnect); + + // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. + const options = { staleTime: 5 * 1000 }; + const query = useListStaff(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { staleTime: 5 * 1000 }; + const query = useListStaff(dataConnect, options); + + // Then, you can render your component dynamically based on the status of the Query. + if (query.isPending) { + return
Loading...
; + } + + if (query.isError) { + return
Error: {query.error.message}
; + } + + // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. + if (query.isSuccess) { + console.log(query.data.staffs); + } + return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; +} +``` + ## listVendor You can execute the `listVendor` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): @@ -1126,553 +1950,6 @@ export default function FilterVendorsComponent() { } ``` -## listVendorRate -You can execute the `listVendorRate` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): - -```javascript -useListVendorRate(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` -You can also pass in a `DataConnect` instance to the Query hook function. -```javascript -useListVendorRate(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` - -### Variables -The `listVendorRate` Query has no variables. -### Return Type -Recall that calling the `listVendorRate` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. - -To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. - -To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `listVendorRate` Query is of type `ListVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface ListVendorRateData { - vendorRates: ({ - id: UUIDString; - vendorName: string; - category: VendorRateCategory; - roleName: string; - employeeWage: number; - markupPercentage?: number | null; - vendorFeePercentage?: number | null; - clientRate: number; - } & VendorRate_Key)[]; -} -``` - -To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). - -### Using `listVendorRate`'s Query hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig } from '@dataconnect/generated'; -import { useListVendorRate } from '@dataconnect/generated/react' - -export default function ListVendorRateComponent() { - // You don't have to do anything to "execute" the Query. - // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. - const query = useListVendorRate(); - - // You can also pass in a `DataConnect` instance to the Query hook function. - const dataConnect = getDataConnect(connectorConfig); - const query = useListVendorRate(dataConnect); - - // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. - const options = { staleTime: 5 * 1000 }; - const query = useListVendorRate(options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { staleTime: 5 * 1000 }; - const query = useListVendorRate(dataConnect, options); - - // Then, you can render your component dynamically based on the status of the Query. - if (query.isPending) { - return
Loading...
; - } - - if (query.isError) { - return
Error: {query.error.message}
; - } - - // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. - if (query.isSuccess) { - console.log(query.data.vendorRates); - } - return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## getVendorRateById -You can execute the `getVendorRateById` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): - -```javascript -useGetVendorRateById(dc: DataConnect, vars: GetVendorRateByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` -You can also pass in a `DataConnect` instance to the Query hook function. -```javascript -useGetVendorRateById(vars: GetVendorRateByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` - -### Variables -The `getVendorRateById` Query requires an argument of type `GetVendorRateByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: - -```javascript -export interface GetVendorRateByIdVariables { - id: UUIDString; -} -``` -### Return Type -Recall that calling the `getVendorRateById` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. - -To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. - -To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `getVendorRateById` Query is of type `GetVendorRateByIdData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -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; -} -``` - -To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). - -### Using `getVendorRateById`'s Query hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, GetVendorRateByIdVariables } from '@dataconnect/generated'; -import { useGetVendorRateById } from '@dataconnect/generated/react' - -export default function GetVendorRateByIdComponent() { - // The `useGetVendorRateById` Query hook requires an argument of type `GetVendorRateByIdVariables`: - const getVendorRateByIdVars: GetVendorRateByIdVariables = { - id: ..., - }; - - // You don't have to do anything to "execute" the Query. - // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. - const query = useGetVendorRateById(getVendorRateByIdVars); - // Variables can be defined inline as well. - const query = useGetVendorRateById({ id: ..., }); - - // You can also pass in a `DataConnect` instance to the Query hook function. - const dataConnect = getDataConnect(connectorConfig); - const query = useGetVendorRateById(dataConnect, getVendorRateByIdVars); - - // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. - const options = { staleTime: 5 * 1000 }; - const query = useGetVendorRateById(getVendorRateByIdVars, options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { staleTime: 5 * 1000 }; - const query = useGetVendorRateById(dataConnect, getVendorRateByIdVars, options); - - // Then, you can render your component dynamically based on the status of the Query. - if (query.isPending) { - return
Loading...
; - } - - if (query.isError) { - return
Error: {query.error.message}
; - } - - // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. - if (query.isSuccess) { - console.log(query.data.vendorRate); - } - return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## filterVendorRates -You can execute the `filterVendorRates` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): - -```javascript -useFilterVendorRates(dc: DataConnect, vars?: FilterVendorRatesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` -You can also pass in a `DataConnect` instance to the Query hook function. -```javascript -useFilterVendorRates(vars?: FilterVendorRatesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` - -### Variables -The `filterVendorRates` Query has an optional argument of type `FilterVendorRatesVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: - -```javascript -export interface FilterVendorRatesVariables { - vendorName?: string | null; - category?: VendorRateCategory | null; - roleName?: string | null; - minClientRate?: number | null; - maxClientRate?: number | null; -} -``` -### Return Type -Recall that calling the `filterVendorRates` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. - -To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. - -To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `filterVendorRates` Query is of type `FilterVendorRatesData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface FilterVendorRatesData { - vendorRates: ({ - id: UUIDString; - vendorName: string; - category: VendorRateCategory; - roleName: string; - employeeWage: number; - markupPercentage?: number | null; - vendorFeePercentage?: number | null; - clientRate: number; - } & VendorRate_Key)[]; -} -``` - -To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). - -### Using `filterVendorRates`'s Query hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, FilterVendorRatesVariables } from '@dataconnect/generated'; -import { useFilterVendorRates } from '@dataconnect/generated/react' - -export default function FilterVendorRatesComponent() { - // The `useFilterVendorRates` Query hook has an optional argument of type `FilterVendorRatesVariables`: - const filterVendorRatesVars: FilterVendorRatesVariables = { - vendorName: ..., // optional - category: ..., // optional - roleName: ..., // optional - minClientRate: ..., // optional - maxClientRate: ..., // optional - }; - - // You don't have to do anything to "execute" the Query. - // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. - const query = useFilterVendorRates(filterVendorRatesVars); - // Variables can be defined inline as well. - const query = useFilterVendorRates({ vendorName: ..., category: ..., roleName: ..., minClientRate: ..., maxClientRate: ..., }); - // Since all variables are optional for this Query, you can omit the `FilterVendorRatesVariables` argument. - // (as long as you don't want to provide any `options`!) - const query = useFilterVendorRates(); - - // You can also pass in a `DataConnect` instance to the Query hook function. - const dataConnect = getDataConnect(connectorConfig); - const query = useFilterVendorRates(dataConnect, filterVendorRatesVars); - - // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. - const options = { staleTime: 5 * 1000 }; - const query = useFilterVendorRates(filterVendorRatesVars, options); - // If you'd like to provide options without providing any variables, you must - // pass `undefined` where you would normally pass the variables. - const query = useFilterVendorRates(undefined, options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { staleTime: 5 * 1000 }; - const query = useFilterVendorRates(dataConnect, filterVendorRatesVars /** or undefined */, options); - - // Then, you can render your component dynamically based on the status of the Query. - if (query.isPending) { - return
Loading...
; - } - - if (query.isError) { - return
Error: {query.error.message}
; - } - - // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. - if (query.isSuccess) { - console.log(query.data.vendorRates); - } - return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## listInvoice -You can execute the `listInvoice` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): - -```javascript -useListInvoice(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` -You can also pass in a `DataConnect` instance to the Query hook function. -```javascript -useListInvoice(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` - -### Variables -The `listInvoice` Query has no variables. -### Return Type -Recall that calling the `listInvoice` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. - -To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. - -To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `listInvoice` Query is of type `ListInvoiceData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface ListInvoiceData { - invoices: ({ - id: UUIDString; - invoiceNumber: string; - amount: number; - status: InvoiceStatus; - issueDate: TimestampString; - dueDate: TimestampString; - isAutoGenerated?: boolean | null; - } & Invoice_Key)[]; -} -``` - -To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). - -### Using `listInvoice`'s Query hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig } from '@dataconnect/generated'; -import { useListInvoice } from '@dataconnect/generated/react' - -export default function ListInvoiceComponent() { - // You don't have to do anything to "execute" the Query. - // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. - const query = useListInvoice(); - - // You can also pass in a `DataConnect` instance to the Query hook function. - const dataConnect = getDataConnect(connectorConfig); - const query = useListInvoice(dataConnect); - - // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. - const options = { staleTime: 5 * 1000 }; - const query = useListInvoice(options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { staleTime: 5 * 1000 }; - const query = useListInvoice(dataConnect, options); - - // Then, you can render your component dynamically based on the status of the Query. - if (query.isPending) { - return
Loading...
; - } - - if (query.isError) { - return
Error: {query.error.message}
; - } - - // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. - if (query.isSuccess) { - console.log(query.data.invoices); - } - return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## getInvoiceById -You can execute the `getInvoiceById` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): - -```javascript -useGetInvoiceById(dc: DataConnect, vars: GetInvoiceByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` -You can also pass in a `DataConnect` instance to the Query hook function. -```javascript -useGetInvoiceById(vars: GetInvoiceByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` - -### Variables -The `getInvoiceById` Query requires an argument of type `GetInvoiceByIdVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: - -```javascript -export interface GetInvoiceByIdVariables { - id: UUIDString; -} -``` -### Return Type -Recall that calling the `getInvoiceById` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. - -To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. - -To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `getInvoiceById` Query is of type `GetInvoiceByIdData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface GetInvoiceByIdData { - invoice?: { - id: UUIDString; - invoiceNumber: string; - amount: number; - status: InvoiceStatus; - issueDate: TimestampString; - dueDate: TimestampString; - disputedItems?: string | null; - isAutoGenerated?: boolean | null; - } & Invoice_Key; -} -``` - -To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). - -### Using `getInvoiceById`'s Query hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, GetInvoiceByIdVariables } from '@dataconnect/generated'; -import { useGetInvoiceById } from '@dataconnect/generated/react' - -export default function GetInvoiceByIdComponent() { - // The `useGetInvoiceById` Query hook requires an argument of type `GetInvoiceByIdVariables`: - const getInvoiceByIdVars: GetInvoiceByIdVariables = { - id: ..., - }; - - // You don't have to do anything to "execute" the Query. - // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. - const query = useGetInvoiceById(getInvoiceByIdVars); - // Variables can be defined inline as well. - const query = useGetInvoiceById({ id: ..., }); - - // You can also pass in a `DataConnect` instance to the Query hook function. - const dataConnect = getDataConnect(connectorConfig); - const query = useGetInvoiceById(dataConnect, getInvoiceByIdVars); - - // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. - const options = { staleTime: 5 * 1000 }; - const query = useGetInvoiceById(getInvoiceByIdVars, options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { staleTime: 5 * 1000 }; - const query = useGetInvoiceById(dataConnect, getInvoiceByIdVars, options); - - // Then, you can render your component dynamically based on the status of the Query. - if (query.isPending) { - return
Loading...
; - } - - if (query.isError) { - return
Error: {query.error.message}
; - } - - // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. - if (query.isSuccess) { - console.log(query.data.invoice); - } - return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## filterInvoices -You can execute the `filterInvoices` Query using the following Query hook function, which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts): - -```javascript -useFilterInvoices(dc: DataConnect, vars?: FilterInvoicesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` -You can also pass in a `DataConnect` instance to the Query hook function. -```javascript -useFilterInvoices(vars?: FilterInvoicesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -``` - -### Variables -The `filterInvoices` Query has an optional argument of type `FilterInvoicesVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: - -```javascript -export interface FilterInvoicesVariables { - invoiceNumber?: string | null; - status?: InvoiceStatus | null; - isAutoGenerated?: boolean | null; - amount?: number | null; -} -``` -### Return Type -Recall that calling the `filterInvoices` Query hook function returns a `UseQueryResult` object. This object holds the state of your Query, including whether the Query is loading, has completed, or has succeeded/failed, and any data returned by the Query, among other things. - -To check the status of a Query, use the `UseQueryResult.status` field. You can also check for pending / success / error status using the `UseQueryResult.isPending`, `UseQueryResult.isSuccess`, and `UseQueryResult.isError` fields. - -To access the data returned by a Query, use the `UseQueryResult.data` field. The data for the `filterInvoices` Query is of type `FilterInvoicesData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface FilterInvoicesData { - invoices: ({ - id: UUIDString; - invoiceNumber: string; - amount: number; - status: InvoiceStatus; - issueDate: TimestampString; - dueDate: TimestampString; - isAutoGenerated?: boolean | null; - } & Invoice_Key)[]; -} -``` - -To learn more about the `UseQueryResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useQuery). - -### Using `filterInvoices`'s Query hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, FilterInvoicesVariables } from '@dataconnect/generated'; -import { useFilterInvoices } from '@dataconnect/generated/react' - -export default function FilterInvoicesComponent() { - // The `useFilterInvoices` Query hook has an optional argument of type `FilterInvoicesVariables`: - const filterInvoicesVars: FilterInvoicesVariables = { - invoiceNumber: ..., // optional - status: ..., // optional - isAutoGenerated: ..., // optional - amount: ..., // optional - }; - - // You don't have to do anything to "execute" the Query. - // Call the Query hook function to get a `UseQueryResult` object which holds the state of your Query. - const query = useFilterInvoices(filterInvoicesVars); - // Variables can be defined inline as well. - const query = useFilterInvoices({ invoiceNumber: ..., status: ..., isAutoGenerated: ..., amount: ..., }); - // Since all variables are optional for this Query, you can omit the `FilterInvoicesVariables` argument. - // (as long as you don't want to provide any `options`!) - const query = useFilterInvoices(); - - // You can also pass in a `DataConnect` instance to the Query hook function. - const dataConnect = getDataConnect(connectorConfig); - const query = useFilterInvoices(dataConnect, filterInvoicesVars); - - // You can also pass in a `useDataConnectQueryOptions` object to the Query hook function. - const options = { staleTime: 5 * 1000 }; - const query = useFilterInvoices(filterInvoicesVars, options); - // If you'd like to provide options without providing any variables, you must - // pass `undefined` where you would normally pass the variables. - const query = useFilterInvoices(undefined, options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectQueryOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { staleTime: 5 * 1000 }; - const query = useFilterInvoices(dataConnect, filterInvoicesVars /** or undefined */, options); - - // Then, you can render your component dynamically based on the status of the Query. - if (query.isPending) { - return
Loading...
; - } - - if (query.isError) { - return
Error: {query.error.message}
; - } - - // If the Query is successful, you can access the data returned using the `UseQueryResult.data` field. - if (query.isSuccess) { - console.log(query.data.invoices); - } - return
Query execution {query.isSuccess ? 'successful' : 'failed'}!
; -} -``` - # Mutations The React generated SDK provides Mutations hook functions that call and return [`useDataConnectMutation`](https://react-query-firebase.invertase.dev/react/data-connect/mutations) hooks from TanStack Query Firebase. @@ -1698,94 +1975,148 @@ Here's a general overview of how to use the generated Mutation hooks in your cod Below are examples of how to use the `krow-connector` connector's generated Mutation hook functions to execute each Mutation. You can also follow the examples from the [Data Connect documentation](https://firebase.google.com/docs/data-connect/web-sdk#operations-react-angular). -## CreateVendor -You can execute the `CreateVendor` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +## CreateEvent +You can execute the `CreateEvent` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): ```javascript -useCreateVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useCreateEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` You can also pass in a `DataConnect` instance to the Mutation hook function. ```javascript -useCreateVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useCreateEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` ### Variables -The `CreateVendor` Mutation requires an argument of type `CreateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +The `CreateEvent` Mutation requires an argument of type `CreateEventVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface CreateVendorVariables { - vendorNumber: string; - legalName: string; - region: VendorRegion; - platformType: VendorPlatformType; - primaryContactEmail: string; - approvalStatus: VendorApprovalStatus; - isActive?: boolean | null; +export interface CreateEventVariables { + eventName: string; + isRapid?: boolean | null; + isRecurring?: boolean | null; + isMultiDay?: boolean | null; + recurrenceType?: RecurrenceType | null; + recurrenceStartDate?: TimestampString | null; + recurrenceEndDate?: TimestampString | null; + scatterDates?: string | null; + multiDayStartDate?: TimestampString | null; + multiDayEndDate?: TimestampString | null; + bufferTimeBefore?: number | null; + bufferTimeAfter?: number | null; + conflictDetectionEnabled?: boolean | null; + detectedConflicts?: string | null; + businessId: UUIDString; + businessName?: string | null; + vendorId?: UUIDString | null; + vendorName?: string | null; + hub?: string | null; + eventLocation?: string | null; + contractType?: ContractType | null; + poReference?: string | null; + status: EventStatus; + date: TimestampString; + shifts?: string | null; + addons?: string | null; + total?: number | null; + clientName?: string | null; + clientEmail?: string | null; + clientPhone?: string | null; + invoiceId?: UUIDString | null; + notes?: string | null; + requested?: number | null; + assignedStaff?: string | null; } ``` ### Return Type -Recall that calling the `CreateVendor` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. +Recall that calling the `CreateEvent` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `CreateVendor` Mutation is of type `CreateVendorData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `CreateEvent` Mutation is of type `CreateEventData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface CreateVendorData { - vendor_insert: Vendor_Key; +export interface CreateEventData { + event_insert: Event_Key; } ``` To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). -### Using `CreateVendor`'s Mutation hook function +### Using `CreateEvent`'s Mutation hook function ```javascript import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, CreateVendorVariables } from '@dataconnect/generated'; -import { useCreateVendor } from '@dataconnect/generated/react' +import { connectorConfig, CreateEventVariables } from '@dataconnect/generated'; +import { useCreateEvent } from '@dataconnect/generated/react' -export default function CreateVendorComponent() { +export default function CreateEventComponent() { // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useCreateVendor(); + const mutation = useCreateEvent(); // You can also pass in a `DataConnect` instance to the Mutation hook function. const dataConnect = getDataConnect(connectorConfig); - const mutation = useCreateVendor(dataConnect); + const mutation = useCreateEvent(dataConnect); // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useCreateVendor(options); + const mutation = useCreateEvent(options); // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. const dataConnect = getDataConnect(connectorConfig); const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useCreateVendor(dataConnect, options); + const mutation = useCreateEvent(dataConnect, options); // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useCreateVendor` Mutation requires an argument of type `CreateVendorVariables`: - const createVendorVars: CreateVendorVariables = { - vendorNumber: ..., - legalName: ..., - region: ..., - platformType: ..., - primaryContactEmail: ..., - approvalStatus: ..., - isActive: ..., // optional + // The `useCreateEvent` 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 }; - mutation.mutate(createVendorVars); + mutation.mutate(createEventVars); // Variables can be defined inline as well. - mutation.mutate({ vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); + mutation.mutate({ 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: ..., }); // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - mutation.mutate(createVendorVars, options); + mutation.mutate(createEventVars, options); // Then, you can render your component dynamically based on the status of the Mutation. if (mutation.isPending) { @@ -1798,102 +2129,156 @@ export default function CreateVendorComponent() { // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. if (mutation.isSuccess) { - console.log(mutation.data.vendor_insert); + console.log(mutation.data.event_insert); } return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; } ``` -## UpdateVendor -You can execute the `UpdateVendor` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +## UpdateEvent +You can execute the `UpdateEvent` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): ```javascript -useUpdateVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useUpdateEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` You can also pass in a `DataConnect` instance to the Mutation hook function. ```javascript -useUpdateVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useUpdateEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` ### Variables -The `UpdateVendor` Mutation requires an argument of type `UpdateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +The `UpdateEvent` Mutation requires an argument of type `UpdateEventVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface UpdateVendorVariables { +export interface UpdateEventVariables { id: UUIDString; - vendorNumber?: string | null; - legalName?: string | null; - region?: VendorRegion | null; - platformType?: VendorPlatformType | null; - primaryContactEmail?: string | null; - approvalStatus?: VendorApprovalStatus | null; - isActive?: boolean | null; + eventName?: string | null; + isRapid?: boolean | null; + isRecurring?: boolean | null; + isMultiDay?: boolean | null; + recurrenceType?: RecurrenceType | null; + recurrenceStartDate?: TimestampString | null; + recurrenceEndDate?: TimestampString | null; + scatterDates?: string | null; + multiDayStartDate?: TimestampString | null; + multiDayEndDate?: TimestampString | null; + bufferTimeBefore?: number | null; + bufferTimeAfter?: number | null; + conflictDetectionEnabled?: boolean | null; + detectedConflicts?: string | null; + businessId?: UUIDString | null; + businessName?: string | null; + vendorId?: UUIDString | null; + vendorName?: string | null; + hub?: string | null; + eventLocation?: string | null; + contractType?: ContractType | null; + poReference?: string | null; + status?: EventStatus | null; + date?: TimestampString | null; + shifts?: string | null; + addons?: string | null; + total?: number | null; + clientName?: string | null; + clientEmail?: string | null; + clientPhone?: string | null; + invoiceId?: UUIDString | null; + notes?: string | null; + requested?: number | null; + assignedStaff?: string | null; } ``` ### Return Type -Recall that calling the `UpdateVendor` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. +Recall that calling the `UpdateEvent` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `UpdateVendor` Mutation is of type `UpdateVendorData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `UpdateEvent` Mutation is of type `UpdateEventData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface UpdateVendorData { - vendor_update?: Vendor_Key | null; +export interface UpdateEventData { + event_update?: Event_Key | null; } ``` To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). -### Using `UpdateVendor`'s Mutation hook function +### Using `UpdateEvent`'s Mutation hook function ```javascript import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, UpdateVendorVariables } from '@dataconnect/generated'; -import { useUpdateVendor } from '@dataconnect/generated/react' +import { connectorConfig, UpdateEventVariables } from '@dataconnect/generated'; +import { useUpdateEvent } from '@dataconnect/generated/react' -export default function UpdateVendorComponent() { +export default function UpdateEventComponent() { // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useUpdateVendor(); + const mutation = useUpdateEvent(); // You can also pass in a `DataConnect` instance to the Mutation hook function. const dataConnect = getDataConnect(connectorConfig); - const mutation = useUpdateVendor(dataConnect); + const mutation = useUpdateEvent(dataConnect); // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useUpdateVendor(options); + const mutation = useUpdateEvent(options); // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. const dataConnect = getDataConnect(connectorConfig); const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useUpdateVendor(dataConnect, options); + const mutation = useUpdateEvent(dataConnect, options); // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useUpdateVendor` Mutation requires an argument of type `UpdateVendorVariables`: - const updateVendorVars: UpdateVendorVariables = { + // The `useUpdateEvent` Mutation requires an argument of type `UpdateEventVariables`: + const updateEventVars: UpdateEventVariables = { id: ..., - vendorNumber: ..., // optional - legalName: ..., // optional - region: ..., // optional - platformType: ..., // optional - primaryContactEmail: ..., // optional - approvalStatus: ..., // optional - isActive: ..., // optional + 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 + assignedStaff: ..., // optional }; - mutation.mutate(updateVendorVars); + mutation.mutate(updateEventVars); // Variables can be defined inline as well. - mutation.mutate({ id: ..., vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); + mutation.mutate({ 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: ..., assignedStaff: ..., }); // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - mutation.mutate(updateVendorVars, options); + mutation.mutate(updateEventVars, options); // Then, you can render your component dynamically based on the status of the Mutation. if (mutation.isPending) { @@ -1906,80 +2291,80 @@ export default function UpdateVendorComponent() { // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. if (mutation.isSuccess) { - console.log(mutation.data.vendor_update); + console.log(mutation.data.event_update); } return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; } ``` -## DeleteVendor -You can execute the `DeleteVendor` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +## DeleteEvent +You can execute the `DeleteEvent` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): ```javascript -useDeleteVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useDeleteEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` You can also pass in a `DataConnect` instance to the Mutation hook function. ```javascript -useDeleteVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useDeleteEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` ### Variables -The `DeleteVendor` Mutation requires an argument of type `DeleteVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +The `DeleteEvent` Mutation requires an argument of type `DeleteEventVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface DeleteVendorVariables { +export interface DeleteEventVariables { id: UUIDString; } ``` ### Return Type -Recall that calling the `DeleteVendor` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. +Recall that calling the `DeleteEvent` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `DeleteVendor` Mutation is of type `DeleteVendorData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `DeleteEvent` Mutation is of type `DeleteEventData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface DeleteVendorData { - vendor_delete?: Vendor_Key | null; +export interface DeleteEventData { + event_delete?: Event_Key | null; } ``` To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). -### Using `DeleteVendor`'s Mutation hook function +### Using `DeleteEvent`'s Mutation hook function ```javascript import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, DeleteVendorVariables } from '@dataconnect/generated'; -import { useDeleteVendor } from '@dataconnect/generated/react' +import { connectorConfig, DeleteEventVariables } from '@dataconnect/generated'; +import { useDeleteEvent } from '@dataconnect/generated/react' -export default function DeleteVendorComponent() { +export default function DeleteEventComponent() { // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useDeleteVendor(); + const mutation = useDeleteEvent(); // You can also pass in a `DataConnect` instance to the Mutation hook function. const dataConnect = getDataConnect(connectorConfig); - const mutation = useDeleteVendor(dataConnect); + const mutation = useDeleteEvent(dataConnect); // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useDeleteVendor(options); + const mutation = useDeleteEvent(options); // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. const dataConnect = getDataConnect(connectorConfig); const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useDeleteVendor(dataConnect, options); + const mutation = useDeleteEvent(dataConnect, options); // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useDeleteVendor` Mutation requires an argument of type `DeleteVendorVariables`: - const deleteVendorVars: DeleteVendorVariables = { + // The `useDeleteEvent` Mutation requires an argument of type `DeleteEventVariables`: + const deleteEventVars: DeleteEventVariables = { id: ..., }; - mutation.mutate(deleteVendorVars); + mutation.mutate(deleteEventVars); // Variables can be defined inline as well. mutation.mutate({ id: ..., }); @@ -1987,7 +2372,7 @@ export default function DeleteVendorComponent() { const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - mutation.mutate(deleteVendorVars, options); + mutation.mutate(deleteEventVars, options); // Then, you can render your component dynamically based on the status of the Mutation. if (mutation.isPending) { @@ -2000,7 +2385,315 @@ export default function DeleteVendorComponent() { // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. if (mutation.isSuccess) { - console.log(mutation.data.vendor_delete); + console.log(mutation.data.event_delete); + } + return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## CreateVendorRate +You can execute the `CreateVendorRate` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +```javascript +useCreateVendorRate(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` +You can also pass in a `DataConnect` instance to the Mutation hook function. +```javascript +useCreateVendorRate(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` + +### Variables +The `CreateVendorRate` Mutation requires an argument of type `CreateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface CreateVendorRateVariables { + vendorName: string; + category: VendorRateCategory; + roleName: string; + employeeWage: number; + markupPercentage?: number | null; + vendorFeePercentage?: number | null; + clientRate: number; +} +``` +### Return Type +Recall that calling the `CreateVendorRate` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. + +To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. + +To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. + +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `CreateVendorRate` Mutation is of type `CreateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface CreateVendorRateData { + vendorRate_insert: VendorRate_Key; +} +``` + +To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). + +### Using `CreateVendorRate`'s Mutation hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, CreateVendorRateVariables } from '@dataconnect/generated'; +import { useCreateVendorRate } from '@dataconnect/generated/react' + +export default function CreateVendorRateComponent() { + // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. + const mutation = useCreateVendorRate(); + + // You can also pass in a `DataConnect` instance to the Mutation hook function. + const dataConnect = getDataConnect(connectorConfig); + const mutation = useCreateVendorRate(dataConnect); + + // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useCreateVendorRate(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useCreateVendorRate(dataConnect, options); + + // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. + // The `useCreateVendorRate` Mutation requires an argument of type `CreateVendorRateVariables`: + const createVendorRateVars: CreateVendorRateVariables = { + vendorName: ..., + category: ..., + roleName: ..., + employeeWage: ..., + markupPercentage: ..., // optional + vendorFeePercentage: ..., // optional + clientRate: ..., + }; + mutation.mutate(createVendorRateVars); + // Variables can be defined inline as well. + mutation.mutate({ vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); + + // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + mutation.mutate(createVendorRateVars, options); + + // Then, you can render your component dynamically based on the status of the Mutation. + if (mutation.isPending) { + return
Loading...
; + } + + if (mutation.isError) { + return
Error: {mutation.error.message}
; + } + + // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. + if (mutation.isSuccess) { + console.log(mutation.data.vendorRate_insert); + } + return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## UpdateVendorRate +You can execute the `UpdateVendorRate` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +```javascript +useUpdateVendorRate(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` +You can also pass in a `DataConnect` instance to the Mutation hook function. +```javascript +useUpdateVendorRate(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` + +### Variables +The `UpdateVendorRate` Mutation requires an argument of type `UpdateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +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 calling the `UpdateVendorRate` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. + +To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. + +To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. + +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `UpdateVendorRate` Mutation is of type `UpdateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface UpdateVendorRateData { + vendorRate_update?: VendorRate_Key | null; +} +``` + +To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). + +### Using `UpdateVendorRate`'s Mutation hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, UpdateVendorRateVariables } from '@dataconnect/generated'; +import { useUpdateVendorRate } from '@dataconnect/generated/react' + +export default function UpdateVendorRateComponent() { + // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. + const mutation = useUpdateVendorRate(); + + // You can also pass in a `DataConnect` instance to the Mutation hook function. + const dataConnect = getDataConnect(connectorConfig); + const mutation = useUpdateVendorRate(dataConnect); + + // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useUpdateVendorRate(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useUpdateVendorRate(dataConnect, options); + + // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. + // The `useUpdateVendorRate` 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 + }; + mutation.mutate(updateVendorRateVars); + // Variables can be defined inline as well. + mutation.mutate({ id: ..., vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); + + // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + mutation.mutate(updateVendorRateVars, options); + + // Then, you can render your component dynamically based on the status of the Mutation. + if (mutation.isPending) { + return
Loading...
; + } + + if (mutation.isError) { + return
Error: {mutation.error.message}
; + } + + // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. + if (mutation.isSuccess) { + console.log(mutation.data.vendorRate_update); + } + return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## DeleteVendorRate +You can execute the `DeleteVendorRate` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +```javascript +useDeleteVendorRate(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` +You can also pass in a `DataConnect` instance to the Mutation hook function. +```javascript +useDeleteVendorRate(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` + +### Variables +The `DeleteVendorRate` Mutation requires an argument of type `DeleteVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface DeleteVendorRateVariables { + id: UUIDString; +} +``` +### Return Type +Recall that calling the `DeleteVendorRate` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. + +To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. + +To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. + +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `DeleteVendorRate` Mutation is of type `DeleteVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface DeleteVendorRateData { + vendorRate_delete?: VendorRate_Key | null; +} +``` + +To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). + +### Using `DeleteVendorRate`'s Mutation hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, DeleteVendorRateVariables } from '@dataconnect/generated'; +import { useDeleteVendorRate } from '@dataconnect/generated/react' + +export default function DeleteVendorRateComponent() { + // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. + const mutation = useDeleteVendorRate(); + + // You can also pass in a `DataConnect` instance to the Mutation hook function. + const dataConnect = getDataConnect(connectorConfig); + const mutation = useDeleteVendorRate(dataConnect); + + // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useDeleteVendorRate(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useDeleteVendorRate(dataConnect, options); + + // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. + // The `useDeleteVendorRate` Mutation requires an argument of type `DeleteVendorRateVariables`: + const deleteVendorRateVars: DeleteVendorRateVariables = { + id: ..., + }; + mutation.mutate(deleteVendorRateVars); + // Variables can be defined inline as well. + mutation.mutate({ id: ..., }); + + // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + mutation.mutate(deleteVendorRateVars, options); + + // Then, you can render your component dynamically based on the status of the Mutation. + if (mutation.isPending) { + return
Loading...
; + } + + if (mutation.isError) { + return
Error: {mutation.error.message}
; + } + + // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. + if (mutation.isSuccess) { + console.log(mutation.data.vendorRate_delete); } return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; } @@ -2424,6 +3117,314 @@ export default function CreateStaffComponent() { } ``` +## CreateVendor +You can execute the `CreateVendor` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +```javascript +useCreateVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` +You can also pass in a `DataConnect` instance to the Mutation hook function. +```javascript +useCreateVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` + +### Variables +The `CreateVendor` Mutation requires an argument of type `CreateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface CreateVendorVariables { + vendorNumber: string; + legalName: string; + region: VendorRegion; + platformType: VendorPlatformType; + primaryContactEmail: string; + approvalStatus: VendorApprovalStatus; + isActive?: boolean | null; +} +``` +### Return Type +Recall that calling the `CreateVendor` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. + +To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. + +To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. + +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `CreateVendor` Mutation is of type `CreateVendorData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface CreateVendorData { + vendor_insert: Vendor_Key; +} +``` + +To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). + +### Using `CreateVendor`'s Mutation hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, CreateVendorVariables } from '@dataconnect/generated'; +import { useCreateVendor } from '@dataconnect/generated/react' + +export default function CreateVendorComponent() { + // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. + const mutation = useCreateVendor(); + + // You can also pass in a `DataConnect` instance to the Mutation hook function. + const dataConnect = getDataConnect(connectorConfig); + const mutation = useCreateVendor(dataConnect); + + // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useCreateVendor(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useCreateVendor(dataConnect, options); + + // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. + // The `useCreateVendor` Mutation requires an argument of type `CreateVendorVariables`: + const createVendorVars: CreateVendorVariables = { + vendorNumber: ..., + legalName: ..., + region: ..., + platformType: ..., + primaryContactEmail: ..., + approvalStatus: ..., + isActive: ..., // optional + }; + mutation.mutate(createVendorVars); + // Variables can be defined inline as well. + mutation.mutate({ vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); + + // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + mutation.mutate(createVendorVars, options); + + // Then, you can render your component dynamically based on the status of the Mutation. + if (mutation.isPending) { + return
Loading...
; + } + + if (mutation.isError) { + return
Error: {mutation.error.message}
; + } + + // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. + if (mutation.isSuccess) { + console.log(mutation.data.vendor_insert); + } + return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## UpdateVendor +You can execute the `UpdateVendor` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +```javascript +useUpdateVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` +You can also pass in a `DataConnect` instance to the Mutation hook function. +```javascript +useUpdateVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` + +### Variables +The `UpdateVendor` Mutation requires an argument of type `UpdateVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +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 calling the `UpdateVendor` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. + +To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. + +To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. + +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `UpdateVendor` Mutation is of type `UpdateVendorData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface UpdateVendorData { + vendor_update?: Vendor_Key | null; +} +``` + +To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). + +### Using `UpdateVendor`'s Mutation hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, UpdateVendorVariables } from '@dataconnect/generated'; +import { useUpdateVendor } from '@dataconnect/generated/react' + +export default function UpdateVendorComponent() { + // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. + const mutation = useUpdateVendor(); + + // You can also pass in a `DataConnect` instance to the Mutation hook function. + const dataConnect = getDataConnect(connectorConfig); + const mutation = useUpdateVendor(dataConnect); + + // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useUpdateVendor(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useUpdateVendor(dataConnect, options); + + // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. + // The `useUpdateVendor` 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 + }; + mutation.mutate(updateVendorVars); + // Variables can be defined inline as well. + mutation.mutate({ id: ..., vendorNumber: ..., legalName: ..., region: ..., platformType: ..., primaryContactEmail: ..., approvalStatus: ..., isActive: ..., }); + + // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + mutation.mutate(updateVendorVars, options); + + // Then, you can render your component dynamically based on the status of the Mutation. + if (mutation.isPending) { + return
Loading...
; + } + + if (mutation.isError) { + return
Error: {mutation.error.message}
; + } + + // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. + if (mutation.isSuccess) { + console.log(mutation.data.vendor_update); + } + return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## DeleteVendor +You can execute the `DeleteVendor` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +```javascript +useDeleteVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` +You can also pass in a `DataConnect` instance to the Mutation hook function. +```javascript +useDeleteVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` + +### Variables +The `DeleteVendor` Mutation requires an argument of type `DeleteVendorVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface DeleteVendorVariables { + id: UUIDString; +} +``` +### Return Type +Recall that calling the `DeleteVendor` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. + +To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. + +To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. + +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `DeleteVendor` Mutation is of type `DeleteVendorData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface DeleteVendorData { + vendor_delete?: Vendor_Key | null; +} +``` + +To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). + +### Using `DeleteVendor`'s Mutation hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, DeleteVendorVariables } from '@dataconnect/generated'; +import { useDeleteVendor } from '@dataconnect/generated/react' + +export default function DeleteVendorComponent() { + // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. + const mutation = useDeleteVendor(); + + // You can also pass in a `DataConnect` instance to the Mutation hook function. + const dataConnect = getDataConnect(connectorConfig); + const mutation = useDeleteVendor(dataConnect); + + // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useDeleteVendor(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useDeleteVendor(dataConnect, options); + + // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. + // The `useDeleteVendor` Mutation requires an argument of type `DeleteVendorVariables`: + const deleteVendorVars: DeleteVendorVariables = { + id: ..., + }; + mutation.mutate(deleteVendorVars); + // Variables can be defined inline as well. + mutation.mutate({ id: ..., }); + + // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + mutation.mutate(deleteVendorVars, options); + + // Then, you can render your component dynamically based on the status of the Mutation. + if (mutation.isPending) { + return
Loading...
; + } + + if (mutation.isError) { + return
Error: {mutation.error.message}
; + } + + // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. + if (mutation.isSuccess) { + console.log(mutation.data.vendor_delete); + } + return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; +} +``` + ## CreateVendorDefaultSetting You can execute the `CreateVendorDefaultSetting` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): ```javascript @@ -2716,618 +3717,92 @@ export default function DeleteVendorDefaultSettingComponent() { } ``` -## CreateVendorRate -You can execute the `CreateVendorRate` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +## CreateBusiness +You can execute the `CreateBusiness` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): ```javascript -useCreateVendorRate(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useCreateBusiness(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` You can also pass in a `DataConnect` instance to the Mutation hook function. ```javascript -useCreateVendorRate(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useCreateBusiness(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` ### Variables -The `CreateVendorRate` Mutation requires an argument of type `CreateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +The `CreateBusiness` Mutation requires an argument of type `CreateBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface CreateVendorRateVariables { - vendorName: string; - category: VendorRateCategory; - roleName: string; - employeeWage: number; - markupPercentage?: number | null; - vendorFeePercentage?: number | null; - clientRate: number; +export interface CreateBusinessVariables { + businessName: string; + contactName: string; + email?: string | null; + sector?: BusinessSector | null; + rateGroup: BusinessRateGroup; + status?: BusinessStatus | null; } ``` ### Return Type -Recall that calling the `CreateVendorRate` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. +Recall that calling the `CreateBusiness` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `CreateVendorRate` Mutation is of type `CreateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `CreateBusiness` Mutation is of type `CreateBusinessData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface CreateVendorRateData { - vendorRate_insert: VendorRate_Key; +export interface CreateBusinessData { + business_insert: Business_Key; } ``` To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). -### Using `CreateVendorRate`'s Mutation hook function +### Using `CreateBusiness`'s Mutation hook function ```javascript import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, CreateVendorRateVariables } from '@dataconnect/generated'; -import { useCreateVendorRate } from '@dataconnect/generated/react' +import { connectorConfig, CreateBusinessVariables } from '@dataconnect/generated'; +import { useCreateBusiness } from '@dataconnect/generated/react' -export default function CreateVendorRateComponent() { +export default function CreateBusinessComponent() { // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useCreateVendorRate(); + const mutation = useCreateBusiness(); // You can also pass in a `DataConnect` instance to the Mutation hook function. const dataConnect = getDataConnect(connectorConfig); - const mutation = useCreateVendorRate(dataConnect); + const mutation = useCreateBusiness(dataConnect); // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useCreateVendorRate(options); + const mutation = useCreateBusiness(options); // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. const dataConnect = getDataConnect(connectorConfig); const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useCreateVendorRate(dataConnect, options); + const mutation = useCreateBusiness(dataConnect, options); // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useCreateVendorRate` Mutation requires an argument of type `CreateVendorRateVariables`: - const createVendorRateVars: CreateVendorRateVariables = { - vendorName: ..., - category: ..., - roleName: ..., - employeeWage: ..., - markupPercentage: ..., // optional - vendorFeePercentage: ..., // optional - clientRate: ..., - }; - mutation.mutate(createVendorRateVars); - // Variables can be defined inline as well. - mutation.mutate({ vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); - - // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - mutation.mutate(createVendorRateVars, options); - - // Then, you can render your component dynamically based on the status of the Mutation. - if (mutation.isPending) { - return
Loading...
; - } - - if (mutation.isError) { - return
Error: {mutation.error.message}
; - } - - // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. - if (mutation.isSuccess) { - console.log(mutation.data.vendorRate_insert); - } - return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## UpdateVendorRate -You can execute the `UpdateVendorRate` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): -```javascript -useUpdateVendorRate(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -``` -You can also pass in a `DataConnect` instance to the Mutation hook function. -```javascript -useUpdateVendorRate(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -``` - -### Variables -The `UpdateVendorRate` Mutation requires an argument of type `UpdateVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: - -```javascript -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 calling the `UpdateVendorRate` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. - -To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. - -To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. - -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `UpdateVendorRate` Mutation is of type `UpdateVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface UpdateVendorRateData { - vendorRate_update?: VendorRate_Key | null; -} -``` - -To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). - -### Using `UpdateVendorRate`'s Mutation hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, UpdateVendorRateVariables } from '@dataconnect/generated'; -import { useUpdateVendorRate } from '@dataconnect/generated/react' - -export default function UpdateVendorRateComponent() { - // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useUpdateVendorRate(); - - // You can also pass in a `DataConnect` instance to the Mutation hook function. - const dataConnect = getDataConnect(connectorConfig); - const mutation = useUpdateVendorRate(dataConnect); - - // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - const mutation = useUpdateVendorRate(options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - const mutation = useUpdateVendorRate(dataConnect, options); - - // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useUpdateVendorRate` 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 - }; - mutation.mutate(updateVendorRateVars); - // Variables can be defined inline as well. - mutation.mutate({ id: ..., vendorName: ..., category: ..., roleName: ..., employeeWage: ..., markupPercentage: ..., vendorFeePercentage: ..., clientRate: ..., }); - - // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - mutation.mutate(updateVendorRateVars, options); - - // Then, you can render your component dynamically based on the status of the Mutation. - if (mutation.isPending) { - return
Loading...
; - } - - if (mutation.isError) { - return
Error: {mutation.error.message}
; - } - - // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. - if (mutation.isSuccess) { - console.log(mutation.data.vendorRate_update); - } - return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## DeleteVendorRate -You can execute the `DeleteVendorRate` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): -```javascript -useDeleteVendorRate(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -``` -You can also pass in a `DataConnect` instance to the Mutation hook function. -```javascript -useDeleteVendorRate(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -``` - -### Variables -The `DeleteVendorRate` Mutation requires an argument of type `DeleteVendorRateVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: - -```javascript -export interface DeleteVendorRateVariables { - id: UUIDString; -} -``` -### Return Type -Recall that calling the `DeleteVendorRate` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. - -To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. - -To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. - -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `DeleteVendorRate` Mutation is of type `DeleteVendorRateData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface DeleteVendorRateData { - vendorRate_delete?: VendorRate_Key | null; -} -``` - -To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). - -### Using `DeleteVendorRate`'s Mutation hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, DeleteVendorRateVariables } from '@dataconnect/generated'; -import { useDeleteVendorRate } from '@dataconnect/generated/react' - -export default function DeleteVendorRateComponent() { - // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useDeleteVendorRate(); - - // You can also pass in a `DataConnect` instance to the Mutation hook function. - const dataConnect = getDataConnect(connectorConfig); - const mutation = useDeleteVendorRate(dataConnect); - - // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - const mutation = useDeleteVendorRate(options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - const mutation = useDeleteVendorRate(dataConnect, options); - - // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useDeleteVendorRate` Mutation requires an argument of type `DeleteVendorRateVariables`: - const deleteVendorRateVars: DeleteVendorRateVariables = { - id: ..., - }; - mutation.mutate(deleteVendorRateVars); - // Variables can be defined inline as well. - mutation.mutate({ id: ..., }); - - // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - mutation.mutate(deleteVendorRateVars, options); - - // Then, you can render your component dynamically based on the status of the Mutation. - if (mutation.isPending) { - return
Loading...
; - } - - if (mutation.isError) { - return
Error: {mutation.error.message}
; - } - - // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. - if (mutation.isSuccess) { - console.log(mutation.data.vendorRate_delete); - } - return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## CreateEvent -You can execute the `CreateEvent` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): -```javascript -useCreateEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -``` -You can also pass in a `DataConnect` instance to the Mutation hook function. -```javascript -useCreateEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -``` - -### Variables -The `CreateEvent` Mutation requires an argument of type `CreateEventVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: - -```javascript -export interface CreateEventVariables { - eventName: string; - isRapid?: boolean | null; - isRecurring?: boolean | null; - isMultiDay?: boolean | null; - recurrenceType?: RecurrenceType | null; - recurrenceStartDate?: TimestampString | null; - recurrenceEndDate?: TimestampString | null; - scatterDates?: string | null; - multiDayStartDate?: TimestampString | null; - multiDayEndDate?: TimestampString | null; - bufferTimeBefore?: number | null; - bufferTimeAfter?: number | null; - conflictDetectionEnabled?: boolean | null; - detectedConflicts?: string | null; - businessId: UUIDString; - businessName?: string | null; - vendorId?: UUIDString | null; - vendorName?: string | null; - hub?: string | null; - eventLocation?: string | null; - contractType?: ContractType | null; - poReference?: string | null; - status: EventStatus; - date: TimestampString; - shifts?: string | null; - addons?: string | null; - total?: number | null; - clientName?: string | null; - clientEmail?: string | null; - clientPhone?: string | null; - invoiceId?: UUIDString | null; - notes?: string | null; - requested?: number | null; - assignedStaff?: string | null; -} -``` -### Return Type -Recall that calling the `CreateEvent` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. - -To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. - -To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. - -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `CreateEvent` Mutation is of type `CreateEventData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface CreateEventData { - event_insert: Event_Key; -} -``` - -To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). - -### Using `CreateEvent`'s Mutation hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, CreateEventVariables } from '@dataconnect/generated'; -import { useCreateEvent } from '@dataconnect/generated/react' - -export default function CreateEventComponent() { - // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useCreateEvent(); - - // You can also pass in a `DataConnect` instance to the Mutation hook function. - const dataConnect = getDataConnect(connectorConfig); - const mutation = useCreateEvent(dataConnect); - - // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - const mutation = useCreateEvent(options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - const mutation = useCreateEvent(dataConnect, options); - - // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useCreateEvent` 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 - }; - mutation.mutate(createEventVars); - // Variables can be defined inline as well. - mutation.mutate({ 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: ..., }); - - // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - mutation.mutate(createEventVars, options); - - // Then, you can render your component dynamically based on the status of the Mutation. - if (mutation.isPending) { - return
Loading...
; - } - - if (mutation.isError) { - return
Error: {mutation.error.message}
; - } - - // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. - if (mutation.isSuccess) { - console.log(mutation.data.event_insert); - } - return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; -} -``` - -## UpdateEvent -You can execute the `UpdateEvent` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): -```javascript -useUpdateEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -``` -You can also pass in a `DataConnect` instance to the Mutation hook function. -```javascript -useUpdateEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -``` - -### Variables -The `UpdateEvent` Mutation requires an argument of type `UpdateEventVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: - -```javascript -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?: string | null; - multiDayStartDate?: TimestampString | null; - multiDayEndDate?: TimestampString | null; - bufferTimeBefore?: number | null; - bufferTimeAfter?: number | null; - conflictDetectionEnabled?: boolean | null; - detectedConflicts?: string | null; - businessId?: UUIDString | null; - businessName?: string | null; - vendorId?: UUIDString | null; - vendorName?: string | null; - hub?: string | null; - eventLocation?: string | null; - contractType?: ContractType | null; - poReference?: string | null; - status?: EventStatus | null; - date?: TimestampString | null; - shifts?: string | null; - addons?: string | null; - total?: number | null; - clientName?: string | null; - clientEmail?: string | null; - clientPhone?: string | null; - invoiceId?: UUIDString | null; - notes?: string | null; - requested?: number | null; - assignedStaff?: string | null; -} -``` -### Return Type -Recall that calling the `UpdateEvent` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. - -To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. - -To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. - -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `UpdateEvent` Mutation is of type `UpdateEventData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: -```javascript -export interface UpdateEventData { - event_update?: Event_Key | null; -} -``` - -To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). - -### Using `UpdateEvent`'s Mutation hook function - -```javascript -import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, UpdateEventVariables } from '@dataconnect/generated'; -import { useUpdateEvent } from '@dataconnect/generated/react' - -export default function UpdateEventComponent() { - // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useUpdateEvent(); - - // You can also pass in a `DataConnect` instance to the Mutation hook function. - const dataConnect = getDataConnect(connectorConfig); - const mutation = useUpdateEvent(dataConnect); - - // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - const mutation = useUpdateEvent(options); - - // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. - const dataConnect = getDataConnect(connectorConfig); - const options = { - onSuccess: () => { console.log('Mutation succeeded!'); } - }; - const mutation = useUpdateEvent(dataConnect, options); - - // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useUpdateEvent` 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 + // The `useCreateBusiness` Mutation requires an argument of type `CreateBusinessVariables`: + const createBusinessVars: CreateBusinessVariables = { + businessName: ..., + contactName: ..., + email: ..., // optional + sector: ..., // optional + rateGroup: ..., status: ..., // optional - date: ..., // optional - shifts: ..., // optional - addons: ..., // optional - total: ..., // optional - clientName: ..., // optional - clientEmail: ..., // optional - clientPhone: ..., // optional - invoiceId: ..., // optional - notes: ..., // optional - requested: ..., // optional - assignedStaff: ..., // optional }; - mutation.mutate(updateEventVars); + mutation.mutate(createBusinessVars); // Variables can be defined inline as well. - mutation.mutate({ 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: ..., assignedStaff: ..., }); + mutation.mutate({ businessName: ..., contactName: ..., email: ..., sector: ..., rateGroup: ..., status: ..., }); // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - mutation.mutate(updateEventVars, options); + mutation.mutate(createBusinessVars, options); // Then, you can render your component dynamically based on the status of the Mutation. if (mutation.isPending) { @@ -3340,80 +3815,186 @@ export default function UpdateEventComponent() { // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. if (mutation.isSuccess) { - console.log(mutation.data.event_update); + console.log(mutation.data.business_insert); } return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; } ``` -## DeleteEvent -You can execute the `DeleteEvent` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +## UpdateBusiness +You can execute the `UpdateBusiness` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): ```javascript -useDeleteEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useUpdateBusiness(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` You can also pass in a `DataConnect` instance to the Mutation hook function. ```javascript -useDeleteEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +useUpdateBusiness(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; ``` ### Variables -The `DeleteEvent` Mutation requires an argument of type `DeleteEventVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +The `UpdateBusiness` Mutation requires an argument of type `UpdateBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface DeleteEventVariables { +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 calling the `DeleteEvent` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. +Recall that calling the `UpdateBusiness` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. -To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `DeleteEvent` Mutation is of type `DeleteEventData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `UpdateBusiness` Mutation is of type `UpdateBusinessData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: ```javascript -export interface DeleteEventData { - event_delete?: Event_Key | null; +export interface UpdateBusinessData { + business_update?: Business_Key | null; } ``` To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). -### Using `DeleteEvent`'s Mutation hook function +### Using `UpdateBusiness`'s Mutation hook function ```javascript import { getDataConnect } from 'firebase/data-connect'; -import { connectorConfig, DeleteEventVariables } from '@dataconnect/generated'; -import { useDeleteEvent } from '@dataconnect/generated/react' +import { connectorConfig, UpdateBusinessVariables } from '@dataconnect/generated'; +import { useUpdateBusiness } from '@dataconnect/generated/react' -export default function DeleteEventComponent() { +export default function UpdateBusinessComponent() { // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. - const mutation = useDeleteEvent(); + const mutation = useUpdateBusiness(); // You can also pass in a `DataConnect` instance to the Mutation hook function. const dataConnect = getDataConnect(connectorConfig); - const mutation = useDeleteEvent(dataConnect); + const mutation = useUpdateBusiness(dataConnect); // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useDeleteEvent(options); + const mutation = useUpdateBusiness(options); // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. const dataConnect = getDataConnect(connectorConfig); const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - const mutation = useDeleteEvent(dataConnect, options); + const mutation = useUpdateBusiness(dataConnect, options); // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. - // The `useDeleteEvent` Mutation requires an argument of type `DeleteEventVariables`: - const deleteEventVars: DeleteEventVariables = { + // The `useUpdateBusiness` Mutation requires an argument of type `UpdateBusinessVariables`: + const updateBusinessVars: UpdateBusinessVariables = { + id: ..., + businessName: ..., // optional + contactName: ..., // optional + email: ..., // optional + sector: ..., // optional + rateGroup: ..., // optional + status: ..., // optional + }; + mutation.mutate(updateBusinessVars); + // Variables can be defined inline as well. + mutation.mutate({ id: ..., businessName: ..., contactName: ..., email: ..., sector: ..., rateGroup: ..., status: ..., }); + + // You can also pass in a `useDataConnectMutationOptions` object to `UseMutationResult.mutate()`. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + mutation.mutate(updateBusinessVars, options); + + // Then, you can render your component dynamically based on the status of the Mutation. + if (mutation.isPending) { + return
Loading...
; + } + + if (mutation.isError) { + return
Error: {mutation.error.message}
; + } + + // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. + if (mutation.isSuccess) { + console.log(mutation.data.business_update); + } + return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; +} +``` + +## DeleteBusiness +You can execute the `DeleteBusiness` Mutation using the `UseMutationResult` object returned by the following Mutation hook function (which is defined in [dataconnect-generated/react/index.d.ts](./index.d.ts)): +```javascript +useDeleteBusiness(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` +You can also pass in a `DataConnect` instance to the Mutation hook function. +```javascript +useDeleteBusiness(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +``` + +### Variables +The `DeleteBusiness` Mutation requires an argument of type `DeleteBusinessVariables`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: + +```javascript +export interface DeleteBusinessVariables { + id: UUIDString; +} +``` +### Return Type +Recall that calling the `DeleteBusiness` Mutation hook function returns a `UseMutationResult` object. This object holds the state of your Mutation, including whether the Mutation is loading, has completed, or has succeeded/failed, among other things. + +To check the status of a Mutation, use the `UseMutationResult.status` field. You can also check for pending / success / error status using the `UseMutationResult.isPending`, `UseMutationResult.isSuccess`, and `UseMutationResult.isError` fields. + +To execute the Mutation, call `UseMutationResult.mutate()`. This function executes the Mutation, but does not return the data from the Mutation. + +To access the data returned by a Mutation, use the `UseMutationResult.data` field. The data for the `DeleteBusiness` Mutation is of type `DeleteBusinessData`, which is defined in [dataconnect-generated/index.d.ts](../index.d.ts). It has the following fields: +```javascript +export interface DeleteBusinessData { + business_delete?: Business_Key | null; +} +``` + +To learn more about the `UseMutationResult` object, see the [TanStack React Query documentation](https://tanstack.com/query/v5/docs/framework/react/reference/useMutation). + +### Using `DeleteBusiness`'s Mutation hook function + +```javascript +import { getDataConnect } from 'firebase/data-connect'; +import { connectorConfig, DeleteBusinessVariables } from '@dataconnect/generated'; +import { useDeleteBusiness } from '@dataconnect/generated/react' + +export default function DeleteBusinessComponent() { + // Call the Mutation hook function to get a `UseMutationResult` object which holds the state of your Mutation. + const mutation = useDeleteBusiness(); + + // You can also pass in a `DataConnect` instance to the Mutation hook function. + const dataConnect = getDataConnect(connectorConfig); + const mutation = useDeleteBusiness(dataConnect); + + // You can also pass in a `useDataConnectMutationOptions` object to the Mutation hook function. + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useDeleteBusiness(options); + + // You can also pass both a `DataConnect` instance and a `useDataConnectMutationOptions` object. + const dataConnect = getDataConnect(connectorConfig); + const options = { + onSuccess: () => { console.log('Mutation succeeded!'); } + }; + const mutation = useDeleteBusiness(dataConnect, options); + + // After calling the Mutation hook function, you must call `UseMutationResult.mutate()` to execute the Mutation. + // The `useDeleteBusiness` Mutation requires an argument of type `DeleteBusinessVariables`: + const deleteBusinessVars: DeleteBusinessVariables = { id: ..., }; - mutation.mutate(deleteEventVars); + mutation.mutate(deleteBusinessVars); // Variables can be defined inline as well. mutation.mutate({ id: ..., }); @@ -3421,7 +4002,7 @@ export default function DeleteEventComponent() { const options = { onSuccess: () => { console.log('Mutation succeeded!'); } }; - mutation.mutate(deleteEventVars, options); + mutation.mutate(deleteBusinessVars, options); // Then, you can render your component dynamically based on the status of the Mutation. if (mutation.isPending) { @@ -3434,7 +4015,7 @@ export default function DeleteEventComponent() { // If the Mutation is successful, you can access the data returned using the `UseMutationResult.data` field. if (mutation.isSuccess) { - console.log(mutation.data.event_delete); + console.log(mutation.data.business_delete); } return
Mutation execution {mutation.isSuccess ? 'successful' : 'failed'}!
; } diff --git a/internal-api-harness/src/dataconnect-generated/react/esm/index.esm.js b/internal-api-harness/src/dataconnect-generated/react/esm/index.esm.js index a007882e..8fcd37c9 100644 --- a/internal-api-harness/src/dataconnect-generated/react/esm/index.esm.js +++ b/internal-api-harness/src/dataconnect-generated/react/esm/index.esm.js @@ -1,33 +1,45 @@ -import { listStaffRef, createVendorRef, updateVendorRef, deleteVendorRef, listVendorDefaultSettingsRef, getVendorDefaultSettingByIdRef, filterVendorDefaultSettingsRef, listEventsRef, getEventByIdRef, filterEventsRef, createInvoiceRef, updateInvoiceRef, deleteInvoiceRef, createStaffRef, listVendorRef, getVendorByIdRef, filterVendorsRef, createVendorDefaultSettingRef, updateVendorDefaultSettingRef, deleteVendorDefaultSettingRef, createVendorRateRef, updateVendorRateRef, deleteVendorRateRef, listVendorRateRef, getVendorRateByIdRef, filterVendorRatesRef, createEventRef, updateEventRef, deleteEventRef, listInvoiceRef, getInvoiceByIdRef, filterInvoicesRef, connectorConfig } from '../../esm/index.esm.js'; +import { listBusinessRef, getBusinessByIdRef, filterBusinessRef, createEventRef, updateEventRef, deleteEventRef, listVendorDefaultSettingsRef, getVendorDefaultSettingByIdRef, filterVendorDefaultSettingsRef, createVendorRateRef, updateVendorRateRef, deleteVendorRateRef, listVendorRateRef, getVendorRateByIdRef, filterVendorRatesRef, listEventsRef, getEventByIdRef, filterEventsRef, createInvoiceRef, updateInvoiceRef, deleteInvoiceRef, listInvoiceRef, getInvoiceByIdRef, filterInvoicesRef, createStaffRef, listStaffRef, createVendorRef, updateVendorRef, deleteVendorRef, listVendorRef, getVendorByIdRef, filterVendorsRef, createVendorDefaultSettingRef, updateVendorDefaultSettingRef, deleteVendorDefaultSettingRef, createBusinessRef, updateBusinessRef, deleteBusinessRef, connectorConfig } from '../../esm/index.esm.js'; import { validateArgs, CallerSdkTypeEnum } from 'firebase/data-connect'; import { useDataConnectQuery, useDataConnectMutation, validateReactArgs } from '@tanstack-query-firebase/react/data-connect'; -export function useListStaff(dcOrOptions, options) { +export function useListBusiness(dcOrOptions, options) { const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); - const ref = listStaffRef(dcInstance); + const ref = listBusinessRef(dcInstance); return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -export function useCreateVendor(dcOrOptions, options) { + +export function useGetBusinessById(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); + const ref = getBusinessByIdRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useFilterBusiness(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); + const ref = filterBusinessRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} +export function useCreateEvent(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return createVendorRef(dcInstance, vars); + return createEventRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -export function useUpdateVendor(dcOrOptions, options) { +export function useUpdateEvent(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return updateVendorRef(dcInstance, vars); + return updateEventRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -export function useDeleteVendor(dcOrOptions, options) { +export function useDeleteEvent(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return deleteVendorRef(dcInstance, vars); + return deleteEventRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } @@ -50,6 +62,48 @@ export function useFilterVendorDefaultSettings(dcOrVars, varsOrOptions, options) const ref = filterVendorDefaultSettingsRef(dcInstance, inputVars); return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); } +export function useCreateVendorRate(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return createVendorRateRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useUpdateVendorRate(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return updateVendorRateRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useDeleteVendorRate(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return deleteVendorRateRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + + +export function useListVendorRate(dcOrOptions, options) { + const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); + const ref = listVendorRateRef(dcInstance); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useGetVendorRateById(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); + const ref = getVendorRateByIdRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useFilterVendorRates(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); + const ref = filterVendorRatesRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} export function useListEvents(dcOrOptions, options) { const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); @@ -92,6 +146,24 @@ export function useDeleteInvoice(dcOrOptions, options) { return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } + +export function useListInvoice(dcOrOptions, options) { + const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); + const ref = listInvoiceRef(dcInstance); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useGetInvoiceById(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); + const ref = getInvoiceByIdRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useFilterInvoices(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); + const ref = filterInvoicesRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} export function useCreateStaff(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { @@ -101,6 +173,36 @@ export function useCreateStaff(dcOrOptions, options) { } +export function useListStaff(dcOrOptions, options) { + const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); + const ref = listStaffRef(dcInstance); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} +export function useCreateVendor(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return createVendorRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useUpdateVendor(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return updateVendorRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +export function useDeleteVendor(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return deleteVendorRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + + export function useListVendor(dcOrOptions, options) { const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); const ref = listVendorRef(dcInstance); @@ -142,87 +244,26 @@ export function useDeleteVendorDefaultSetting(dcOrOptions, options) { return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -export function useCreateVendorRate(dcOrOptions, options) { +export function useCreateBusiness(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return createVendorRateRef(dcInstance, vars); + return createBusinessRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -export function useUpdateVendorRate(dcOrOptions, options) { +export function useUpdateBusiness(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return updateVendorRateRef(dcInstance, vars); + return updateBusinessRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -export function useDeleteVendorRate(dcOrOptions, options) { +export function useDeleteBusiness(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return deleteVendorRateRef(dcInstance, vars); + return deleteBusinessRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } - - -export function useListVendorRate(dcOrOptions, options) { - const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); - const ref = listVendorRateRef(dcInstance); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -export function useGetVendorRateById(dcOrVars, varsOrOptions, options) { - const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); - const ref = getVendorRateByIdRef(dcInstance, inputVars); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -export function useFilterVendorRates(dcOrVars, varsOrOptions, options) { - const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); - const ref = filterVendorRatesRef(dcInstance, inputVars); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} -export function useCreateEvent(dcOrOptions, options) { - const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); - function refFactory(vars) { - return createEventRef(dcInstance, vars); - } - return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -export function useUpdateEvent(dcOrOptions, options) { - const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); - function refFactory(vars) { - return updateEventRef(dcInstance, vars); - } - return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -export function useDeleteEvent(dcOrOptions, options) { - const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); - function refFactory(vars) { - return deleteEventRef(dcInstance, vars); - } - return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - - -export function useListInvoice(dcOrOptions, options) { - const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); - const ref = listInvoiceRef(dcInstance); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -export function useGetInvoiceById(dcOrVars, varsOrOptions, options) { - const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); - const ref = getInvoiceByIdRef(dcInstance, inputVars); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -export function useFilterInvoices(dcOrVars, varsOrOptions, options) { - const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); - const ref = filterInvoicesRef(dcInstance, inputVars); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} \ No newline at end of file diff --git a/internal-api-harness/src/dataconnect-generated/react/index.cjs.js b/internal-api-harness/src/dataconnect-generated/react/index.cjs.js index d7deeadc..3ecd5152 100644 --- a/internal-api-harness/src/dataconnect-generated/react/index.cjs.js +++ b/internal-api-harness/src/dataconnect-generated/react/index.cjs.js @@ -1,33 +1,45 @@ -const { listStaffRef, createVendorRef, updateVendorRef, deleteVendorRef, listVendorDefaultSettingsRef, getVendorDefaultSettingByIdRef, filterVendorDefaultSettingsRef, listEventsRef, getEventByIdRef, filterEventsRef, createInvoiceRef, updateInvoiceRef, deleteInvoiceRef, createStaffRef, listVendorRef, getVendorByIdRef, filterVendorsRef, createVendorDefaultSettingRef, updateVendorDefaultSettingRef, deleteVendorDefaultSettingRef, createVendorRateRef, updateVendorRateRef, deleteVendorRateRef, listVendorRateRef, getVendorRateByIdRef, filterVendorRatesRef, createEventRef, updateEventRef, deleteEventRef, listInvoiceRef, getInvoiceByIdRef, filterInvoicesRef, connectorConfig } = require('../index.cjs.js'); +const { listBusinessRef, getBusinessByIdRef, filterBusinessRef, createEventRef, updateEventRef, deleteEventRef, listVendorDefaultSettingsRef, getVendorDefaultSettingByIdRef, filterVendorDefaultSettingsRef, createVendorRateRef, updateVendorRateRef, deleteVendorRateRef, listVendorRateRef, getVendorRateByIdRef, filterVendorRatesRef, listEventsRef, getEventByIdRef, filterEventsRef, createInvoiceRef, updateInvoiceRef, deleteInvoiceRef, listInvoiceRef, getInvoiceByIdRef, filterInvoicesRef, createStaffRef, listStaffRef, createVendorRef, updateVendorRef, deleteVendorRef, listVendorRef, getVendorByIdRef, filterVendorsRef, createVendorDefaultSettingRef, updateVendorDefaultSettingRef, deleteVendorDefaultSettingRef, createBusinessRef, updateBusinessRef, deleteBusinessRef, connectorConfig } = require('../index.cjs.js'); const { validateArgs, CallerSdkTypeEnum } = require('firebase/data-connect'); const { useDataConnectQuery, useDataConnectMutation, validateReactArgs } = require('@tanstack-query-firebase/react/data-connect'); -exports.useListStaff = function useListStaff(dcOrOptions, options) { +exports.useListBusiness = function useListBusiness(dcOrOptions, options) { const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); - const ref = listStaffRef(dcInstance); + const ref = listBusinessRef(dcInstance); return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -exports.useCreateVendor = function useCreateVendor(dcOrOptions, options) { + +exports.useGetBusinessById = function useGetBusinessById(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); + const ref = getBusinessByIdRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useFilterBusiness = function useFilterBusiness(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); + const ref = filterBusinessRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} +exports.useCreateEvent = function useCreateEvent(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return createVendorRef(dcInstance, vars); + return createEventRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -exports.useUpdateVendor = function useUpdateVendor(dcOrOptions, options) { +exports.useUpdateEvent = function useUpdateEvent(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return updateVendorRef(dcInstance, vars); + return updateEventRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -exports.useDeleteVendor = function useDeleteVendor(dcOrOptions, options) { +exports.useDeleteEvent = function useDeleteEvent(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return deleteVendorRef(dcInstance, vars); + return deleteEventRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } @@ -50,6 +62,48 @@ exports.useFilterVendorDefaultSettings = function useFilterVendorDefaultSettings const ref = filterVendorDefaultSettingsRef(dcInstance, inputVars); return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); } +exports.useCreateVendorRate = function useCreateVendorRate(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return createVendorRateRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useUpdateVendorRate = function useUpdateVendorRate(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return updateVendorRateRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useDeleteVendorRate = function useDeleteVendorRate(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return deleteVendorRateRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + + +exports.useListVendorRate = function useListVendorRate(dcOrOptions, options) { + const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); + const ref = listVendorRateRef(dcInstance); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useGetVendorRateById = function useGetVendorRateById(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); + const ref = getVendorRateByIdRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useFilterVendorRates = function useFilterVendorRates(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); + const ref = filterVendorRatesRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} exports.useListEvents = function useListEvents(dcOrOptions, options) { const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); @@ -92,6 +146,24 @@ exports.useDeleteInvoice = function useDeleteInvoice(dcOrOptions, options) { return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } + +exports.useListInvoice = function useListInvoice(dcOrOptions, options) { + const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); + const ref = listInvoiceRef(dcInstance); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useGetInvoiceById = function useGetInvoiceById(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); + const ref = getInvoiceByIdRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useFilterInvoices = function useFilterInvoices(dcOrVars, varsOrOptions, options) { + const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); + const ref = filterInvoicesRef(dcInstance, inputVars); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} exports.useCreateStaff = function useCreateStaff(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { @@ -101,6 +173,36 @@ exports.useCreateStaff = function useCreateStaff(dcOrOptions, options) { } +exports.useListStaff = function useListStaff(dcOrOptions, options) { + const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); + const ref = listStaffRef(dcInstance); + return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} +exports.useCreateVendor = function useCreateVendor(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return createVendorRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useUpdateVendor = function useUpdateVendor(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return updateVendorRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + +exports.useDeleteVendor = function useDeleteVendor(dcOrOptions, options) { + const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); + function refFactory(vars) { + return deleteVendorRef(dcInstance, vars); + } + return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); +} + + exports.useListVendor = function useListVendor(dcOrOptions, options) { const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); const ref = listVendorRef(dcInstance); @@ -142,87 +244,26 @@ exports.useDeleteVendorDefaultSetting = function useDeleteVendorDefaultSetting(d return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -exports.useCreateVendorRate = function useCreateVendorRate(dcOrOptions, options) { +exports.useCreateBusiness = function useCreateBusiness(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return createVendorRateRef(dcInstance, vars); + return createBusinessRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -exports.useUpdateVendorRate = function useUpdateVendorRate(dcOrOptions, options) { +exports.useUpdateBusiness = function useUpdateBusiness(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return updateVendorRateRef(dcInstance, vars); + return updateBusinessRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } -exports.useDeleteVendorRate = function useDeleteVendorRate(dcOrOptions, options) { +exports.useDeleteBusiness = function useDeleteBusiness(dcOrOptions, options) { const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); function refFactory(vars) { - return deleteVendorRateRef(dcInstance, vars); + return deleteBusinessRef(dcInstance, vars); } return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); } - - -exports.useListVendorRate = function useListVendorRate(dcOrOptions, options) { - const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); - const ref = listVendorRateRef(dcInstance); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -exports.useGetVendorRateById = function useGetVendorRateById(dcOrVars, varsOrOptions, options) { - const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); - const ref = getVendorRateByIdRef(dcInstance, inputVars); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -exports.useFilterVendorRates = function useFilterVendorRates(dcOrVars, varsOrOptions, options) { - const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); - const ref = filterVendorRatesRef(dcInstance, inputVars); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} -exports.useCreateEvent = function useCreateEvent(dcOrOptions, options) { - const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); - function refFactory(vars) { - return createEventRef(dcInstance, vars); - } - return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -exports.useUpdateEvent = function useUpdateEvent(dcOrOptions, options) { - const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); - function refFactory(vars) { - return updateEventRef(dcInstance, vars); - } - return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -exports.useDeleteEvent = function useDeleteEvent(dcOrOptions, options) { - const { dc: dcInstance, vars: inputOpts } = validateArgs(connectorConfig, dcOrOptions, options); - function refFactory(vars) { - return deleteEventRef(dcInstance, vars); - } - return useDataConnectMutation(refFactory, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - - -exports.useListInvoice = function useListInvoice(dcOrOptions, options) { - const { dc: dcInstance, options: inputOpts } = validateReactArgs(connectorConfig, dcOrOptions, options); - const ref = listInvoiceRef(dcInstance); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -exports.useGetInvoiceById = function useGetInvoiceById(dcOrVars, varsOrOptions, options) { - const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, true); - const ref = getInvoiceByIdRef(dcInstance, inputVars); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} - -exports.useFilterInvoices = function useFilterInvoices(dcOrVars, varsOrOptions, options) { - const { dc: dcInstance, vars: inputVars, options: inputOpts } = validateReactArgs(connectorConfig, dcOrVars, varsOrOptions, options, true, false); - const ref = filterInvoicesRef(dcInstance, inputVars); - return useDataConnectQuery(ref, inputOpts, CallerSdkTypeEnum.GeneratedReact); -} \ No newline at end of file diff --git a/internal-api-harness/src/dataconnect-generated/react/index.d.ts b/internal-api-harness/src/dataconnect-generated/react/index.d.ts index e5957f90..18a7afb1 100644 --- a/internal-api-harness/src/dataconnect-generated/react/index.d.ts +++ b/internal-api-harness/src/dataconnect-generated/react/index.d.ts @@ -1,21 +1,27 @@ -import { ListStaffData, CreateVendorData, CreateVendorVariables, UpdateVendorData, UpdateVendorVariables, DeleteVendorData, DeleteVendorVariables, ListVendorDefaultSettingsData, GetVendorDefaultSettingByIdData, GetVendorDefaultSettingByIdVariables, FilterVendorDefaultSettingsData, FilterVendorDefaultSettingsVariables, ListEventsData, GetEventByIdData, GetEventByIdVariables, FilterEventsData, FilterEventsVariables, CreateInvoiceData, CreateInvoiceVariables, UpdateInvoiceData, UpdateInvoiceVariables, DeleteInvoiceData, DeleteInvoiceVariables, CreateStaffData, CreateStaffVariables, ListVendorData, GetVendorByIdData, GetVendorByIdVariables, FilterVendorsData, FilterVendorsVariables, CreateVendorDefaultSettingData, CreateVendorDefaultSettingVariables, UpdateVendorDefaultSettingData, UpdateVendorDefaultSettingVariables, DeleteVendorDefaultSettingData, DeleteVendorDefaultSettingVariables, CreateVendorRateData, CreateVendorRateVariables, UpdateVendorRateData, UpdateVendorRateVariables, DeleteVendorRateData, DeleteVendorRateVariables, ListVendorRateData, GetVendorRateByIdData, GetVendorRateByIdVariables, FilterVendorRatesData, FilterVendorRatesVariables, CreateEventData, CreateEventVariables, UpdateEventData, UpdateEventVariables, DeleteEventData, DeleteEventVariables, ListInvoiceData, GetInvoiceByIdData, GetInvoiceByIdVariables, FilterInvoicesData, FilterInvoicesVariables } from '../'; +import { ListBusinessData, GetBusinessByIdData, GetBusinessByIdVariables, FilterBusinessData, FilterBusinessVariables, CreateEventData, CreateEventVariables, UpdateEventData, UpdateEventVariables, DeleteEventData, DeleteEventVariables, ListVendorDefaultSettingsData, GetVendorDefaultSettingByIdData, GetVendorDefaultSettingByIdVariables, FilterVendorDefaultSettingsData, FilterVendorDefaultSettingsVariables, CreateVendorRateData, CreateVendorRateVariables, UpdateVendorRateData, UpdateVendorRateVariables, DeleteVendorRateData, DeleteVendorRateVariables, ListVendorRateData, GetVendorRateByIdData, GetVendorRateByIdVariables, FilterVendorRatesData, FilterVendorRatesVariables, ListEventsData, GetEventByIdData, GetEventByIdVariables, FilterEventsData, FilterEventsVariables, CreateInvoiceData, CreateInvoiceVariables, UpdateInvoiceData, UpdateInvoiceVariables, DeleteInvoiceData, DeleteInvoiceVariables, ListInvoiceData, GetInvoiceByIdData, GetInvoiceByIdVariables, FilterInvoicesData, FilterInvoicesVariables, CreateStaffData, CreateStaffVariables, ListStaffData, CreateVendorData, CreateVendorVariables, UpdateVendorData, UpdateVendorVariables, DeleteVendorData, DeleteVendorVariables, ListVendorData, GetVendorByIdData, GetVendorByIdVariables, FilterVendorsData, FilterVendorsVariables, CreateVendorDefaultSettingData, CreateVendorDefaultSettingVariables, UpdateVendorDefaultSettingData, UpdateVendorDefaultSettingVariables, DeleteVendorDefaultSettingData, DeleteVendorDefaultSettingVariables, CreateBusinessData, CreateBusinessVariables, UpdateBusinessData, UpdateBusinessVariables, DeleteBusinessData, DeleteBusinessVariables } from '../'; import { UseDataConnectQueryResult, useDataConnectQueryOptions, UseDataConnectMutationResult, useDataConnectMutationOptions} from '@tanstack-query-firebase/react/data-connect'; import { UseQueryResult, UseMutationResult} from '@tanstack/react-query'; import { DataConnect } from 'firebase/data-connect'; import { FirebaseError } from 'firebase/app'; -export function useListStaff(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useListStaff(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useListBusiness(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useListBusiness(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useCreateVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useCreateVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useGetBusinessById(vars: GetBusinessByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useGetBusinessById(dc: DataConnect, vars: GetBusinessByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useUpdateVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useUpdateVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useFilterBusiness(vars?: FilterBusinessVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useFilterBusiness(dc: DataConnect, vars?: FilterBusinessVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useDeleteVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useDeleteVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useCreateEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useCreateEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useUpdateEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useUpdateEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useDeleteEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useDeleteEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; export function useListVendorDefaultSettings(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; export function useListVendorDefaultSettings(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; @@ -26,45 +32,6 @@ export function useGetVendorDefaultSettingById(dc: DataConnect, vars: GetVendorD export function useFilterVendorDefaultSettings(vars?: FilterVendorDefaultSettingsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; export function useFilterVendorDefaultSettings(dc: DataConnect, vars?: FilterVendorDefaultSettingsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useListEvents(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useListEvents(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; - -export function useGetEventById(vars: GetEventByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useGetEventById(dc: DataConnect, vars: GetEventByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; - -export function useFilterEvents(vars?: FilterEventsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useFilterEvents(dc: DataConnect, vars?: FilterEventsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; - -export function useCreateInvoice(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useCreateInvoice(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; - -export function useUpdateInvoice(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useUpdateInvoice(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; - -export function useDeleteInvoice(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useDeleteInvoice(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; - -export function useCreateStaff(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useCreateStaff(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; - -export function useListVendor(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useListVendor(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; - -export function useGetVendorById(vars: GetVendorByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useGetVendorById(dc: DataConnect, vars: GetVendorByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; - -export function useFilterVendors(vars?: FilterVendorsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useFilterVendors(dc: DataConnect, vars?: FilterVendorsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; - -export function useCreateVendorDefaultSetting(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useCreateVendorDefaultSetting(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; - -export function useUpdateVendorDefaultSetting(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useUpdateVendorDefaultSetting(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; - -export function useDeleteVendorDefaultSetting(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useDeleteVendorDefaultSetting(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; - export function useCreateVendorRate(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; export function useCreateVendorRate(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; @@ -83,14 +50,23 @@ export function useGetVendorRateById(dc: DataConnect, vars: GetVendorRateByIdVar export function useFilterVendorRates(vars?: FilterVendorRatesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; export function useFilterVendorRates(dc: DataConnect, vars?: FilterVendorRatesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useCreateEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useCreateEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useListEvents(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useListEvents(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useUpdateEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useUpdateEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useGetEventById(vars: GetEventByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useGetEventById(dc: DataConnect, vars: GetEventByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; -export function useDeleteEvent(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; -export function useDeleteEvent(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useFilterEvents(vars?: FilterEventsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useFilterEvents(dc: DataConnect, vars?: FilterEventsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; + +export function useCreateInvoice(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useCreateInvoice(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useUpdateInvoice(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useUpdateInvoice(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useDeleteInvoice(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useDeleteInvoice(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; export function useListInvoice(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; export function useListInvoice(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; @@ -100,3 +76,45 @@ export function useGetInvoiceById(dc: DataConnect, vars: GetInvoiceByIdVariables export function useFilterInvoices(vars?: FilterInvoicesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; export function useFilterInvoices(dc: DataConnect, vars?: FilterInvoicesVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; + +export function useCreateStaff(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useCreateStaff(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useListStaff(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useListStaff(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; + +export function useCreateVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useCreateVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useUpdateVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useUpdateVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useDeleteVendor(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useDeleteVendor(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useListVendor(options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useListVendor(dc: DataConnect, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; + +export function useGetVendorById(vars: GetVendorByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useGetVendorById(dc: DataConnect, vars: GetVendorByIdVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; + +export function useFilterVendors(vars?: FilterVendorsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; +export function useFilterVendors(dc: DataConnect, vars?: FilterVendorsVariables, options?: useDataConnectQueryOptions): UseDataConnectQueryResult; + +export function useCreateVendorDefaultSetting(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useCreateVendorDefaultSetting(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useUpdateVendorDefaultSetting(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useUpdateVendorDefaultSetting(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useDeleteVendorDefaultSetting(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useDeleteVendorDefaultSetting(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useCreateBusiness(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useCreateBusiness(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useUpdateBusiness(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useUpdateBusiness(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult; + +export function useDeleteBusiness(options?: useDataConnectMutationOptions): UseDataConnectMutationResult; +export function useDeleteBusiness(dc: DataConnect, options?: useDataConnectMutationOptions): UseDataConnectMutationResult;