# dataconnect_generated SDK

## Installation
```sh
flutter pub get firebase_data_connect
flutterfire configure
```
For more information, see [Flutter for Firebase installation documentation](https://firebase.google.com/docs/data-connect/flutter-sdk#use-core).

## Data Connect instance
Each connector creates a static class, with an instance of the `DataConnect` class that can be used to connect to your Data Connect backend and call operations.

### Connecting to the emulator

```dart
String host = 'localhost'; // or your host name
int port = 9399; // or your port number
ExampleConnector.instance.dataConnect.useDataConnectEmulator(host, port);
```

You can also call queries and mutations by using the connector class.
## Queries

### listBusinesses
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listBusinesses().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listBusinessesData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listBusinesses();
listBusinessesData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listBusinesses().ref();
ref.execute();

ref.subscribe(...);
```


### getBusinessesByUserId
#### Required Arguments
```dart
String userId = ...;
ExampleConnector.instance.getBusinessesByUserId(
  userId: userId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getBusinessesByUserIdData, getBusinessesByUserIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getBusinessesByUserId(
  userId: userId,
);
getBusinessesByUserIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String userId = ...;

final ref = ExampleConnector.instance.getBusinessesByUserId(
  userId: userId,
).ref();
ref.execute();

ref.subscribe(...);
```


### getBusinessById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getBusinessById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getBusinessByIdData, getBusinessByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getBusinessById(
  id: id,
);
getBusinessByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getBusinessById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### listConversations
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listConversations().execute();
```

#### Optional Arguments
We return a builder for each query. For listConversations, we created `listConversationsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListConversationsVariablesBuilder {
  ...
 
  ListConversationsVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListConversationsVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listConversations()
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listConversationsData, listConversationsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listConversations();
listConversationsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listConversations().ref();
ref.execute();

ref.subscribe(...);
```


### getConversationById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getConversationById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getConversationByIdData, getConversationByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getConversationById(
  id: id,
);
getConversationByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getConversationById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### listConversationsByType
#### Required Arguments
```dart
ConversationType conversationType = ...;
ExampleConnector.instance.listConversationsByType(
  conversationType: conversationType,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listConversationsByType, we created `listConversationsByTypeBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListConversationsByTypeVariablesBuilder {
  ...
   ListConversationsByTypeVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListConversationsByTypeVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listConversationsByType(
  conversationType: conversationType,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listConversationsByTypeData, listConversationsByTypeVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listConversationsByType(
  conversationType: conversationType,
);
listConversationsByTypeData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
ConversationType conversationType = ...;

final ref = ExampleConnector.instance.listConversationsByType(
  conversationType: conversationType,
).ref();
ref.execute();

ref.subscribe(...);
```


### listConversationsByStatus
#### Required Arguments
```dart
ConversationStatus status = ...;
ExampleConnector.instance.listConversationsByStatus(
  status: status,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listConversationsByStatus, we created `listConversationsByStatusBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListConversationsByStatusVariablesBuilder {
  ...
   ListConversationsByStatusVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListConversationsByStatusVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listConversationsByStatus(
  status: status,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listConversationsByStatusData, listConversationsByStatusVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listConversationsByStatus(
  status: status,
);
listConversationsByStatusData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
ConversationStatus status = ...;

final ref = ExampleConnector.instance.listConversationsByStatus(
  status: status,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterConversations
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterConversations().execute();
```

#### Optional Arguments
We return a builder for each query. For filterConversations, we created `filterConversationsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterConversationsVariablesBuilder {
  ...
 
  FilterConversationsVariablesBuilder status(ConversationStatus? t) {
   _status.value = t;
   return this;
  }
  FilterConversationsVariablesBuilder conversationType(ConversationType? t) {
   _conversationType.value = t;
   return this;
  }
  FilterConversationsVariablesBuilder isGroup(bool? t) {
   _isGroup.value = t;
   return this;
  }
  FilterConversationsVariablesBuilder lastMessageAfter(Timestamp? t) {
   _lastMessageAfter.value = t;
   return this;
  }
  FilterConversationsVariablesBuilder lastMessageBefore(Timestamp? t) {
   _lastMessageBefore.value = t;
   return this;
  }
  FilterConversationsVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  FilterConversationsVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterConversations()
.status(status)
.conversationType(conversationType)
.isGroup(isGroup)
.lastMessageAfter(lastMessageAfter)
.lastMessageBefore(lastMessageBefore)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterConversationsData, filterConversationsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterConversations();
filterConversationsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterConversations().ref();
ref.execute();

ref.subscribe(...);
```


### getStaffDocumentByKey
#### Required Arguments
```dart
String staffId = ...;
String documentId = ...;
ExampleConnector.instance.getStaffDocumentByKey(
  staffId: staffId,
  documentId: documentId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getStaffDocumentByKeyData, getStaffDocumentByKeyVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getStaffDocumentByKey(
  staffId: staffId,
  documentId: documentId,
);
getStaffDocumentByKeyData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;
String documentId = ...;

final ref = ExampleConnector.instance.getStaffDocumentByKey(
  staffId: staffId,
  documentId: documentId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listStaffDocumentsByStaffId
#### Required Arguments
```dart
String staffId = ...;
ExampleConnector.instance.listStaffDocumentsByStaffId(
  staffId: staffId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listStaffDocumentsByStaffId, we created `listStaffDocumentsByStaffIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListStaffDocumentsByStaffIdVariablesBuilder {
  ...
   ListStaffDocumentsByStaffIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListStaffDocumentsByStaffIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listStaffDocumentsByStaffId(
  staffId: staffId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listStaffDocumentsByStaffIdData, listStaffDocumentsByStaffIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listStaffDocumentsByStaffId(
  staffId: staffId,
);
listStaffDocumentsByStaffIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;

final ref = ExampleConnector.instance.listStaffDocumentsByStaffId(
  staffId: staffId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listStaffDocumentsByDocumentType
#### Required Arguments
```dart
DocumentType documentType = ...;
ExampleConnector.instance.listStaffDocumentsByDocumentType(
  documentType: documentType,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listStaffDocumentsByDocumentType, we created `listStaffDocumentsByDocumentTypeBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListStaffDocumentsByDocumentTypeVariablesBuilder {
  ...
   ListStaffDocumentsByDocumentTypeVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListStaffDocumentsByDocumentTypeVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listStaffDocumentsByDocumentType(
  documentType: documentType,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listStaffDocumentsByDocumentTypeData, listStaffDocumentsByDocumentTypeVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listStaffDocumentsByDocumentType(
  documentType: documentType,
);
listStaffDocumentsByDocumentTypeData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
DocumentType documentType = ...;

final ref = ExampleConnector.instance.listStaffDocumentsByDocumentType(
  documentType: documentType,
).ref();
ref.execute();

ref.subscribe(...);
```


### listStaffDocumentsByStatus
#### Required Arguments
```dart
DocumentStatus status = ...;
ExampleConnector.instance.listStaffDocumentsByStatus(
  status: status,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listStaffDocumentsByStatus, we created `listStaffDocumentsByStatusBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListStaffDocumentsByStatusVariablesBuilder {
  ...
   ListStaffDocumentsByStatusVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListStaffDocumentsByStatusVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listStaffDocumentsByStatus(
  status: status,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listStaffDocumentsByStatusData, listStaffDocumentsByStatusVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listStaffDocumentsByStatus(
  status: status,
);
listStaffDocumentsByStatusData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
DocumentStatus status = ...;

final ref = ExampleConnector.instance.listStaffDocumentsByStatus(
  status: status,
).ref();
ref.execute();

ref.subscribe(...);
```


### listTasks
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listTasks().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listTasksData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listTasks();
listTasksData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listTasks().ref();
ref.execute();

ref.subscribe(...);
```


### getTaskById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getTaskById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getTaskByIdData, getTaskByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getTaskById(
  id: id,
);
getTaskByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getTaskById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### getTasksByOwnerId
#### Required Arguments
```dart
String ownerId = ...;
ExampleConnector.instance.getTasksByOwnerId(
  ownerId: ownerId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getTasksByOwnerIdData, getTasksByOwnerIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getTasksByOwnerId(
  ownerId: ownerId,
);
getTasksByOwnerIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String ownerId = ...;

final ref = ExampleConnector.instance.getTasksByOwnerId(
  ownerId: ownerId,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterTasks
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterTasks().execute();
```

#### Optional Arguments
We return a builder for each query. For filterTasks, we created `filterTasksBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterTasksVariablesBuilder {
  ...
 
  FilterTasksVariablesBuilder status(TaskStatus? t) {
   _status.value = t;
   return this;
  }
  FilterTasksVariablesBuilder priority(TaskPriority? t) {
   _priority.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterTasks()
.status(status)
.priority(priority)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterTasksData, filterTasksVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterTasks();
filterTasksData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterTasks().ref();
ref.execute();

ref.subscribe(...);
```


### listClientFeedbacks
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listClientFeedbacks().execute();
```

#### Optional Arguments
We return a builder for each query. For listClientFeedbacks, we created `listClientFeedbacksBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListClientFeedbacksVariablesBuilder {
  ...
 
  ListClientFeedbacksVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListClientFeedbacksVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listClientFeedbacks()
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listClientFeedbacksData, listClientFeedbacksVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listClientFeedbacks();
listClientFeedbacksData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listClientFeedbacks().ref();
ref.execute();

ref.subscribe(...);
```


### getClientFeedbackById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getClientFeedbackById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getClientFeedbackByIdData, getClientFeedbackByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getClientFeedbackById(
  id: id,
);
getClientFeedbackByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getClientFeedbackById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### listClientFeedbacksByBusinessId
#### Required Arguments
```dart
String businessId = ...;
ExampleConnector.instance.listClientFeedbacksByBusinessId(
  businessId: businessId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listClientFeedbacksByBusinessId, we created `listClientFeedbacksByBusinessIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListClientFeedbacksByBusinessIdVariablesBuilder {
  ...
   ListClientFeedbacksByBusinessIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListClientFeedbacksByBusinessIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listClientFeedbacksByBusinessId(
  businessId: businessId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listClientFeedbacksByBusinessIdData, listClientFeedbacksByBusinessIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listClientFeedbacksByBusinessId(
  businessId: businessId,
);
listClientFeedbacksByBusinessIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;

final ref = ExampleConnector.instance.listClientFeedbacksByBusinessId(
  businessId: businessId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listClientFeedbacksByVendorId
#### Required Arguments
```dart
String vendorId = ...;
ExampleConnector.instance.listClientFeedbacksByVendorId(
  vendorId: vendorId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listClientFeedbacksByVendorId, we created `listClientFeedbacksByVendorIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListClientFeedbacksByVendorIdVariablesBuilder {
  ...
   ListClientFeedbacksByVendorIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListClientFeedbacksByVendorIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listClientFeedbacksByVendorId(
  vendorId: vendorId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listClientFeedbacksByVendorIdData, listClientFeedbacksByVendorIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listClientFeedbacksByVendorId(
  vendorId: vendorId,
);
listClientFeedbacksByVendorIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;

final ref = ExampleConnector.instance.listClientFeedbacksByVendorId(
  vendorId: vendorId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listClientFeedbacksByBusinessAndVendor
#### Required Arguments
```dart
String businessId = ...;
String vendorId = ...;
ExampleConnector.instance.listClientFeedbacksByBusinessAndVendor(
  businessId: businessId,
  vendorId: vendorId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listClientFeedbacksByBusinessAndVendor, we created `listClientFeedbacksByBusinessAndVendorBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListClientFeedbacksByBusinessAndVendorVariablesBuilder {
  ...
   ListClientFeedbacksByBusinessAndVendorVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListClientFeedbacksByBusinessAndVendorVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listClientFeedbacksByBusinessAndVendor(
  businessId: businessId,
  vendorId: vendorId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listClientFeedbacksByBusinessAndVendorData, listClientFeedbacksByBusinessAndVendorVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listClientFeedbacksByBusinessAndVendor(
  businessId: businessId,
  vendorId: vendorId,
);
listClientFeedbacksByBusinessAndVendorData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;
String vendorId = ...;

final ref = ExampleConnector.instance.listClientFeedbacksByBusinessAndVendor(
  businessId: businessId,
  vendorId: vendorId,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterClientFeedbacks
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterClientFeedbacks().execute();
```

#### Optional Arguments
We return a builder for each query. For filterClientFeedbacks, we created `filterClientFeedbacksBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterClientFeedbacksVariablesBuilder {
  ...
 
  FilterClientFeedbacksVariablesBuilder businessId(String? t) {
   _businessId.value = t;
   return this;
  }
  FilterClientFeedbacksVariablesBuilder vendorId(String? t) {
   _vendorId.value = t;
   return this;
  }
  FilterClientFeedbacksVariablesBuilder ratingMin(int? t) {
   _ratingMin.value = t;
   return this;
  }
  FilterClientFeedbacksVariablesBuilder ratingMax(int? t) {
   _ratingMax.value = t;
   return this;
  }
  FilterClientFeedbacksVariablesBuilder dateFrom(Timestamp? t) {
   _dateFrom.value = t;
   return this;
  }
  FilterClientFeedbacksVariablesBuilder dateTo(Timestamp? t) {
   _dateTo.value = t;
   return this;
  }
  FilterClientFeedbacksVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  FilterClientFeedbacksVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterClientFeedbacks()
.businessId(businessId)
.vendorId(vendorId)
.ratingMin(ratingMin)
.ratingMax(ratingMax)
.dateFrom(dateFrom)
.dateTo(dateTo)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterClientFeedbacksData, filterClientFeedbacksVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterClientFeedbacks();
filterClientFeedbacksData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterClientFeedbacks().ref();
ref.execute();

ref.subscribe(...);
```


### listClientFeedbackRatingsByVendorId
#### Required Arguments
```dart
String vendorId = ...;
ExampleConnector.instance.listClientFeedbackRatingsByVendorId(
  vendorId: vendorId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listClientFeedbackRatingsByVendorId, we created `listClientFeedbackRatingsByVendorIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListClientFeedbackRatingsByVendorIdVariablesBuilder {
  ...
   ListClientFeedbackRatingsByVendorIdVariablesBuilder dateFrom(Timestamp? t) {
   _dateFrom.value = t;
   return this;
  }
  ListClientFeedbackRatingsByVendorIdVariablesBuilder dateTo(Timestamp? t) {
   _dateTo.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listClientFeedbackRatingsByVendorId(
  vendorId: vendorId,
)
.dateFrom(dateFrom)
.dateTo(dateTo)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listClientFeedbackRatingsByVendorIdData, listClientFeedbackRatingsByVendorIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listClientFeedbackRatingsByVendorId(
  vendorId: vendorId,
);
listClientFeedbackRatingsByVendorIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;

final ref = ExampleConnector.instance.listClientFeedbackRatingsByVendorId(
  vendorId: vendorId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listStaff
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listStaff().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listStaffData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listStaff();
listStaffData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listStaff().ref();
ref.execute();

ref.subscribe(...);
```


### getStaffById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getStaffById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getStaffByIdData, getStaffByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getStaffById(
  id: id,
);
getStaffByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getStaffById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### getStaffByUserId
#### Required Arguments
```dart
String userId = ...;
ExampleConnector.instance.getStaffByUserId(
  userId: userId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getStaffByUserIdData, getStaffByUserIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getStaffByUserId(
  userId: userId,
);
getStaffByUserIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String userId = ...;

final ref = ExampleConnector.instance.getStaffByUserId(
  userId: userId,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterStaff
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterStaff().execute();
```

#### Optional Arguments
We return a builder for each query. For filterStaff, we created `filterStaffBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterStaffVariablesBuilder {
  ...
 
  FilterStaffVariablesBuilder ownerId(String? t) {
   _ownerId.value = t;
   return this;
  }
  FilterStaffVariablesBuilder fullName(String? t) {
   _fullName.value = t;
   return this;
  }
  FilterStaffVariablesBuilder level(String? t) {
   _level.value = t;
   return this;
  }
  FilterStaffVariablesBuilder email(String? t) {
   _email.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterStaff()
.ownerId(ownerId)
.fullName(fullName)
.level(level)
.email(email)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterStaffData, filterStaffVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterStaff();
filterStaffData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterStaff().ref();
ref.execute();

ref.subscribe(...);
```


### listActivityLogs
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listActivityLogs().execute();
```

#### Optional Arguments
We return a builder for each query. For listActivityLogs, we created `listActivityLogsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListActivityLogsVariablesBuilder {
  ...
 
  ListActivityLogsVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListActivityLogsVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listActivityLogs()
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listActivityLogsData, listActivityLogsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listActivityLogs();
listActivityLogsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listActivityLogs().ref();
ref.execute();

ref.subscribe(...);
```


### getActivityLogById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getActivityLogById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getActivityLogByIdData, getActivityLogByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getActivityLogById(
  id: id,
);
getActivityLogByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getActivityLogById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### listActivityLogsByUserId
#### Required Arguments
```dart
String userId = ...;
ExampleConnector.instance.listActivityLogsByUserId(
  userId: userId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listActivityLogsByUserId, we created `listActivityLogsByUserIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListActivityLogsByUserIdVariablesBuilder {
  ...
   ListActivityLogsByUserIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListActivityLogsByUserIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listActivityLogsByUserId(
  userId: userId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listActivityLogsByUserIdData, listActivityLogsByUserIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listActivityLogsByUserId(
  userId: userId,
);
listActivityLogsByUserIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String userId = ...;

final ref = ExampleConnector.instance.listActivityLogsByUserId(
  userId: userId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listUnreadActivityLogsByUserId
#### Required Arguments
```dart
String userId = ...;
ExampleConnector.instance.listUnreadActivityLogsByUserId(
  userId: userId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listUnreadActivityLogsByUserId, we created `listUnreadActivityLogsByUserIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListUnreadActivityLogsByUserIdVariablesBuilder {
  ...
   ListUnreadActivityLogsByUserIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListUnreadActivityLogsByUserIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listUnreadActivityLogsByUserId(
  userId: userId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listUnreadActivityLogsByUserIdData, listUnreadActivityLogsByUserIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listUnreadActivityLogsByUserId(
  userId: userId,
);
listUnreadActivityLogsByUserIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String userId = ...;

final ref = ExampleConnector.instance.listUnreadActivityLogsByUserId(
  userId: userId,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterActivityLogs
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterActivityLogs().execute();
```

#### Optional Arguments
We return a builder for each query. For filterActivityLogs, we created `filterActivityLogsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterActivityLogsVariablesBuilder {
  ...
 
  FilterActivityLogsVariablesBuilder userId(String? t) {
   _userId.value = t;
   return this;
  }
  FilterActivityLogsVariablesBuilder dateFrom(Timestamp? t) {
   _dateFrom.value = t;
   return this;
  }
  FilterActivityLogsVariablesBuilder dateTo(Timestamp? t) {
   _dateTo.value = t;
   return this;
  }
  FilterActivityLogsVariablesBuilder isRead(bool? t) {
   _isRead.value = t;
   return this;
  }
  FilterActivityLogsVariablesBuilder activityType(ActivityType? t) {
   _activityType.value = t;
   return this;
  }
  FilterActivityLogsVariablesBuilder iconType(ActivityIconType? t) {
   _iconType.value = t;
   return this;
  }
  FilterActivityLogsVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  FilterActivityLogsVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterActivityLogs()
.userId(userId)
.dateFrom(dateFrom)
.dateTo(dateTo)
.isRead(isRead)
.activityType(activityType)
.iconType(iconType)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterActivityLogsData, filterActivityLogsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterActivityLogs();
filterActivityLogsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterActivityLogs().ref();
ref.execute();

ref.subscribe(...);
```


### listApplications
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listApplications().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listApplicationsData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listApplications();
listApplicationsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listApplications().ref();
ref.execute();

ref.subscribe(...);
```


### getApplicationById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getApplicationById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getApplicationByIdData, getApplicationByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getApplicationById(
  id: id,
);
getApplicationByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getApplicationById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### getApplicationsByShiftId
#### Required Arguments
```dart
String shiftId = ...;
ExampleConnector.instance.getApplicationsByShiftId(
  shiftId: shiftId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getApplicationsByShiftIdData, getApplicationsByShiftIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getApplicationsByShiftId(
  shiftId: shiftId,
);
getApplicationsByShiftIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String shiftId = ...;

final ref = ExampleConnector.instance.getApplicationsByShiftId(
  shiftId: shiftId,
).ref();
ref.execute();

ref.subscribe(...);
```


### getApplicationsByShiftIdAndStatus
#### Required Arguments
```dart
String shiftId = ...;
ApplicationStatus status = ...;
ExampleConnector.instance.getApplicationsByShiftIdAndStatus(
  shiftId: shiftId,
  status: status,
).execute();
```

#### Optional Arguments
We return a builder for each query. For getApplicationsByShiftIdAndStatus, we created `getApplicationsByShiftIdAndStatusBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class GetApplicationsByShiftIdAndStatusVariablesBuilder {
  ...
   GetApplicationsByShiftIdAndStatusVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  GetApplicationsByShiftIdAndStatusVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.getApplicationsByShiftIdAndStatus(
  shiftId: shiftId,
  status: status,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<getApplicationsByShiftIdAndStatusData, getApplicationsByShiftIdAndStatusVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getApplicationsByShiftIdAndStatus(
  shiftId: shiftId,
  status: status,
);
getApplicationsByShiftIdAndStatusData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String shiftId = ...;
ApplicationStatus status = ...;

final ref = ExampleConnector.instance.getApplicationsByShiftIdAndStatus(
  shiftId: shiftId,
  status: status,
).ref();
ref.execute();

ref.subscribe(...);
```


### getApplicationsByStaffId
#### Required Arguments
```dart
String staffId = ...;
ExampleConnector.instance.getApplicationsByStaffId(
  staffId: staffId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For getApplicationsByStaffId, we created `getApplicationsByStaffIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class GetApplicationsByStaffIdVariablesBuilder {
  ...
   GetApplicationsByStaffIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  GetApplicationsByStaffIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.getApplicationsByStaffId(
  staffId: staffId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<getApplicationsByStaffIdData, getApplicationsByStaffIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getApplicationsByStaffId(
  staffId: staffId,
);
getApplicationsByStaffIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;

final ref = ExampleConnector.instance.getApplicationsByStaffId(
  staffId: staffId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listAcceptedApplicationsByShiftRoleKey
#### Required Arguments
```dart
String shiftId = ...;
String roleId = ...;
ExampleConnector.instance.listAcceptedApplicationsByShiftRoleKey(
  shiftId: shiftId,
  roleId: roleId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listAcceptedApplicationsByShiftRoleKey, we created `listAcceptedApplicationsByShiftRoleKeyBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListAcceptedApplicationsByShiftRoleKeyVariablesBuilder {
  ...
   ListAcceptedApplicationsByShiftRoleKeyVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListAcceptedApplicationsByShiftRoleKeyVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listAcceptedApplicationsByShiftRoleKey(
  shiftId: shiftId,
  roleId: roleId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listAcceptedApplicationsByShiftRoleKeyData, listAcceptedApplicationsByShiftRoleKeyVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listAcceptedApplicationsByShiftRoleKey(
  shiftId: shiftId,
  roleId: roleId,
);
listAcceptedApplicationsByShiftRoleKeyData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String shiftId = ...;
String roleId = ...;

final ref = ExampleConnector.instance.listAcceptedApplicationsByShiftRoleKey(
  shiftId: shiftId,
  roleId: roleId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listAcceptedApplicationsByBusinessForDay
#### Required Arguments
```dart
String businessId = ...;
Timestamp dayStart = ...;
Timestamp dayEnd = ...;
ExampleConnector.instance.listAcceptedApplicationsByBusinessForDay(
  businessId: businessId,
  dayStart: dayStart,
  dayEnd: dayEnd,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listAcceptedApplicationsByBusinessForDay, we created `listAcceptedApplicationsByBusinessForDayBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListAcceptedApplicationsByBusinessForDayVariablesBuilder {
  ...
   ListAcceptedApplicationsByBusinessForDayVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListAcceptedApplicationsByBusinessForDayVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listAcceptedApplicationsByBusinessForDay(
  businessId: businessId,
  dayStart: dayStart,
  dayEnd: dayEnd,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listAcceptedApplicationsByBusinessForDayData, listAcceptedApplicationsByBusinessForDayVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listAcceptedApplicationsByBusinessForDay(
  businessId: businessId,
  dayStart: dayStart,
  dayEnd: dayEnd,
);
listAcceptedApplicationsByBusinessForDayData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;
Timestamp dayStart = ...;
Timestamp dayEnd = ...;

final ref = ExampleConnector.instance.listAcceptedApplicationsByBusinessForDay(
  businessId: businessId,
  dayStart: dayStart,
  dayEnd: dayEnd,
).ref();
ref.execute();

ref.subscribe(...);
```


### listStaffsApplicationsByBusinessForDay
#### Required Arguments
```dart
String businessId = ...;
Timestamp dayStart = ...;
Timestamp dayEnd = ...;
ExampleConnector.instance.listStaffsApplicationsByBusinessForDay(
  businessId: businessId,
  dayStart: dayStart,
  dayEnd: dayEnd,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listStaffsApplicationsByBusinessForDay, we created `listStaffsApplicationsByBusinessForDayBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListStaffsApplicationsByBusinessForDayVariablesBuilder {
  ...
   ListStaffsApplicationsByBusinessForDayVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListStaffsApplicationsByBusinessForDayVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listStaffsApplicationsByBusinessForDay(
  businessId: businessId,
  dayStart: dayStart,
  dayEnd: dayEnd,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listStaffsApplicationsByBusinessForDayData, listStaffsApplicationsByBusinessForDayVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listStaffsApplicationsByBusinessForDay(
  businessId: businessId,
  dayStart: dayStart,
  dayEnd: dayEnd,
);
listStaffsApplicationsByBusinessForDayData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;
Timestamp dayStart = ...;
Timestamp dayEnd = ...;

final ref = ExampleConnector.instance.listStaffsApplicationsByBusinessForDay(
  businessId: businessId,
  dayStart: dayStart,
  dayEnd: dayEnd,
).ref();
ref.execute();

ref.subscribe(...);
```


### listRecentPayments
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listRecentPayments().execute();
```

#### Optional Arguments
We return a builder for each query. For listRecentPayments, we created `listRecentPaymentsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListRecentPaymentsVariablesBuilder {
  ...
 
  ListRecentPaymentsVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListRecentPaymentsVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listRecentPayments()
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listRecentPaymentsData, listRecentPaymentsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listRecentPayments();
listRecentPaymentsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listRecentPayments().ref();
ref.execute();

ref.subscribe(...);
```


### getRecentPaymentById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getRecentPaymentById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getRecentPaymentByIdData, getRecentPaymentByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getRecentPaymentById(
  id: id,
);
getRecentPaymentByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getRecentPaymentById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### listRecentPaymentsByStaffId
#### Required Arguments
```dart
String staffId = ...;
ExampleConnector.instance.listRecentPaymentsByStaffId(
  staffId: staffId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listRecentPaymentsByStaffId, we created `listRecentPaymentsByStaffIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListRecentPaymentsByStaffIdVariablesBuilder {
  ...
   ListRecentPaymentsByStaffIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListRecentPaymentsByStaffIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listRecentPaymentsByStaffId(
  staffId: staffId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listRecentPaymentsByStaffIdData, listRecentPaymentsByStaffIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listRecentPaymentsByStaffId(
  staffId: staffId,
);
listRecentPaymentsByStaffIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;

final ref = ExampleConnector.instance.listRecentPaymentsByStaffId(
  staffId: staffId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listRecentPaymentsByApplicationId
#### Required Arguments
```dart
String applicationId = ...;
ExampleConnector.instance.listRecentPaymentsByApplicationId(
  applicationId: applicationId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listRecentPaymentsByApplicationId, we created `listRecentPaymentsByApplicationIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListRecentPaymentsByApplicationIdVariablesBuilder {
  ...
   ListRecentPaymentsByApplicationIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListRecentPaymentsByApplicationIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listRecentPaymentsByApplicationId(
  applicationId: applicationId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listRecentPaymentsByApplicationIdData, listRecentPaymentsByApplicationIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listRecentPaymentsByApplicationId(
  applicationId: applicationId,
);
listRecentPaymentsByApplicationIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String applicationId = ...;

final ref = ExampleConnector.instance.listRecentPaymentsByApplicationId(
  applicationId: applicationId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listRecentPaymentsByInvoiceId
#### Required Arguments
```dart
String invoiceId = ...;
ExampleConnector.instance.listRecentPaymentsByInvoiceId(
  invoiceId: invoiceId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listRecentPaymentsByInvoiceId, we created `listRecentPaymentsByInvoiceIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListRecentPaymentsByInvoiceIdVariablesBuilder {
  ...
   ListRecentPaymentsByInvoiceIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListRecentPaymentsByInvoiceIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listRecentPaymentsByInvoiceId(
  invoiceId: invoiceId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listRecentPaymentsByInvoiceIdData, listRecentPaymentsByInvoiceIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listRecentPaymentsByInvoiceId(
  invoiceId: invoiceId,
);
listRecentPaymentsByInvoiceIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String invoiceId = ...;

final ref = ExampleConnector.instance.listRecentPaymentsByInvoiceId(
  invoiceId: invoiceId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listRecentPaymentsByStatus
#### Required Arguments
```dart
RecentPaymentStatus status = ...;
ExampleConnector.instance.listRecentPaymentsByStatus(
  status: status,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listRecentPaymentsByStatus, we created `listRecentPaymentsByStatusBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListRecentPaymentsByStatusVariablesBuilder {
  ...
   ListRecentPaymentsByStatusVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListRecentPaymentsByStatusVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listRecentPaymentsByStatus(
  status: status,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listRecentPaymentsByStatusData, listRecentPaymentsByStatusVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listRecentPaymentsByStatus(
  status: status,
);
listRecentPaymentsByStatusData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
RecentPaymentStatus status = ...;

final ref = ExampleConnector.instance.listRecentPaymentsByStatus(
  status: status,
).ref();
ref.execute();

ref.subscribe(...);
```


### listRecentPaymentsByInvoiceIds
#### Required Arguments
```dart
String invoiceIds = ...;
ExampleConnector.instance.listRecentPaymentsByInvoiceIds(
  invoiceIds: invoiceIds,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listRecentPaymentsByInvoiceIds, we created `listRecentPaymentsByInvoiceIdsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListRecentPaymentsByInvoiceIdsVariablesBuilder {
  ...
   ListRecentPaymentsByInvoiceIdsVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListRecentPaymentsByInvoiceIdsVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listRecentPaymentsByInvoiceIds(
  invoiceIds: invoiceIds,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listRecentPaymentsByInvoiceIdsData, listRecentPaymentsByInvoiceIdsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listRecentPaymentsByInvoiceIds(
  invoiceIds: invoiceIds,
);
listRecentPaymentsByInvoiceIdsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String invoiceIds = ...;

final ref = ExampleConnector.instance.listRecentPaymentsByInvoiceIds(
  invoiceIds: invoiceIds,
).ref();
ref.execute();

ref.subscribe(...);
```


### listRecentPaymentsByBusinessId
#### Required Arguments
```dart
String businessId = ...;
ExampleConnector.instance.listRecentPaymentsByBusinessId(
  businessId: businessId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listRecentPaymentsByBusinessId, we created `listRecentPaymentsByBusinessIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListRecentPaymentsByBusinessIdVariablesBuilder {
  ...
   ListRecentPaymentsByBusinessIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListRecentPaymentsByBusinessIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listRecentPaymentsByBusinessId(
  businessId: businessId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listRecentPaymentsByBusinessIdData, listRecentPaymentsByBusinessIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listRecentPaymentsByBusinessId(
  businessId: businessId,
);
listRecentPaymentsByBusinessIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;

final ref = ExampleConnector.instance.listRecentPaymentsByBusinessId(
  businessId: businessId,
).ref();
ref.execute();

ref.subscribe(...);
```


### getVendorById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getVendorById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getVendorByIdData, getVendorByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getVendorById(
  id: id,
);
getVendorByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getVendorById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### getVendorByUserId
#### Required Arguments
```dart
String userId = ...;
ExampleConnector.instance.getVendorByUserId(
  userId: userId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getVendorByUserIdData, getVendorByUserIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getVendorByUserId(
  userId: userId,
);
getVendorByUserIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String userId = ...;

final ref = ExampleConnector.instance.getVendorByUserId(
  userId: userId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listVendors
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listVendors().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listVendorsData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listVendors();
listVendorsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listVendors().ref();
ref.execute();

ref.subscribe(...);
```


### listShiftsForCoverage
#### Required Arguments
```dart
String businessId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;
ExampleConnector.instance.listShiftsForCoverage(
  businessId: businessId,
  startDate: startDate,
  endDate: endDate,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listShiftsForCoverageData, listShiftsForCoverageVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShiftsForCoverage(
  businessId: businessId,
  startDate: startDate,
  endDate: endDate,
);
listShiftsForCoverageData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;

final ref = ExampleConnector.instance.listShiftsForCoverage(
  businessId: businessId,
  startDate: startDate,
  endDate: endDate,
).ref();
ref.execute();

ref.subscribe(...);
```


### listApplicationsForCoverage
#### Required Arguments
```dart
String shiftIds = ...;
ExampleConnector.instance.listApplicationsForCoverage(
  shiftIds: shiftIds,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listApplicationsForCoverageData, listApplicationsForCoverageVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listApplicationsForCoverage(
  shiftIds: shiftIds,
);
listApplicationsForCoverageData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String shiftIds = ...;

final ref = ExampleConnector.instance.listApplicationsForCoverage(
  shiftIds: shiftIds,
).ref();
ref.execute();

ref.subscribe(...);
```


### listShiftsForDailyOpsByBusiness
#### Required Arguments
```dart
String businessId = ...;
Timestamp date = ...;
ExampleConnector.instance.listShiftsForDailyOpsByBusiness(
  businessId: businessId,
  date: date,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listShiftsForDailyOpsByBusinessData, listShiftsForDailyOpsByBusinessVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShiftsForDailyOpsByBusiness(
  businessId: businessId,
  date: date,
);
listShiftsForDailyOpsByBusinessData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;
Timestamp date = ...;

final ref = ExampleConnector.instance.listShiftsForDailyOpsByBusiness(
  businessId: businessId,
  date: date,
).ref();
ref.execute();

ref.subscribe(...);
```


### listShiftsForDailyOpsByVendor
#### Required Arguments
```dart
String vendorId = ...;
Timestamp date = ...;
ExampleConnector.instance.listShiftsForDailyOpsByVendor(
  vendorId: vendorId,
  date: date,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listShiftsForDailyOpsByVendorData, listShiftsForDailyOpsByVendorVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShiftsForDailyOpsByVendor(
  vendorId: vendorId,
  date: date,
);
listShiftsForDailyOpsByVendorData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;
Timestamp date = ...;

final ref = ExampleConnector.instance.listShiftsForDailyOpsByVendor(
  vendorId: vendorId,
  date: date,
).ref();
ref.execute();

ref.subscribe(...);
```


### listApplicationsForDailyOps
#### Required Arguments
```dart
String shiftIds = ...;
ExampleConnector.instance.listApplicationsForDailyOps(
  shiftIds: shiftIds,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listApplicationsForDailyOpsData, listApplicationsForDailyOpsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listApplicationsForDailyOps(
  shiftIds: shiftIds,
);
listApplicationsForDailyOpsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String shiftIds = ...;

final ref = ExampleConnector.instance.listApplicationsForDailyOps(
  shiftIds: shiftIds,
).ref();
ref.execute();

ref.subscribe(...);
```


### listShiftsForForecastByBusiness
#### Required Arguments
```dart
String businessId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;
ExampleConnector.instance.listShiftsForForecastByBusiness(
  businessId: businessId,
  startDate: startDate,
  endDate: endDate,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listShiftsForForecastByBusinessData, listShiftsForForecastByBusinessVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShiftsForForecastByBusiness(
  businessId: businessId,
  startDate: startDate,
  endDate: endDate,
);
listShiftsForForecastByBusinessData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;

final ref = ExampleConnector.instance.listShiftsForForecastByBusiness(
  businessId: businessId,
  startDate: startDate,
  endDate: endDate,
).ref();
ref.execute();

ref.subscribe(...);
```


### listShiftsForForecastByVendor
#### Required Arguments
```dart
String vendorId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;
ExampleConnector.instance.listShiftsForForecastByVendor(
  vendorId: vendorId,
  startDate: startDate,
  endDate: endDate,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listShiftsForForecastByVendorData, listShiftsForForecastByVendorVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShiftsForForecastByVendor(
  vendorId: vendorId,
  startDate: startDate,
  endDate: endDate,
);
listShiftsForForecastByVendorData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;

final ref = ExampleConnector.instance.listShiftsForForecastByVendor(
  vendorId: vendorId,
  startDate: startDate,
  endDate: endDate,
).ref();
ref.execute();

ref.subscribe(...);
```


### listShiftsForNoShowRangeByBusiness
#### Required Arguments
```dart
String businessId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;
ExampleConnector.instance.listShiftsForNoShowRangeByBusiness(
  businessId: businessId,
  startDate: startDate,
  endDate: endDate,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listShiftsForNoShowRangeByBusinessData, listShiftsForNoShowRangeByBusinessVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShiftsForNoShowRangeByBusiness(
  businessId: businessId,
  startDate: startDate,
  endDate: endDate,
);
listShiftsForNoShowRangeByBusinessData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;

final ref = ExampleConnector.instance.listShiftsForNoShowRangeByBusiness(
  businessId: businessId,
  startDate: startDate,
  endDate: endDate,
).ref();
ref.execute();

ref.subscribe(...);
```


### listShiftsForNoShowRangeByVendor
#### Required Arguments
```dart
String vendorId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;
ExampleConnector.instance.listShiftsForNoShowRangeByVendor(
  vendorId: vendorId,
  startDate: startDate,
  endDate: endDate,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listShiftsForNoShowRangeByVendorData, listShiftsForNoShowRangeByVendorVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShiftsForNoShowRangeByVendor(
  vendorId: vendorId,
  startDate: startDate,
  endDate: endDate,
);
listShiftsForNoShowRangeByVendorData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;

final ref = ExampleConnector.instance.listShiftsForNoShowRangeByVendor(
  vendorId: vendorId,
  startDate: startDate,
  endDate: endDate,
).ref();
ref.execute();

ref.subscribe(...);
```


### listApplicationsForNoShowRange
#### Required Arguments
```dart
String shiftIds = ...;
ExampleConnector.instance.listApplicationsForNoShowRange(
  shiftIds: shiftIds,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listApplicationsForNoShowRangeData, listApplicationsForNoShowRangeVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listApplicationsForNoShowRange(
  shiftIds: shiftIds,
);
listApplicationsForNoShowRangeData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String shiftIds = ...;

final ref = ExampleConnector.instance.listApplicationsForNoShowRange(
  shiftIds: shiftIds,
).ref();
ref.execute();

ref.subscribe(...);
```


### listStaffForNoShowReport
#### Required Arguments
```dart
String staffIds = ...;
ExampleConnector.instance.listStaffForNoShowReport(
  staffIds: staffIds,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listStaffForNoShowReportData, listStaffForNoShowReportVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listStaffForNoShowReport(
  staffIds: staffIds,
);
listStaffForNoShowReportData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffIds = ...;

final ref = ExampleConnector.instance.listStaffForNoShowReport(
  staffIds: staffIds,
).ref();
ref.execute();

ref.subscribe(...);
```


### listInvoicesForSpendByBusiness
#### Required Arguments
```dart
String businessId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;
ExampleConnector.instance.listInvoicesForSpendByBusiness(
  businessId: businessId,
  startDate: startDate,
  endDate: endDate,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listInvoicesForSpendByBusinessData, listInvoicesForSpendByBusinessVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listInvoicesForSpendByBusiness(
  businessId: businessId,
  startDate: startDate,
  endDate: endDate,
);
listInvoicesForSpendByBusinessData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;

final ref = ExampleConnector.instance.listInvoicesForSpendByBusiness(
  businessId: businessId,
  startDate: startDate,
  endDate: endDate,
).ref();
ref.execute();

ref.subscribe(...);
```


### listInvoicesForSpendByVendor
#### Required Arguments
```dart
String vendorId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;
ExampleConnector.instance.listInvoicesForSpendByVendor(
  vendorId: vendorId,
  startDate: startDate,
  endDate: endDate,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listInvoicesForSpendByVendorData, listInvoicesForSpendByVendorVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listInvoicesForSpendByVendor(
  vendorId: vendorId,
  startDate: startDate,
  endDate: endDate,
);
listInvoicesForSpendByVendorData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;

final ref = ExampleConnector.instance.listInvoicesForSpendByVendor(
  vendorId: vendorId,
  startDate: startDate,
  endDate: endDate,
).ref();
ref.execute();

ref.subscribe(...);
```


### listInvoicesForSpendByOrder
#### Required Arguments
```dart
String orderId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;
ExampleConnector.instance.listInvoicesForSpendByOrder(
  orderId: orderId,
  startDate: startDate,
  endDate: endDate,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listInvoicesForSpendByOrderData, listInvoicesForSpendByOrderVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listInvoicesForSpendByOrder(
  orderId: orderId,
  startDate: startDate,
  endDate: endDate,
);
listInvoicesForSpendByOrderData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String orderId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;

final ref = ExampleConnector.instance.listInvoicesForSpendByOrder(
  orderId: orderId,
  startDate: startDate,
  endDate: endDate,
).ref();
ref.execute();

ref.subscribe(...);
```


### listTimesheetsForSpend
#### Required Arguments
```dart
Timestamp startTime = ...;
Timestamp endTime = ...;
ExampleConnector.instance.listTimesheetsForSpend(
  startTime: startTime,
  endTime: endTime,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listTimesheetsForSpendData, listTimesheetsForSpendVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listTimesheetsForSpend(
  startTime: startTime,
  endTime: endTime,
);
listTimesheetsForSpendData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
Timestamp startTime = ...;
Timestamp endTime = ...;

final ref = ExampleConnector.instance.listTimesheetsForSpend(
  startTime: startTime,
  endTime: endTime,
).ref();
ref.execute();

ref.subscribe(...);
```


### listShiftsForPerformanceByBusiness
#### Required Arguments
```dart
String businessId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;
ExampleConnector.instance.listShiftsForPerformanceByBusiness(
  businessId: businessId,
  startDate: startDate,
  endDate: endDate,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listShiftsForPerformanceByBusinessData, listShiftsForPerformanceByBusinessVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShiftsForPerformanceByBusiness(
  businessId: businessId,
  startDate: startDate,
  endDate: endDate,
);
listShiftsForPerformanceByBusinessData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;

final ref = ExampleConnector.instance.listShiftsForPerformanceByBusiness(
  businessId: businessId,
  startDate: startDate,
  endDate: endDate,
).ref();
ref.execute();

ref.subscribe(...);
```


### listShiftsForPerformanceByVendor
#### Required Arguments
```dart
String vendorId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;
ExampleConnector.instance.listShiftsForPerformanceByVendor(
  vendorId: vendorId,
  startDate: startDate,
  endDate: endDate,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listShiftsForPerformanceByVendorData, listShiftsForPerformanceByVendorVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShiftsForPerformanceByVendor(
  vendorId: vendorId,
  startDate: startDate,
  endDate: endDate,
);
listShiftsForPerformanceByVendorData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;
Timestamp startDate = ...;
Timestamp endDate = ...;

final ref = ExampleConnector.instance.listShiftsForPerformanceByVendor(
  vendorId: vendorId,
  startDate: startDate,
  endDate: endDate,
).ref();
ref.execute();

ref.subscribe(...);
```


### listApplicationsForPerformance
#### Required Arguments
```dart
String shiftIds = ...;
ExampleConnector.instance.listApplicationsForPerformance(
  shiftIds: shiftIds,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listApplicationsForPerformanceData, listApplicationsForPerformanceVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listApplicationsForPerformance(
  shiftIds: shiftIds,
);
listApplicationsForPerformanceData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String shiftIds = ...;

final ref = ExampleConnector.instance.listApplicationsForPerformance(
  shiftIds: shiftIds,
).ref();
ref.execute();

ref.subscribe(...);
```


### listStaffForPerformance
#### Required Arguments
```dart
String staffIds = ...;
ExampleConnector.instance.listStaffForPerformance(
  staffIds: staffIds,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listStaffForPerformanceData, listStaffForPerformanceVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listStaffForPerformance(
  staffIds: staffIds,
);
listStaffForPerformanceData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffIds = ...;

final ref = ExampleConnector.instance.listStaffForPerformance(
  staffIds: staffIds,
).ref();
ref.execute();

ref.subscribe(...);
```


### listRoles
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listRoles().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listRolesData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listRoles();
listRolesData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listRoles().ref();
ref.execute();

ref.subscribe(...);
```


### getRoleById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getRoleById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getRoleByIdData, getRoleByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getRoleById(
  id: id,
);
getRoleByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getRoleById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### listRolesByVendorId
#### Required Arguments
```dart
String vendorId = ...;
ExampleConnector.instance.listRolesByVendorId(
  vendorId: vendorId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listRolesByVendorIdData, listRolesByVendorIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listRolesByVendorId(
  vendorId: vendorId,
);
listRolesByVendorIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;

final ref = ExampleConnector.instance.listRolesByVendorId(
  vendorId: vendorId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listRolesByroleCategoryId
#### Required Arguments
```dart
String roleCategoryId = ...;
ExampleConnector.instance.listRolesByroleCategoryId(
  roleCategoryId: roleCategoryId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listRolesByroleCategoryIdData, listRolesByroleCategoryIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listRolesByroleCategoryId(
  roleCategoryId: roleCategoryId,
);
listRolesByroleCategoryIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String roleCategoryId = ...;

final ref = ExampleConnector.instance.listRolesByroleCategoryId(
  roleCategoryId: roleCategoryId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listShifts
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listShifts().execute();
```

#### Optional Arguments
We return a builder for each query. For listShifts, we created `listShiftsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListShiftsVariablesBuilder {
  ...
 
  ListShiftsVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListShiftsVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listShifts()
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listShiftsData, listShiftsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShifts();
listShiftsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listShifts().ref();
ref.execute();

ref.subscribe(...);
```


### getShiftById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getShiftById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getShiftByIdData, getShiftByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getShiftById(
  id: id,
);
getShiftByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getShiftById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterShifts
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterShifts().execute();
```

#### Optional Arguments
We return a builder for each query. For filterShifts, we created `filterShiftsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterShiftsVariablesBuilder {
  ...
 
  FilterShiftsVariablesBuilder status(ShiftStatus? t) {
   _status.value = t;
   return this;
  }
  FilterShiftsVariablesBuilder orderId(String? t) {
   _orderId.value = t;
   return this;
  }
  FilterShiftsVariablesBuilder dateFrom(Timestamp? t) {
   _dateFrom.value = t;
   return this;
  }
  FilterShiftsVariablesBuilder dateTo(Timestamp? t) {
   _dateTo.value = t;
   return this;
  }
  FilterShiftsVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  FilterShiftsVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterShifts()
.status(status)
.orderId(orderId)
.dateFrom(dateFrom)
.dateTo(dateTo)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterShiftsData, filterShiftsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterShifts();
filterShiftsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterShifts().ref();
ref.execute();

ref.subscribe(...);
```


### getShiftsByBusinessId
#### Required Arguments
```dart
String businessId = ...;
ExampleConnector.instance.getShiftsByBusinessId(
  businessId: businessId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For getShiftsByBusinessId, we created `getShiftsByBusinessIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class GetShiftsByBusinessIdVariablesBuilder {
  ...
   GetShiftsByBusinessIdVariablesBuilder dateFrom(Timestamp? t) {
   _dateFrom.value = t;
   return this;
  }
  GetShiftsByBusinessIdVariablesBuilder dateTo(Timestamp? t) {
   _dateTo.value = t;
   return this;
  }
  GetShiftsByBusinessIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  GetShiftsByBusinessIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.getShiftsByBusinessId(
  businessId: businessId,
)
.dateFrom(dateFrom)
.dateTo(dateTo)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<getShiftsByBusinessIdData, getShiftsByBusinessIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getShiftsByBusinessId(
  businessId: businessId,
);
getShiftsByBusinessIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;

final ref = ExampleConnector.instance.getShiftsByBusinessId(
  businessId: businessId,
).ref();
ref.execute();

ref.subscribe(...);
```


### getShiftsByVendorId
#### Required Arguments
```dart
String vendorId = ...;
ExampleConnector.instance.getShiftsByVendorId(
  vendorId: vendorId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For getShiftsByVendorId, we created `getShiftsByVendorIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class GetShiftsByVendorIdVariablesBuilder {
  ...
   GetShiftsByVendorIdVariablesBuilder dateFrom(Timestamp? t) {
   _dateFrom.value = t;
   return this;
  }
  GetShiftsByVendorIdVariablesBuilder dateTo(Timestamp? t) {
   _dateTo.value = t;
   return this;
  }
  GetShiftsByVendorIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  GetShiftsByVendorIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.getShiftsByVendorId(
  vendorId: vendorId,
)
.dateFrom(dateFrom)
.dateTo(dateTo)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<getShiftsByVendorIdData, getShiftsByVendorIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getShiftsByVendorId(
  vendorId: vendorId,
);
getShiftsByVendorIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;

final ref = ExampleConnector.instance.getShiftsByVendorId(
  vendorId: vendorId,
).ref();
ref.execute();

ref.subscribe(...);
```


### getWorkforceById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getWorkforceById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getWorkforceByIdData, getWorkforceByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getWorkforceById(
  id: id,
);
getWorkforceByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getWorkforceById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### getWorkforceByVendorAndStaff
#### Required Arguments
```dart
String vendorId = ...;
String staffId = ...;
ExampleConnector.instance.getWorkforceByVendorAndStaff(
  vendorId: vendorId,
  staffId: staffId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getWorkforceByVendorAndStaffData, getWorkforceByVendorAndStaffVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getWorkforceByVendorAndStaff(
  vendorId: vendorId,
  staffId: staffId,
);
getWorkforceByVendorAndStaffData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;
String staffId = ...;

final ref = ExampleConnector.instance.getWorkforceByVendorAndStaff(
  vendorId: vendorId,
  staffId: staffId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listWorkforceByVendorId
#### Required Arguments
```dart
String vendorId = ...;
ExampleConnector.instance.listWorkforceByVendorId(
  vendorId: vendorId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listWorkforceByVendorId, we created `listWorkforceByVendorIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListWorkforceByVendorIdVariablesBuilder {
  ...
   ListWorkforceByVendorIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListWorkforceByVendorIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listWorkforceByVendorId(
  vendorId: vendorId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listWorkforceByVendorIdData, listWorkforceByVendorIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listWorkforceByVendorId(
  vendorId: vendorId,
);
listWorkforceByVendorIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;

final ref = ExampleConnector.instance.listWorkforceByVendorId(
  vendorId: vendorId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listWorkforceByStaffId
#### Required Arguments
```dart
String staffId = ...;
ExampleConnector.instance.listWorkforceByStaffId(
  staffId: staffId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listWorkforceByStaffId, we created `listWorkforceByStaffIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListWorkforceByStaffIdVariablesBuilder {
  ...
   ListWorkforceByStaffIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListWorkforceByStaffIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listWorkforceByStaffId(
  staffId: staffId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listWorkforceByStaffIdData, listWorkforceByStaffIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listWorkforceByStaffId(
  staffId: staffId,
);
listWorkforceByStaffIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;

final ref = ExampleConnector.instance.listWorkforceByStaffId(
  staffId: staffId,
).ref();
ref.execute();

ref.subscribe(...);
```


### getWorkforceByVendorAndNumber
#### Required Arguments
```dart
String vendorId = ...;
String workforceNumber = ...;
ExampleConnector.instance.getWorkforceByVendorAndNumber(
  vendorId: vendorId,
  workforceNumber: workforceNumber,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getWorkforceByVendorAndNumberData, getWorkforceByVendorAndNumberVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getWorkforceByVendorAndNumber(
  vendorId: vendorId,
  workforceNumber: workforceNumber,
);
getWorkforceByVendorAndNumberData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;
String workforceNumber = ...;

final ref = ExampleConnector.instance.getWorkforceByVendorAndNumber(
  vendorId: vendorId,
  workforceNumber: workforceNumber,
).ref();
ref.execute();

ref.subscribe(...);
```


### listCustomRateCards
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listCustomRateCards().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listCustomRateCardsData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listCustomRateCards();
listCustomRateCardsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listCustomRateCards().ref();
ref.execute();

ref.subscribe(...);
```


### getCustomRateCardById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getCustomRateCardById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getCustomRateCardByIdData, getCustomRateCardByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getCustomRateCardById(
  id: id,
);
getCustomRateCardByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getCustomRateCardById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### listEmergencyContacts
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listEmergencyContacts().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listEmergencyContactsData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listEmergencyContacts();
listEmergencyContactsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listEmergencyContacts().ref();
ref.execute();

ref.subscribe(...);
```


### getEmergencyContactById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getEmergencyContactById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getEmergencyContactByIdData, getEmergencyContactByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getEmergencyContactById(
  id: id,
);
getEmergencyContactByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getEmergencyContactById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### getEmergencyContactsByStaffId
#### Required Arguments
```dart
String staffId = ...;
ExampleConnector.instance.getEmergencyContactsByStaffId(
  staffId: staffId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getEmergencyContactsByStaffIdData, getEmergencyContactsByStaffIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getEmergencyContactsByStaffId(
  staffId: staffId,
);
getEmergencyContactsByStaffIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;

final ref = ExampleConnector.instance.getEmergencyContactsByStaffId(
  staffId: staffId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listLevels
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listLevels().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listLevelsData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listLevels();
listLevelsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listLevels().ref();
ref.execute();

ref.subscribe(...);
```


### getLevelById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getLevelById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getLevelByIdData, getLevelByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getLevelById(
  id: id,
);
getLevelByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getLevelById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterLevels
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterLevels().execute();
```

#### Optional Arguments
We return a builder for each query. For filterLevels, we created `filterLevelsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterLevelsVariablesBuilder {
  ...
 
  FilterLevelsVariablesBuilder name(String? t) {
   _name.value = t;
   return this;
  }
  FilterLevelsVariablesBuilder xpRequired(int? t) {
   _xpRequired.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterLevels()
.name(name)
.xpRequired(xpRequired)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterLevelsData, filterLevelsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterLevels();
filterLevelsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterLevels().ref();
ref.execute();

ref.subscribe(...);
```


### listCategories
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listCategories().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listCategoriesData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listCategories();
listCategoriesData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listCategories().ref();
ref.execute();

ref.subscribe(...);
```


### getCategoryById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getCategoryById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getCategoryByIdData, getCategoryByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getCategoryById(
  id: id,
);
getCategoryByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getCategoryById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterCategories
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterCategories().execute();
```

#### Optional Arguments
We return a builder for each query. For filterCategories, we created `filterCategoriesBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterCategoriesVariablesBuilder {
  ...
 
  FilterCategoriesVariablesBuilder categoryId(String? t) {
   _categoryId.value = t;
   return this;
  }
  FilterCategoriesVariablesBuilder label(String? t) {
   _label.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterCategories()
.categoryId(categoryId)
.label(label)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterCategoriesData, filterCategoriesVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterCategories();
filterCategoriesData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterCategories().ref();
ref.execute();

ref.subscribe(...);
```


### listInvoices
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listInvoices().execute();
```

#### Optional Arguments
We return a builder for each query. For listInvoices, we created `listInvoicesBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListInvoicesVariablesBuilder {
  ...
 
  ListInvoicesVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListInvoicesVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listInvoices()
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listInvoicesData, listInvoicesVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listInvoices();
listInvoicesData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listInvoices().ref();
ref.execute();

ref.subscribe(...);
```


### getInvoiceById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getInvoiceById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getInvoiceByIdData, getInvoiceByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getInvoiceById(
  id: id,
);
getInvoiceByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getInvoiceById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### listInvoicesByVendorId
#### Required Arguments
```dart
String vendorId = ...;
ExampleConnector.instance.listInvoicesByVendorId(
  vendorId: vendorId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listInvoicesByVendorId, we created `listInvoicesByVendorIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListInvoicesByVendorIdVariablesBuilder {
  ...
   ListInvoicesByVendorIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListInvoicesByVendorIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listInvoicesByVendorId(
  vendorId: vendorId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listInvoicesByVendorIdData, listInvoicesByVendorIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listInvoicesByVendorId(
  vendorId: vendorId,
);
listInvoicesByVendorIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;

final ref = ExampleConnector.instance.listInvoicesByVendorId(
  vendorId: vendorId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listInvoicesByBusinessId
#### Required Arguments
```dart
String businessId = ...;
ExampleConnector.instance.listInvoicesByBusinessId(
  businessId: businessId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listInvoicesByBusinessId, we created `listInvoicesByBusinessIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListInvoicesByBusinessIdVariablesBuilder {
  ...
   ListInvoicesByBusinessIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListInvoicesByBusinessIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listInvoicesByBusinessId(
  businessId: businessId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listInvoicesByBusinessIdData, listInvoicesByBusinessIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listInvoicesByBusinessId(
  businessId: businessId,
);
listInvoicesByBusinessIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;

final ref = ExampleConnector.instance.listInvoicesByBusinessId(
  businessId: businessId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listInvoicesByOrderId
#### Required Arguments
```dart
String orderId = ...;
ExampleConnector.instance.listInvoicesByOrderId(
  orderId: orderId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listInvoicesByOrderId, we created `listInvoicesByOrderIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListInvoicesByOrderIdVariablesBuilder {
  ...
   ListInvoicesByOrderIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListInvoicesByOrderIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listInvoicesByOrderId(
  orderId: orderId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listInvoicesByOrderIdData, listInvoicesByOrderIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listInvoicesByOrderId(
  orderId: orderId,
);
listInvoicesByOrderIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String orderId = ...;

final ref = ExampleConnector.instance.listInvoicesByOrderId(
  orderId: orderId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listInvoicesByStatus
#### Required Arguments
```dart
InvoiceStatus status = ...;
ExampleConnector.instance.listInvoicesByStatus(
  status: status,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listInvoicesByStatus, we created `listInvoicesByStatusBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListInvoicesByStatusVariablesBuilder {
  ...
   ListInvoicesByStatusVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListInvoicesByStatusVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listInvoicesByStatus(
  status: status,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listInvoicesByStatusData, listInvoicesByStatusVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listInvoicesByStatus(
  status: status,
);
listInvoicesByStatusData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
InvoiceStatus status = ...;

final ref = ExampleConnector.instance.listInvoicesByStatus(
  status: status,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterInvoices
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterInvoices().execute();
```

#### Optional Arguments
We return a builder for each query. For filterInvoices, we created `filterInvoicesBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterInvoicesVariablesBuilder {
  ...
 
  FilterInvoicesVariablesBuilder vendorId(String? t) {
   _vendorId.value = t;
   return this;
  }
  FilterInvoicesVariablesBuilder businessId(String? t) {
   _businessId.value = t;
   return this;
  }
  FilterInvoicesVariablesBuilder orderId(String? t) {
   _orderId.value = t;
   return this;
  }
  FilterInvoicesVariablesBuilder status(InvoiceStatus? t) {
   _status.value = t;
   return this;
  }
  FilterInvoicesVariablesBuilder issueDateFrom(Timestamp? t) {
   _issueDateFrom.value = t;
   return this;
  }
  FilterInvoicesVariablesBuilder issueDateTo(Timestamp? t) {
   _issueDateTo.value = t;
   return this;
  }
  FilterInvoicesVariablesBuilder dueDateFrom(Timestamp? t) {
   _dueDateFrom.value = t;
   return this;
  }
  FilterInvoicesVariablesBuilder dueDateTo(Timestamp? t) {
   _dueDateTo.value = t;
   return this;
  }
  FilterInvoicesVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  FilterInvoicesVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterInvoices()
.vendorId(vendorId)
.businessId(businessId)
.orderId(orderId)
.status(status)
.issueDateFrom(issueDateFrom)
.issueDateTo(issueDateTo)
.dueDateFrom(dueDateFrom)
.dueDateTo(dueDateTo)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterInvoicesData, filterInvoicesVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterInvoices();
filterInvoicesData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterInvoices().ref();
ref.execute();

ref.subscribe(...);
```


### listOverdueInvoices
#### Required Arguments
```dart
Timestamp now = ...;
ExampleConnector.instance.listOverdueInvoices(
  now: now,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listOverdueInvoices, we created `listOverdueInvoicesBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListOverdueInvoicesVariablesBuilder {
  ...
   ListOverdueInvoicesVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListOverdueInvoicesVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listOverdueInvoices(
  now: now,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listOverdueInvoicesData, listOverdueInvoicesVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listOverdueInvoices(
  now: now,
);
listOverdueInvoicesData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
Timestamp now = ...;

final ref = ExampleConnector.instance.listOverdueInvoices(
  now: now,
).ref();
ref.execute();

ref.subscribe(...);
```


### listStaffAvailabilityStats
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listStaffAvailabilityStats().execute();
```

#### Optional Arguments
We return a builder for each query. For listStaffAvailabilityStats, we created `listStaffAvailabilityStatsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListStaffAvailabilityStatsVariablesBuilder {
  ...
 
  ListStaffAvailabilityStatsVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListStaffAvailabilityStatsVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listStaffAvailabilityStats()
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listStaffAvailabilityStatsData, listStaffAvailabilityStatsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listStaffAvailabilityStats();
listStaffAvailabilityStatsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listStaffAvailabilityStats().ref();
ref.execute();

ref.subscribe(...);
```


### getStaffAvailabilityStatsByStaffId
#### Required Arguments
```dart
String staffId = ...;
ExampleConnector.instance.getStaffAvailabilityStatsByStaffId(
  staffId: staffId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getStaffAvailabilityStatsByStaffIdData, getStaffAvailabilityStatsByStaffIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getStaffAvailabilityStatsByStaffId(
  staffId: staffId,
);
getStaffAvailabilityStatsByStaffIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;

final ref = ExampleConnector.instance.getStaffAvailabilityStatsByStaffId(
  staffId: staffId,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterStaffAvailabilityStats
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterStaffAvailabilityStats().execute();
```

#### Optional Arguments
We return a builder for each query. For filterStaffAvailabilityStats, we created `filterStaffAvailabilityStatsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterStaffAvailabilityStatsVariablesBuilder {
  ...
 
  FilterStaffAvailabilityStatsVariablesBuilder needWorkIndexMin(int? t) {
   _needWorkIndexMin.value = t;
   return this;
  }
  FilterStaffAvailabilityStatsVariablesBuilder needWorkIndexMax(int? t) {
   _needWorkIndexMax.value = t;
   return this;
  }
  FilterStaffAvailabilityStatsVariablesBuilder utilizationMin(int? t) {
   _utilizationMin.value = t;
   return this;
  }
  FilterStaffAvailabilityStatsVariablesBuilder utilizationMax(int? t) {
   _utilizationMax.value = t;
   return this;
  }
  FilterStaffAvailabilityStatsVariablesBuilder acceptanceRateMin(int? t) {
   _acceptanceRateMin.value = t;
   return this;
  }
  FilterStaffAvailabilityStatsVariablesBuilder acceptanceRateMax(int? t) {
   _acceptanceRateMax.value = t;
   return this;
  }
  FilterStaffAvailabilityStatsVariablesBuilder lastShiftAfter(Timestamp? t) {
   _lastShiftAfter.value = t;
   return this;
  }
  FilterStaffAvailabilityStatsVariablesBuilder lastShiftBefore(Timestamp? t) {
   _lastShiftBefore.value = t;
   return this;
  }
  FilterStaffAvailabilityStatsVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  FilterStaffAvailabilityStatsVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterStaffAvailabilityStats()
.needWorkIndexMin(needWorkIndexMin)
.needWorkIndexMax(needWorkIndexMax)
.utilizationMin(utilizationMin)
.utilizationMax(utilizationMax)
.acceptanceRateMin(acceptanceRateMin)
.acceptanceRateMax(acceptanceRateMax)
.lastShiftAfter(lastShiftAfter)
.lastShiftBefore(lastShiftBefore)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterStaffAvailabilityStatsData, filterStaffAvailabilityStatsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterStaffAvailabilityStats();
filterStaffAvailabilityStatsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterStaffAvailabilityStats().ref();
ref.execute();

ref.subscribe(...);
```


### listUserConversations
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listUserConversations().execute();
```

#### Optional Arguments
We return a builder for each query. For listUserConversations, we created `listUserConversationsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListUserConversationsVariablesBuilder {
  ...
 
  ListUserConversationsVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListUserConversationsVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listUserConversations()
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listUserConversationsData, listUserConversationsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listUserConversations();
listUserConversationsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listUserConversations().ref();
ref.execute();

ref.subscribe(...);
```


### getUserConversationByKey
#### Required Arguments
```dart
String conversationId = ...;
String userId = ...;
ExampleConnector.instance.getUserConversationByKey(
  conversationId: conversationId,
  userId: userId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getUserConversationByKeyData, getUserConversationByKeyVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getUserConversationByKey(
  conversationId: conversationId,
  userId: userId,
);
getUserConversationByKeyData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String conversationId = ...;
String userId = ...;

final ref = ExampleConnector.instance.getUserConversationByKey(
  conversationId: conversationId,
  userId: userId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listUserConversationsByUserId
#### Required Arguments
```dart
String userId = ...;
ExampleConnector.instance.listUserConversationsByUserId(
  userId: userId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listUserConversationsByUserId, we created `listUserConversationsByUserIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListUserConversationsByUserIdVariablesBuilder {
  ...
   ListUserConversationsByUserIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListUserConversationsByUserIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listUserConversationsByUserId(
  userId: userId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listUserConversationsByUserIdData, listUserConversationsByUserIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listUserConversationsByUserId(
  userId: userId,
);
listUserConversationsByUserIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String userId = ...;

final ref = ExampleConnector.instance.listUserConversationsByUserId(
  userId: userId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listUnreadUserConversationsByUserId
#### Required Arguments
```dart
String userId = ...;
ExampleConnector.instance.listUnreadUserConversationsByUserId(
  userId: userId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listUnreadUserConversationsByUserId, we created `listUnreadUserConversationsByUserIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListUnreadUserConversationsByUserIdVariablesBuilder {
  ...
   ListUnreadUserConversationsByUserIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListUnreadUserConversationsByUserIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listUnreadUserConversationsByUserId(
  userId: userId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listUnreadUserConversationsByUserIdData, listUnreadUserConversationsByUserIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listUnreadUserConversationsByUserId(
  userId: userId,
);
listUnreadUserConversationsByUserIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String userId = ...;

final ref = ExampleConnector.instance.listUnreadUserConversationsByUserId(
  userId: userId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listUserConversationsByConversationId
#### Required Arguments
```dart
String conversationId = ...;
ExampleConnector.instance.listUserConversationsByConversationId(
  conversationId: conversationId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listUserConversationsByConversationId, we created `listUserConversationsByConversationIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListUserConversationsByConversationIdVariablesBuilder {
  ...
   ListUserConversationsByConversationIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListUserConversationsByConversationIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listUserConversationsByConversationId(
  conversationId: conversationId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listUserConversationsByConversationIdData, listUserConversationsByConversationIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listUserConversationsByConversationId(
  conversationId: conversationId,
);
listUserConversationsByConversationIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String conversationId = ...;

final ref = ExampleConnector.instance.listUserConversationsByConversationId(
  conversationId: conversationId,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterUserConversations
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterUserConversations().execute();
```

#### Optional Arguments
We return a builder for each query. For filterUserConversations, we created `filterUserConversationsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterUserConversationsVariablesBuilder {
  ...
 
  FilterUserConversationsVariablesBuilder userId(String? t) {
   _userId.value = t;
   return this;
  }
  FilterUserConversationsVariablesBuilder conversationId(String? t) {
   _conversationId.value = t;
   return this;
  }
  FilterUserConversationsVariablesBuilder unreadMin(int? t) {
   _unreadMin.value = t;
   return this;
  }
  FilterUserConversationsVariablesBuilder unreadMax(int? t) {
   _unreadMax.value = t;
   return this;
  }
  FilterUserConversationsVariablesBuilder lastReadAfter(Timestamp? t) {
   _lastReadAfter.value = t;
   return this;
  }
  FilterUserConversationsVariablesBuilder lastReadBefore(Timestamp? t) {
   _lastReadBefore.value = t;
   return this;
  }
  FilterUserConversationsVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  FilterUserConversationsVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterUserConversations()
.userId(userId)
.conversationId(conversationId)
.unreadMin(unreadMin)
.unreadMax(unreadMax)
.lastReadAfter(lastReadAfter)
.lastReadBefore(lastReadBefore)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterUserConversationsData, filterUserConversationsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterUserConversations();
filterUserConversationsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterUserConversations().ref();
ref.execute();

ref.subscribe(...);
```


### listMessages
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listMessages().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listMessagesData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listMessages();
listMessagesData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listMessages().ref();
ref.execute();

ref.subscribe(...);
```


### getMessageById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getMessageById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getMessageByIdData, getMessageByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getMessageById(
  id: id,
);
getMessageByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getMessageById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### getMessagesByConversationId
#### Required Arguments
```dart
String conversationId = ...;
ExampleConnector.instance.getMessagesByConversationId(
  conversationId: conversationId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getMessagesByConversationIdData, getMessagesByConversationIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getMessagesByConversationId(
  conversationId: conversationId,
);
getMessagesByConversationIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String conversationId = ...;

final ref = ExampleConnector.instance.getMessagesByConversationId(
  conversationId: conversationId,
).ref();
ref.execute();

ref.subscribe(...);
```


### getShiftRoleById
#### Required Arguments
```dart
String shiftId = ...;
String roleId = ...;
ExampleConnector.instance.getShiftRoleById(
  shiftId: shiftId,
  roleId: roleId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getShiftRoleByIdData, getShiftRoleByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getShiftRoleById(
  shiftId: shiftId,
  roleId: roleId,
);
getShiftRoleByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String shiftId = ...;
String roleId = ...;

final ref = ExampleConnector.instance.getShiftRoleById(
  shiftId: shiftId,
  roleId: roleId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listShiftRolesByShiftId
#### Required Arguments
```dart
String shiftId = ...;
ExampleConnector.instance.listShiftRolesByShiftId(
  shiftId: shiftId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listShiftRolesByShiftId, we created `listShiftRolesByShiftIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListShiftRolesByShiftIdVariablesBuilder {
  ...
   ListShiftRolesByShiftIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListShiftRolesByShiftIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listShiftRolesByShiftId(
  shiftId: shiftId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listShiftRolesByShiftIdData, listShiftRolesByShiftIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShiftRolesByShiftId(
  shiftId: shiftId,
);
listShiftRolesByShiftIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String shiftId = ...;

final ref = ExampleConnector.instance.listShiftRolesByShiftId(
  shiftId: shiftId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listShiftRolesByRoleId
#### Required Arguments
```dart
String roleId = ...;
ExampleConnector.instance.listShiftRolesByRoleId(
  roleId: roleId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listShiftRolesByRoleId, we created `listShiftRolesByRoleIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListShiftRolesByRoleIdVariablesBuilder {
  ...
   ListShiftRolesByRoleIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListShiftRolesByRoleIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listShiftRolesByRoleId(
  roleId: roleId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listShiftRolesByRoleIdData, listShiftRolesByRoleIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShiftRolesByRoleId(
  roleId: roleId,
);
listShiftRolesByRoleIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String roleId = ...;

final ref = ExampleConnector.instance.listShiftRolesByRoleId(
  roleId: roleId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listShiftRolesByShiftIdAndTimeRange
#### Required Arguments
```dart
String shiftId = ...;
Timestamp start = ...;
Timestamp end = ...;
ExampleConnector.instance.listShiftRolesByShiftIdAndTimeRange(
  shiftId: shiftId,
  start: start,
  end: end,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listShiftRolesByShiftIdAndTimeRange, we created `listShiftRolesByShiftIdAndTimeRangeBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListShiftRolesByShiftIdAndTimeRangeVariablesBuilder {
  ...
   ListShiftRolesByShiftIdAndTimeRangeVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListShiftRolesByShiftIdAndTimeRangeVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listShiftRolesByShiftIdAndTimeRange(
  shiftId: shiftId,
  start: start,
  end: end,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listShiftRolesByShiftIdAndTimeRangeData, listShiftRolesByShiftIdAndTimeRangeVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShiftRolesByShiftIdAndTimeRange(
  shiftId: shiftId,
  start: start,
  end: end,
);
listShiftRolesByShiftIdAndTimeRangeData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String shiftId = ...;
Timestamp start = ...;
Timestamp end = ...;

final ref = ExampleConnector.instance.listShiftRolesByShiftIdAndTimeRange(
  shiftId: shiftId,
  start: start,
  end: end,
).ref();
ref.execute();

ref.subscribe(...);
```


### listShiftRolesByVendorId
#### Required Arguments
```dart
String vendorId = ...;
ExampleConnector.instance.listShiftRolesByVendorId(
  vendorId: vendorId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listShiftRolesByVendorId, we created `listShiftRolesByVendorIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListShiftRolesByVendorIdVariablesBuilder {
  ...
   ListShiftRolesByVendorIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListShiftRolesByVendorIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listShiftRolesByVendorId(
  vendorId: vendorId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listShiftRolesByVendorIdData, listShiftRolesByVendorIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShiftRolesByVendorId(
  vendorId: vendorId,
);
listShiftRolesByVendorIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;

final ref = ExampleConnector.instance.listShiftRolesByVendorId(
  vendorId: vendorId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listShiftRolesByBusinessAndDateRange
#### Required Arguments
```dart
String businessId = ...;
Timestamp start = ...;
Timestamp end = ...;
ExampleConnector.instance.listShiftRolesByBusinessAndDateRange(
  businessId: businessId,
  start: start,
  end: end,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listShiftRolesByBusinessAndDateRange, we created `listShiftRolesByBusinessAndDateRangeBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListShiftRolesByBusinessAndDateRangeVariablesBuilder {
  ...
   ListShiftRolesByBusinessAndDateRangeVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListShiftRolesByBusinessAndDateRangeVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listShiftRolesByBusinessAndDateRange(
  businessId: businessId,
  start: start,
  end: end,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listShiftRolesByBusinessAndDateRangeData, listShiftRolesByBusinessAndDateRangeVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShiftRolesByBusinessAndDateRange(
  businessId: businessId,
  start: start,
  end: end,
);
listShiftRolesByBusinessAndDateRangeData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;
Timestamp start = ...;
Timestamp end = ...;

final ref = ExampleConnector.instance.listShiftRolesByBusinessAndDateRange(
  businessId: businessId,
  start: start,
  end: end,
).ref();
ref.execute();

ref.subscribe(...);
```


### listShiftRolesByBusinessAndOrder
#### Required Arguments
```dart
String businessId = ...;
String orderId = ...;
ExampleConnector.instance.listShiftRolesByBusinessAndOrder(
  businessId: businessId,
  orderId: orderId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listShiftRolesByBusinessAndOrder, we created `listShiftRolesByBusinessAndOrderBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListShiftRolesByBusinessAndOrderVariablesBuilder {
  ...
   ListShiftRolesByBusinessAndOrderVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListShiftRolesByBusinessAndOrderVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listShiftRolesByBusinessAndOrder(
  businessId: businessId,
  orderId: orderId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listShiftRolesByBusinessAndOrderData, listShiftRolesByBusinessAndOrderVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShiftRolesByBusinessAndOrder(
  businessId: businessId,
  orderId: orderId,
);
listShiftRolesByBusinessAndOrderData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;
String orderId = ...;

final ref = ExampleConnector.instance.listShiftRolesByBusinessAndOrder(
  businessId: businessId,
  orderId: orderId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listShiftRolesByBusinessDateRangeCompletedOrders
#### Required Arguments
```dart
String businessId = ...;
Timestamp start = ...;
Timestamp end = ...;
ExampleConnector.instance.listShiftRolesByBusinessDateRangeCompletedOrders(
  businessId: businessId,
  start: start,
  end: end,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listShiftRolesByBusinessDateRangeCompletedOrders, we created `listShiftRolesByBusinessDateRangeCompletedOrdersBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListShiftRolesByBusinessDateRangeCompletedOrdersVariablesBuilder {
  ...
   ListShiftRolesByBusinessDateRangeCompletedOrdersVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListShiftRolesByBusinessDateRangeCompletedOrdersVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listShiftRolesByBusinessDateRangeCompletedOrders(
  businessId: businessId,
  start: start,
  end: end,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listShiftRolesByBusinessDateRangeCompletedOrdersData, listShiftRolesByBusinessDateRangeCompletedOrdersVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShiftRolesByBusinessDateRangeCompletedOrders(
  businessId: businessId,
  start: start,
  end: end,
);
listShiftRolesByBusinessDateRangeCompletedOrdersData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;
Timestamp start = ...;
Timestamp end = ...;

final ref = ExampleConnector.instance.listShiftRolesByBusinessDateRangeCompletedOrders(
  businessId: businessId,
  start: start,
  end: end,
).ref();
ref.execute();

ref.subscribe(...);
```


### listShiftRolesByBusinessAndDatesSummary
#### Required Arguments
```dart
String businessId = ...;
Timestamp start = ...;
Timestamp end = ...;
ExampleConnector.instance.listShiftRolesByBusinessAndDatesSummary(
  businessId: businessId,
  start: start,
  end: end,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listShiftRolesByBusinessAndDatesSummary, we created `listShiftRolesByBusinessAndDatesSummaryBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListShiftRolesByBusinessAndDatesSummaryVariablesBuilder {
  ...
   ListShiftRolesByBusinessAndDatesSummaryVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListShiftRolesByBusinessAndDatesSummaryVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listShiftRolesByBusinessAndDatesSummary(
  businessId: businessId,
  start: start,
  end: end,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listShiftRolesByBusinessAndDatesSummaryData, listShiftRolesByBusinessAndDatesSummaryVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listShiftRolesByBusinessAndDatesSummary(
  businessId: businessId,
  start: start,
  end: end,
);
listShiftRolesByBusinessAndDatesSummaryData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;
Timestamp start = ...;
Timestamp end = ...;

final ref = ExampleConnector.instance.listShiftRolesByBusinessAndDatesSummary(
  businessId: businessId,
  start: start,
  end: end,
).ref();
ref.execute();

ref.subscribe(...);
```


### listAttireOptions
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listAttireOptions().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listAttireOptionsData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listAttireOptions();
listAttireOptionsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listAttireOptions().ref();
ref.execute();

ref.subscribe(...);
```


### getAttireOptionById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getAttireOptionById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getAttireOptionByIdData, getAttireOptionByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getAttireOptionById(
  id: id,
);
getAttireOptionByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getAttireOptionById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterAttireOptions
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterAttireOptions().execute();
```

#### Optional Arguments
We return a builder for each query. For filterAttireOptions, we created `filterAttireOptionsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterAttireOptionsVariablesBuilder {
  ...
 
  FilterAttireOptionsVariablesBuilder itemId(String? t) {
   _itemId.value = t;
   return this;
  }
  FilterAttireOptionsVariablesBuilder isMandatory(bool? t) {
   _isMandatory.value = t;
   return this;
  }
  FilterAttireOptionsVariablesBuilder vendorId(String? t) {
   _vendorId.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterAttireOptions()
.itemId(itemId)
.isMandatory(isMandatory)
.vendorId(vendorId)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterAttireOptionsData, filterAttireOptionsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterAttireOptions();
filterAttireOptionsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterAttireOptions().ref();
ref.execute();

ref.subscribe(...);
```


### listOrders
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listOrders().execute();
```

#### Optional Arguments
We return a builder for each query. For listOrders, we created `listOrdersBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListOrdersVariablesBuilder {
  ...
 
  ListOrdersVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListOrdersVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listOrders()
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listOrdersData, listOrdersVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listOrders();
listOrdersData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listOrders().ref();
ref.execute();

ref.subscribe(...);
```


### getOrderById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getOrderById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getOrderByIdData, getOrderByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getOrderById(
  id: id,
);
getOrderByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getOrderById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### getOrdersByBusinessId
#### Required Arguments
```dart
String businessId = ...;
ExampleConnector.instance.getOrdersByBusinessId(
  businessId: businessId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For getOrdersByBusinessId, we created `getOrdersByBusinessIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class GetOrdersByBusinessIdVariablesBuilder {
  ...
   GetOrdersByBusinessIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  GetOrdersByBusinessIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.getOrdersByBusinessId(
  businessId: businessId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<getOrdersByBusinessIdData, getOrdersByBusinessIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getOrdersByBusinessId(
  businessId: businessId,
);
getOrdersByBusinessIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;

final ref = ExampleConnector.instance.getOrdersByBusinessId(
  businessId: businessId,
).ref();
ref.execute();

ref.subscribe(...);
```


### getOrdersByVendorId
#### Required Arguments
```dart
String vendorId = ...;
ExampleConnector.instance.getOrdersByVendorId(
  vendorId: vendorId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For getOrdersByVendorId, we created `getOrdersByVendorIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class GetOrdersByVendorIdVariablesBuilder {
  ...
   GetOrdersByVendorIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  GetOrdersByVendorIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.getOrdersByVendorId(
  vendorId: vendorId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<getOrdersByVendorIdData, getOrdersByVendorIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getOrdersByVendorId(
  vendorId: vendorId,
);
getOrdersByVendorIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;

final ref = ExampleConnector.instance.getOrdersByVendorId(
  vendorId: vendorId,
).ref();
ref.execute();

ref.subscribe(...);
```


### getOrdersByStatus
#### Required Arguments
```dart
OrderStatus status = ...;
ExampleConnector.instance.getOrdersByStatus(
  status: status,
).execute();
```

#### Optional Arguments
We return a builder for each query. For getOrdersByStatus, we created `getOrdersByStatusBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class GetOrdersByStatusVariablesBuilder {
  ...
   GetOrdersByStatusVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  GetOrdersByStatusVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.getOrdersByStatus(
  status: status,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<getOrdersByStatusData, getOrdersByStatusVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getOrdersByStatus(
  status: status,
);
getOrdersByStatusData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
OrderStatus status = ...;

final ref = ExampleConnector.instance.getOrdersByStatus(
  status: status,
).ref();
ref.execute();

ref.subscribe(...);
```


### getOrdersByDateRange
#### Required Arguments
```dart
Timestamp start = ...;
Timestamp end = ...;
ExampleConnector.instance.getOrdersByDateRange(
  start: start,
  end: end,
).execute();
```

#### Optional Arguments
We return a builder for each query. For getOrdersByDateRange, we created `getOrdersByDateRangeBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class GetOrdersByDateRangeVariablesBuilder {
  ...
   GetOrdersByDateRangeVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  GetOrdersByDateRangeVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.getOrdersByDateRange(
  start: start,
  end: end,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<getOrdersByDateRangeData, getOrdersByDateRangeVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getOrdersByDateRange(
  start: start,
  end: end,
);
getOrdersByDateRangeData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
Timestamp start = ...;
Timestamp end = ...;

final ref = ExampleConnector.instance.getOrdersByDateRange(
  start: start,
  end: end,
).ref();
ref.execute();

ref.subscribe(...);
```


### getRapidOrders
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.getRapidOrders().execute();
```

#### Optional Arguments
We return a builder for each query. For getRapidOrders, we created `getRapidOrdersBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class GetRapidOrdersVariablesBuilder {
  ...
 
  GetRapidOrdersVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  GetRapidOrdersVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.getRapidOrders()
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<getRapidOrdersData, getRapidOrdersVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getRapidOrders();
getRapidOrdersData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.getRapidOrders().ref();
ref.execute();

ref.subscribe(...);
```


### listStaffAvailabilities
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listStaffAvailabilities().execute();
```

#### Optional Arguments
We return a builder for each query. For listStaffAvailabilities, we created `listStaffAvailabilitiesBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListStaffAvailabilitiesVariablesBuilder {
  ...
 
  ListStaffAvailabilitiesVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListStaffAvailabilitiesVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listStaffAvailabilities()
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listStaffAvailabilitiesData, listStaffAvailabilitiesVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listStaffAvailabilities();
listStaffAvailabilitiesData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listStaffAvailabilities().ref();
ref.execute();

ref.subscribe(...);
```


### listStaffAvailabilitiesByStaffId
#### Required Arguments
```dart
String staffId = ...;
ExampleConnector.instance.listStaffAvailabilitiesByStaffId(
  staffId: staffId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listStaffAvailabilitiesByStaffId, we created `listStaffAvailabilitiesByStaffIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListStaffAvailabilitiesByStaffIdVariablesBuilder {
  ...
   ListStaffAvailabilitiesByStaffIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListStaffAvailabilitiesByStaffIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listStaffAvailabilitiesByStaffId(
  staffId: staffId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listStaffAvailabilitiesByStaffIdData, listStaffAvailabilitiesByStaffIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listStaffAvailabilitiesByStaffId(
  staffId: staffId,
);
listStaffAvailabilitiesByStaffIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;

final ref = ExampleConnector.instance.listStaffAvailabilitiesByStaffId(
  staffId: staffId,
).ref();
ref.execute();

ref.subscribe(...);
```


### getStaffAvailabilityByKey
#### Required Arguments
```dart
String staffId = ...;
DayOfWeek day = ...;
AvailabilitySlot slot = ...;
ExampleConnector.instance.getStaffAvailabilityByKey(
  staffId: staffId,
  day: day,
  slot: slot,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getStaffAvailabilityByKeyData, getStaffAvailabilityByKeyVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getStaffAvailabilityByKey(
  staffId: staffId,
  day: day,
  slot: slot,
);
getStaffAvailabilityByKeyData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;
DayOfWeek day = ...;
AvailabilitySlot slot = ...;

final ref = ExampleConnector.instance.getStaffAvailabilityByKey(
  staffId: staffId,
  day: day,
  slot: slot,
).ref();
ref.execute();

ref.subscribe(...);
```


### listStaffAvailabilitiesByDay
#### Required Arguments
```dart
DayOfWeek day = ...;
ExampleConnector.instance.listStaffAvailabilitiesByDay(
  day: day,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listStaffAvailabilitiesByDay, we created `listStaffAvailabilitiesByDayBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListStaffAvailabilitiesByDayVariablesBuilder {
  ...
   ListStaffAvailabilitiesByDayVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListStaffAvailabilitiesByDayVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listStaffAvailabilitiesByDay(
  day: day,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listStaffAvailabilitiesByDayData, listStaffAvailabilitiesByDayVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listStaffAvailabilitiesByDay(
  day: day,
);
listStaffAvailabilitiesByDayData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
DayOfWeek day = ...;

final ref = ExampleConnector.instance.listStaffAvailabilitiesByDay(
  day: day,
).ref();
ref.execute();

ref.subscribe(...);
```


### getStaffCourseById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getStaffCourseById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getStaffCourseByIdData, getStaffCourseByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getStaffCourseById(
  id: id,
);
getStaffCourseByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getStaffCourseById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### listStaffCoursesByStaffId
#### Required Arguments
```dart
String staffId = ...;
ExampleConnector.instance.listStaffCoursesByStaffId(
  staffId: staffId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listStaffCoursesByStaffId, we created `listStaffCoursesByStaffIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListStaffCoursesByStaffIdVariablesBuilder {
  ...
   ListStaffCoursesByStaffIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListStaffCoursesByStaffIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listStaffCoursesByStaffId(
  staffId: staffId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listStaffCoursesByStaffIdData, listStaffCoursesByStaffIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listStaffCoursesByStaffId(
  staffId: staffId,
);
listStaffCoursesByStaffIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;

final ref = ExampleConnector.instance.listStaffCoursesByStaffId(
  staffId: staffId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listStaffCoursesByCourseId
#### Required Arguments
```dart
String courseId = ...;
ExampleConnector.instance.listStaffCoursesByCourseId(
  courseId: courseId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listStaffCoursesByCourseId, we created `listStaffCoursesByCourseIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListStaffCoursesByCourseIdVariablesBuilder {
  ...
   ListStaffCoursesByCourseIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListStaffCoursesByCourseIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listStaffCoursesByCourseId(
  courseId: courseId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listStaffCoursesByCourseIdData, listStaffCoursesByCourseIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listStaffCoursesByCourseId(
  courseId: courseId,
);
listStaffCoursesByCourseIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String courseId = ...;

final ref = ExampleConnector.instance.listStaffCoursesByCourseId(
  courseId: courseId,
).ref();
ref.execute();

ref.subscribe(...);
```


### getStaffCourseByStaffAndCourse
#### Required Arguments
```dart
String staffId = ...;
String courseId = ...;
ExampleConnector.instance.getStaffCourseByStaffAndCourse(
  staffId: staffId,
  courseId: courseId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getStaffCourseByStaffAndCourseData, getStaffCourseByStaffAndCourseVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getStaffCourseByStaffAndCourse(
  staffId: staffId,
  courseId: courseId,
);
getStaffCourseByStaffAndCourseData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;
String courseId = ...;

final ref = ExampleConnector.instance.getStaffCourseByStaffAndCourse(
  staffId: staffId,
  courseId: courseId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listBenefitsData
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listBenefitsData().execute();
```

#### Optional Arguments
We return a builder for each query. For listBenefitsData, we created `listBenefitsDataBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListBenefitsDataVariablesBuilder {
  ...
 
  ListBenefitsDataVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListBenefitsDataVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listBenefitsData()
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listBenefitsDataData, listBenefitsDataVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listBenefitsData();
listBenefitsDataData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listBenefitsData().ref();
ref.execute();

ref.subscribe(...);
```


### getBenefitsDataByKey
#### Required Arguments
```dart
String staffId = ...;
String vendorBenefitPlanId = ...;
ExampleConnector.instance.getBenefitsDataByKey(
  staffId: staffId,
  vendorBenefitPlanId: vendorBenefitPlanId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getBenefitsDataByKeyData, getBenefitsDataByKeyVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getBenefitsDataByKey(
  staffId: staffId,
  vendorBenefitPlanId: vendorBenefitPlanId,
);
getBenefitsDataByKeyData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;
String vendorBenefitPlanId = ...;

final ref = ExampleConnector.instance.getBenefitsDataByKey(
  staffId: staffId,
  vendorBenefitPlanId: vendorBenefitPlanId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listBenefitsDataByStaffId
#### Required Arguments
```dart
String staffId = ...;
ExampleConnector.instance.listBenefitsDataByStaffId(
  staffId: staffId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listBenefitsDataByStaffId, we created `listBenefitsDataByStaffIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListBenefitsDataByStaffIdVariablesBuilder {
  ...
   ListBenefitsDataByStaffIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListBenefitsDataByStaffIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listBenefitsDataByStaffId(
  staffId: staffId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listBenefitsDataByStaffIdData, listBenefitsDataByStaffIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listBenefitsDataByStaffId(
  staffId: staffId,
);
listBenefitsDataByStaffIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;

final ref = ExampleConnector.instance.listBenefitsDataByStaffId(
  staffId: staffId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listBenefitsDataByVendorBenefitPlanId
#### Required Arguments
```dart
String vendorBenefitPlanId = ...;
ExampleConnector.instance.listBenefitsDataByVendorBenefitPlanId(
  vendorBenefitPlanId: vendorBenefitPlanId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listBenefitsDataByVendorBenefitPlanId, we created `listBenefitsDataByVendorBenefitPlanIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListBenefitsDataByVendorBenefitPlanIdVariablesBuilder {
  ...
   ListBenefitsDataByVendorBenefitPlanIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListBenefitsDataByVendorBenefitPlanIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listBenefitsDataByVendorBenefitPlanId(
  vendorBenefitPlanId: vendorBenefitPlanId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listBenefitsDataByVendorBenefitPlanIdData, listBenefitsDataByVendorBenefitPlanIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listBenefitsDataByVendorBenefitPlanId(
  vendorBenefitPlanId: vendorBenefitPlanId,
);
listBenefitsDataByVendorBenefitPlanIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorBenefitPlanId = ...;

final ref = ExampleConnector.instance.listBenefitsDataByVendorBenefitPlanId(
  vendorBenefitPlanId: vendorBenefitPlanId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listBenefitsDataByVendorBenefitPlanIds
#### Required Arguments
```dart
String vendorBenefitPlanIds = ...;
ExampleConnector.instance.listBenefitsDataByVendorBenefitPlanIds(
  vendorBenefitPlanIds: vendorBenefitPlanIds,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listBenefitsDataByVendorBenefitPlanIds, we created `listBenefitsDataByVendorBenefitPlanIdsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListBenefitsDataByVendorBenefitPlanIdsVariablesBuilder {
  ...
   ListBenefitsDataByVendorBenefitPlanIdsVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListBenefitsDataByVendorBenefitPlanIdsVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listBenefitsDataByVendorBenefitPlanIds(
  vendorBenefitPlanIds: vendorBenefitPlanIds,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listBenefitsDataByVendorBenefitPlanIdsData, listBenefitsDataByVendorBenefitPlanIdsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listBenefitsDataByVendorBenefitPlanIds(
  vendorBenefitPlanIds: vendorBenefitPlanIds,
);
listBenefitsDataByVendorBenefitPlanIdsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorBenefitPlanIds = ...;

final ref = ExampleConnector.instance.listBenefitsDataByVendorBenefitPlanIds(
  vendorBenefitPlanIds: vendorBenefitPlanIds,
).ref();
ref.execute();

ref.subscribe(...);
```


### listFaqDatas
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listFaqDatas().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listFaqDatasData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listFaqDatas();
listFaqDatasData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listFaqDatas().ref();
ref.execute();

ref.subscribe(...);
```


### getFaqDataById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getFaqDataById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getFaqDataByIdData, getFaqDataByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getFaqDataById(
  id: id,
);
getFaqDataByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getFaqDataById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterFaqDatas
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterFaqDatas().execute();
```

#### Optional Arguments
We return a builder for each query. For filterFaqDatas, we created `filterFaqDatasBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterFaqDatasVariablesBuilder {
  ...
 
  FilterFaqDatasVariablesBuilder category(String? t) {
   _category.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterFaqDatas()
.category(category)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterFaqDatasData, filterFaqDatasVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterFaqDatas();
filterFaqDatasData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterFaqDatas().ref();
ref.execute();

ref.subscribe(...);
```


### listTaxForms
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listTaxForms().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listTaxFormsData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listTaxForms();
listTaxFormsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listTaxForms().ref();
ref.execute();

ref.subscribe(...);
```


### getTaxFormById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getTaxFormById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getTaxFormByIdData, getTaxFormByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getTaxFormById(
  id: id,
);
getTaxFormByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getTaxFormById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### getTaxFormsBystaffId
#### Required Arguments
```dart
String staffId = ...;
ExampleConnector.instance.getTaxFormsBystaffId(
  staffId: staffId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getTaxFormsBystaffIdData, getTaxFormsBystaffIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getTaxFormsBystaffId(
  staffId: staffId,
);
getTaxFormsBystaffIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;

final ref = ExampleConnector.instance.getTaxFormsBystaffId(
  staffId: staffId,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterTaxForms
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterTaxForms().execute();
```

#### Optional Arguments
We return a builder for each query. For filterTaxForms, we created `filterTaxFormsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterTaxFormsVariablesBuilder {
  ...
 
  FilterTaxFormsVariablesBuilder formType(TaxFormType? t) {
   _formType.value = t;
   return this;
  }
  FilterTaxFormsVariablesBuilder status(TaxFormStatus? t) {
   _status.value = t;
   return this;
  }
  FilterTaxFormsVariablesBuilder staffId(String? t) {
   _staffId.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterTaxForms()
.formType(formType)
.status(status)
.staffId(staffId)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterTaxFormsData, filterTaxFormsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterTaxForms();
filterTaxFormsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterTaxForms().ref();
ref.execute();

ref.subscribe(...);
```


### listTeamMembers
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listTeamMembers().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listTeamMembersData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listTeamMembers();
listTeamMembersData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listTeamMembers().ref();
ref.execute();

ref.subscribe(...);
```


### getTeamMemberById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getTeamMemberById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getTeamMemberByIdData, getTeamMemberByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getTeamMemberById(
  id: id,
);
getTeamMemberByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getTeamMemberById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### getTeamMembersByTeamId
#### Required Arguments
```dart
String teamId = ...;
ExampleConnector.instance.getTeamMembersByTeamId(
  teamId: teamId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getTeamMembersByTeamIdData, getTeamMembersByTeamIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getTeamMembersByTeamId(
  teamId: teamId,
);
getTeamMembersByTeamIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String teamId = ...;

final ref = ExampleConnector.instance.getTeamMembersByTeamId(
  teamId: teamId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listVendorBenefitPlans
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listVendorBenefitPlans().execute();
```

#### Optional Arguments
We return a builder for each query. For listVendorBenefitPlans, we created `listVendorBenefitPlansBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListVendorBenefitPlansVariablesBuilder {
  ...
 
  ListVendorBenefitPlansVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListVendorBenefitPlansVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listVendorBenefitPlans()
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listVendorBenefitPlansData, listVendorBenefitPlansVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listVendorBenefitPlans();
listVendorBenefitPlansData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listVendorBenefitPlans().ref();
ref.execute();

ref.subscribe(...);
```


### getVendorBenefitPlanById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getVendorBenefitPlanById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getVendorBenefitPlanByIdData, getVendorBenefitPlanByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getVendorBenefitPlanById(
  id: id,
);
getVendorBenefitPlanByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getVendorBenefitPlanById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### listVendorBenefitPlansByVendorId
#### Required Arguments
```dart
String vendorId = ...;
ExampleConnector.instance.listVendorBenefitPlansByVendorId(
  vendorId: vendorId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listVendorBenefitPlansByVendorId, we created `listVendorBenefitPlansByVendorIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListVendorBenefitPlansByVendorIdVariablesBuilder {
  ...
   ListVendorBenefitPlansByVendorIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListVendorBenefitPlansByVendorIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listVendorBenefitPlansByVendorId(
  vendorId: vendorId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listVendorBenefitPlansByVendorIdData, listVendorBenefitPlansByVendorIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listVendorBenefitPlansByVendorId(
  vendorId: vendorId,
);
listVendorBenefitPlansByVendorIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;

final ref = ExampleConnector.instance.listVendorBenefitPlansByVendorId(
  vendorId: vendorId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listActiveVendorBenefitPlansByVendorId
#### Required Arguments
```dart
String vendorId = ...;
ExampleConnector.instance.listActiveVendorBenefitPlansByVendorId(
  vendorId: vendorId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listActiveVendorBenefitPlansByVendorId, we created `listActiveVendorBenefitPlansByVendorIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListActiveVendorBenefitPlansByVendorIdVariablesBuilder {
  ...
   ListActiveVendorBenefitPlansByVendorIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListActiveVendorBenefitPlansByVendorIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listActiveVendorBenefitPlansByVendorId(
  vendorId: vendorId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listActiveVendorBenefitPlansByVendorIdData, listActiveVendorBenefitPlansByVendorIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listActiveVendorBenefitPlansByVendorId(
  vendorId: vendorId,
);
listActiveVendorBenefitPlansByVendorIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;

final ref = ExampleConnector.instance.listActiveVendorBenefitPlansByVendorId(
  vendorId: vendorId,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterVendorBenefitPlans
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterVendorBenefitPlans().execute();
```

#### Optional Arguments
We return a builder for each query. For filterVendorBenefitPlans, we created `filterVendorBenefitPlansBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterVendorBenefitPlansVariablesBuilder {
  ...
 
  FilterVendorBenefitPlansVariablesBuilder vendorId(String? t) {
   _vendorId.value = t;
   return this;
  }
  FilterVendorBenefitPlansVariablesBuilder title(String? t) {
   _title.value = t;
   return this;
  }
  FilterVendorBenefitPlansVariablesBuilder isActive(bool? t) {
   _isActive.value = t;
   return this;
  }
  FilterVendorBenefitPlansVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  FilterVendorBenefitPlansVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterVendorBenefitPlans()
.vendorId(vendorId)
.title(title)
.isActive(isActive)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterVendorBenefitPlansData, filterVendorBenefitPlansVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterVendorBenefitPlans();
filterVendorBenefitPlansData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterVendorBenefitPlans().ref();
ref.execute();

ref.subscribe(...);
```


### listAssignments
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listAssignments().execute();
```

#### Optional Arguments
We return a builder for each query. For listAssignments, we created `listAssignmentsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListAssignmentsVariablesBuilder {
  ...
 
  ListAssignmentsVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListAssignmentsVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listAssignments()
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listAssignmentsData, listAssignmentsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listAssignments();
listAssignmentsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listAssignments().ref();
ref.execute();

ref.subscribe(...);
```


### getAssignmentById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getAssignmentById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getAssignmentByIdData, getAssignmentByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getAssignmentById(
  id: id,
);
getAssignmentByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getAssignmentById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### listAssignmentsByWorkforceId
#### Required Arguments
```dart
String workforceId = ...;
ExampleConnector.instance.listAssignmentsByWorkforceId(
  workforceId: workforceId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listAssignmentsByWorkforceId, we created `listAssignmentsByWorkforceIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListAssignmentsByWorkforceIdVariablesBuilder {
  ...
   ListAssignmentsByWorkforceIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListAssignmentsByWorkforceIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listAssignmentsByWorkforceId(
  workforceId: workforceId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listAssignmentsByWorkforceIdData, listAssignmentsByWorkforceIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listAssignmentsByWorkforceId(
  workforceId: workforceId,
);
listAssignmentsByWorkforceIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String workforceId = ...;

final ref = ExampleConnector.instance.listAssignmentsByWorkforceId(
  workforceId: workforceId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listAssignmentsByWorkforceIds
#### Required Arguments
```dart
String workforceIds = ...;
ExampleConnector.instance.listAssignmentsByWorkforceIds(
  workforceIds: workforceIds,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listAssignmentsByWorkforceIds, we created `listAssignmentsByWorkforceIdsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListAssignmentsByWorkforceIdsVariablesBuilder {
  ...
   ListAssignmentsByWorkforceIdsVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListAssignmentsByWorkforceIdsVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listAssignmentsByWorkforceIds(
  workforceIds: workforceIds,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listAssignmentsByWorkforceIdsData, listAssignmentsByWorkforceIdsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listAssignmentsByWorkforceIds(
  workforceIds: workforceIds,
);
listAssignmentsByWorkforceIdsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String workforceIds = ...;

final ref = ExampleConnector.instance.listAssignmentsByWorkforceIds(
  workforceIds: workforceIds,
).ref();
ref.execute();

ref.subscribe(...);
```


### listAssignmentsByShiftRole
#### Required Arguments
```dart
String shiftId = ...;
String roleId = ...;
ExampleConnector.instance.listAssignmentsByShiftRole(
  shiftId: shiftId,
  roleId: roleId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listAssignmentsByShiftRole, we created `listAssignmentsByShiftRoleBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListAssignmentsByShiftRoleVariablesBuilder {
  ...
   ListAssignmentsByShiftRoleVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListAssignmentsByShiftRoleVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listAssignmentsByShiftRole(
  shiftId: shiftId,
  roleId: roleId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listAssignmentsByShiftRoleData, listAssignmentsByShiftRoleVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listAssignmentsByShiftRole(
  shiftId: shiftId,
  roleId: roleId,
);
listAssignmentsByShiftRoleData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String shiftId = ...;
String roleId = ...;

final ref = ExampleConnector.instance.listAssignmentsByShiftRole(
  shiftId: shiftId,
  roleId: roleId,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterAssignments
#### Required Arguments
```dart
String shiftIds = ...;
String roleIds = ...;
ExampleConnector.instance.filterAssignments(
  shiftIds: shiftIds,
  roleIds: roleIds,
).execute();
```

#### Optional Arguments
We return a builder for each query. For filterAssignments, we created `filterAssignmentsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterAssignmentsVariablesBuilder {
  ...
   FilterAssignmentsVariablesBuilder status(AssignmentStatus? t) {
   _status.value = t;
   return this;
  }
  FilterAssignmentsVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  FilterAssignmentsVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterAssignments(
  shiftIds: shiftIds,
  roleIds: roleIds,
)
.status(status)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterAssignmentsData, filterAssignmentsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterAssignments(
  shiftIds: shiftIds,
  roleIds: roleIds,
);
filterAssignmentsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String shiftIds = ...;
String roleIds = ...;

final ref = ExampleConnector.instance.filterAssignments(
  shiftIds: shiftIds,
  roleIds: roleIds,
).ref();
ref.execute();

ref.subscribe(...);
```


### listVendorRates
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listVendorRates().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listVendorRatesData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listVendorRates();
listVendorRatesData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listVendorRates().ref();
ref.execute();

ref.subscribe(...);
```


### getVendorRateById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getVendorRateById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getVendorRateByIdData, getVendorRateByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getVendorRateById(
  id: id,
);
getVendorRateByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getVendorRateById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### listHubs
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listHubs().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listHubsData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listHubs();
listHubsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listHubs().ref();
ref.execute();

ref.subscribe(...);
```


### getHubById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getHubById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getHubByIdData, getHubByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getHubById(
  id: id,
);
getHubByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getHubById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### getHubsByOwnerId
#### Required Arguments
```dart
String ownerId = ...;
ExampleConnector.instance.getHubsByOwnerId(
  ownerId: ownerId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getHubsByOwnerIdData, getHubsByOwnerIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getHubsByOwnerId(
  ownerId: ownerId,
);
getHubsByOwnerIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String ownerId = ...;

final ref = ExampleConnector.instance.getHubsByOwnerId(
  ownerId: ownerId,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterHubs
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterHubs().execute();
```

#### Optional Arguments
We return a builder for each query. For filterHubs, we created `filterHubsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterHubsVariablesBuilder {
  ...
 
  FilterHubsVariablesBuilder ownerId(String? t) {
   _ownerId.value = t;
   return this;
  }
  FilterHubsVariablesBuilder name(String? t) {
   _name.value = t;
   return this;
  }
  FilterHubsVariablesBuilder nfcTagId(String? t) {
   _nfcTagId.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterHubs()
.ownerId(ownerId)
.name(name)
.nfcTagId(nfcTagId)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterHubsData, filterHubsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterHubs();
filterHubsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterHubs().ref();
ref.execute();

ref.subscribe(...);
```


### listInvoiceTemplates
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listInvoiceTemplates().execute();
```

#### Optional Arguments
We return a builder for each query. For listInvoiceTemplates, we created `listInvoiceTemplatesBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListInvoiceTemplatesVariablesBuilder {
  ...
 
  ListInvoiceTemplatesVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListInvoiceTemplatesVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listInvoiceTemplates()
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listInvoiceTemplatesData, listInvoiceTemplatesVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listInvoiceTemplates();
listInvoiceTemplatesData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listInvoiceTemplates().ref();
ref.execute();

ref.subscribe(...);
```


### getInvoiceTemplateById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getInvoiceTemplateById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getInvoiceTemplateByIdData, getInvoiceTemplateByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getInvoiceTemplateById(
  id: id,
);
getInvoiceTemplateByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getInvoiceTemplateById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### listInvoiceTemplatesByOwnerId
#### Required Arguments
```dart
String ownerId = ...;
ExampleConnector.instance.listInvoiceTemplatesByOwnerId(
  ownerId: ownerId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listInvoiceTemplatesByOwnerId, we created `listInvoiceTemplatesByOwnerIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListInvoiceTemplatesByOwnerIdVariablesBuilder {
  ...
   ListInvoiceTemplatesByOwnerIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListInvoiceTemplatesByOwnerIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listInvoiceTemplatesByOwnerId(
  ownerId: ownerId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listInvoiceTemplatesByOwnerIdData, listInvoiceTemplatesByOwnerIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listInvoiceTemplatesByOwnerId(
  ownerId: ownerId,
);
listInvoiceTemplatesByOwnerIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String ownerId = ...;

final ref = ExampleConnector.instance.listInvoiceTemplatesByOwnerId(
  ownerId: ownerId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listInvoiceTemplatesByVendorId
#### Required Arguments
```dart
String vendorId = ...;
ExampleConnector.instance.listInvoiceTemplatesByVendorId(
  vendorId: vendorId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listInvoiceTemplatesByVendorId, we created `listInvoiceTemplatesByVendorIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListInvoiceTemplatesByVendorIdVariablesBuilder {
  ...
   ListInvoiceTemplatesByVendorIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListInvoiceTemplatesByVendorIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listInvoiceTemplatesByVendorId(
  vendorId: vendorId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listInvoiceTemplatesByVendorIdData, listInvoiceTemplatesByVendorIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listInvoiceTemplatesByVendorId(
  vendorId: vendorId,
);
listInvoiceTemplatesByVendorIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;

final ref = ExampleConnector.instance.listInvoiceTemplatesByVendorId(
  vendorId: vendorId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listInvoiceTemplatesByBusinessId
#### Required Arguments
```dart
String businessId = ...;
ExampleConnector.instance.listInvoiceTemplatesByBusinessId(
  businessId: businessId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listInvoiceTemplatesByBusinessId, we created `listInvoiceTemplatesByBusinessIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListInvoiceTemplatesByBusinessIdVariablesBuilder {
  ...
   ListInvoiceTemplatesByBusinessIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListInvoiceTemplatesByBusinessIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listInvoiceTemplatesByBusinessId(
  businessId: businessId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listInvoiceTemplatesByBusinessIdData, listInvoiceTemplatesByBusinessIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listInvoiceTemplatesByBusinessId(
  businessId: businessId,
);
listInvoiceTemplatesByBusinessIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;

final ref = ExampleConnector.instance.listInvoiceTemplatesByBusinessId(
  businessId: businessId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listInvoiceTemplatesByOrderId
#### Required Arguments
```dart
String orderId = ...;
ExampleConnector.instance.listInvoiceTemplatesByOrderId(
  orderId: orderId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listInvoiceTemplatesByOrderId, we created `listInvoiceTemplatesByOrderIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListInvoiceTemplatesByOrderIdVariablesBuilder {
  ...
   ListInvoiceTemplatesByOrderIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListInvoiceTemplatesByOrderIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listInvoiceTemplatesByOrderId(
  orderId: orderId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listInvoiceTemplatesByOrderIdData, listInvoiceTemplatesByOrderIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listInvoiceTemplatesByOrderId(
  orderId: orderId,
);
listInvoiceTemplatesByOrderIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String orderId = ...;

final ref = ExampleConnector.instance.listInvoiceTemplatesByOrderId(
  orderId: orderId,
).ref();
ref.execute();

ref.subscribe(...);
```


### searchInvoiceTemplatesByOwnerAndName
#### Required Arguments
```dart
String ownerId = ...;
String name = ...;
ExampleConnector.instance.searchInvoiceTemplatesByOwnerAndName(
  ownerId: ownerId,
  name: name,
).execute();
```

#### Optional Arguments
We return a builder for each query. For searchInvoiceTemplatesByOwnerAndName, we created `searchInvoiceTemplatesByOwnerAndNameBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class SearchInvoiceTemplatesByOwnerAndNameVariablesBuilder {
  ...
   SearchInvoiceTemplatesByOwnerAndNameVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  SearchInvoiceTemplatesByOwnerAndNameVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.searchInvoiceTemplatesByOwnerAndName(
  ownerId: ownerId,
  name: name,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<searchInvoiceTemplatesByOwnerAndNameData, searchInvoiceTemplatesByOwnerAndNameVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.searchInvoiceTemplatesByOwnerAndName(
  ownerId: ownerId,
  name: name,
);
searchInvoiceTemplatesByOwnerAndNameData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String ownerId = ...;
String name = ...;

final ref = ExampleConnector.instance.searchInvoiceTemplatesByOwnerAndName(
  ownerId: ownerId,
  name: name,
).ref();
ref.execute();

ref.subscribe(...);
```


### getMyTasks
#### Required Arguments
```dart
String teamMemberId = ...;
ExampleConnector.instance.getMyTasks(
  teamMemberId: teamMemberId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getMyTasksData, getMyTasksVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getMyTasks(
  teamMemberId: teamMemberId,
);
getMyTasksData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String teamMemberId = ...;

final ref = ExampleConnector.instance.getMyTasks(
  teamMemberId: teamMemberId,
).ref();
ref.execute();

ref.subscribe(...);
```


### getMemberTaskByIdKey
#### Required Arguments
```dart
String teamMemberId = ...;
String taskId = ...;
ExampleConnector.instance.getMemberTaskByIdKey(
  teamMemberId: teamMemberId,
  taskId: taskId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getMemberTaskByIdKeyData, getMemberTaskByIdKeyVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getMemberTaskByIdKey(
  teamMemberId: teamMemberId,
  taskId: taskId,
);
getMemberTaskByIdKeyData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String teamMemberId = ...;
String taskId = ...;

final ref = ExampleConnector.instance.getMemberTaskByIdKey(
  teamMemberId: teamMemberId,
  taskId: taskId,
).ref();
ref.execute();

ref.subscribe(...);
```


### getMemberTasksByTaskId
#### Required Arguments
```dart
String taskId = ...;
ExampleConnector.instance.getMemberTasksByTaskId(
  taskId: taskId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getMemberTasksByTaskIdData, getMemberTasksByTaskIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getMemberTasksByTaskId(
  taskId: taskId,
);
getMemberTasksByTaskIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String taskId = ...;

final ref = ExampleConnector.instance.getMemberTasksByTaskId(
  taskId: taskId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listTaskComments
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listTaskComments().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listTaskCommentsData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listTaskComments();
listTaskCommentsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listTaskComments().ref();
ref.execute();

ref.subscribe(...);
```


### getTaskCommentById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getTaskCommentById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getTaskCommentByIdData, getTaskCommentByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getTaskCommentById(
  id: id,
);
getTaskCommentByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getTaskCommentById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### getTaskCommentsByTaskId
#### Required Arguments
```dart
String taskId = ...;
ExampleConnector.instance.getTaskCommentsByTaskId(
  taskId: taskId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getTaskCommentsByTaskIdData, getTaskCommentsByTaskIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getTaskCommentsByTaskId(
  taskId: taskId,
);
getTaskCommentsByTaskIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String taskId = ...;

final ref = ExampleConnector.instance.getTaskCommentsByTaskId(
  taskId: taskId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listCourses
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listCourses().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listCoursesData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listCourses();
listCoursesData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listCourses().ref();
ref.execute();

ref.subscribe(...);
```


### getCourseById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getCourseById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getCourseByIdData, getCourseByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getCourseById(
  id: id,
);
getCourseByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getCourseById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterCourses
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterCourses().execute();
```

#### Optional Arguments
We return a builder for each query. For filterCourses, we created `filterCoursesBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterCoursesVariablesBuilder {
  ...
 
  FilterCoursesVariablesBuilder categoryId(String? t) {
   _categoryId.value = t;
   return this;
  }
  FilterCoursesVariablesBuilder isCertification(bool? t) {
   _isCertification.value = t;
   return this;
  }
  FilterCoursesVariablesBuilder levelRequired(String? t) {
   _levelRequired.value = t;
   return this;
  }
  FilterCoursesVariablesBuilder completed(bool? t) {
   _completed.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterCourses()
.categoryId(categoryId)
.isCertification(isCertification)
.levelRequired(levelRequired)
.completed(completed)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterCoursesData, filterCoursesVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterCourses();
filterCoursesData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterCourses().ref();
ref.execute();

ref.subscribe(...);
```


### listTeamHudDepartments
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listTeamHudDepartments().execute();
```

#### Optional Arguments
We return a builder for each query. For listTeamHudDepartments, we created `listTeamHudDepartmentsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListTeamHudDepartmentsVariablesBuilder {
  ...
 
  ListTeamHudDepartmentsVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListTeamHudDepartmentsVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listTeamHudDepartments()
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listTeamHudDepartmentsData, listTeamHudDepartmentsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listTeamHudDepartments();
listTeamHudDepartmentsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listTeamHudDepartments().ref();
ref.execute();

ref.subscribe(...);
```


### getTeamHudDepartmentById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getTeamHudDepartmentById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getTeamHudDepartmentByIdData, getTeamHudDepartmentByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getTeamHudDepartmentById(
  id: id,
);
getTeamHudDepartmentByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getTeamHudDepartmentById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### listTeamHudDepartmentsByTeamHubId
#### Required Arguments
```dart
String teamHubId = ...;
ExampleConnector.instance.listTeamHudDepartmentsByTeamHubId(
  teamHubId: teamHubId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listTeamHudDepartmentsByTeamHubId, we created `listTeamHudDepartmentsByTeamHubIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListTeamHudDepartmentsByTeamHubIdVariablesBuilder {
  ...
   ListTeamHudDepartmentsByTeamHubIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListTeamHudDepartmentsByTeamHubIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listTeamHudDepartmentsByTeamHubId(
  teamHubId: teamHubId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listTeamHudDepartmentsByTeamHubIdData, listTeamHudDepartmentsByTeamHubIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listTeamHudDepartmentsByTeamHubId(
  teamHubId: teamHubId,
);
listTeamHudDepartmentsByTeamHubIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String teamHubId = ...;

final ref = ExampleConnector.instance.listTeamHudDepartmentsByTeamHubId(
  teamHubId: teamHubId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listStaffRoles
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listStaffRoles().execute();
```

#### Optional Arguments
We return a builder for each query. For listStaffRoles, we created `listStaffRolesBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListStaffRolesVariablesBuilder {
  ...
 
  ListStaffRolesVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListStaffRolesVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listStaffRoles()
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listStaffRolesData, listStaffRolesVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listStaffRoles();
listStaffRolesData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listStaffRoles().ref();
ref.execute();

ref.subscribe(...);
```


### getStaffRoleByKey
#### Required Arguments
```dart
String staffId = ...;
String roleId = ...;
ExampleConnector.instance.getStaffRoleByKey(
  staffId: staffId,
  roleId: roleId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getStaffRoleByKeyData, getStaffRoleByKeyVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getStaffRoleByKey(
  staffId: staffId,
  roleId: roleId,
);
getStaffRoleByKeyData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;
String roleId = ...;

final ref = ExampleConnector.instance.getStaffRoleByKey(
  staffId: staffId,
  roleId: roleId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listStaffRolesByStaffId
#### Required Arguments
```dart
String staffId = ...;
ExampleConnector.instance.listStaffRolesByStaffId(
  staffId: staffId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listStaffRolesByStaffId, we created `listStaffRolesByStaffIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListStaffRolesByStaffIdVariablesBuilder {
  ...
   ListStaffRolesByStaffIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListStaffRolesByStaffIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listStaffRolesByStaffId(
  staffId: staffId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listStaffRolesByStaffIdData, listStaffRolesByStaffIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listStaffRolesByStaffId(
  staffId: staffId,
);
listStaffRolesByStaffIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;

final ref = ExampleConnector.instance.listStaffRolesByStaffId(
  staffId: staffId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listStaffRolesByRoleId
#### Required Arguments
```dart
String roleId = ...;
ExampleConnector.instance.listStaffRolesByRoleId(
  roleId: roleId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For listStaffRolesByRoleId, we created `listStaffRolesByRoleIdBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class ListStaffRolesByRoleIdVariablesBuilder {
  ...
   ListStaffRolesByRoleIdVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  ListStaffRolesByRoleIdVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.listStaffRolesByRoleId(
  roleId: roleId,
)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<listStaffRolesByRoleIdData, listStaffRolesByRoleIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listStaffRolesByRoleId(
  roleId: roleId,
);
listStaffRolesByRoleIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String roleId = ...;

final ref = ExampleConnector.instance.listStaffRolesByRoleId(
  roleId: roleId,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterStaffRoles
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterStaffRoles().execute();
```

#### Optional Arguments
We return a builder for each query. For filterStaffRoles, we created `filterStaffRolesBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterStaffRolesVariablesBuilder {
  ...
 
  FilterStaffRolesVariablesBuilder staffId(String? t) {
   _staffId.value = t;
   return this;
  }
  FilterStaffRolesVariablesBuilder roleId(String? t) {
   _roleId.value = t;
   return this;
  }
  FilterStaffRolesVariablesBuilder offset(int? t) {
   _offset.value = t;
   return this;
  }
  FilterStaffRolesVariablesBuilder limit(int? t) {
   _limit.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterStaffRoles()
.staffId(staffId)
.roleId(roleId)
.offset(offset)
.limit(limit)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterStaffRolesData, filterStaffRolesVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterStaffRoles();
filterStaffRolesData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterStaffRoles().ref();
ref.execute();

ref.subscribe(...);
```


### listTeams
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listTeams().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listTeamsData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listTeams();
listTeamsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listTeams().ref();
ref.execute();

ref.subscribe(...);
```


### getTeamById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getTeamById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getTeamByIdData, getTeamByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getTeamById(
  id: id,
);
getTeamByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getTeamById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### getTeamsByOwnerId
#### Required Arguments
```dart
String ownerId = ...;
ExampleConnector.instance.getTeamsByOwnerId(
  ownerId: ownerId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getTeamsByOwnerIdData, getTeamsByOwnerIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getTeamsByOwnerId(
  ownerId: ownerId,
);
getTeamsByOwnerIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String ownerId = ...;

final ref = ExampleConnector.instance.getTeamsByOwnerId(
  ownerId: ownerId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listUsers
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listUsers().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listUsersData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listUsers();
listUsersData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listUsers().ref();
ref.execute();

ref.subscribe(...);
```


### getUserById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getUserById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getUserByIdData, getUserByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getUserById(
  id: id,
);
getUserByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getUserById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterUsers
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterUsers().execute();
```

#### Optional Arguments
We return a builder for each query. For filterUsers, we created `filterUsersBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterUsersVariablesBuilder {
  ...
 
  FilterUsersVariablesBuilder id(String? t) {
   _id.value = t;
   return this;
  }
  FilterUsersVariablesBuilder email(String? t) {
   _email.value = t;
   return this;
  }
  FilterUsersVariablesBuilder role(UserBaseRole? t) {
   _role.value = t;
   return this;
  }
  FilterUsersVariablesBuilder userRole(String? t) {
   _userRole.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterUsers()
.id(id)
.email(email)
.role(role)
.userRole(userRole)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterUsersData, filterUsersVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterUsers();
filterUsersData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterUsers().ref();
ref.execute();

ref.subscribe(...);
```


### listAccounts
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listAccounts().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listAccountsData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listAccounts();
listAccountsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listAccounts().ref();
ref.execute();

ref.subscribe(...);
```


### getAccountById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getAccountById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getAccountByIdData, getAccountByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getAccountById(
  id: id,
);
getAccountByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getAccountById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### getAccountsByOwnerId
#### Required Arguments
```dart
String ownerId = ...;
ExampleConnector.instance.getAccountsByOwnerId(
  ownerId: ownerId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getAccountsByOwnerIdData, getAccountsByOwnerIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getAccountsByOwnerId(
  ownerId: ownerId,
);
getAccountsByOwnerIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String ownerId = ...;

final ref = ExampleConnector.instance.getAccountsByOwnerId(
  ownerId: ownerId,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterAccounts
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterAccounts().execute();
```

#### Optional Arguments
We return a builder for each query. For filterAccounts, we created `filterAccountsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterAccountsVariablesBuilder {
  ...
 
  FilterAccountsVariablesBuilder bank(String? t) {
   _bank.value = t;
   return this;
  }
  FilterAccountsVariablesBuilder type(AccountType? t) {
   _type.value = t;
   return this;
  }
  FilterAccountsVariablesBuilder isPrimary(bool? t) {
   _isPrimary.value = t;
   return this;
  }
  FilterAccountsVariablesBuilder ownerId(String? t) {
   _ownerId.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterAccounts()
.bank(bank)
.type(type)
.isPrimary(isPrimary)
.ownerId(ownerId)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterAccountsData, filterAccountsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterAccounts();
filterAccountsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterAccounts().ref();
ref.execute();

ref.subscribe(...);
```


### listCertificates
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listCertificates().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listCertificatesData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listCertificates();
listCertificatesData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listCertificates().ref();
ref.execute();

ref.subscribe(...);
```


### getCertificateById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getCertificateById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getCertificateByIdData, getCertificateByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getCertificateById(
  id: id,
);
getCertificateByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getCertificateById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### listCertificatesByStaffId
#### Required Arguments
```dart
String staffId = ...;
ExampleConnector.instance.listCertificatesByStaffId(
  staffId: staffId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listCertificatesByStaffIdData, listCertificatesByStaffIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listCertificatesByStaffId(
  staffId: staffId,
);
listCertificatesByStaffIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;

final ref = ExampleConnector.instance.listCertificatesByStaffId(
  staffId: staffId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listRoleCategories
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listRoleCategories().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listRoleCategoriesData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listRoleCategories();
listRoleCategoriesData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listRoleCategories().ref();
ref.execute();

ref.subscribe(...);
```


### getRoleCategoryById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getRoleCategoryById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getRoleCategoryByIdData, getRoleCategoryByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getRoleCategoryById(
  id: id,
);
getRoleCategoryByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getRoleCategoryById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### getRoleCategoriesByCategory
#### Required Arguments
```dart
RoleCategoryType category = ...;
ExampleConnector.instance.getRoleCategoriesByCategory(
  category: category,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getRoleCategoriesByCategoryData, getRoleCategoriesByCategoryVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getRoleCategoriesByCategory(
  category: category,
);
getRoleCategoriesByCategoryData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
RoleCategoryType category = ...;

final ref = ExampleConnector.instance.getRoleCategoriesByCategory(
  category: category,
).ref();
ref.execute();

ref.subscribe(...);
```


### listTeamHubs
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listTeamHubs().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listTeamHubsData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listTeamHubs();
listTeamHubsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listTeamHubs().ref();
ref.execute();

ref.subscribe(...);
```


### getTeamHubById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getTeamHubById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getTeamHubByIdData, getTeamHubByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getTeamHubById(
  id: id,
);
getTeamHubByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getTeamHubById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### getTeamHubsByTeamId
#### Required Arguments
```dart
String teamId = ...;
ExampleConnector.instance.getTeamHubsByTeamId(
  teamId: teamId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getTeamHubsByTeamIdData, getTeamHubsByTeamIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getTeamHubsByTeamId(
  teamId: teamId,
);
getTeamHubsByTeamIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String teamId = ...;

final ref = ExampleConnector.instance.getTeamHubsByTeamId(
  teamId: teamId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listTeamHubsByOwnerId
#### Required Arguments
```dart
String ownerId = ...;
ExampleConnector.instance.listTeamHubsByOwnerId(
  ownerId: ownerId,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<listTeamHubsByOwnerIdData, listTeamHubsByOwnerIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listTeamHubsByOwnerId(
  ownerId: ownerId,
);
listTeamHubsByOwnerIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String ownerId = ...;

final ref = ExampleConnector.instance.listTeamHubsByOwnerId(
  ownerId: ownerId,
).ref();
ref.execute();

ref.subscribe(...);
```


### listDocuments
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.listDocuments().execute();
```



#### Return Type
`execute()` returns a `QueryResult<listDocumentsData, void>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.listDocuments();
listDocumentsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.listDocuments().ref();
ref.execute();

ref.subscribe(...);
```


### getDocumentById
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.getDocumentById(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `QueryResult<getDocumentByIdData, getDocumentByIdVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.getDocumentById(
  id: id,
);
getDocumentByIdData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.getDocumentById(
  id: id,
).ref();
ref.execute();

ref.subscribe(...);
```


### filterDocuments
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.filterDocuments().execute();
```

#### Optional Arguments
We return a builder for each query. For filterDocuments, we created `filterDocumentsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class FilterDocumentsVariablesBuilder {
  ...
 
  FilterDocumentsVariablesBuilder documentType(DocumentType? t) {
   _documentType.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.filterDocuments()
.documentType(documentType)
.execute();
```

#### Return Type
`execute()` returns a `QueryResult<filterDocumentsData, filterDocumentsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

/// Result of a query request. Created to hold extra variables in the future.
class QueryResult<Data, Variables> extends OperationResult<Data, Variables> {
  QueryResult(super.dataConnect, super.data, super.ref);
}

final result = await ExampleConnector.instance.filterDocuments();
filterDocumentsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.filterDocuments().ref();
ref.execute();

ref.subscribe(...);
```

## Mutations

### createStaffRole
#### Required Arguments
```dart
String staffId = ...;
String roleId = ...;
ExampleConnector.instance.createStaffRole(
  staffId: staffId,
  roleId: roleId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createStaffRole, we created `createStaffRoleBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateStaffRoleVariablesBuilder {
  ...
   CreateStaffRoleVariablesBuilder roleType(RoleType? t) {
   _roleType.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createStaffRole(
  staffId: staffId,
  roleId: roleId,
)
.roleType(roleType)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createStaffRoleData, createStaffRoleVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createStaffRole(
  staffId: staffId,
  roleId: roleId,
);
createStaffRoleData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;
String roleId = ...;

final ref = ExampleConnector.instance.createStaffRole(
  staffId: staffId,
  roleId: roleId,
).ref();
ref.execute();
```


### deleteStaffRole
#### Required Arguments
```dart
String staffId = ...;
String roleId = ...;
ExampleConnector.instance.deleteStaffRole(
  staffId: staffId,
  roleId: roleId,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteStaffRoleData, deleteStaffRoleVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteStaffRole(
  staffId: staffId,
  roleId: roleId,
);
deleteStaffRoleData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;
String roleId = ...;

final ref = ExampleConnector.instance.deleteStaffRole(
  staffId: staffId,
  roleId: roleId,
).ref();
ref.execute();
```


### createTeamMember
#### Required Arguments
```dart
String teamId = ...;
TeamMemberRole role = ...;
String userId = ...;
ExampleConnector.instance.createTeamMember(
  teamId: teamId,
  role: role,
  userId: userId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createTeamMember, we created `createTeamMemberBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateTeamMemberVariablesBuilder {
  ...
   CreateTeamMemberVariablesBuilder title(String? t) {
   _title.value = t;
   return this;
  }
  CreateTeamMemberVariablesBuilder department(String? t) {
   _department.value = t;
   return this;
  }
  CreateTeamMemberVariablesBuilder teamHubId(String? t) {
   _teamHubId.value = t;
   return this;
  }
  CreateTeamMemberVariablesBuilder isActive(bool? t) {
   _isActive.value = t;
   return this;
  }
  CreateTeamMemberVariablesBuilder inviteStatus(TeamMemberInviteStatus? t) {
   _inviteStatus.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createTeamMember(
  teamId: teamId,
  role: role,
  userId: userId,
)
.title(title)
.department(department)
.teamHubId(teamHubId)
.isActive(isActive)
.inviteStatus(inviteStatus)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createTeamMemberData, createTeamMemberVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createTeamMember(
  teamId: teamId,
  role: role,
  userId: userId,
);
createTeamMemberData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String teamId = ...;
TeamMemberRole role = ...;
String userId = ...;

final ref = ExampleConnector.instance.createTeamMember(
  teamId: teamId,
  role: role,
  userId: userId,
).ref();
ref.execute();
```


### updateTeamMember
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateTeamMember(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateTeamMember, we created `updateTeamMemberBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateTeamMemberVariablesBuilder {
  ...
   UpdateTeamMemberVariablesBuilder role(TeamMemberRole? t) {
   _role.value = t;
   return this;
  }
  UpdateTeamMemberVariablesBuilder title(String? t) {
   _title.value = t;
   return this;
  }
  UpdateTeamMemberVariablesBuilder department(String? t) {
   _department.value = t;
   return this;
  }
  UpdateTeamMemberVariablesBuilder teamHubId(String? t) {
   _teamHubId.value = t;
   return this;
  }
  UpdateTeamMemberVariablesBuilder isActive(bool? t) {
   _isActive.value = t;
   return this;
  }
  UpdateTeamMemberVariablesBuilder inviteStatus(TeamMemberInviteStatus? t) {
   _inviteStatus.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateTeamMember(
  id: id,
)
.role(role)
.title(title)
.department(department)
.teamHubId(teamHubId)
.isActive(isActive)
.inviteStatus(inviteStatus)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateTeamMemberData, updateTeamMemberVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateTeamMember(
  id: id,
);
updateTeamMemberData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateTeamMember(
  id: id,
).ref();
ref.execute();
```


### updateTeamMemberInviteStatus
#### Required Arguments
```dart
String id = ...;
TeamMemberInviteStatus inviteStatus = ...;
ExampleConnector.instance.updateTeamMemberInviteStatus(
  id: id,
  inviteStatus: inviteStatus,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<updateTeamMemberInviteStatusData, updateTeamMemberInviteStatusVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateTeamMemberInviteStatus(
  id: id,
  inviteStatus: inviteStatus,
);
updateTeamMemberInviteStatusData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;
TeamMemberInviteStatus inviteStatus = ...;

final ref = ExampleConnector.instance.updateTeamMemberInviteStatus(
  id: id,
  inviteStatus: inviteStatus,
).ref();
ref.execute();
```


### acceptInviteByCode
#### Required Arguments
```dart
String inviteCode = ...;
ExampleConnector.instance.acceptInviteByCode(
  inviteCode: inviteCode,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<acceptInviteByCodeData, acceptInviteByCodeVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.acceptInviteByCode(
  inviteCode: inviteCode,
);
acceptInviteByCodeData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String inviteCode = ...;

final ref = ExampleConnector.instance.acceptInviteByCode(
  inviteCode: inviteCode,
).ref();
ref.execute();
```


### cancelInviteByCode
#### Required Arguments
```dart
String inviteCode = ...;
ExampleConnector.instance.cancelInviteByCode(
  inviteCode: inviteCode,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<cancelInviteByCodeData, cancelInviteByCodeVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.cancelInviteByCode(
  inviteCode: inviteCode,
);
cancelInviteByCodeData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String inviteCode = ...;

final ref = ExampleConnector.instance.cancelInviteByCode(
  inviteCode: inviteCode,
).ref();
ref.execute();
```


### deleteTeamMember
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteTeamMember(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteTeamMemberData, deleteTeamMemberVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteTeamMember(
  id: id,
);
deleteTeamMemberData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteTeamMember(
  id: id,
).ref();
ref.execute();
```


### createUserConversation
#### Required Arguments
```dart
String conversationId = ...;
String userId = ...;
ExampleConnector.instance.createUserConversation(
  conversationId: conversationId,
  userId: userId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createUserConversation, we created `createUserConversationBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateUserConversationVariablesBuilder {
  ...
   CreateUserConversationVariablesBuilder unreadCount(int? t) {
   _unreadCount.value = t;
   return this;
  }
  CreateUserConversationVariablesBuilder lastReadAt(Timestamp? t) {
   _lastReadAt.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createUserConversation(
  conversationId: conversationId,
  userId: userId,
)
.unreadCount(unreadCount)
.lastReadAt(lastReadAt)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createUserConversationData, createUserConversationVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createUserConversation(
  conversationId: conversationId,
  userId: userId,
);
createUserConversationData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String conversationId = ...;
String userId = ...;

final ref = ExampleConnector.instance.createUserConversation(
  conversationId: conversationId,
  userId: userId,
).ref();
ref.execute();
```


### updateUserConversation
#### Required Arguments
```dart
String conversationId = ...;
String userId = ...;
ExampleConnector.instance.updateUserConversation(
  conversationId: conversationId,
  userId: userId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateUserConversation, we created `updateUserConversationBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateUserConversationVariablesBuilder {
  ...
   UpdateUserConversationVariablesBuilder unreadCount(int? t) {
   _unreadCount.value = t;
   return this;
  }
  UpdateUserConversationVariablesBuilder lastReadAt(Timestamp? t) {
   _lastReadAt.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateUserConversation(
  conversationId: conversationId,
  userId: userId,
)
.unreadCount(unreadCount)
.lastReadAt(lastReadAt)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateUserConversationData, updateUserConversationVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateUserConversation(
  conversationId: conversationId,
  userId: userId,
);
updateUserConversationData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String conversationId = ...;
String userId = ...;

final ref = ExampleConnector.instance.updateUserConversation(
  conversationId: conversationId,
  userId: userId,
).ref();
ref.execute();
```


### markConversationAsRead
#### Required Arguments
```dart
String conversationId = ...;
String userId = ...;
ExampleConnector.instance.markConversationAsRead(
  conversationId: conversationId,
  userId: userId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For markConversationAsRead, we created `markConversationAsReadBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class MarkConversationAsReadVariablesBuilder {
  ...
   MarkConversationAsReadVariablesBuilder lastReadAt(Timestamp? t) {
   _lastReadAt.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.markConversationAsRead(
  conversationId: conversationId,
  userId: userId,
)
.lastReadAt(lastReadAt)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<markConversationAsReadData, markConversationAsReadVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.markConversationAsRead(
  conversationId: conversationId,
  userId: userId,
);
markConversationAsReadData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String conversationId = ...;
String userId = ...;

final ref = ExampleConnector.instance.markConversationAsRead(
  conversationId: conversationId,
  userId: userId,
).ref();
ref.execute();
```


### incrementUnreadForUser
#### Required Arguments
```dart
String conversationId = ...;
String userId = ...;
int unreadCount = ...;
ExampleConnector.instance.incrementUnreadForUser(
  conversationId: conversationId,
  userId: userId,
  unreadCount: unreadCount,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<incrementUnreadForUserData, incrementUnreadForUserVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.incrementUnreadForUser(
  conversationId: conversationId,
  userId: userId,
  unreadCount: unreadCount,
);
incrementUnreadForUserData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String conversationId = ...;
String userId = ...;
int unreadCount = ...;

final ref = ExampleConnector.instance.incrementUnreadForUser(
  conversationId: conversationId,
  userId: userId,
  unreadCount: unreadCount,
).ref();
ref.execute();
```


### deleteUserConversation
#### Required Arguments
```dart
String conversationId = ...;
String userId = ...;
ExampleConnector.instance.deleteUserConversation(
  conversationId: conversationId,
  userId: userId,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteUserConversationData, deleteUserConversationVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteUserConversation(
  conversationId: conversationId,
  userId: userId,
);
deleteUserConversationData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String conversationId = ...;
String userId = ...;

final ref = ExampleConnector.instance.deleteUserConversation(
  conversationId: conversationId,
  userId: userId,
).ref();
ref.execute();
```


### createVendorRate
#### Required Arguments
```dart
String vendorId = ...;
ExampleConnector.instance.createVendorRate(
  vendorId: vendorId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createVendorRate, we created `createVendorRateBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateVendorRateVariablesBuilder {
  ...
   CreateVendorRateVariablesBuilder roleName(String? t) {
   _roleName.value = t;
   return this;
  }
  CreateVendorRateVariablesBuilder category(CategoryType? t) {
   _category.value = t;
   return this;
  }
  CreateVendorRateVariablesBuilder clientRate(double? t) {
   _clientRate.value = t;
   return this;
  }
  CreateVendorRateVariablesBuilder employeeWage(double? t) {
   _employeeWage.value = t;
   return this;
  }
  CreateVendorRateVariablesBuilder markupPercentage(double? t) {
   _markupPercentage.value = t;
   return this;
  }
  CreateVendorRateVariablesBuilder vendorFeePercentage(double? t) {
   _vendorFeePercentage.value = t;
   return this;
  }
  CreateVendorRateVariablesBuilder isActive(bool? t) {
   _isActive.value = t;
   return this;
  }
  CreateVendorRateVariablesBuilder notes(String? t) {
   _notes.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createVendorRate(
  vendorId: vendorId,
)
.roleName(roleName)
.category(category)
.clientRate(clientRate)
.employeeWage(employeeWage)
.markupPercentage(markupPercentage)
.vendorFeePercentage(vendorFeePercentage)
.isActive(isActive)
.notes(notes)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createVendorRateData, createVendorRateVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createVendorRate(
  vendorId: vendorId,
);
createVendorRateData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;

final ref = ExampleConnector.instance.createVendorRate(
  vendorId: vendorId,
).ref();
ref.execute();
```


### updateVendorRate
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateVendorRate(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateVendorRate, we created `updateVendorRateBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateVendorRateVariablesBuilder {
  ...
   UpdateVendorRateVariablesBuilder vendorId(String? t) {
   _vendorId.value = t;
   return this;
  }
  UpdateVendorRateVariablesBuilder roleName(String? t) {
   _roleName.value = t;
   return this;
  }
  UpdateVendorRateVariablesBuilder category(CategoryType? t) {
   _category.value = t;
   return this;
  }
  UpdateVendorRateVariablesBuilder clientRate(double? t) {
   _clientRate.value = t;
   return this;
  }
  UpdateVendorRateVariablesBuilder employeeWage(double? t) {
   _employeeWage.value = t;
   return this;
  }
  UpdateVendorRateVariablesBuilder markupPercentage(double? t) {
   _markupPercentage.value = t;
   return this;
  }
  UpdateVendorRateVariablesBuilder vendorFeePercentage(double? t) {
   _vendorFeePercentage.value = t;
   return this;
  }
  UpdateVendorRateVariablesBuilder isActive(bool? t) {
   _isActive.value = t;
   return this;
  }
  UpdateVendorRateVariablesBuilder notes(String? t) {
   _notes.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateVendorRate(
  id: id,
)
.vendorId(vendorId)
.roleName(roleName)
.category(category)
.clientRate(clientRate)
.employeeWage(employeeWage)
.markupPercentage(markupPercentage)
.vendorFeePercentage(vendorFeePercentage)
.isActive(isActive)
.notes(notes)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateVendorRateData, updateVendorRateVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateVendorRate(
  id: id,
);
updateVendorRateData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateVendorRate(
  id: id,
).ref();
ref.execute();
```


### deleteVendorRate
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteVendorRate(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteVendorRateData, deleteVendorRateVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteVendorRate(
  id: id,
);
deleteVendorRateData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteVendorRate(
  id: id,
).ref();
ref.execute();
```


### createMessage
#### Required Arguments
```dart
String conversationId = ...;
String senderId = ...;
String content = ...;
ExampleConnector.instance.createMessage(
  conversationId: conversationId,
  senderId: senderId,
  content: content,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createMessage, we created `createMessageBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateMessageVariablesBuilder {
  ...
   CreateMessageVariablesBuilder isSystem(bool? t) {
   _isSystem.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createMessage(
  conversationId: conversationId,
  senderId: senderId,
  content: content,
)
.isSystem(isSystem)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createMessageData, createMessageVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createMessage(
  conversationId: conversationId,
  senderId: senderId,
  content: content,
);
createMessageData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String conversationId = ...;
String senderId = ...;
String content = ...;

final ref = ExampleConnector.instance.createMessage(
  conversationId: conversationId,
  senderId: senderId,
  content: content,
).ref();
ref.execute();
```


### updateMessage
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateMessage(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateMessage, we created `updateMessageBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateMessageVariablesBuilder {
  ...
   UpdateMessageVariablesBuilder conversationId(String? t) {
   _conversationId.value = t;
   return this;
  }
  UpdateMessageVariablesBuilder senderId(String? t) {
   _senderId.value = t;
   return this;
  }
  UpdateMessageVariablesBuilder content(String? t) {
   _content.value = t;
   return this;
  }
  UpdateMessageVariablesBuilder isSystem(bool? t) {
   _isSystem.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateMessage(
  id: id,
)
.conversationId(conversationId)
.senderId(senderId)
.content(content)
.isSystem(isSystem)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateMessageData, updateMessageVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateMessage(
  id: id,
);
updateMessageData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateMessage(
  id: id,
).ref();
ref.execute();
```


### deleteMessage
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteMessage(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteMessageData, deleteMessageVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteMessage(
  id: id,
);
deleteMessageData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteMessage(
  id: id,
).ref();
ref.execute();
```


### createOrder
#### Required Arguments
```dart
String businessId = ...;
OrderType orderType = ...;
ExampleConnector.instance.createOrder(
  businessId: businessId,
  orderType: orderType,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createOrder, we created `createOrderBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateOrderVariablesBuilder {
  ...
 
  CreateOrderVariablesBuilder vendorId(String? t) {
   _vendorId.value = t;
   return this;
  }
  CreateOrderVariablesBuilder location(String? t) {
   _location.value = t;
   return this;
  }
  CreateOrderVariablesBuilder status(OrderStatus? t) {
   _status.value = t;
   return this;
  }
  CreateOrderVariablesBuilder date(Timestamp? t) {
   _date.value = t;
   return this;
  }
  CreateOrderVariablesBuilder startDate(Timestamp? t) {
   _startDate.value = t;
   return this;
  }
  CreateOrderVariablesBuilder endDate(Timestamp? t) {
   _endDate.value = t;
   return this;
  }
  CreateOrderVariablesBuilder duration(OrderDuration? t) {
   _duration.value = t;
   return this;
  }
  CreateOrderVariablesBuilder lunchBreak(int? t) {
   _lunchBreak.value = t;
   return this;
  }
  CreateOrderVariablesBuilder total(double? t) {
   _total.value = t;
   return this;
  }
  CreateOrderVariablesBuilder eventName(String? t) {
   _eventName.value = t;
   return this;
  }
  CreateOrderVariablesBuilder assignedStaff(AnyValue? t) {
   _assignedStaff.value = t;
   return this;
  }
  CreateOrderVariablesBuilder shifts(AnyValue? t) {
   _shifts.value = t;
   return this;
  }
  CreateOrderVariablesBuilder requested(int? t) {
   _requested.value = t;
   return this;
  }
  CreateOrderVariablesBuilder hub(String? t) {
   _hub.value = t;
   return this;
  }
  CreateOrderVariablesBuilder recurringDays(AnyValue? t) {
   _recurringDays.value = t;
   return this;
  }
  CreateOrderVariablesBuilder permanentStartDate(Timestamp? t) {
   _permanentStartDate.value = t;
   return this;
  }
  CreateOrderVariablesBuilder permanentDays(AnyValue? t) {
   _permanentDays.value = t;
   return this;
  }
  CreateOrderVariablesBuilder notes(String? t) {
   _notes.value = t;
   return this;
  }
  CreateOrderVariablesBuilder detectedConflicts(AnyValue? t) {
   _detectedConflicts.value = t;
   return this;
  }
  CreateOrderVariablesBuilder poReference(String? t) {
   _poReference.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createOrder(
  businessId: businessId,
  orderType: orderType,
)
.vendorId(vendorId)
.location(location)
.status(status)
.date(date)
.startDate(startDate)
.endDate(endDate)
.duration(duration)
.lunchBreak(lunchBreak)
.total(total)
.eventName(eventName)
.assignedStaff(assignedStaff)
.shifts(shifts)
.requested(requested)
.hub(hub)
.recurringDays(recurringDays)
.permanentStartDate(permanentStartDate)
.permanentDays(permanentDays)
.notes(notes)
.detectedConflicts(detectedConflicts)
.poReference(poReference)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createOrderData, createOrderVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createOrder(
  businessId: businessId,
  orderType: orderType,
);
createOrderData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;
OrderType orderType = ...;

final ref = ExampleConnector.instance.createOrder(
  businessId: businessId,
  orderType: orderType,
).ref();
ref.execute();
```


### updateOrder
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateOrder(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateOrder, we created `updateOrderBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateOrderVariablesBuilder {
  ...
   UpdateOrderVariablesBuilder vendorId(String? t) {
   _vendorId.value = t;
   return this;
  }
  UpdateOrderVariablesBuilder businessId(String? t) {
   _businessId.value = t;
   return this;
  }
  UpdateOrderVariablesBuilder location(String? t) {
   _location.value = t;
   return this;
  }
  UpdateOrderVariablesBuilder status(OrderStatus? t) {
   _status.value = t;
   return this;
  }
  UpdateOrderVariablesBuilder date(Timestamp? t) {
   _date.value = t;
   return this;
  }
  UpdateOrderVariablesBuilder startDate(Timestamp? t) {
   _startDate.value = t;
   return this;
  }
  UpdateOrderVariablesBuilder endDate(Timestamp? t) {
   _endDate.value = t;
   return this;
  }
  UpdateOrderVariablesBuilder total(double? t) {
   _total.value = t;
   return this;
  }
  UpdateOrderVariablesBuilder eventName(String? t) {
   _eventName.value = t;
   return this;
  }
  UpdateOrderVariablesBuilder assignedStaff(AnyValue? t) {
   _assignedStaff.value = t;
   return this;
  }
  UpdateOrderVariablesBuilder shifts(AnyValue? t) {
   _shifts.value = t;
   return this;
  }
  UpdateOrderVariablesBuilder requested(int? t) {
   _requested.value = t;
   return this;
  }
  UpdateOrderVariablesBuilder hub(String? t) {
   _hub.value = t;
   return this;
  }
  UpdateOrderVariablesBuilder recurringDays(AnyValue? t) {
   _recurringDays.value = t;
   return this;
  }
  UpdateOrderVariablesBuilder permanentDays(AnyValue? t) {
   _permanentDays.value = t;
   return this;
  }
  UpdateOrderVariablesBuilder notes(String? t) {
   _notes.value = t;
   return this;
  }
  UpdateOrderVariablesBuilder detectedConflicts(AnyValue? t) {
   _detectedConflicts.value = t;
   return this;
  }
  UpdateOrderVariablesBuilder poReference(String? t) {
   _poReference.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateOrder(
  id: id,
)
.vendorId(vendorId)
.businessId(businessId)
.location(location)
.status(status)
.date(date)
.startDate(startDate)
.endDate(endDate)
.total(total)
.eventName(eventName)
.assignedStaff(assignedStaff)
.shifts(shifts)
.requested(requested)
.hub(hub)
.recurringDays(recurringDays)
.permanentDays(permanentDays)
.notes(notes)
.detectedConflicts(detectedConflicts)
.poReference(poReference)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateOrderData, updateOrderVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateOrder(
  id: id,
);
updateOrderData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateOrder(
  id: id,
).ref();
ref.execute();
```


### deleteOrder
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteOrder(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteOrderData, deleteOrderVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteOrder(
  id: id,
);
deleteOrderData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteOrder(
  id: id,
).ref();
ref.execute();
```


### createRecentPayment
#### Required Arguments
```dart
String staffId = ...;
String applicationId = ...;
String invoiceId = ...;
ExampleConnector.instance.createRecentPayment(
  staffId: staffId,
  applicationId: applicationId,
  invoiceId: invoiceId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createRecentPayment, we created `createRecentPaymentBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateRecentPaymentVariablesBuilder {
  ...
 
  CreateRecentPaymentVariablesBuilder workedTime(String? t) {
   _workedTime.value = t;
   return this;
  }
  CreateRecentPaymentVariablesBuilder status(RecentPaymentStatus? t) {
   _status.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createRecentPayment(
  staffId: staffId,
  applicationId: applicationId,
  invoiceId: invoiceId,
)
.workedTime(workedTime)
.status(status)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createRecentPaymentData, createRecentPaymentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createRecentPayment(
  staffId: staffId,
  applicationId: applicationId,
  invoiceId: invoiceId,
);
createRecentPaymentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;
String applicationId = ...;
String invoiceId = ...;

final ref = ExampleConnector.instance.createRecentPayment(
  staffId: staffId,
  applicationId: applicationId,
  invoiceId: invoiceId,
).ref();
ref.execute();
```


### updateRecentPayment
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateRecentPayment(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateRecentPayment, we created `updateRecentPaymentBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateRecentPaymentVariablesBuilder {
  ...
   UpdateRecentPaymentVariablesBuilder workedTime(String? t) {
   _workedTime.value = t;
   return this;
  }
  UpdateRecentPaymentVariablesBuilder status(RecentPaymentStatus? t) {
   _status.value = t;
   return this;
  }
  UpdateRecentPaymentVariablesBuilder staffId(String? t) {
   _staffId.value = t;
   return this;
  }
  UpdateRecentPaymentVariablesBuilder applicationId(String? t) {
   _applicationId.value = t;
   return this;
  }
  UpdateRecentPaymentVariablesBuilder invoiceId(String? t) {
   _invoiceId.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateRecentPayment(
  id: id,
)
.workedTime(workedTime)
.status(status)
.staffId(staffId)
.applicationId(applicationId)
.invoiceId(invoiceId)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateRecentPaymentData, updateRecentPaymentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateRecentPayment(
  id: id,
);
updateRecentPaymentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateRecentPayment(
  id: id,
).ref();
ref.execute();
```


### deleteRecentPayment
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteRecentPayment(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteRecentPaymentData, deleteRecentPaymentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteRecentPayment(
  id: id,
);
deleteRecentPaymentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteRecentPayment(
  id: id,
).ref();
ref.execute();
```


### CreateStaff
#### Required Arguments
```dart
String userId = ...;
String fullName = ...;
ExampleConnector.instance.createStaff(
  userId: userId,
  fullName: fullName,
).execute();
```

#### Optional Arguments
We return a builder for each query. For CreateStaff, we created `CreateStaffBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateStaffVariablesBuilder {
  ...
   CreateStaffVariablesBuilder level(String? t) {
   _level.value = t;
   return this;
  }
  CreateStaffVariablesBuilder role(String? t) {
   _role.value = t;
   return this;
  }
  CreateStaffVariablesBuilder phone(String? t) {
   _phone.value = t;
   return this;
  }
  CreateStaffVariablesBuilder email(String? t) {
   _email.value = t;
   return this;
  }
  CreateStaffVariablesBuilder photoUrl(String? t) {
   _photoUrl.value = t;
   return this;
  }
  CreateStaffVariablesBuilder totalShifts(int? t) {
   _totalShifts.value = t;
   return this;
  }
  CreateStaffVariablesBuilder averageRating(double? t) {
   _averageRating.value = t;
   return this;
  }
  CreateStaffVariablesBuilder onTimeRate(int? t) {
   _onTimeRate.value = t;
   return this;
  }
  CreateStaffVariablesBuilder noShowCount(int? t) {
   _noShowCount.value = t;
   return this;
  }
  CreateStaffVariablesBuilder cancellationCount(int? t) {
   _cancellationCount.value = t;
   return this;
  }
  CreateStaffVariablesBuilder reliabilityScore(int? t) {
   _reliabilityScore.value = t;
   return this;
  }
  CreateStaffVariablesBuilder bio(String? t) {
   _bio.value = t;
   return this;
  }
  CreateStaffVariablesBuilder skills(AnyValue? t) {
   _skills.value = t;
   return this;
  }
  CreateStaffVariablesBuilder industries(AnyValue? t) {
   _industries.value = t;
   return this;
  }
  CreateStaffVariablesBuilder preferredLocations(AnyValue? t) {
   _preferredLocations.value = t;
   return this;
  }
  CreateStaffVariablesBuilder maxDistanceMiles(int? t) {
   _maxDistanceMiles.value = t;
   return this;
  }
  CreateStaffVariablesBuilder languages(AnyValue? t) {
   _languages.value = t;
   return this;
  }
  CreateStaffVariablesBuilder itemsAttire(AnyValue? t) {
   _itemsAttire.value = t;
   return this;
  }
  CreateStaffVariablesBuilder xp(int? t) {
   _xp.value = t;
   return this;
  }
  CreateStaffVariablesBuilder badges(AnyValue? t) {
   _badges.value = t;
   return this;
  }
  CreateStaffVariablesBuilder isRecommended(bool? t) {
   _isRecommended.value = t;
   return this;
  }
  CreateStaffVariablesBuilder ownerId(String? t) {
   _ownerId.value = t;
   return this;
  }
  CreateStaffVariablesBuilder department(DepartmentType? t) {
   _department.value = t;
   return this;
  }
  CreateStaffVariablesBuilder hubId(String? t) {
   _hubId.value = t;
   return this;
  }
  CreateStaffVariablesBuilder manager(String? t) {
   _manager.value = t;
   return this;
  }
  CreateStaffVariablesBuilder english(EnglishProficiency? t) {
   _english.value = t;
   return this;
  }
  CreateStaffVariablesBuilder backgroundCheckStatus(BackgroundCheckStatus? t) {
   _backgroundCheckStatus.value = t;
   return this;
  }
  CreateStaffVariablesBuilder employmentType(EmploymentType? t) {
   _employmentType.value = t;
   return this;
  }
  CreateStaffVariablesBuilder initial(String? t) {
   _initial.value = t;
   return this;
  }
  CreateStaffVariablesBuilder englishRequired(bool? t) {
   _englishRequired.value = t;
   return this;
  }
  CreateStaffVariablesBuilder city(String? t) {
   _city.value = t;
   return this;
  }
  CreateStaffVariablesBuilder addres(String? t) {
   _addres.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createStaff(
  userId: userId,
  fullName: fullName,
)
.level(level)
.role(role)
.phone(phone)
.email(email)
.photoUrl(photoUrl)
.totalShifts(totalShifts)
.averageRating(averageRating)
.onTimeRate(onTimeRate)
.noShowCount(noShowCount)
.cancellationCount(cancellationCount)
.reliabilityScore(reliabilityScore)
.bio(bio)
.skills(skills)
.industries(industries)
.preferredLocations(preferredLocations)
.maxDistanceMiles(maxDistanceMiles)
.languages(languages)
.itemsAttire(itemsAttire)
.xp(xp)
.badges(badges)
.isRecommended(isRecommended)
.ownerId(ownerId)
.department(department)
.hubId(hubId)
.manager(manager)
.english(english)
.backgroundCheckStatus(backgroundCheckStatus)
.employmentType(employmentType)
.initial(initial)
.englishRequired(englishRequired)
.city(city)
.addres(addres)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<CreateStaffData, CreateStaffVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createStaff(
  userId: userId,
  fullName: fullName,
);
CreateStaffData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String userId = ...;
String fullName = ...;

final ref = ExampleConnector.instance.createStaff(
  userId: userId,
  fullName: fullName,
).ref();
ref.execute();
```


### UpdateStaff
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateStaff(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For UpdateStaff, we created `UpdateStaffBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateStaffVariablesBuilder {
  ...
   UpdateStaffVariablesBuilder userId(String? t) {
   _userId.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder fullName(String? t) {
   _fullName.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder level(String? t) {
   _level.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder role(String? t) {
   _role.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder phone(String? t) {
   _phone.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder email(String? t) {
   _email.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder photoUrl(String? t) {
   _photoUrl.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder totalShifts(int? t) {
   _totalShifts.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder averageRating(double? t) {
   _averageRating.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder onTimeRate(int? t) {
   _onTimeRate.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder noShowCount(int? t) {
   _noShowCount.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder cancellationCount(int? t) {
   _cancellationCount.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder reliabilityScore(int? t) {
   _reliabilityScore.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder bio(String? t) {
   _bio.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder skills(AnyValue? t) {
   _skills.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder industries(AnyValue? t) {
   _industries.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder preferredLocations(AnyValue? t) {
   _preferredLocations.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder maxDistanceMiles(int? t) {
   _maxDistanceMiles.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder languages(AnyValue? t) {
   _languages.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder itemsAttire(AnyValue? t) {
   _itemsAttire.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder xp(int? t) {
   _xp.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder badges(AnyValue? t) {
   _badges.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder isRecommended(bool? t) {
   _isRecommended.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder ownerId(String? t) {
   _ownerId.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder department(DepartmentType? t) {
   _department.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder hubId(String? t) {
   _hubId.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder manager(String? t) {
   _manager.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder english(EnglishProficiency? t) {
   _english.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder backgroundCheckStatus(BackgroundCheckStatus? t) {
   _backgroundCheckStatus.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder employmentType(EmploymentType? t) {
   _employmentType.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder initial(String? t) {
   _initial.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder englishRequired(bool? t) {
   _englishRequired.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder city(String? t) {
   _city.value = t;
   return this;
  }
  UpdateStaffVariablesBuilder addres(String? t) {
   _addres.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateStaff(
  id: id,
)
.userId(userId)
.fullName(fullName)
.level(level)
.role(role)
.phone(phone)
.email(email)
.photoUrl(photoUrl)
.totalShifts(totalShifts)
.averageRating(averageRating)
.onTimeRate(onTimeRate)
.noShowCount(noShowCount)
.cancellationCount(cancellationCount)
.reliabilityScore(reliabilityScore)
.bio(bio)
.skills(skills)
.industries(industries)
.preferredLocations(preferredLocations)
.maxDistanceMiles(maxDistanceMiles)
.languages(languages)
.itemsAttire(itemsAttire)
.xp(xp)
.badges(badges)
.isRecommended(isRecommended)
.ownerId(ownerId)
.department(department)
.hubId(hubId)
.manager(manager)
.english(english)
.backgroundCheckStatus(backgroundCheckStatus)
.employmentType(employmentType)
.initial(initial)
.englishRequired(englishRequired)
.city(city)
.addres(addres)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<UpdateStaffData, UpdateStaffVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateStaff(
  id: id,
);
UpdateStaffData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateStaff(
  id: id,
).ref();
ref.execute();
```


### DeleteStaff
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteStaff(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<DeleteStaffData, DeleteStaffVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteStaff(
  id: id,
);
DeleteStaffData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteStaff(
  id: id,
).ref();
ref.execute();
```


### createActivityLog
#### Required Arguments
```dart
String userId = ...;
Timestamp date = ...;
String title = ...;
String description = ...;
ActivityType activityType = ...;
ExampleConnector.instance.createActivityLog(
  userId: userId,
  date: date,
  title: title,
  description: description,
  activityType: activityType,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createActivityLog, we created `createActivityLogBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateActivityLogVariablesBuilder {
  ...
   CreateActivityLogVariablesBuilder hourStart(String? t) {
   _hourStart.value = t;
   return this;
  }
  CreateActivityLogVariablesBuilder hourEnd(String? t) {
   _hourEnd.value = t;
   return this;
  }
  CreateActivityLogVariablesBuilder totalhours(String? t) {
   _totalhours.value = t;
   return this;
  }
  CreateActivityLogVariablesBuilder iconType(ActivityIconType? t) {
   _iconType.value = t;
   return this;
  }
  CreateActivityLogVariablesBuilder iconColor(String? t) {
   _iconColor.value = t;
   return this;
  }
  CreateActivityLogVariablesBuilder isRead(bool? t) {
   _isRead.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createActivityLog(
  userId: userId,
  date: date,
  title: title,
  description: description,
  activityType: activityType,
)
.hourStart(hourStart)
.hourEnd(hourEnd)
.totalhours(totalhours)
.iconType(iconType)
.iconColor(iconColor)
.isRead(isRead)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createActivityLogData, createActivityLogVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createActivityLog(
  userId: userId,
  date: date,
  title: title,
  description: description,
  activityType: activityType,
);
createActivityLogData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String userId = ...;
Timestamp date = ...;
String title = ...;
String description = ...;
ActivityType activityType = ...;

final ref = ExampleConnector.instance.createActivityLog(
  userId: userId,
  date: date,
  title: title,
  description: description,
  activityType: activityType,
).ref();
ref.execute();
```


### updateActivityLog
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateActivityLog(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateActivityLog, we created `updateActivityLogBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateActivityLogVariablesBuilder {
  ...
   UpdateActivityLogVariablesBuilder userId(String? t) {
   _userId.value = t;
   return this;
  }
  UpdateActivityLogVariablesBuilder date(Timestamp? t) {
   _date.value = t;
   return this;
  }
  UpdateActivityLogVariablesBuilder hourStart(String? t) {
   _hourStart.value = t;
   return this;
  }
  UpdateActivityLogVariablesBuilder hourEnd(String? t) {
   _hourEnd.value = t;
   return this;
  }
  UpdateActivityLogVariablesBuilder totalhours(String? t) {
   _totalhours.value = t;
   return this;
  }
  UpdateActivityLogVariablesBuilder iconType(ActivityIconType? t) {
   _iconType.value = t;
   return this;
  }
  UpdateActivityLogVariablesBuilder iconColor(String? t) {
   _iconColor.value = t;
   return this;
  }
  UpdateActivityLogVariablesBuilder title(String? t) {
   _title.value = t;
   return this;
  }
  UpdateActivityLogVariablesBuilder description(String? t) {
   _description.value = t;
   return this;
  }
  UpdateActivityLogVariablesBuilder isRead(bool? t) {
   _isRead.value = t;
   return this;
  }
  UpdateActivityLogVariablesBuilder activityType(ActivityType? t) {
   _activityType.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateActivityLog(
  id: id,
)
.userId(userId)
.date(date)
.hourStart(hourStart)
.hourEnd(hourEnd)
.totalhours(totalhours)
.iconType(iconType)
.iconColor(iconColor)
.title(title)
.description(description)
.isRead(isRead)
.activityType(activityType)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateActivityLogData, updateActivityLogVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateActivityLog(
  id: id,
);
updateActivityLogData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateActivityLog(
  id: id,
).ref();
ref.execute();
```


### markActivityLogAsRead
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.markActivityLogAsRead(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<markActivityLogAsReadData, markActivityLogAsReadVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.markActivityLogAsRead(
  id: id,
);
markActivityLogAsReadData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.markActivityLogAsRead(
  id: id,
).ref();
ref.execute();
```


### markActivityLogsAsRead
#### Required Arguments
```dart
String ids = ...;
ExampleConnector.instance.markActivityLogsAsRead(
  ids: ids,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<markActivityLogsAsReadData, markActivityLogsAsReadVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.markActivityLogsAsRead(
  ids: ids,
);
markActivityLogsAsReadData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String ids = ...;

final ref = ExampleConnector.instance.markActivityLogsAsRead(
  ids: ids,
).ref();
ref.execute();
```


### deleteActivityLog
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteActivityLog(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteActivityLogData, deleteActivityLogVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteActivityLog(
  id: id,
);
deleteActivityLogData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteActivityLog(
  id: id,
).ref();
ref.execute();
```


### createMemberTask
#### Required Arguments
```dart
String teamMemberId = ...;
String taskId = ...;
ExampleConnector.instance.createMemberTask(
  teamMemberId: teamMemberId,
  taskId: taskId,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<createMemberTaskData, createMemberTaskVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createMemberTask(
  teamMemberId: teamMemberId,
  taskId: taskId,
);
createMemberTaskData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String teamMemberId = ...;
String taskId = ...;

final ref = ExampleConnector.instance.createMemberTask(
  teamMemberId: teamMemberId,
  taskId: taskId,
).ref();
ref.execute();
```


### deleteMemberTask
#### Required Arguments
```dart
String teamMemberId = ...;
String taskId = ...;
ExampleConnector.instance.deleteMemberTask(
  teamMemberId: teamMemberId,
  taskId: taskId,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteMemberTaskData, deleteMemberTaskVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteMemberTask(
  teamMemberId: teamMemberId,
  taskId: taskId,
);
deleteMemberTaskData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String teamMemberId = ...;
String taskId = ...;

final ref = ExampleConnector.instance.deleteMemberTask(
  teamMemberId: teamMemberId,
  taskId: taskId,
).ref();
ref.execute();
```


### createStaffAvailability
#### Required Arguments
```dart
String staffId = ...;
DayOfWeek day = ...;
AvailabilitySlot slot = ...;
ExampleConnector.instance.createStaffAvailability(
  staffId: staffId,
  day: day,
  slot: slot,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createStaffAvailability, we created `createStaffAvailabilityBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateStaffAvailabilityVariablesBuilder {
  ...
   CreateStaffAvailabilityVariablesBuilder status(AvailabilityStatus? t) {
   _status.value = t;
   return this;
  }
  CreateStaffAvailabilityVariablesBuilder notes(String? t) {
   _notes.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createStaffAvailability(
  staffId: staffId,
  day: day,
  slot: slot,
)
.status(status)
.notes(notes)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createStaffAvailabilityData, createStaffAvailabilityVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createStaffAvailability(
  staffId: staffId,
  day: day,
  slot: slot,
);
createStaffAvailabilityData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;
DayOfWeek day = ...;
AvailabilitySlot slot = ...;

final ref = ExampleConnector.instance.createStaffAvailability(
  staffId: staffId,
  day: day,
  slot: slot,
).ref();
ref.execute();
```


### updateStaffAvailability
#### Required Arguments
```dart
String staffId = ...;
DayOfWeek day = ...;
AvailabilitySlot slot = ...;
ExampleConnector.instance.updateStaffAvailability(
  staffId: staffId,
  day: day,
  slot: slot,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateStaffAvailability, we created `updateStaffAvailabilityBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateStaffAvailabilityVariablesBuilder {
  ...
   UpdateStaffAvailabilityVariablesBuilder status(AvailabilityStatus? t) {
   _status.value = t;
   return this;
  }
  UpdateStaffAvailabilityVariablesBuilder notes(String? t) {
   _notes.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateStaffAvailability(
  staffId: staffId,
  day: day,
  slot: slot,
)
.status(status)
.notes(notes)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateStaffAvailabilityData, updateStaffAvailabilityVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateStaffAvailability(
  staffId: staffId,
  day: day,
  slot: slot,
);
updateStaffAvailabilityData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;
DayOfWeek day = ...;
AvailabilitySlot slot = ...;

final ref = ExampleConnector.instance.updateStaffAvailability(
  staffId: staffId,
  day: day,
  slot: slot,
).ref();
ref.execute();
```


### deleteStaffAvailability
#### Required Arguments
```dart
String staffId = ...;
DayOfWeek day = ...;
AvailabilitySlot slot = ...;
ExampleConnector.instance.deleteStaffAvailability(
  staffId: staffId,
  day: day,
  slot: slot,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteStaffAvailabilityData, deleteStaffAvailabilityVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteStaffAvailability(
  staffId: staffId,
  day: day,
  slot: slot,
);
deleteStaffAvailabilityData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;
DayOfWeek day = ...;
AvailabilitySlot slot = ...;

final ref = ExampleConnector.instance.deleteStaffAvailability(
  staffId: staffId,
  day: day,
  slot: slot,
).ref();
ref.execute();
```


### createWorkforce
#### Required Arguments
```dart
String vendorId = ...;
String staffId = ...;
String workforceNumber = ...;
ExampleConnector.instance.createWorkforce(
  vendorId: vendorId,
  staffId: staffId,
  workforceNumber: workforceNumber,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createWorkforce, we created `createWorkforceBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateWorkforceVariablesBuilder {
  ...
   CreateWorkforceVariablesBuilder employmentType(WorkforceEmploymentType? t) {
   _employmentType.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createWorkforce(
  vendorId: vendorId,
  staffId: staffId,
  workforceNumber: workforceNumber,
)
.employmentType(employmentType)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createWorkforceData, createWorkforceVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createWorkforce(
  vendorId: vendorId,
  staffId: staffId,
  workforceNumber: workforceNumber,
);
createWorkforceData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;
String staffId = ...;
String workforceNumber = ...;

final ref = ExampleConnector.instance.createWorkforce(
  vendorId: vendorId,
  staffId: staffId,
  workforceNumber: workforceNumber,
).ref();
ref.execute();
```


### updateWorkforce
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateWorkforce(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateWorkforce, we created `updateWorkforceBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateWorkforceVariablesBuilder {
  ...
   UpdateWorkforceVariablesBuilder workforceNumber(String? t) {
   _workforceNumber.value = t;
   return this;
  }
  UpdateWorkforceVariablesBuilder employmentType(WorkforceEmploymentType? t) {
   _employmentType.value = t;
   return this;
  }
  UpdateWorkforceVariablesBuilder status(WorkforceStatus? t) {
   _status.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateWorkforce(
  id: id,
)
.workforceNumber(workforceNumber)
.employmentType(employmentType)
.status(status)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateWorkforceData, updateWorkforceVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateWorkforce(
  id: id,
);
updateWorkforceData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateWorkforce(
  id: id,
).ref();
ref.execute();
```


### deactivateWorkforce
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deactivateWorkforce(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deactivateWorkforceData, deactivateWorkforceVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deactivateWorkforce(
  id: id,
);
deactivateWorkforceData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deactivateWorkforce(
  id: id,
).ref();
ref.execute();
```


### createInvoice
#### Required Arguments
```dart
InvoiceStatus status = ...;
String vendorId = ...;
String businessId = ...;
String orderId = ...;
String invoiceNumber = ...;
Timestamp issueDate = ...;
Timestamp dueDate = ...;
double amount = ...;
ExampleConnector.instance.createInvoice(
  status: status,
  vendorId: vendorId,
  businessId: businessId,
  orderId: orderId,
  invoiceNumber: invoiceNumber,
  issueDate: issueDate,
  dueDate: dueDate,
  amount: amount,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createInvoice, we created `createInvoiceBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateInvoiceVariablesBuilder {
  ...
   CreateInvoiceVariablesBuilder paymentTerms(InovicePaymentTerms? t) {
   _paymentTerms.value = t;
   return this;
  }
  CreateInvoiceVariablesBuilder hub(String? t) {
   _hub.value = t;
   return this;
  }
  CreateInvoiceVariablesBuilder managerName(String? t) {
   _managerName.value = t;
   return this;
  }
  CreateInvoiceVariablesBuilder vendorNumber(String? t) {
   _vendorNumber.value = t;
   return this;
  }
  CreateInvoiceVariablesBuilder roles(AnyValue? t) {
   _roles.value = t;
   return this;
  }
  CreateInvoiceVariablesBuilder charges(AnyValue? t) {
   _charges.value = t;
   return this;
  }
  CreateInvoiceVariablesBuilder otherCharges(double? t) {
   _otherCharges.value = t;
   return this;
  }
  CreateInvoiceVariablesBuilder subtotal(double? t) {
   _subtotal.value = t;
   return this;
  }
  CreateInvoiceVariablesBuilder notes(String? t) {
   _notes.value = t;
   return this;
  }
  CreateInvoiceVariablesBuilder staffCount(int? t) {
   _staffCount.value = t;
   return this;
  }
  CreateInvoiceVariablesBuilder chargesCount(int? t) {
   _chargesCount.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createInvoice(
  status: status,
  vendorId: vendorId,
  businessId: businessId,
  orderId: orderId,
  invoiceNumber: invoiceNumber,
  issueDate: issueDate,
  dueDate: dueDate,
  amount: amount,
)
.paymentTerms(paymentTerms)
.hub(hub)
.managerName(managerName)
.vendorNumber(vendorNumber)
.roles(roles)
.charges(charges)
.otherCharges(otherCharges)
.subtotal(subtotal)
.notes(notes)
.staffCount(staffCount)
.chargesCount(chargesCount)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createInvoiceData, createInvoiceVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createInvoice(
  status: status,
  vendorId: vendorId,
  businessId: businessId,
  orderId: orderId,
  invoiceNumber: invoiceNumber,
  issueDate: issueDate,
  dueDate: dueDate,
  amount: amount,
);
createInvoiceData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
InvoiceStatus status = ...;
String vendorId = ...;
String businessId = ...;
String orderId = ...;
String invoiceNumber = ...;
Timestamp issueDate = ...;
Timestamp dueDate = ...;
double amount = ...;

final ref = ExampleConnector.instance.createInvoice(
  status: status,
  vendorId: vendorId,
  businessId: businessId,
  orderId: orderId,
  invoiceNumber: invoiceNumber,
  issueDate: issueDate,
  dueDate: dueDate,
  amount: amount,
).ref();
ref.execute();
```


### updateInvoice
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateInvoice(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateInvoice, we created `updateInvoiceBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateInvoiceVariablesBuilder {
  ...
   UpdateInvoiceVariablesBuilder status(InvoiceStatus? t) {
   _status.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder vendorId(String? t) {
   _vendorId.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder businessId(String? t) {
   _businessId.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder orderId(String? t) {
   _orderId.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder paymentTerms(InovicePaymentTerms? t) {
   _paymentTerms.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder invoiceNumber(String? t) {
   _invoiceNumber.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder issueDate(Timestamp? t) {
   _issueDate.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder dueDate(Timestamp? t) {
   _dueDate.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder hub(String? t) {
   _hub.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder managerName(String? t) {
   _managerName.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder vendorNumber(String? t) {
   _vendorNumber.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder roles(AnyValue? t) {
   _roles.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder charges(AnyValue? t) {
   _charges.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder otherCharges(double? t) {
   _otherCharges.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder subtotal(double? t) {
   _subtotal.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder amount(double? t) {
   _amount.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder notes(String? t) {
   _notes.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder staffCount(int? t) {
   _staffCount.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder chargesCount(int? t) {
   _chargesCount.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder disputedItems(AnyValue? t) {
   _disputedItems.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder disputeReason(String? t) {
   _disputeReason.value = t;
   return this;
  }
  UpdateInvoiceVariablesBuilder disputeDetails(String? t) {
   _disputeDetails.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateInvoice(
  id: id,
)
.status(status)
.vendorId(vendorId)
.businessId(businessId)
.orderId(orderId)
.paymentTerms(paymentTerms)
.invoiceNumber(invoiceNumber)
.issueDate(issueDate)
.dueDate(dueDate)
.hub(hub)
.managerName(managerName)
.vendorNumber(vendorNumber)
.roles(roles)
.charges(charges)
.otherCharges(otherCharges)
.subtotal(subtotal)
.amount(amount)
.notes(notes)
.staffCount(staffCount)
.chargesCount(chargesCount)
.disputedItems(disputedItems)
.disputeReason(disputeReason)
.disputeDetails(disputeDetails)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateInvoiceData, updateInvoiceVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateInvoice(
  id: id,
);
updateInvoiceData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateInvoice(
  id: id,
).ref();
ref.execute();
```


### deleteInvoice
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteInvoice(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteInvoiceData, deleteInvoiceVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteInvoice(
  id: id,
);
deleteInvoiceData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteInvoice(
  id: id,
).ref();
ref.execute();
```


### CreateCertificate
#### Required Arguments
```dart
String name = ...;
CertificateStatus status = ...;
String staffId = ...;
ExampleConnector.instance.createCertificate(
  name: name,
  status: status,
  staffId: staffId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For CreateCertificate, we created `CreateCertificateBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateCertificateVariablesBuilder {
  ...
   CreateCertificateVariablesBuilder description(String? t) {
   _description.value = t;
   return this;
  }
  CreateCertificateVariablesBuilder expiry(Timestamp? t) {
   _expiry.value = t;
   return this;
  }
  CreateCertificateVariablesBuilder fileUrl(String? t) {
   _fileUrl.value = t;
   return this;
  }
  CreateCertificateVariablesBuilder icon(String? t) {
   _icon.value = t;
   return this;
  }
  CreateCertificateVariablesBuilder certificationType(ComplianceType? t) {
   _certificationType.value = t;
   return this;
  }
  CreateCertificateVariablesBuilder issuer(String? t) {
   _issuer.value = t;
   return this;
  }
  CreateCertificateVariablesBuilder validationStatus(ValidationStatus? t) {
   _validationStatus.value = t;
   return this;
  }
  CreateCertificateVariablesBuilder certificateNumber(String? t) {
   _certificateNumber.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createCertificate(
  name: name,
  status: status,
  staffId: staffId,
)
.description(description)
.expiry(expiry)
.fileUrl(fileUrl)
.icon(icon)
.certificationType(certificationType)
.issuer(issuer)
.validationStatus(validationStatus)
.certificateNumber(certificateNumber)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<CreateCertificateData, CreateCertificateVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createCertificate(
  name: name,
  status: status,
  staffId: staffId,
);
CreateCertificateData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String name = ...;
CertificateStatus status = ...;
String staffId = ...;

final ref = ExampleConnector.instance.createCertificate(
  name: name,
  status: status,
  staffId: staffId,
).ref();
ref.execute();
```


### UpdateCertificate
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateCertificate(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For UpdateCertificate, we created `UpdateCertificateBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateCertificateVariablesBuilder {
  ...
   UpdateCertificateVariablesBuilder name(String? t) {
   _name.value = t;
   return this;
  }
  UpdateCertificateVariablesBuilder description(String? t) {
   _description.value = t;
   return this;
  }
  UpdateCertificateVariablesBuilder expiry(Timestamp? t) {
   _expiry.value = t;
   return this;
  }
  UpdateCertificateVariablesBuilder status(CertificateStatus? t) {
   _status.value = t;
   return this;
  }
  UpdateCertificateVariablesBuilder fileUrl(String? t) {
   _fileUrl.value = t;
   return this;
  }
  UpdateCertificateVariablesBuilder icon(String? t) {
   _icon.value = t;
   return this;
  }
  UpdateCertificateVariablesBuilder staffId(String? t) {
   _staffId.value = t;
   return this;
  }
  UpdateCertificateVariablesBuilder certificationType(ComplianceType? t) {
   _certificationType.value = t;
   return this;
  }
  UpdateCertificateVariablesBuilder issuer(String? t) {
   _issuer.value = t;
   return this;
  }
  UpdateCertificateVariablesBuilder validationStatus(ValidationStatus? t) {
   _validationStatus.value = t;
   return this;
  }
  UpdateCertificateVariablesBuilder certificateNumber(String? t) {
   _certificateNumber.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateCertificate(
  id: id,
)
.name(name)
.description(description)
.expiry(expiry)
.status(status)
.fileUrl(fileUrl)
.icon(icon)
.staffId(staffId)
.certificationType(certificationType)
.issuer(issuer)
.validationStatus(validationStatus)
.certificateNumber(certificateNumber)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<UpdateCertificateData, UpdateCertificateVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateCertificate(
  id: id,
);
UpdateCertificateData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateCertificate(
  id: id,
).ref();
ref.execute();
```


### DeleteCertificate
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteCertificate(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<DeleteCertificateData, DeleteCertificateVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteCertificate(
  id: id,
);
DeleteCertificateData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteCertificate(
  id: id,
).ref();
ref.execute();
```


### createStaffDocument
#### Required Arguments
```dart
String staffId = ...;
String staffName = ...;
String documentId = ...;
DocumentStatus status = ...;
ExampleConnector.instance.createStaffDocument(
  staffId: staffId,
  staffName: staffName,
  documentId: documentId,
  status: status,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createStaffDocument, we created `createStaffDocumentBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateStaffDocumentVariablesBuilder {
  ...
   CreateStaffDocumentVariablesBuilder documentUrl(String? t) {
   _documentUrl.value = t;
   return this;
  }
  CreateStaffDocumentVariablesBuilder expiryDate(Timestamp? t) {
   _expiryDate.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createStaffDocument(
  staffId: staffId,
  staffName: staffName,
  documentId: documentId,
  status: status,
)
.documentUrl(documentUrl)
.expiryDate(expiryDate)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createStaffDocumentData, createStaffDocumentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createStaffDocument(
  staffId: staffId,
  staffName: staffName,
  documentId: documentId,
  status: status,
);
createStaffDocumentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;
String staffName = ...;
String documentId = ...;
DocumentStatus status = ...;

final ref = ExampleConnector.instance.createStaffDocument(
  staffId: staffId,
  staffName: staffName,
  documentId: documentId,
  status: status,
).ref();
ref.execute();
```


### updateStaffDocument
#### Required Arguments
```dart
String staffId = ...;
String documentId = ...;
ExampleConnector.instance.updateStaffDocument(
  staffId: staffId,
  documentId: documentId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateStaffDocument, we created `updateStaffDocumentBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateStaffDocumentVariablesBuilder {
  ...
   UpdateStaffDocumentVariablesBuilder status(DocumentStatus? t) {
   _status.value = t;
   return this;
  }
  UpdateStaffDocumentVariablesBuilder documentUrl(String? t) {
   _documentUrl.value = t;
   return this;
  }
  UpdateStaffDocumentVariablesBuilder expiryDate(Timestamp? t) {
   _expiryDate.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateStaffDocument(
  staffId: staffId,
  documentId: documentId,
)
.status(status)
.documentUrl(documentUrl)
.expiryDate(expiryDate)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateStaffDocumentData, updateStaffDocumentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateStaffDocument(
  staffId: staffId,
  documentId: documentId,
);
updateStaffDocumentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;
String documentId = ...;

final ref = ExampleConnector.instance.updateStaffDocument(
  staffId: staffId,
  documentId: documentId,
).ref();
ref.execute();
```


### deleteStaffDocument
#### Required Arguments
```dart
String staffId = ...;
String documentId = ...;
ExampleConnector.instance.deleteStaffDocument(
  staffId: staffId,
  documentId: documentId,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteStaffDocumentData, deleteStaffDocumentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteStaffDocument(
  staffId: staffId,
  documentId: documentId,
);
deleteStaffDocumentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;
String documentId = ...;

final ref = ExampleConnector.instance.deleteStaffDocument(
  staffId: staffId,
  documentId: documentId,
).ref();
ref.execute();
```


### createTask
#### Required Arguments
```dart
String taskName = ...;
TaskPriority priority = ...;
TaskStatus status = ...;
String ownerId = ...;
ExampleConnector.instance.createTask(
  taskName: taskName,
  priority: priority,
  status: status,
  ownerId: ownerId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createTask, we created `createTaskBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateTaskVariablesBuilder {
  ...
   CreateTaskVariablesBuilder description(String? t) {
   _description.value = t;
   return this;
  }
  CreateTaskVariablesBuilder dueDate(Timestamp? t) {
   _dueDate.value = t;
   return this;
  }
  CreateTaskVariablesBuilder progress(int? t) {
   _progress.value = t;
   return this;
  }
  CreateTaskVariablesBuilder orderIndex(int? t) {
   _orderIndex.value = t;
   return this;
  }
  CreateTaskVariablesBuilder commentCount(int? t) {
   _commentCount.value = t;
   return this;
  }
  CreateTaskVariablesBuilder attachmentCount(int? t) {
   _attachmentCount.value = t;
   return this;
  }
  CreateTaskVariablesBuilder files(AnyValue? t) {
   _files.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createTask(
  taskName: taskName,
  priority: priority,
  status: status,
  ownerId: ownerId,
)
.description(description)
.dueDate(dueDate)
.progress(progress)
.orderIndex(orderIndex)
.commentCount(commentCount)
.attachmentCount(attachmentCount)
.files(files)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createTaskData, createTaskVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createTask(
  taskName: taskName,
  priority: priority,
  status: status,
  ownerId: ownerId,
);
createTaskData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String taskName = ...;
TaskPriority priority = ...;
TaskStatus status = ...;
String ownerId = ...;

final ref = ExampleConnector.instance.createTask(
  taskName: taskName,
  priority: priority,
  status: status,
  ownerId: ownerId,
).ref();
ref.execute();
```


### updateTask
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateTask(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateTask, we created `updateTaskBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateTaskVariablesBuilder {
  ...
   UpdateTaskVariablesBuilder taskName(String? t) {
   _taskName.value = t;
   return this;
  }
  UpdateTaskVariablesBuilder description(String? t) {
   _description.value = t;
   return this;
  }
  UpdateTaskVariablesBuilder priority(TaskPriority? t) {
   _priority.value = t;
   return this;
  }
  UpdateTaskVariablesBuilder status(TaskStatus? t) {
   _status.value = t;
   return this;
  }
  UpdateTaskVariablesBuilder dueDate(Timestamp? t) {
   _dueDate.value = t;
   return this;
  }
  UpdateTaskVariablesBuilder progress(int? t) {
   _progress.value = t;
   return this;
  }
  UpdateTaskVariablesBuilder assignedMembers(AnyValue? t) {
   _assignedMembers.value = t;
   return this;
  }
  UpdateTaskVariablesBuilder orderIndex(int? t) {
   _orderIndex.value = t;
   return this;
  }
  UpdateTaskVariablesBuilder commentCount(int? t) {
   _commentCount.value = t;
   return this;
  }
  UpdateTaskVariablesBuilder attachmentCount(int? t) {
   _attachmentCount.value = t;
   return this;
  }
  UpdateTaskVariablesBuilder files(AnyValue? t) {
   _files.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateTask(
  id: id,
)
.taskName(taskName)
.description(description)
.priority(priority)
.status(status)
.dueDate(dueDate)
.progress(progress)
.assignedMembers(assignedMembers)
.orderIndex(orderIndex)
.commentCount(commentCount)
.attachmentCount(attachmentCount)
.files(files)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateTaskData, updateTaskVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateTask(
  id: id,
);
updateTaskData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateTask(
  id: id,
).ref();
ref.execute();
```


### deleteTask
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteTask(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteTaskData, deleteTaskVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteTask(
  id: id,
);
deleteTaskData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteTask(
  id: id,
).ref();
ref.execute();
```


### createClientFeedback
#### Required Arguments
```dart
String businessId = ...;
String vendorId = ...;
ExampleConnector.instance.createClientFeedback(
  businessId: businessId,
  vendorId: vendorId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createClientFeedback, we created `createClientFeedbackBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateClientFeedbackVariablesBuilder {
  ...
   CreateClientFeedbackVariablesBuilder rating(int? t) {
   _rating.value = t;
   return this;
  }
  CreateClientFeedbackVariablesBuilder comment(String? t) {
   _comment.value = t;
   return this;
  }
  CreateClientFeedbackVariablesBuilder date(Timestamp? t) {
   _date.value = t;
   return this;
  }
  CreateClientFeedbackVariablesBuilder createdBy(String? t) {
   _createdBy.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createClientFeedback(
  businessId: businessId,
  vendorId: vendorId,
)
.rating(rating)
.comment(comment)
.date(date)
.createdBy(createdBy)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createClientFeedbackData, createClientFeedbackVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createClientFeedback(
  businessId: businessId,
  vendorId: vendorId,
);
createClientFeedbackData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessId = ...;
String vendorId = ...;

final ref = ExampleConnector.instance.createClientFeedback(
  businessId: businessId,
  vendorId: vendorId,
).ref();
ref.execute();
```


### updateClientFeedback
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateClientFeedback(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateClientFeedback, we created `updateClientFeedbackBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateClientFeedbackVariablesBuilder {
  ...
   UpdateClientFeedbackVariablesBuilder businessId(String? t) {
   _businessId.value = t;
   return this;
  }
  UpdateClientFeedbackVariablesBuilder vendorId(String? t) {
   _vendorId.value = t;
   return this;
  }
  UpdateClientFeedbackVariablesBuilder rating(int? t) {
   _rating.value = t;
   return this;
  }
  UpdateClientFeedbackVariablesBuilder comment(String? t) {
   _comment.value = t;
   return this;
  }
  UpdateClientFeedbackVariablesBuilder date(Timestamp? t) {
   _date.value = t;
   return this;
  }
  UpdateClientFeedbackVariablesBuilder createdBy(String? t) {
   _createdBy.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateClientFeedback(
  id: id,
)
.businessId(businessId)
.vendorId(vendorId)
.rating(rating)
.comment(comment)
.date(date)
.createdBy(createdBy)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateClientFeedbackData, updateClientFeedbackVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateClientFeedback(
  id: id,
);
updateClientFeedbackData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateClientFeedback(
  id: id,
).ref();
ref.execute();
```


### deleteClientFeedback
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteClientFeedback(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteClientFeedbackData, deleteClientFeedbackVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteClientFeedback(
  id: id,
);
deleteClientFeedbackData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteClientFeedback(
  id: id,
).ref();
ref.execute();
```


### createLevel
#### Required Arguments
```dart
String name = ...;
int xpRequired = ...;
ExampleConnector.instance.createLevel(
  name: name,
  xpRequired: xpRequired,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createLevel, we created `createLevelBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateLevelVariablesBuilder {
  ...
   CreateLevelVariablesBuilder icon(String? t) {
   _icon.value = t;
   return this;
  }
  CreateLevelVariablesBuilder colors(AnyValue? t) {
   _colors.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createLevel(
  name: name,
  xpRequired: xpRequired,
)
.icon(icon)
.colors(colors)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createLevelData, createLevelVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createLevel(
  name: name,
  xpRequired: xpRequired,
);
createLevelData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String name = ...;
int xpRequired = ...;

final ref = ExampleConnector.instance.createLevel(
  name: name,
  xpRequired: xpRequired,
).ref();
ref.execute();
```


### updateLevel
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateLevel(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateLevel, we created `updateLevelBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateLevelVariablesBuilder {
  ...
   UpdateLevelVariablesBuilder name(String? t) {
   _name.value = t;
   return this;
  }
  UpdateLevelVariablesBuilder xpRequired(int? t) {
   _xpRequired.value = t;
   return this;
  }
  UpdateLevelVariablesBuilder icon(String? t) {
   _icon.value = t;
   return this;
  }
  UpdateLevelVariablesBuilder colors(AnyValue? t) {
   _colors.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateLevel(
  id: id,
)
.name(name)
.xpRequired(xpRequired)
.icon(icon)
.colors(colors)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateLevelData, updateLevelVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateLevel(
  id: id,
);
updateLevelData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateLevel(
  id: id,
).ref();
ref.execute();
```


### deleteLevel
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteLevel(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteLevelData, deleteLevelVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteLevel(
  id: id,
);
deleteLevelData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteLevel(
  id: id,
).ref();
ref.execute();
```


### createShiftRole
#### Required Arguments
```dart
String shiftId = ...;
String roleId = ...;
int count = ...;
ExampleConnector.instance.createShiftRole(
  shiftId: shiftId,
  roleId: roleId,
  count: count,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createShiftRole, we created `createShiftRoleBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateShiftRoleVariablesBuilder {
  ...
   CreateShiftRoleVariablesBuilder assigned(int? t) {
   _assigned.value = t;
   return this;
  }
  CreateShiftRoleVariablesBuilder startTime(Timestamp? t) {
   _startTime.value = t;
   return this;
  }
  CreateShiftRoleVariablesBuilder endTime(Timestamp? t) {
   _endTime.value = t;
   return this;
  }
  CreateShiftRoleVariablesBuilder hours(double? t) {
   _hours.value = t;
   return this;
  }
  CreateShiftRoleVariablesBuilder department(String? t) {
   _department.value = t;
   return this;
  }
  CreateShiftRoleVariablesBuilder uniform(String? t) {
   _uniform.value = t;
   return this;
  }
  CreateShiftRoleVariablesBuilder breakType(BreakDuration? t) {
   _breakType.value = t;
   return this;
  }
  CreateShiftRoleVariablesBuilder totalValue(double? t) {
   _totalValue.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createShiftRole(
  shiftId: shiftId,
  roleId: roleId,
  count: count,
)
.assigned(assigned)
.startTime(startTime)
.endTime(endTime)
.hours(hours)
.department(department)
.uniform(uniform)
.breakType(breakType)
.totalValue(totalValue)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createShiftRoleData, createShiftRoleVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createShiftRole(
  shiftId: shiftId,
  roleId: roleId,
  count: count,
);
createShiftRoleData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String shiftId = ...;
String roleId = ...;
int count = ...;

final ref = ExampleConnector.instance.createShiftRole(
  shiftId: shiftId,
  roleId: roleId,
  count: count,
).ref();
ref.execute();
```


### updateShiftRole
#### Required Arguments
```dart
String shiftId = ...;
String roleId = ...;
ExampleConnector.instance.updateShiftRole(
  shiftId: shiftId,
  roleId: roleId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateShiftRole, we created `updateShiftRoleBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateShiftRoleVariablesBuilder {
  ...
   UpdateShiftRoleVariablesBuilder count(int? t) {
   _count.value = t;
   return this;
  }
  UpdateShiftRoleVariablesBuilder assigned(int? t) {
   _assigned.value = t;
   return this;
  }
  UpdateShiftRoleVariablesBuilder startTime(Timestamp? t) {
   _startTime.value = t;
   return this;
  }
  UpdateShiftRoleVariablesBuilder endTime(Timestamp? t) {
   _endTime.value = t;
   return this;
  }
  UpdateShiftRoleVariablesBuilder hours(double? t) {
   _hours.value = t;
   return this;
  }
  UpdateShiftRoleVariablesBuilder department(String? t) {
   _department.value = t;
   return this;
  }
  UpdateShiftRoleVariablesBuilder uniform(String? t) {
   _uniform.value = t;
   return this;
  }
  UpdateShiftRoleVariablesBuilder breakType(BreakDuration? t) {
   _breakType.value = t;
   return this;
  }
  UpdateShiftRoleVariablesBuilder totalValue(double? t) {
   _totalValue.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateShiftRole(
  shiftId: shiftId,
  roleId: roleId,
)
.count(count)
.assigned(assigned)
.startTime(startTime)
.endTime(endTime)
.hours(hours)
.department(department)
.uniform(uniform)
.breakType(breakType)
.totalValue(totalValue)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateShiftRoleData, updateShiftRoleVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateShiftRole(
  shiftId: shiftId,
  roleId: roleId,
);
updateShiftRoleData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String shiftId = ...;
String roleId = ...;

final ref = ExampleConnector.instance.updateShiftRole(
  shiftId: shiftId,
  roleId: roleId,
).ref();
ref.execute();
```


### deleteShiftRole
#### Required Arguments
```dart
String shiftId = ...;
String roleId = ...;
ExampleConnector.instance.deleteShiftRole(
  shiftId: shiftId,
  roleId: roleId,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteShiftRoleData, deleteShiftRoleVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteShiftRole(
  shiftId: shiftId,
  roleId: roleId,
);
deleteShiftRoleData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String shiftId = ...;
String roleId = ...;

final ref = ExampleConnector.instance.deleteShiftRole(
  shiftId: shiftId,
  roleId: roleId,
).ref();
ref.execute();
```


### createTeam
#### Required Arguments
```dart
String teamName = ...;
String ownerId = ...;
String ownerName = ...;
String ownerRole = ...;
ExampleConnector.instance.createTeam(
  teamName: teamName,
  ownerId: ownerId,
  ownerName: ownerName,
  ownerRole: ownerRole,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createTeam, we created `createTeamBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateTeamVariablesBuilder {
  ...
   CreateTeamVariablesBuilder email(String? t) {
   _email.value = t;
   return this;
  }
  CreateTeamVariablesBuilder companyLogo(String? t) {
   _companyLogo.value = t;
   return this;
  }
  CreateTeamVariablesBuilder totalMembers(int? t) {
   _totalMembers.value = t;
   return this;
  }
  CreateTeamVariablesBuilder activeMembers(int? t) {
   _activeMembers.value = t;
   return this;
  }
  CreateTeamVariablesBuilder totalHubs(int? t) {
   _totalHubs.value = t;
   return this;
  }
  CreateTeamVariablesBuilder departments(AnyValue? t) {
   _departments.value = t;
   return this;
  }
  CreateTeamVariablesBuilder favoriteStaffCount(int? t) {
   _favoriteStaffCount.value = t;
   return this;
  }
  CreateTeamVariablesBuilder blockedStaffCount(int? t) {
   _blockedStaffCount.value = t;
   return this;
  }
  CreateTeamVariablesBuilder favoriteStaff(AnyValue? t) {
   _favoriteStaff.value = t;
   return this;
  }
  CreateTeamVariablesBuilder blockedStaff(AnyValue? t) {
   _blockedStaff.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createTeam(
  teamName: teamName,
  ownerId: ownerId,
  ownerName: ownerName,
  ownerRole: ownerRole,
)
.email(email)
.companyLogo(companyLogo)
.totalMembers(totalMembers)
.activeMembers(activeMembers)
.totalHubs(totalHubs)
.departments(departments)
.favoriteStaffCount(favoriteStaffCount)
.blockedStaffCount(blockedStaffCount)
.favoriteStaff(favoriteStaff)
.blockedStaff(blockedStaff)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createTeamData, createTeamVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createTeam(
  teamName: teamName,
  ownerId: ownerId,
  ownerName: ownerName,
  ownerRole: ownerRole,
);
createTeamData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String teamName = ...;
String ownerId = ...;
String ownerName = ...;
String ownerRole = ...;

final ref = ExampleConnector.instance.createTeam(
  teamName: teamName,
  ownerId: ownerId,
  ownerName: ownerName,
  ownerRole: ownerRole,
).ref();
ref.execute();
```


### updateTeam
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateTeam(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateTeam, we created `updateTeamBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateTeamVariablesBuilder {
  ...
   UpdateTeamVariablesBuilder teamName(String? t) {
   _teamName.value = t;
   return this;
  }
  UpdateTeamVariablesBuilder ownerName(String? t) {
   _ownerName.value = t;
   return this;
  }
  UpdateTeamVariablesBuilder ownerRole(String? t) {
   _ownerRole.value = t;
   return this;
  }
  UpdateTeamVariablesBuilder companyLogo(String? t) {
   _companyLogo.value = t;
   return this;
  }
  UpdateTeamVariablesBuilder totalMembers(int? t) {
   _totalMembers.value = t;
   return this;
  }
  UpdateTeamVariablesBuilder activeMembers(int? t) {
   _activeMembers.value = t;
   return this;
  }
  UpdateTeamVariablesBuilder totalHubs(int? t) {
   _totalHubs.value = t;
   return this;
  }
  UpdateTeamVariablesBuilder departments(AnyValue? t) {
   _departments.value = t;
   return this;
  }
  UpdateTeamVariablesBuilder favoriteStaffCount(int? t) {
   _favoriteStaffCount.value = t;
   return this;
  }
  UpdateTeamVariablesBuilder blockedStaffCount(int? t) {
   _blockedStaffCount.value = t;
   return this;
  }
  UpdateTeamVariablesBuilder favoriteStaff(AnyValue? t) {
   _favoriteStaff.value = t;
   return this;
  }
  UpdateTeamVariablesBuilder blockedStaff(AnyValue? t) {
   _blockedStaff.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateTeam(
  id: id,
)
.teamName(teamName)
.ownerName(ownerName)
.ownerRole(ownerRole)
.companyLogo(companyLogo)
.totalMembers(totalMembers)
.activeMembers(activeMembers)
.totalHubs(totalHubs)
.departments(departments)
.favoriteStaffCount(favoriteStaffCount)
.blockedStaffCount(blockedStaffCount)
.favoriteStaff(favoriteStaff)
.blockedStaff(blockedStaff)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateTeamData, updateTeamVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateTeam(
  id: id,
);
updateTeamData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateTeam(
  id: id,
).ref();
ref.execute();
```


### deleteTeam
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteTeam(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteTeamData, deleteTeamVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteTeam(
  id: id,
);
deleteTeamData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteTeam(
  id: id,
).ref();
ref.execute();
```


### createTeamHudDepartment
#### Required Arguments
```dart
String name = ...;
String teamHubId = ...;
ExampleConnector.instance.createTeamHudDepartment(
  name: name,
  teamHubId: teamHubId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createTeamHudDepartment, we created `createTeamHudDepartmentBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateTeamHudDepartmentVariablesBuilder {
  ...
   CreateTeamHudDepartmentVariablesBuilder costCenter(String? t) {
   _costCenter.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createTeamHudDepartment(
  name: name,
  teamHubId: teamHubId,
)
.costCenter(costCenter)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createTeamHudDepartmentData, createTeamHudDepartmentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createTeamHudDepartment(
  name: name,
  teamHubId: teamHubId,
);
createTeamHudDepartmentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String name = ...;
String teamHubId = ...;

final ref = ExampleConnector.instance.createTeamHudDepartment(
  name: name,
  teamHubId: teamHubId,
).ref();
ref.execute();
```


### updateTeamHudDepartment
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateTeamHudDepartment(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateTeamHudDepartment, we created `updateTeamHudDepartmentBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateTeamHudDepartmentVariablesBuilder {
  ...
   UpdateTeamHudDepartmentVariablesBuilder name(String? t) {
   _name.value = t;
   return this;
  }
  UpdateTeamHudDepartmentVariablesBuilder costCenter(String? t) {
   _costCenter.value = t;
   return this;
  }
  UpdateTeamHudDepartmentVariablesBuilder teamHubId(String? t) {
   _teamHubId.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateTeamHudDepartment(
  id: id,
)
.name(name)
.costCenter(costCenter)
.teamHubId(teamHubId)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateTeamHudDepartmentData, updateTeamHudDepartmentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateTeamHudDepartment(
  id: id,
);
updateTeamHudDepartmentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateTeamHudDepartment(
  id: id,
).ref();
ref.execute();
```


### deleteTeamHudDepartment
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteTeamHudDepartment(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteTeamHudDepartmentData, deleteTeamHudDepartmentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteTeamHudDepartment(
  id: id,
);
deleteTeamHudDepartmentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteTeamHudDepartment(
  id: id,
).ref();
ref.execute();
```


### createBusiness
#### Required Arguments
```dart
String businessName = ...;
String userId = ...;
BusinessRateGroup rateGroup = ...;
BusinessStatus status = ...;
ExampleConnector.instance.createBusiness(
  businessName: businessName,
  userId: userId,
  rateGroup: rateGroup,
  status: status,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createBusiness, we created `createBusinessBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateBusinessVariablesBuilder {
  ...
   CreateBusinessVariablesBuilder contactName(String? t) {
   _contactName.value = t;
   return this;
  }
  CreateBusinessVariablesBuilder companyLogoUrl(String? t) {
   _companyLogoUrl.value = t;
   return this;
  }
  CreateBusinessVariablesBuilder phone(String? t) {
   _phone.value = t;
   return this;
  }
  CreateBusinessVariablesBuilder email(String? t) {
   _email.value = t;
   return this;
  }
  CreateBusinessVariablesBuilder hubBuilding(String? t) {
   _hubBuilding.value = t;
   return this;
  }
  CreateBusinessVariablesBuilder address(String? t) {
   _address.value = t;
   return this;
  }
  CreateBusinessVariablesBuilder city(String? t) {
   _city.value = t;
   return this;
  }
  CreateBusinessVariablesBuilder area(BusinessArea? t) {
   _area.value = t;
   return this;
  }
  CreateBusinessVariablesBuilder sector(BusinessSector? t) {
   _sector.value = t;
   return this;
  }
  CreateBusinessVariablesBuilder notes(String? t) {
   _notes.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createBusiness(
  businessName: businessName,
  userId: userId,
  rateGroup: rateGroup,
  status: status,
)
.contactName(contactName)
.companyLogoUrl(companyLogoUrl)
.phone(phone)
.email(email)
.hubBuilding(hubBuilding)
.address(address)
.city(city)
.area(area)
.sector(sector)
.notes(notes)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createBusinessData, createBusinessVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createBusiness(
  businessName: businessName,
  userId: userId,
  rateGroup: rateGroup,
  status: status,
);
createBusinessData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String businessName = ...;
String userId = ...;
BusinessRateGroup rateGroup = ...;
BusinessStatus status = ...;

final ref = ExampleConnector.instance.createBusiness(
  businessName: businessName,
  userId: userId,
  rateGroup: rateGroup,
  status: status,
).ref();
ref.execute();
```


### updateBusiness
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateBusiness(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateBusiness, we created `updateBusinessBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateBusinessVariablesBuilder {
  ...
   UpdateBusinessVariablesBuilder businessName(String? t) {
   _businessName.value = t;
   return this;
  }
  UpdateBusinessVariablesBuilder contactName(String? t) {
   _contactName.value = t;
   return this;
  }
  UpdateBusinessVariablesBuilder companyLogoUrl(String? t) {
   _companyLogoUrl.value = t;
   return this;
  }
  UpdateBusinessVariablesBuilder phone(String? t) {
   _phone.value = t;
   return this;
  }
  UpdateBusinessVariablesBuilder email(String? t) {
   _email.value = t;
   return this;
  }
  UpdateBusinessVariablesBuilder hubBuilding(String? t) {
   _hubBuilding.value = t;
   return this;
  }
  UpdateBusinessVariablesBuilder address(String? t) {
   _address.value = t;
   return this;
  }
  UpdateBusinessVariablesBuilder city(String? t) {
   _city.value = t;
   return this;
  }
  UpdateBusinessVariablesBuilder area(BusinessArea? t) {
   _area.value = t;
   return this;
  }
  UpdateBusinessVariablesBuilder sector(BusinessSector? t) {
   _sector.value = t;
   return this;
  }
  UpdateBusinessVariablesBuilder rateGroup(BusinessRateGroup? t) {
   _rateGroup.value = t;
   return this;
  }
  UpdateBusinessVariablesBuilder status(BusinessStatus? t) {
   _status.value = t;
   return this;
  }
  UpdateBusinessVariablesBuilder notes(String? t) {
   _notes.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateBusiness(
  id: id,
)
.businessName(businessName)
.contactName(contactName)
.companyLogoUrl(companyLogoUrl)
.phone(phone)
.email(email)
.hubBuilding(hubBuilding)
.address(address)
.city(city)
.area(area)
.sector(sector)
.rateGroup(rateGroup)
.status(status)
.notes(notes)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateBusinessData, updateBusinessVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateBusiness(
  id: id,
);
updateBusinessData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateBusiness(
  id: id,
).ref();
ref.execute();
```


### deleteBusiness
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteBusiness(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteBusinessData, deleteBusinessVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteBusiness(
  id: id,
);
deleteBusinessData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteBusiness(
  id: id,
).ref();
ref.execute();
```


### createStaffAvailabilityStats
#### Required Arguments
```dart
String staffId = ...;
ExampleConnector.instance.createStaffAvailabilityStats(
  staffId: staffId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createStaffAvailabilityStats, we created `createStaffAvailabilityStatsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateStaffAvailabilityStatsVariablesBuilder {
  ...
   CreateStaffAvailabilityStatsVariablesBuilder needWorkIndex(int? t) {
   _needWorkIndex.value = t;
   return this;
  }
  CreateStaffAvailabilityStatsVariablesBuilder utilizationPercentage(int? t) {
   _utilizationPercentage.value = t;
   return this;
  }
  CreateStaffAvailabilityStatsVariablesBuilder predictedAvailabilityScore(int? t) {
   _predictedAvailabilityScore.value = t;
   return this;
  }
  CreateStaffAvailabilityStatsVariablesBuilder scheduledHoursThisPeriod(int? t) {
   _scheduledHoursThisPeriod.value = t;
   return this;
  }
  CreateStaffAvailabilityStatsVariablesBuilder desiredHoursThisPeriod(int? t) {
   _desiredHoursThisPeriod.value = t;
   return this;
  }
  CreateStaffAvailabilityStatsVariablesBuilder lastShiftDate(Timestamp? t) {
   _lastShiftDate.value = t;
   return this;
  }
  CreateStaffAvailabilityStatsVariablesBuilder acceptanceRate(int? t) {
   _acceptanceRate.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createStaffAvailabilityStats(
  staffId: staffId,
)
.needWorkIndex(needWorkIndex)
.utilizationPercentage(utilizationPercentage)
.predictedAvailabilityScore(predictedAvailabilityScore)
.scheduledHoursThisPeriod(scheduledHoursThisPeriod)
.desiredHoursThisPeriod(desiredHoursThisPeriod)
.lastShiftDate(lastShiftDate)
.acceptanceRate(acceptanceRate)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createStaffAvailabilityStatsData, createStaffAvailabilityStatsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createStaffAvailabilityStats(
  staffId: staffId,
);
createStaffAvailabilityStatsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;

final ref = ExampleConnector.instance.createStaffAvailabilityStats(
  staffId: staffId,
).ref();
ref.execute();
```


### updateStaffAvailabilityStats
#### Required Arguments
```dart
String staffId = ...;
ExampleConnector.instance.updateStaffAvailabilityStats(
  staffId: staffId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateStaffAvailabilityStats, we created `updateStaffAvailabilityStatsBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateStaffAvailabilityStatsVariablesBuilder {
  ...
   UpdateStaffAvailabilityStatsVariablesBuilder needWorkIndex(int? t) {
   _needWorkIndex.value = t;
   return this;
  }
  UpdateStaffAvailabilityStatsVariablesBuilder utilizationPercentage(int? t) {
   _utilizationPercentage.value = t;
   return this;
  }
  UpdateStaffAvailabilityStatsVariablesBuilder predictedAvailabilityScore(int? t) {
   _predictedAvailabilityScore.value = t;
   return this;
  }
  UpdateStaffAvailabilityStatsVariablesBuilder scheduledHoursThisPeriod(int? t) {
   _scheduledHoursThisPeriod.value = t;
   return this;
  }
  UpdateStaffAvailabilityStatsVariablesBuilder desiredHoursThisPeriod(int? t) {
   _desiredHoursThisPeriod.value = t;
   return this;
  }
  UpdateStaffAvailabilityStatsVariablesBuilder lastShiftDate(Timestamp? t) {
   _lastShiftDate.value = t;
   return this;
  }
  UpdateStaffAvailabilityStatsVariablesBuilder acceptanceRate(int? t) {
   _acceptanceRate.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateStaffAvailabilityStats(
  staffId: staffId,
)
.needWorkIndex(needWorkIndex)
.utilizationPercentage(utilizationPercentage)
.predictedAvailabilityScore(predictedAvailabilityScore)
.scheduledHoursThisPeriod(scheduledHoursThisPeriod)
.desiredHoursThisPeriod(desiredHoursThisPeriod)
.lastShiftDate(lastShiftDate)
.acceptanceRate(acceptanceRate)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateStaffAvailabilityStatsData, updateStaffAvailabilityStatsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateStaffAvailabilityStats(
  staffId: staffId,
);
updateStaffAvailabilityStatsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;

final ref = ExampleConnector.instance.updateStaffAvailabilityStats(
  staffId: staffId,
).ref();
ref.execute();
```


### deleteStaffAvailabilityStats
#### Required Arguments
```dart
String staffId = ...;
ExampleConnector.instance.deleteStaffAvailabilityStats(
  staffId: staffId,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteStaffAvailabilityStatsData, deleteStaffAvailabilityStatsVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteStaffAvailabilityStats(
  staffId: staffId,
);
deleteStaffAvailabilityStatsData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;

final ref = ExampleConnector.instance.deleteStaffAvailabilityStats(
  staffId: staffId,
).ref();
ref.execute();
```


### createFaqData
#### Required Arguments
```dart
String category = ...;
ExampleConnector.instance.createFaqData(
  category: category,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createFaqData, we created `createFaqDataBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateFaqDataVariablesBuilder {
  ...
   CreateFaqDataVariablesBuilder questions(List<AnyValue>? t) {
   _questions.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createFaqData(
  category: category,
)
.questions(questions)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createFaqDataData, createFaqDataVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createFaqData(
  category: category,
);
createFaqDataData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String category = ...;

final ref = ExampleConnector.instance.createFaqData(
  category: category,
).ref();
ref.execute();
```


### updateFaqData
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateFaqData(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateFaqData, we created `updateFaqDataBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateFaqDataVariablesBuilder {
  ...
   UpdateFaqDataVariablesBuilder category(String? t) {
   _category.value = t;
   return this;
  }
  UpdateFaqDataVariablesBuilder questions(List<AnyValue>? t) {
   _questions.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateFaqData(
  id: id,
)
.category(category)
.questions(questions)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateFaqDataData, updateFaqDataVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateFaqData(
  id: id,
);
updateFaqDataData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateFaqData(
  id: id,
).ref();
ref.execute();
```


### deleteFaqData
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteFaqData(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteFaqDataData, deleteFaqDataVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteFaqData(
  id: id,
);
deleteFaqDataData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteFaqData(
  id: id,
).ref();
ref.execute();
```


### createStaffCourse
#### Required Arguments
```dart
String staffId = ...;
String courseId = ...;
ExampleConnector.instance.createStaffCourse(
  staffId: staffId,
  courseId: courseId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createStaffCourse, we created `createStaffCourseBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateStaffCourseVariablesBuilder {
  ...
   CreateStaffCourseVariablesBuilder progressPercent(int? t) {
   _progressPercent.value = t;
   return this;
  }
  CreateStaffCourseVariablesBuilder completed(bool? t) {
   _completed.value = t;
   return this;
  }
  CreateStaffCourseVariablesBuilder completedAt(Timestamp? t) {
   _completedAt.value = t;
   return this;
  }
  CreateStaffCourseVariablesBuilder startedAt(Timestamp? t) {
   _startedAt.value = t;
   return this;
  }
  CreateStaffCourseVariablesBuilder lastAccessedAt(Timestamp? t) {
   _lastAccessedAt.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createStaffCourse(
  staffId: staffId,
  courseId: courseId,
)
.progressPercent(progressPercent)
.completed(completed)
.completedAt(completedAt)
.startedAt(startedAt)
.lastAccessedAt(lastAccessedAt)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createStaffCourseData, createStaffCourseVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createStaffCourse(
  staffId: staffId,
  courseId: courseId,
);
createStaffCourseData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;
String courseId = ...;

final ref = ExampleConnector.instance.createStaffCourse(
  staffId: staffId,
  courseId: courseId,
).ref();
ref.execute();
```


### updateStaffCourse
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateStaffCourse(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateStaffCourse, we created `updateStaffCourseBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateStaffCourseVariablesBuilder {
  ...
   UpdateStaffCourseVariablesBuilder progressPercent(int? t) {
   _progressPercent.value = t;
   return this;
  }
  UpdateStaffCourseVariablesBuilder completed(bool? t) {
   _completed.value = t;
   return this;
  }
  UpdateStaffCourseVariablesBuilder completedAt(Timestamp? t) {
   _completedAt.value = t;
   return this;
  }
  UpdateStaffCourseVariablesBuilder startedAt(Timestamp? t) {
   _startedAt.value = t;
   return this;
  }
  UpdateStaffCourseVariablesBuilder lastAccessedAt(Timestamp? t) {
   _lastAccessedAt.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateStaffCourse(
  id: id,
)
.progressPercent(progressPercent)
.completed(completed)
.completedAt(completedAt)
.startedAt(startedAt)
.lastAccessedAt(lastAccessedAt)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateStaffCourseData, updateStaffCourseVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateStaffCourse(
  id: id,
);
updateStaffCourseData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateStaffCourse(
  id: id,
).ref();
ref.execute();
```


### deleteStaffCourse
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteStaffCourse(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteStaffCourseData, deleteStaffCourseVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteStaffCourse(
  id: id,
);
deleteStaffCourseData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteStaffCourse(
  id: id,
).ref();
ref.execute();
```


### createTaskComment
#### Required Arguments
```dart
String taskId = ...;
String teamMemberId = ...;
String comment = ...;
ExampleConnector.instance.createTaskComment(
  taskId: taskId,
  teamMemberId: teamMemberId,
  comment: comment,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createTaskComment, we created `createTaskCommentBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateTaskCommentVariablesBuilder {
  ...
   CreateTaskCommentVariablesBuilder isSystem(bool? t) {
   _isSystem.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createTaskComment(
  taskId: taskId,
  teamMemberId: teamMemberId,
  comment: comment,
)
.isSystem(isSystem)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createTaskCommentData, createTaskCommentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createTaskComment(
  taskId: taskId,
  teamMemberId: teamMemberId,
  comment: comment,
);
createTaskCommentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String taskId = ...;
String teamMemberId = ...;
String comment = ...;

final ref = ExampleConnector.instance.createTaskComment(
  taskId: taskId,
  teamMemberId: teamMemberId,
  comment: comment,
).ref();
ref.execute();
```


### updateTaskComment
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateTaskComment(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateTaskComment, we created `updateTaskCommentBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateTaskCommentVariablesBuilder {
  ...
   UpdateTaskCommentVariablesBuilder comment(String? t) {
   _comment.value = t;
   return this;
  }
  UpdateTaskCommentVariablesBuilder isSystem(bool? t) {
   _isSystem.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateTaskComment(
  id: id,
)
.comment(comment)
.isSystem(isSystem)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateTaskCommentData, updateTaskCommentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateTaskComment(
  id: id,
);
updateTaskCommentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateTaskComment(
  id: id,
).ref();
ref.execute();
```


### deleteTaskComment
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteTaskComment(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteTaskCommentData, deleteTaskCommentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteTaskComment(
  id: id,
);
deleteTaskCommentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteTaskComment(
  id: id,
).ref();
ref.execute();
```


### createTaxForm
#### Required Arguments
```dart
TaxFormType formType = ...;
String title = ...;
String staffId = ...;
ExampleConnector.instance.createTaxForm(
  formType: formType,
  title: title,
  staffId: staffId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createTaxForm, we created `createTaxFormBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateTaxFormVariablesBuilder {
  ...
   CreateTaxFormVariablesBuilder subtitle(String? t) {
   _subtitle.value = t;
   return this;
  }
  CreateTaxFormVariablesBuilder description(String? t) {
   _description.value = t;
   return this;
  }
  CreateTaxFormVariablesBuilder status(TaxFormStatus? t) {
   _status.value = t;
   return this;
  }
  CreateTaxFormVariablesBuilder formData(AnyValue? t) {
   _formData.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createTaxForm(
  formType: formType,
  title: title,
  staffId: staffId,
)
.subtitle(subtitle)
.description(description)
.status(status)
.formData(formData)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createTaxFormData, createTaxFormVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createTaxForm(
  formType: formType,
  title: title,
  staffId: staffId,
);
createTaxFormData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
TaxFormType formType = ...;
String title = ...;
String staffId = ...;

final ref = ExampleConnector.instance.createTaxForm(
  formType: formType,
  title: title,
  staffId: staffId,
).ref();
ref.execute();
```


### updateTaxForm
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateTaxForm(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateTaxForm, we created `updateTaxFormBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateTaxFormVariablesBuilder {
  ...
   UpdateTaxFormVariablesBuilder status(TaxFormStatus? t) {
   _status.value = t;
   return this;
  }
  UpdateTaxFormVariablesBuilder formData(AnyValue? t) {
   _formData.value = t;
   return this;
  }
  UpdateTaxFormVariablesBuilder title(String? t) {
   _title.value = t;
   return this;
  }
  UpdateTaxFormVariablesBuilder subtitle(String? t) {
   _subtitle.value = t;
   return this;
  }
  UpdateTaxFormVariablesBuilder description(String? t) {
   _description.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateTaxForm(
  id: id,
)
.status(status)
.formData(formData)
.title(title)
.subtitle(subtitle)
.description(description)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateTaxFormData, updateTaxFormVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateTaxForm(
  id: id,
);
updateTaxFormData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateTaxForm(
  id: id,
).ref();
ref.execute();
```


### deleteTaxForm
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteTaxForm(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteTaxFormData, deleteTaxFormVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteTaxForm(
  id: id,
);
deleteTaxFormData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteTaxForm(
  id: id,
).ref();
ref.execute();
```


### createCategory
#### Required Arguments
```dart
String categoryId = ...;
String label = ...;
ExampleConnector.instance.createCategory(
  categoryId: categoryId,
  label: label,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createCategory, we created `createCategoryBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateCategoryVariablesBuilder {
  ...
   CreateCategoryVariablesBuilder icon(String? t) {
   _icon.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createCategory(
  categoryId: categoryId,
  label: label,
)
.icon(icon)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createCategoryData, createCategoryVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createCategory(
  categoryId: categoryId,
  label: label,
);
createCategoryData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String categoryId = ...;
String label = ...;

final ref = ExampleConnector.instance.createCategory(
  categoryId: categoryId,
  label: label,
).ref();
ref.execute();
```


### updateCategory
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateCategory(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateCategory, we created `updateCategoryBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateCategoryVariablesBuilder {
  ...
   UpdateCategoryVariablesBuilder categoryId(String? t) {
   _categoryId.value = t;
   return this;
  }
  UpdateCategoryVariablesBuilder label(String? t) {
   _label.value = t;
   return this;
  }
  UpdateCategoryVariablesBuilder icon(String? t) {
   _icon.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateCategory(
  id: id,
)
.categoryId(categoryId)
.label(label)
.icon(icon)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateCategoryData, updateCategoryVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateCategory(
  id: id,
);
updateCategoryData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateCategory(
  id: id,
).ref();
ref.execute();
```


### deleteCategory
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteCategory(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteCategoryData, deleteCategoryVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteCategory(
  id: id,
);
deleteCategoryData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteCategory(
  id: id,
).ref();
ref.execute();
```


### createCourse
#### Required Arguments
```dart
String categoryId = ...;
ExampleConnector.instance.createCourse(
  categoryId: categoryId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createCourse, we created `createCourseBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateCourseVariablesBuilder {
  ...
 
  CreateCourseVariablesBuilder title(String? t) {
   _title.value = t;
   return this;
  }
  CreateCourseVariablesBuilder description(String? t) {
   _description.value = t;
   return this;
  }
  CreateCourseVariablesBuilder thumbnailUrl(String? t) {
   _thumbnailUrl.value = t;
   return this;
  }
  CreateCourseVariablesBuilder durationMinutes(int? t) {
   _durationMinutes.value = t;
   return this;
  }
  CreateCourseVariablesBuilder xpReward(int? t) {
   _xpReward.value = t;
   return this;
  }
  CreateCourseVariablesBuilder levelRequired(String? t) {
   _levelRequired.value = t;
   return this;
  }
  CreateCourseVariablesBuilder isCertification(bool? t) {
   _isCertification.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createCourse(
  categoryId: categoryId,
)
.title(title)
.description(description)
.thumbnailUrl(thumbnailUrl)
.durationMinutes(durationMinutes)
.xpReward(xpReward)
.levelRequired(levelRequired)
.isCertification(isCertification)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createCourseData, createCourseVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createCourse(
  categoryId: categoryId,
);
createCourseData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String categoryId = ...;

final ref = ExampleConnector.instance.createCourse(
  categoryId: categoryId,
).ref();
ref.execute();
```


### updateCourse
#### Required Arguments
```dart
String id = ...;
String categoryId = ...;
ExampleConnector.instance.updateCourse(
  id: id,
  categoryId: categoryId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateCourse, we created `updateCourseBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateCourseVariablesBuilder {
  ...
   UpdateCourseVariablesBuilder title(String? t) {
   _title.value = t;
   return this;
  }
  UpdateCourseVariablesBuilder description(String? t) {
   _description.value = t;
   return this;
  }
  UpdateCourseVariablesBuilder thumbnailUrl(String? t) {
   _thumbnailUrl.value = t;
   return this;
  }
  UpdateCourseVariablesBuilder durationMinutes(int? t) {
   _durationMinutes.value = t;
   return this;
  }
  UpdateCourseVariablesBuilder xpReward(int? t) {
   _xpReward.value = t;
   return this;
  }
  UpdateCourseVariablesBuilder levelRequired(String? t) {
   _levelRequired.value = t;
   return this;
  }
  UpdateCourseVariablesBuilder isCertification(bool? t) {
   _isCertification.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateCourse(
  id: id,
  categoryId: categoryId,
)
.title(title)
.description(description)
.thumbnailUrl(thumbnailUrl)
.durationMinutes(durationMinutes)
.xpReward(xpReward)
.levelRequired(levelRequired)
.isCertification(isCertification)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateCourseData, updateCourseVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateCourse(
  id: id,
  categoryId: categoryId,
);
updateCourseData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;
String categoryId = ...;

final ref = ExampleConnector.instance.updateCourse(
  id: id,
  categoryId: categoryId,
).ref();
ref.execute();
```


### deleteCourse
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteCourse(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteCourseData, deleteCourseVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteCourse(
  id: id,
);
deleteCourseData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteCourse(
  id: id,
).ref();
ref.execute();
```


### createHub
#### Required Arguments
```dart
String name = ...;
String ownerId = ...;
ExampleConnector.instance.createHub(
  name: name,
  ownerId: ownerId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createHub, we created `createHubBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateHubVariablesBuilder {
  ...
   CreateHubVariablesBuilder locationName(String? t) {
   _locationName.value = t;
   return this;
  }
  CreateHubVariablesBuilder address(String? t) {
   _address.value = t;
   return this;
  }
  CreateHubVariablesBuilder nfcTagId(String? t) {
   _nfcTagId.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createHub(
  name: name,
  ownerId: ownerId,
)
.locationName(locationName)
.address(address)
.nfcTagId(nfcTagId)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createHubData, createHubVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createHub(
  name: name,
  ownerId: ownerId,
);
createHubData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String name = ...;
String ownerId = ...;

final ref = ExampleConnector.instance.createHub(
  name: name,
  ownerId: ownerId,
).ref();
ref.execute();
```


### updateHub
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateHub(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateHub, we created `updateHubBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateHubVariablesBuilder {
  ...
   UpdateHubVariablesBuilder name(String? t) {
   _name.value = t;
   return this;
  }
  UpdateHubVariablesBuilder locationName(String? t) {
   _locationName.value = t;
   return this;
  }
  UpdateHubVariablesBuilder address(String? t) {
   _address.value = t;
   return this;
  }
  UpdateHubVariablesBuilder nfcTagId(String? t) {
   _nfcTagId.value = t;
   return this;
  }
  UpdateHubVariablesBuilder ownerId(String? t) {
   _ownerId.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateHub(
  id: id,
)
.name(name)
.locationName(locationName)
.address(address)
.nfcTagId(nfcTagId)
.ownerId(ownerId)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateHubData, updateHubVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateHub(
  id: id,
);
updateHubData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateHub(
  id: id,
).ref();
ref.execute();
```


### deleteHub
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteHub(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteHubData, deleteHubVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteHub(
  id: id,
);
deleteHubData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteHub(
  id: id,
).ref();
ref.execute();
```


### createInvoiceTemplate
#### Required Arguments
```dart
String name = ...;
String ownerId = ...;
ExampleConnector.instance.createInvoiceTemplate(
  name: name,
  ownerId: ownerId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createInvoiceTemplate, we created `createInvoiceTemplateBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateInvoiceTemplateVariablesBuilder {
  ...
   CreateInvoiceTemplateVariablesBuilder vendorId(String? t) {
   _vendorId.value = t;
   return this;
  }
  CreateInvoiceTemplateVariablesBuilder businessId(String? t) {
   _businessId.value = t;
   return this;
  }
  CreateInvoiceTemplateVariablesBuilder orderId(String? t) {
   _orderId.value = t;
   return this;
  }
  CreateInvoiceTemplateVariablesBuilder paymentTerms(InovicePaymentTermsTemp? t) {
   _paymentTerms.value = t;
   return this;
  }
  CreateInvoiceTemplateVariablesBuilder invoiceNumber(String? t) {
   _invoiceNumber.value = t;
   return this;
  }
  CreateInvoiceTemplateVariablesBuilder issueDate(Timestamp? t) {
   _issueDate.value = t;
   return this;
  }
  CreateInvoiceTemplateVariablesBuilder dueDate(Timestamp? t) {
   _dueDate.value = t;
   return this;
  }
  CreateInvoiceTemplateVariablesBuilder hub(String? t) {
   _hub.value = t;
   return this;
  }
  CreateInvoiceTemplateVariablesBuilder managerName(String? t) {
   _managerName.value = t;
   return this;
  }
  CreateInvoiceTemplateVariablesBuilder vendorNumber(String? t) {
   _vendorNumber.value = t;
   return this;
  }
  CreateInvoiceTemplateVariablesBuilder roles(AnyValue? t) {
   _roles.value = t;
   return this;
  }
  CreateInvoiceTemplateVariablesBuilder charges(AnyValue? t) {
   _charges.value = t;
   return this;
  }
  CreateInvoiceTemplateVariablesBuilder otherCharges(double? t) {
   _otherCharges.value = t;
   return this;
  }
  CreateInvoiceTemplateVariablesBuilder subtotal(double? t) {
   _subtotal.value = t;
   return this;
  }
  CreateInvoiceTemplateVariablesBuilder amount(double? t) {
   _amount.value = t;
   return this;
  }
  CreateInvoiceTemplateVariablesBuilder notes(String? t) {
   _notes.value = t;
   return this;
  }
  CreateInvoiceTemplateVariablesBuilder staffCount(int? t) {
   _staffCount.value = t;
   return this;
  }
  CreateInvoiceTemplateVariablesBuilder chargesCount(int? t) {
   _chargesCount.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createInvoiceTemplate(
  name: name,
  ownerId: ownerId,
)
.vendorId(vendorId)
.businessId(businessId)
.orderId(orderId)
.paymentTerms(paymentTerms)
.invoiceNumber(invoiceNumber)
.issueDate(issueDate)
.dueDate(dueDate)
.hub(hub)
.managerName(managerName)
.vendorNumber(vendorNumber)
.roles(roles)
.charges(charges)
.otherCharges(otherCharges)
.subtotal(subtotal)
.amount(amount)
.notes(notes)
.staffCount(staffCount)
.chargesCount(chargesCount)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createInvoiceTemplateData, createInvoiceTemplateVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createInvoiceTemplate(
  name: name,
  ownerId: ownerId,
);
createInvoiceTemplateData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String name = ...;
String ownerId = ...;

final ref = ExampleConnector.instance.createInvoiceTemplate(
  name: name,
  ownerId: ownerId,
).ref();
ref.execute();
```


### updateInvoiceTemplate
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateInvoiceTemplate(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateInvoiceTemplate, we created `updateInvoiceTemplateBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateInvoiceTemplateVariablesBuilder {
  ...
   UpdateInvoiceTemplateVariablesBuilder name(String? t) {
   _name.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder ownerId(String? t) {
   _ownerId.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder vendorId(String? t) {
   _vendorId.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder businessId(String? t) {
   _businessId.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder orderId(String? t) {
   _orderId.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder paymentTerms(InovicePaymentTermsTemp? t) {
   _paymentTerms.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder invoiceNumber(String? t) {
   _invoiceNumber.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder issueDate(Timestamp? t) {
   _issueDate.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder dueDate(Timestamp? t) {
   _dueDate.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder hub(String? t) {
   _hub.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder managerName(String? t) {
   _managerName.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder vendorNumber(String? t) {
   _vendorNumber.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder roles(AnyValue? t) {
   _roles.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder charges(AnyValue? t) {
   _charges.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder otherCharges(double? t) {
   _otherCharges.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder subtotal(double? t) {
   _subtotal.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder amount(double? t) {
   _amount.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder notes(String? t) {
   _notes.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder staffCount(int? t) {
   _staffCount.value = t;
   return this;
  }
  UpdateInvoiceTemplateVariablesBuilder chargesCount(int? t) {
   _chargesCount.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateInvoiceTemplate(
  id: id,
)
.name(name)
.ownerId(ownerId)
.vendorId(vendorId)
.businessId(businessId)
.orderId(orderId)
.paymentTerms(paymentTerms)
.invoiceNumber(invoiceNumber)
.issueDate(issueDate)
.dueDate(dueDate)
.hub(hub)
.managerName(managerName)
.vendorNumber(vendorNumber)
.roles(roles)
.charges(charges)
.otherCharges(otherCharges)
.subtotal(subtotal)
.amount(amount)
.notes(notes)
.staffCount(staffCount)
.chargesCount(chargesCount)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateInvoiceTemplateData, updateInvoiceTemplateVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateInvoiceTemplate(
  id: id,
);
updateInvoiceTemplateData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateInvoiceTemplate(
  id: id,
).ref();
ref.execute();
```


### deleteInvoiceTemplate
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteInvoiceTemplate(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteInvoiceTemplateData, deleteInvoiceTemplateVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteInvoiceTemplate(
  id: id,
);
deleteInvoiceTemplateData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteInvoiceTemplate(
  id: id,
).ref();
ref.execute();
```


### createEmergencyContact
#### Required Arguments
```dart
String name = ...;
String phone = ...;
RelationshipType relationship = ...;
String staffId = ...;
ExampleConnector.instance.createEmergencyContact(
  name: name,
  phone: phone,
  relationship: relationship,
  staffId: staffId,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<createEmergencyContactData, createEmergencyContactVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createEmergencyContact(
  name: name,
  phone: phone,
  relationship: relationship,
  staffId: staffId,
);
createEmergencyContactData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String name = ...;
String phone = ...;
RelationshipType relationship = ...;
String staffId = ...;

final ref = ExampleConnector.instance.createEmergencyContact(
  name: name,
  phone: phone,
  relationship: relationship,
  staffId: staffId,
).ref();
ref.execute();
```


### updateEmergencyContact
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateEmergencyContact(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateEmergencyContact, we created `updateEmergencyContactBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateEmergencyContactVariablesBuilder {
  ...
   UpdateEmergencyContactVariablesBuilder name(String? t) {
   _name.value = t;
   return this;
  }
  UpdateEmergencyContactVariablesBuilder phone(String? t) {
   _phone.value = t;
   return this;
  }
  UpdateEmergencyContactVariablesBuilder relationship(RelationshipType? t) {
   _relationship.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateEmergencyContact(
  id: id,
)
.name(name)
.phone(phone)
.relationship(relationship)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateEmergencyContactData, updateEmergencyContactVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateEmergencyContact(
  id: id,
);
updateEmergencyContactData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateEmergencyContact(
  id: id,
).ref();
ref.execute();
```


### deleteEmergencyContact
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteEmergencyContact(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteEmergencyContactData, deleteEmergencyContactVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteEmergencyContact(
  id: id,
);
deleteEmergencyContactData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteEmergencyContact(
  id: id,
).ref();
ref.execute();
```


### createRoleCategory
#### Required Arguments
```dart
String roleName = ...;
RoleCategoryType category = ...;
ExampleConnector.instance.createRoleCategory(
  roleName: roleName,
  category: category,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<createRoleCategoryData, createRoleCategoryVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createRoleCategory(
  roleName: roleName,
  category: category,
);
createRoleCategoryData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String roleName = ...;
RoleCategoryType category = ...;

final ref = ExampleConnector.instance.createRoleCategory(
  roleName: roleName,
  category: category,
).ref();
ref.execute();
```


### updateRoleCategory
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateRoleCategory(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateRoleCategory, we created `updateRoleCategoryBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateRoleCategoryVariablesBuilder {
  ...
   UpdateRoleCategoryVariablesBuilder roleName(String? t) {
   _roleName.value = t;
   return this;
  }
  UpdateRoleCategoryVariablesBuilder category(RoleCategoryType? t) {
   _category.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateRoleCategory(
  id: id,
)
.roleName(roleName)
.category(category)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateRoleCategoryData, updateRoleCategoryVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateRoleCategory(
  id: id,
);
updateRoleCategoryData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateRoleCategory(
  id: id,
).ref();
ref.execute();
```


### deleteRoleCategory
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteRoleCategory(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteRoleCategoryData, deleteRoleCategoryVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteRoleCategory(
  id: id,
);
deleteRoleCategoryData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteRoleCategory(
  id: id,
).ref();
ref.execute();
```


### createTeamHub
#### Required Arguments
```dart
String teamId = ...;
String hubName = ...;
String address = ...;
ExampleConnector.instance.createTeamHub(
  teamId: teamId,
  hubName: hubName,
  address: address,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createTeamHub, we created `createTeamHubBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateTeamHubVariablesBuilder {
  ...
   CreateTeamHubVariablesBuilder city(String? t) {
   _city.value = t;
   return this;
  }
  CreateTeamHubVariablesBuilder state(String? t) {
   _state.value = t;
   return this;
  }
  CreateTeamHubVariablesBuilder zipCode(String? t) {
   _zipCode.value = t;
   return this;
  }
  CreateTeamHubVariablesBuilder managerName(String? t) {
   _managerName.value = t;
   return this;
  }
  CreateTeamHubVariablesBuilder isActive(bool? t) {
   _isActive.value = t;
   return this;
  }
  CreateTeamHubVariablesBuilder departments(AnyValue? t) {
   _departments.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createTeamHub(
  teamId: teamId,
  hubName: hubName,
  address: address,
)
.city(city)
.state(state)
.zipCode(zipCode)
.managerName(managerName)
.isActive(isActive)
.departments(departments)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createTeamHubData, createTeamHubVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createTeamHub(
  teamId: teamId,
  hubName: hubName,
  address: address,
);
createTeamHubData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String teamId = ...;
String hubName = ...;
String address = ...;

final ref = ExampleConnector.instance.createTeamHub(
  teamId: teamId,
  hubName: hubName,
  address: address,
).ref();
ref.execute();
```


### updateTeamHub
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateTeamHub(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateTeamHub, we created `updateTeamHubBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateTeamHubVariablesBuilder {
  ...
   UpdateTeamHubVariablesBuilder hubName(String? t) {
   _hubName.value = t;
   return this;
  }
  UpdateTeamHubVariablesBuilder address(String? t) {
   _address.value = t;
   return this;
  }
  UpdateTeamHubVariablesBuilder city(String? t) {
   _city.value = t;
   return this;
  }
  UpdateTeamHubVariablesBuilder state(String? t) {
   _state.value = t;
   return this;
  }
  UpdateTeamHubVariablesBuilder zipCode(String? t) {
   _zipCode.value = t;
   return this;
  }
  UpdateTeamHubVariablesBuilder managerName(String? t) {
   _managerName.value = t;
   return this;
  }
  UpdateTeamHubVariablesBuilder isActive(bool? t) {
   _isActive.value = t;
   return this;
  }
  UpdateTeamHubVariablesBuilder departments(AnyValue? t) {
   _departments.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateTeamHub(
  id: id,
)
.hubName(hubName)
.address(address)
.city(city)
.state(state)
.zipCode(zipCode)
.managerName(managerName)
.isActive(isActive)
.departments(departments)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateTeamHubData, updateTeamHubVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateTeamHub(
  id: id,
);
updateTeamHubData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateTeamHub(
  id: id,
).ref();
ref.execute();
```


### deleteTeamHub
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteTeamHub(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteTeamHubData, deleteTeamHubVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteTeamHub(
  id: id,
);
deleteTeamHubData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteTeamHub(
  id: id,
).ref();
ref.execute();
```


### createAttireOption
#### Required Arguments
```dart
String itemId = ...;
String label = ...;
ExampleConnector.instance.createAttireOption(
  itemId: itemId,
  label: label,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createAttireOption, we created `createAttireOptionBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateAttireOptionVariablesBuilder {
  ...
   CreateAttireOptionVariablesBuilder icon(String? t) {
   _icon.value = t;
   return this;
  }
  CreateAttireOptionVariablesBuilder imageUrl(String? t) {
   _imageUrl.value = t;
   return this;
  }
  CreateAttireOptionVariablesBuilder isMandatory(bool? t) {
   _isMandatory.value = t;
   return this;
  }
  CreateAttireOptionVariablesBuilder vendorId(String? t) {
   _vendorId.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createAttireOption(
  itemId: itemId,
  label: label,
)
.icon(icon)
.imageUrl(imageUrl)
.isMandatory(isMandatory)
.vendorId(vendorId)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createAttireOptionData, createAttireOptionVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createAttireOption(
  itemId: itemId,
  label: label,
);
createAttireOptionData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String itemId = ...;
String label = ...;

final ref = ExampleConnector.instance.createAttireOption(
  itemId: itemId,
  label: label,
).ref();
ref.execute();
```


### updateAttireOption
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateAttireOption(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateAttireOption, we created `updateAttireOptionBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateAttireOptionVariablesBuilder {
  ...
   UpdateAttireOptionVariablesBuilder itemId(String? t) {
   _itemId.value = t;
   return this;
  }
  UpdateAttireOptionVariablesBuilder label(String? t) {
   _label.value = t;
   return this;
  }
  UpdateAttireOptionVariablesBuilder icon(String? t) {
   _icon.value = t;
   return this;
  }
  UpdateAttireOptionVariablesBuilder imageUrl(String? t) {
   _imageUrl.value = t;
   return this;
  }
  UpdateAttireOptionVariablesBuilder isMandatory(bool? t) {
   _isMandatory.value = t;
   return this;
  }
  UpdateAttireOptionVariablesBuilder vendorId(String? t) {
   _vendorId.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateAttireOption(
  id: id,
)
.itemId(itemId)
.label(label)
.icon(icon)
.imageUrl(imageUrl)
.isMandatory(isMandatory)
.vendorId(vendorId)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateAttireOptionData, updateAttireOptionVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateAttireOption(
  id: id,
);
updateAttireOptionData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateAttireOption(
  id: id,
).ref();
ref.execute();
```


### deleteAttireOption
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteAttireOption(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteAttireOptionData, deleteAttireOptionVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteAttireOption(
  id: id,
);
deleteAttireOptionData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteAttireOption(
  id: id,
).ref();
ref.execute();
```


### createVendor
#### Required Arguments
```dart
String userId = ...;
String companyName = ...;
ExampleConnector.instance.createVendor(
  userId: userId,
  companyName: companyName,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createVendor, we created `createVendorBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateVendorVariablesBuilder {
  ...
   CreateVendorVariablesBuilder email(String? t) {
   _email.value = t;
   return this;
  }
  CreateVendorVariablesBuilder phone(String? t) {
   _phone.value = t;
   return this;
  }
  CreateVendorVariablesBuilder photoUrl(String? t) {
   _photoUrl.value = t;
   return this;
  }
  CreateVendorVariablesBuilder address(String? t) {
   _address.value = t;
   return this;
  }
  CreateVendorVariablesBuilder billingAddress(String? t) {
   _billingAddress.value = t;
   return this;
  }
  CreateVendorVariablesBuilder timezone(String? t) {
   _timezone.value = t;
   return this;
  }
  CreateVendorVariablesBuilder legalName(String? t) {
   _legalName.value = t;
   return this;
  }
  CreateVendorVariablesBuilder doingBusinessAs(String? t) {
   _doingBusinessAs.value = t;
   return this;
  }
  CreateVendorVariablesBuilder region(String? t) {
   _region.value = t;
   return this;
  }
  CreateVendorVariablesBuilder state(String? t) {
   _state.value = t;
   return this;
  }
  CreateVendorVariablesBuilder city(String? t) {
   _city.value = t;
   return this;
  }
  CreateVendorVariablesBuilder serviceSpecialty(String? t) {
   _serviceSpecialty.value = t;
   return this;
  }
  CreateVendorVariablesBuilder approvalStatus(ApprovalStatus? t) {
   _approvalStatus.value = t;
   return this;
  }
  CreateVendorVariablesBuilder isActive(bool? t) {
   _isActive.value = t;
   return this;
  }
  CreateVendorVariablesBuilder markup(double? t) {
   _markup.value = t;
   return this;
  }
  CreateVendorVariablesBuilder fee(double? t) {
   _fee.value = t;
   return this;
  }
  CreateVendorVariablesBuilder csat(double? t) {
   _csat.value = t;
   return this;
  }
  CreateVendorVariablesBuilder tier(VendorTier? t) {
   _tier.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createVendor(
  userId: userId,
  companyName: companyName,
)
.email(email)
.phone(phone)
.photoUrl(photoUrl)
.address(address)
.billingAddress(billingAddress)
.timezone(timezone)
.legalName(legalName)
.doingBusinessAs(doingBusinessAs)
.region(region)
.state(state)
.city(city)
.serviceSpecialty(serviceSpecialty)
.approvalStatus(approvalStatus)
.isActive(isActive)
.markup(markup)
.fee(fee)
.csat(csat)
.tier(tier)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createVendorData, createVendorVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createVendor(
  userId: userId,
  companyName: companyName,
);
createVendorData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String userId = ...;
String companyName = ...;

final ref = ExampleConnector.instance.createVendor(
  userId: userId,
  companyName: companyName,
).ref();
ref.execute();
```


### updateVendor
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateVendor(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateVendor, we created `updateVendorBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateVendorVariablesBuilder {
  ...
   UpdateVendorVariablesBuilder companyName(String? t) {
   _companyName.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder email(String? t) {
   _email.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder phone(String? t) {
   _phone.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder photoUrl(String? t) {
   _photoUrl.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder address(String? t) {
   _address.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder billingAddress(String? t) {
   _billingAddress.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder timezone(String? t) {
   _timezone.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder legalName(String? t) {
   _legalName.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder doingBusinessAs(String? t) {
   _doingBusinessAs.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder region(String? t) {
   _region.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder state(String? t) {
   _state.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder city(String? t) {
   _city.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder serviceSpecialty(String? t) {
   _serviceSpecialty.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder approvalStatus(ApprovalStatus? t) {
   _approvalStatus.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder isActive(bool? t) {
   _isActive.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder markup(double? t) {
   _markup.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder fee(double? t) {
   _fee.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder csat(double? t) {
   _csat.value = t;
   return this;
  }
  UpdateVendorVariablesBuilder tier(VendorTier? t) {
   _tier.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateVendor(
  id: id,
)
.companyName(companyName)
.email(email)
.phone(phone)
.photoUrl(photoUrl)
.address(address)
.billingAddress(billingAddress)
.timezone(timezone)
.legalName(legalName)
.doingBusinessAs(doingBusinessAs)
.region(region)
.state(state)
.city(city)
.serviceSpecialty(serviceSpecialty)
.approvalStatus(approvalStatus)
.isActive(isActive)
.markup(markup)
.fee(fee)
.csat(csat)
.tier(tier)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateVendorData, updateVendorVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateVendor(
  id: id,
);
updateVendorData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateVendor(
  id: id,
).ref();
ref.execute();
```


### deleteVendor
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteVendor(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteVendorData, deleteVendorVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteVendor(
  id: id,
);
deleteVendorData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteVendor(
  id: id,
).ref();
ref.execute();
```


### CreateUser
#### Required Arguments
```dart
String id = ...;
UserBaseRole role = ...;
ExampleConnector.instance.createUser(
  id: id,
  role: role,
).execute();
```

#### Optional Arguments
We return a builder for each query. For CreateUser, we created `CreateUserBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateUserVariablesBuilder {
  ...
   CreateUserVariablesBuilder email(String? t) {
   _email.value = t;
   return this;
  }
  CreateUserVariablesBuilder fullName(String? t) {
   _fullName.value = t;
   return this;
  }
  CreateUserVariablesBuilder userRole(String? t) {
   _userRole.value = t;
   return this;
  }
  CreateUserVariablesBuilder photoUrl(String? t) {
   _photoUrl.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createUser(
  id: id,
  role: role,
)
.email(email)
.fullName(fullName)
.userRole(userRole)
.photoUrl(photoUrl)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<CreateUserData, CreateUserVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createUser(
  id: id,
  role: role,
);
CreateUserData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;
UserBaseRole role = ...;

final ref = ExampleConnector.instance.createUser(
  id: id,
  role: role,
).ref();
ref.execute();
```


### UpdateUser
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateUser(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For UpdateUser, we created `UpdateUserBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateUserVariablesBuilder {
  ...
   UpdateUserVariablesBuilder email(String? t) {
   _email.value = t;
   return this;
  }
  UpdateUserVariablesBuilder fullName(String? t) {
   _fullName.value = t;
   return this;
  }
  UpdateUserVariablesBuilder role(UserBaseRole? t) {
   _role.value = t;
   return this;
  }
  UpdateUserVariablesBuilder userRole(String? t) {
   _userRole.value = t;
   return this;
  }
  UpdateUserVariablesBuilder photoUrl(String? t) {
   _photoUrl.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateUser(
  id: id,
)
.email(email)
.fullName(fullName)
.role(role)
.userRole(userRole)
.photoUrl(photoUrl)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<UpdateUserData, UpdateUserVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateUser(
  id: id,
);
UpdateUserData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateUser(
  id: id,
).ref();
ref.execute();
```


### DeleteUser
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteUser(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<DeleteUserData, DeleteUserVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteUser(
  id: id,
);
DeleteUserData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteUser(
  id: id,
).ref();
ref.execute();
```


### createAccount
#### Required Arguments
```dart
String bank = ...;
AccountType type = ...;
String last4 = ...;
String ownerId = ...;
ExampleConnector.instance.createAccount(
  bank: bank,
  type: type,
  last4: last4,
  ownerId: ownerId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createAccount, we created `createAccountBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateAccountVariablesBuilder {
  ...
   CreateAccountVariablesBuilder isPrimary(bool? t) {
   _isPrimary.value = t;
   return this;
  }
  CreateAccountVariablesBuilder accountNumber(String? t) {
   _accountNumber.value = t;
   return this;
  }
  CreateAccountVariablesBuilder routeNumber(String? t) {
   _routeNumber.value = t;
   return this;
  }
  CreateAccountVariablesBuilder expiryTime(Timestamp? t) {
   _expiryTime.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createAccount(
  bank: bank,
  type: type,
  last4: last4,
  ownerId: ownerId,
)
.isPrimary(isPrimary)
.accountNumber(accountNumber)
.routeNumber(routeNumber)
.expiryTime(expiryTime)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createAccountData, createAccountVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createAccount(
  bank: bank,
  type: type,
  last4: last4,
  ownerId: ownerId,
);
createAccountData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String bank = ...;
AccountType type = ...;
String last4 = ...;
String ownerId = ...;

final ref = ExampleConnector.instance.createAccount(
  bank: bank,
  type: type,
  last4: last4,
  ownerId: ownerId,
).ref();
ref.execute();
```


### updateAccount
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateAccount(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateAccount, we created `updateAccountBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateAccountVariablesBuilder {
  ...
   UpdateAccountVariablesBuilder bank(String? t) {
   _bank.value = t;
   return this;
  }
  UpdateAccountVariablesBuilder type(AccountType? t) {
   _type.value = t;
   return this;
  }
  UpdateAccountVariablesBuilder last4(String? t) {
   _last4.value = t;
   return this;
  }
  UpdateAccountVariablesBuilder isPrimary(bool? t) {
   _isPrimary.value = t;
   return this;
  }
  UpdateAccountVariablesBuilder accountNumber(String? t) {
   _accountNumber.value = t;
   return this;
  }
  UpdateAccountVariablesBuilder routeNumber(String? t) {
   _routeNumber.value = t;
   return this;
  }
  UpdateAccountVariablesBuilder expiryTime(Timestamp? t) {
   _expiryTime.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateAccount(
  id: id,
)
.bank(bank)
.type(type)
.last4(last4)
.isPrimary(isPrimary)
.accountNumber(accountNumber)
.routeNumber(routeNumber)
.expiryTime(expiryTime)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateAccountData, updateAccountVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateAccount(
  id: id,
);
updateAccountData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateAccount(
  id: id,
).ref();
ref.execute();
```


### deleteAccount
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteAccount(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteAccountData, deleteAccountVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteAccount(
  id: id,
);
deleteAccountData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteAccount(
  id: id,
).ref();
ref.execute();
```


### createApplication
#### Required Arguments
```dart
String shiftId = ...;
String staffId = ...;
ApplicationStatus status = ...;
ApplicationOrigin origin = ...;
String roleId = ...;
ExampleConnector.instance.createApplication(
  shiftId: shiftId,
  staffId: staffId,
  status: status,
  origin: origin,
  roleId: roleId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createApplication, we created `createApplicationBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateApplicationVariablesBuilder {
  ...
   CreateApplicationVariablesBuilder checkInTime(Timestamp? t) {
   _checkInTime.value = t;
   return this;
  }
  CreateApplicationVariablesBuilder checkOutTime(Timestamp? t) {
   _checkOutTime.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createApplication(
  shiftId: shiftId,
  staffId: staffId,
  status: status,
  origin: origin,
  roleId: roleId,
)
.checkInTime(checkInTime)
.checkOutTime(checkOutTime)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createApplicationData, createApplicationVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createApplication(
  shiftId: shiftId,
  staffId: staffId,
  status: status,
  origin: origin,
  roleId: roleId,
);
createApplicationData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String shiftId = ...;
String staffId = ...;
ApplicationStatus status = ...;
ApplicationOrigin origin = ...;
String roleId = ...;

final ref = ExampleConnector.instance.createApplication(
  shiftId: shiftId,
  staffId: staffId,
  status: status,
  origin: origin,
  roleId: roleId,
).ref();
ref.execute();
```


### updateApplicationStatus
#### Required Arguments
```dart
String id = ...;
String roleId = ...;
ExampleConnector.instance.updateApplicationStatus(
  id: id,
  roleId: roleId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateApplicationStatus, we created `updateApplicationStatusBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateApplicationStatusVariablesBuilder {
  ...
   UpdateApplicationStatusVariablesBuilder shiftId(String? t) {
   _shiftId.value = t;
   return this;
  }
  UpdateApplicationStatusVariablesBuilder staffId(String? t) {
   _staffId.value = t;
   return this;
  }
  UpdateApplicationStatusVariablesBuilder status(ApplicationStatus? t) {
   _status.value = t;
   return this;
  }
  UpdateApplicationStatusVariablesBuilder checkInTime(Timestamp? t) {
   _checkInTime.value = t;
   return this;
  }
  UpdateApplicationStatusVariablesBuilder checkOutTime(Timestamp? t) {
   _checkOutTime.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateApplicationStatus(
  id: id,
  roleId: roleId,
)
.shiftId(shiftId)
.staffId(staffId)
.status(status)
.checkInTime(checkInTime)
.checkOutTime(checkOutTime)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateApplicationStatusData, updateApplicationStatusVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateApplicationStatus(
  id: id,
  roleId: roleId,
);
updateApplicationStatusData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;
String roleId = ...;

final ref = ExampleConnector.instance.updateApplicationStatus(
  id: id,
  roleId: roleId,
).ref();
ref.execute();
```


### deleteApplication
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteApplication(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteApplicationData, deleteApplicationVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteApplication(
  id: id,
);
deleteApplicationData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteApplication(
  id: id,
).ref();
ref.execute();
```


### createCustomRateCard
#### Required Arguments
```dart
String name = ...;
ExampleConnector.instance.createCustomRateCard(
  name: name,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createCustomRateCard, we created `createCustomRateCardBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateCustomRateCardVariablesBuilder {
  ...
   CreateCustomRateCardVariablesBuilder baseBook(String? t) {
   _baseBook.value = t;
   return this;
  }
  CreateCustomRateCardVariablesBuilder discount(double? t) {
   _discount.value = t;
   return this;
  }
  CreateCustomRateCardVariablesBuilder isDefault(bool? t) {
   _isDefault.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createCustomRateCard(
  name: name,
)
.baseBook(baseBook)
.discount(discount)
.isDefault(isDefault)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createCustomRateCardData, createCustomRateCardVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createCustomRateCard(
  name: name,
);
createCustomRateCardData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String name = ...;

final ref = ExampleConnector.instance.createCustomRateCard(
  name: name,
).ref();
ref.execute();
```


### updateCustomRateCard
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateCustomRateCard(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateCustomRateCard, we created `updateCustomRateCardBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateCustomRateCardVariablesBuilder {
  ...
   UpdateCustomRateCardVariablesBuilder name(String? t) {
   _name.value = t;
   return this;
  }
  UpdateCustomRateCardVariablesBuilder baseBook(String? t) {
   _baseBook.value = t;
   return this;
  }
  UpdateCustomRateCardVariablesBuilder discount(double? t) {
   _discount.value = t;
   return this;
  }
  UpdateCustomRateCardVariablesBuilder isDefault(bool? t) {
   _isDefault.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateCustomRateCard(
  id: id,
)
.name(name)
.baseBook(baseBook)
.discount(discount)
.isDefault(isDefault)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateCustomRateCardData, updateCustomRateCardVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateCustomRateCard(
  id: id,
);
updateCustomRateCardData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateCustomRateCard(
  id: id,
).ref();
ref.execute();
```


### deleteCustomRateCard
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteCustomRateCard(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteCustomRateCardData, deleteCustomRateCardVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteCustomRateCard(
  id: id,
);
deleteCustomRateCardData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteCustomRateCard(
  id: id,
).ref();
ref.execute();
```


### createDocument
#### Required Arguments
```dart
DocumentType documentType = ...;
String name = ...;
ExampleConnector.instance.createDocument(
  documentType: documentType,
  name: name,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createDocument, we created `createDocumentBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateDocumentVariablesBuilder {
  ...
   CreateDocumentVariablesBuilder description(String? t) {
   _description.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createDocument(
  documentType: documentType,
  name: name,
)
.description(description)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createDocumentData, createDocumentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createDocument(
  documentType: documentType,
  name: name,
);
createDocumentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
DocumentType documentType = ...;
String name = ...;

final ref = ExampleConnector.instance.createDocument(
  documentType: documentType,
  name: name,
).ref();
ref.execute();
```


### updateDocument
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateDocument(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateDocument, we created `updateDocumentBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateDocumentVariablesBuilder {
  ...
   UpdateDocumentVariablesBuilder documentType(DocumentType? t) {
   _documentType.value = t;
   return this;
  }
  UpdateDocumentVariablesBuilder name(String? t) {
   _name.value = t;
   return this;
  }
  UpdateDocumentVariablesBuilder description(String? t) {
   _description.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateDocument(
  id: id,
)
.documentType(documentType)
.name(name)
.description(description)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateDocumentData, updateDocumentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateDocument(
  id: id,
);
updateDocumentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateDocument(
  id: id,
).ref();
ref.execute();
```


### deleteDocument
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteDocument(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteDocumentData, deleteDocumentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteDocument(
  id: id,
);
deleteDocumentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteDocument(
  id: id,
).ref();
ref.execute();
```


### createVendorBenefitPlan
#### Required Arguments
```dart
String vendorId = ...;
String title = ...;
ExampleConnector.instance.createVendorBenefitPlan(
  vendorId: vendorId,
  title: title,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createVendorBenefitPlan, we created `createVendorBenefitPlanBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateVendorBenefitPlanVariablesBuilder {
  ...
   CreateVendorBenefitPlanVariablesBuilder description(String? t) {
   _description.value = t;
   return this;
  }
  CreateVendorBenefitPlanVariablesBuilder requestLabel(String? t) {
   _requestLabel.value = t;
   return this;
  }
  CreateVendorBenefitPlanVariablesBuilder total(int? t) {
   _total.value = t;
   return this;
  }
  CreateVendorBenefitPlanVariablesBuilder isActive(bool? t) {
   _isActive.value = t;
   return this;
  }
  CreateVendorBenefitPlanVariablesBuilder createdBy(String? t) {
   _createdBy.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createVendorBenefitPlan(
  vendorId: vendorId,
  title: title,
)
.description(description)
.requestLabel(requestLabel)
.total(total)
.isActive(isActive)
.createdBy(createdBy)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createVendorBenefitPlanData, createVendorBenefitPlanVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createVendorBenefitPlan(
  vendorId: vendorId,
  title: title,
);
createVendorBenefitPlanData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorId = ...;
String title = ...;

final ref = ExampleConnector.instance.createVendorBenefitPlan(
  vendorId: vendorId,
  title: title,
).ref();
ref.execute();
```


### updateVendorBenefitPlan
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateVendorBenefitPlan(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateVendorBenefitPlan, we created `updateVendorBenefitPlanBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateVendorBenefitPlanVariablesBuilder {
  ...
   UpdateVendorBenefitPlanVariablesBuilder vendorId(String? t) {
   _vendorId.value = t;
   return this;
  }
  UpdateVendorBenefitPlanVariablesBuilder title(String? t) {
   _title.value = t;
   return this;
  }
  UpdateVendorBenefitPlanVariablesBuilder description(String? t) {
   _description.value = t;
   return this;
  }
  UpdateVendorBenefitPlanVariablesBuilder requestLabel(String? t) {
   _requestLabel.value = t;
   return this;
  }
  UpdateVendorBenefitPlanVariablesBuilder total(int? t) {
   _total.value = t;
   return this;
  }
  UpdateVendorBenefitPlanVariablesBuilder isActive(bool? t) {
   _isActive.value = t;
   return this;
  }
  UpdateVendorBenefitPlanVariablesBuilder createdBy(String? t) {
   _createdBy.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateVendorBenefitPlan(
  id: id,
)
.vendorId(vendorId)
.title(title)
.description(description)
.requestLabel(requestLabel)
.total(total)
.isActive(isActive)
.createdBy(createdBy)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateVendorBenefitPlanData, updateVendorBenefitPlanVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateVendorBenefitPlan(
  id: id,
);
updateVendorBenefitPlanData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateVendorBenefitPlan(
  id: id,
).ref();
ref.execute();
```


### deleteVendorBenefitPlan
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteVendorBenefitPlan(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteVendorBenefitPlanData, deleteVendorBenefitPlanVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteVendorBenefitPlan(
  id: id,
);
deleteVendorBenefitPlanData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteVendorBenefitPlan(
  id: id,
).ref();
ref.execute();
```


### createBenefitsData
#### Required Arguments
```dart
String vendorBenefitPlanId = ...;
String staffId = ...;
int current = ...;
ExampleConnector.instance.createBenefitsData(
  vendorBenefitPlanId: vendorBenefitPlanId,
  staffId: staffId,
  current: current,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<createBenefitsDataData, createBenefitsDataVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createBenefitsData(
  vendorBenefitPlanId: vendorBenefitPlanId,
  staffId: staffId,
  current: current,
);
createBenefitsDataData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String vendorBenefitPlanId = ...;
String staffId = ...;
int current = ...;

final ref = ExampleConnector.instance.createBenefitsData(
  vendorBenefitPlanId: vendorBenefitPlanId,
  staffId: staffId,
  current: current,
).ref();
ref.execute();
```


### updateBenefitsData
#### Required Arguments
```dart
String staffId = ...;
String vendorBenefitPlanId = ...;
ExampleConnector.instance.updateBenefitsData(
  staffId: staffId,
  vendorBenefitPlanId: vendorBenefitPlanId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateBenefitsData, we created `updateBenefitsDataBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateBenefitsDataVariablesBuilder {
  ...
   UpdateBenefitsDataVariablesBuilder current(int? t) {
   _current.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateBenefitsData(
  staffId: staffId,
  vendorBenefitPlanId: vendorBenefitPlanId,
)
.current(current)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateBenefitsDataData, updateBenefitsDataVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateBenefitsData(
  staffId: staffId,
  vendorBenefitPlanId: vendorBenefitPlanId,
);
updateBenefitsDataData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;
String vendorBenefitPlanId = ...;

final ref = ExampleConnector.instance.updateBenefitsData(
  staffId: staffId,
  vendorBenefitPlanId: vendorBenefitPlanId,
).ref();
ref.execute();
```


### deleteBenefitsData
#### Required Arguments
```dart
String staffId = ...;
String vendorBenefitPlanId = ...;
ExampleConnector.instance.deleteBenefitsData(
  staffId: staffId,
  vendorBenefitPlanId: vendorBenefitPlanId,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteBenefitsDataData, deleteBenefitsDataVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteBenefitsData(
  staffId: staffId,
  vendorBenefitPlanId: vendorBenefitPlanId,
);
deleteBenefitsDataData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String staffId = ...;
String vendorBenefitPlanId = ...;

final ref = ExampleConnector.instance.deleteBenefitsData(
  staffId: staffId,
  vendorBenefitPlanId: vendorBenefitPlanId,
).ref();
ref.execute();
```


### createRole
#### Required Arguments
```dart
String name = ...;
double costPerHour = ...;
String vendorId = ...;
String roleCategoryId = ...;
ExampleConnector.instance.createRole(
  name: name,
  costPerHour: costPerHour,
  vendorId: vendorId,
  roleCategoryId: roleCategoryId,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<createRoleData, createRoleVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createRole(
  name: name,
  costPerHour: costPerHour,
  vendorId: vendorId,
  roleCategoryId: roleCategoryId,
);
createRoleData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String name = ...;
double costPerHour = ...;
String vendorId = ...;
String roleCategoryId = ...;

final ref = ExampleConnector.instance.createRole(
  name: name,
  costPerHour: costPerHour,
  vendorId: vendorId,
  roleCategoryId: roleCategoryId,
).ref();
ref.execute();
```


### updateRole
#### Required Arguments
```dart
String id = ...;
String roleCategoryId = ...;
ExampleConnector.instance.updateRole(
  id: id,
  roleCategoryId: roleCategoryId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateRole, we created `updateRoleBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateRoleVariablesBuilder {
  ...
   UpdateRoleVariablesBuilder name(String? t) {
   _name.value = t;
   return this;
  }
  UpdateRoleVariablesBuilder costPerHour(double? t) {
   _costPerHour.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateRole(
  id: id,
  roleCategoryId: roleCategoryId,
)
.name(name)
.costPerHour(costPerHour)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateRoleData, updateRoleVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateRole(
  id: id,
  roleCategoryId: roleCategoryId,
);
updateRoleData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;
String roleCategoryId = ...;

final ref = ExampleConnector.instance.updateRole(
  id: id,
  roleCategoryId: roleCategoryId,
).ref();
ref.execute();
```


### deleteRole
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteRole(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteRoleData, deleteRoleVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteRole(
  id: id,
);
deleteRoleData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteRole(
  id: id,
).ref();
ref.execute();
```


### CreateAssignment
#### Required Arguments
```dart
String workforceId = ...;
String roleId = ...;
String shiftId = ...;
ExampleConnector.instance.createAssignment(
  workforceId: workforceId,
  roleId: roleId,
  shiftId: shiftId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For CreateAssignment, we created `CreateAssignmentBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateAssignmentVariablesBuilder {
  ...
   CreateAssignmentVariablesBuilder title(String? t) {
   _title.value = t;
   return this;
  }
  CreateAssignmentVariablesBuilder description(String? t) {
   _description.value = t;
   return this;
  }
  CreateAssignmentVariablesBuilder instructions(String? t) {
   _instructions.value = t;
   return this;
  }
  CreateAssignmentVariablesBuilder status(AssignmentStatus? t) {
   _status.value = t;
   return this;
  }
  CreateAssignmentVariablesBuilder tipsAvailable(bool? t) {
   _tipsAvailable.value = t;
   return this;
  }
  CreateAssignmentVariablesBuilder travelTime(bool? t) {
   _travelTime.value = t;
   return this;
  }
  CreateAssignmentVariablesBuilder mealProvided(bool? t) {
   _mealProvided.value = t;
   return this;
  }
  CreateAssignmentVariablesBuilder parkingAvailable(bool? t) {
   _parkingAvailable.value = t;
   return this;
  }
  CreateAssignmentVariablesBuilder gasCompensation(bool? t) {
   _gasCompensation.value = t;
   return this;
  }
  CreateAssignmentVariablesBuilder managers(List<AnyValue>? t) {
   _managers.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createAssignment(
  workforceId: workforceId,
  roleId: roleId,
  shiftId: shiftId,
)
.title(title)
.description(description)
.instructions(instructions)
.status(status)
.tipsAvailable(tipsAvailable)
.travelTime(travelTime)
.mealProvided(mealProvided)
.parkingAvailable(parkingAvailable)
.gasCompensation(gasCompensation)
.managers(managers)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<CreateAssignmentData, CreateAssignmentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createAssignment(
  workforceId: workforceId,
  roleId: roleId,
  shiftId: shiftId,
);
CreateAssignmentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String workforceId = ...;
String roleId = ...;
String shiftId = ...;

final ref = ExampleConnector.instance.createAssignment(
  workforceId: workforceId,
  roleId: roleId,
  shiftId: shiftId,
).ref();
ref.execute();
```


### UpdateAssignment
#### Required Arguments
```dart
String id = ...;
String roleId = ...;
String shiftId = ...;
ExampleConnector.instance.updateAssignment(
  id: id,
  roleId: roleId,
  shiftId: shiftId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For UpdateAssignment, we created `UpdateAssignmentBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateAssignmentVariablesBuilder {
  ...
   UpdateAssignmentVariablesBuilder title(String? t) {
   _title.value = t;
   return this;
  }
  UpdateAssignmentVariablesBuilder description(String? t) {
   _description.value = t;
   return this;
  }
  UpdateAssignmentVariablesBuilder instructions(String? t) {
   _instructions.value = t;
   return this;
  }
  UpdateAssignmentVariablesBuilder status(AssignmentStatus? t) {
   _status.value = t;
   return this;
  }
  UpdateAssignmentVariablesBuilder tipsAvailable(bool? t) {
   _tipsAvailable.value = t;
   return this;
  }
  UpdateAssignmentVariablesBuilder travelTime(bool? t) {
   _travelTime.value = t;
   return this;
  }
  UpdateAssignmentVariablesBuilder mealProvided(bool? t) {
   _mealProvided.value = t;
   return this;
  }
  UpdateAssignmentVariablesBuilder parkingAvailable(bool? t) {
   _parkingAvailable.value = t;
   return this;
  }
  UpdateAssignmentVariablesBuilder gasCompensation(bool? t) {
   _gasCompensation.value = t;
   return this;
  }
  UpdateAssignmentVariablesBuilder managers(List<AnyValue>? t) {
   _managers.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateAssignment(
  id: id,
  roleId: roleId,
  shiftId: shiftId,
)
.title(title)
.description(description)
.instructions(instructions)
.status(status)
.tipsAvailable(tipsAvailable)
.travelTime(travelTime)
.mealProvided(mealProvided)
.parkingAvailable(parkingAvailable)
.gasCompensation(gasCompensation)
.managers(managers)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<UpdateAssignmentData, UpdateAssignmentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateAssignment(
  id: id,
  roleId: roleId,
  shiftId: shiftId,
);
UpdateAssignmentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;
String roleId = ...;
String shiftId = ...;

final ref = ExampleConnector.instance.updateAssignment(
  id: id,
  roleId: roleId,
  shiftId: shiftId,
).ref();
ref.execute();
```


### DeleteAssignment
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteAssignment(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<DeleteAssignmentData, DeleteAssignmentVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteAssignment(
  id: id,
);
DeleteAssignmentData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteAssignment(
  id: id,
).ref();
ref.execute();
```


### createConversation
#### Required Arguments
```dart
// No required arguments
ExampleConnector.instance.createConversation().execute();
```

#### Optional Arguments
We return a builder for each query. For createConversation, we created `createConversationBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateConversationVariablesBuilder {
  ...
 
  CreateConversationVariablesBuilder subject(String? t) {
   _subject.value = t;
   return this;
  }
  CreateConversationVariablesBuilder status(ConversationStatus? t) {
   _status.value = t;
   return this;
  }
  CreateConversationVariablesBuilder conversationType(ConversationType? t) {
   _conversationType.value = t;
   return this;
  }
  CreateConversationVariablesBuilder isGroup(bool? t) {
   _isGroup.value = t;
   return this;
  }
  CreateConversationVariablesBuilder groupName(String? t) {
   _groupName.value = t;
   return this;
  }
  CreateConversationVariablesBuilder lastMessage(String? t) {
   _lastMessage.value = t;
   return this;
  }
  CreateConversationVariablesBuilder lastMessageAt(Timestamp? t) {
   _lastMessageAt.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createConversation()
.subject(subject)
.status(status)
.conversationType(conversationType)
.isGroup(isGroup)
.groupName(groupName)
.lastMessage(lastMessage)
.lastMessageAt(lastMessageAt)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createConversationData, createConversationVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createConversation();
createConversationData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
final ref = ExampleConnector.instance.createConversation().ref();
ref.execute();
```


### updateConversation
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateConversation(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateConversation, we created `updateConversationBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateConversationVariablesBuilder {
  ...
   UpdateConversationVariablesBuilder subject(String? t) {
   _subject.value = t;
   return this;
  }
  UpdateConversationVariablesBuilder status(ConversationStatus? t) {
   _status.value = t;
   return this;
  }
  UpdateConversationVariablesBuilder conversationType(ConversationType? t) {
   _conversationType.value = t;
   return this;
  }
  UpdateConversationVariablesBuilder isGroup(bool? t) {
   _isGroup.value = t;
   return this;
  }
  UpdateConversationVariablesBuilder groupName(String? t) {
   _groupName.value = t;
   return this;
  }
  UpdateConversationVariablesBuilder lastMessage(String? t) {
   _lastMessage.value = t;
   return this;
  }
  UpdateConversationVariablesBuilder lastMessageAt(Timestamp? t) {
   _lastMessageAt.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateConversation(
  id: id,
)
.subject(subject)
.status(status)
.conversationType(conversationType)
.isGroup(isGroup)
.groupName(groupName)
.lastMessage(lastMessage)
.lastMessageAt(lastMessageAt)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateConversationData, updateConversationVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateConversation(
  id: id,
);
updateConversationData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateConversation(
  id: id,
).ref();
ref.execute();
```


### updateConversationLastMessage
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateConversationLastMessage(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateConversationLastMessage, we created `updateConversationLastMessageBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateConversationLastMessageVariablesBuilder {
  ...
   UpdateConversationLastMessageVariablesBuilder lastMessage(String? t) {
   _lastMessage.value = t;
   return this;
  }
  UpdateConversationLastMessageVariablesBuilder lastMessageAt(Timestamp? t) {
   _lastMessageAt.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateConversationLastMessage(
  id: id,
)
.lastMessage(lastMessage)
.lastMessageAt(lastMessageAt)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateConversationLastMessageData, updateConversationLastMessageVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateConversationLastMessage(
  id: id,
);
updateConversationLastMessageData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateConversationLastMessage(
  id: id,
).ref();
ref.execute();
```


### deleteConversation
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteConversation(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteConversationData, deleteConversationVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteConversation(
  id: id,
);
deleteConversationData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteConversation(
  id: id,
).ref();
ref.execute();
```


### createShift
#### Required Arguments
```dart
String title = ...;
String orderId = ...;
ExampleConnector.instance.createShift(
  title: title,
  orderId: orderId,
).execute();
```

#### Optional Arguments
We return a builder for each query. For createShift, we created `createShiftBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class CreateShiftVariablesBuilder {
  ...
   CreateShiftVariablesBuilder date(Timestamp? t) {
   _date.value = t;
   return this;
  }
  CreateShiftVariablesBuilder startTime(Timestamp? t) {
   _startTime.value = t;
   return this;
  }
  CreateShiftVariablesBuilder endTime(Timestamp? t) {
   _endTime.value = t;
   return this;
  }
  CreateShiftVariablesBuilder hours(double? t) {
   _hours.value = t;
   return this;
  }
  CreateShiftVariablesBuilder cost(double? t) {
   _cost.value = t;
   return this;
  }
  CreateShiftVariablesBuilder location(String? t) {
   _location.value = t;
   return this;
  }
  CreateShiftVariablesBuilder locationAddress(String? t) {
   _locationAddress.value = t;
   return this;
  }
  CreateShiftVariablesBuilder latitude(double? t) {
   _latitude.value = t;
   return this;
  }
  CreateShiftVariablesBuilder longitude(double? t) {
   _longitude.value = t;
   return this;
  }
  CreateShiftVariablesBuilder description(String? t) {
   _description.value = t;
   return this;
  }
  CreateShiftVariablesBuilder status(ShiftStatus? t) {
   _status.value = t;
   return this;
  }
  CreateShiftVariablesBuilder workersNeeded(int? t) {
   _workersNeeded.value = t;
   return this;
  }
  CreateShiftVariablesBuilder filled(int? t) {
   _filled.value = t;
   return this;
  }
  CreateShiftVariablesBuilder filledAt(Timestamp? t) {
   _filledAt.value = t;
   return this;
  }
  CreateShiftVariablesBuilder managers(List<AnyValue>? t) {
   _managers.value = t;
   return this;
  }
  CreateShiftVariablesBuilder durationDays(int? t) {
   _durationDays.value = t;
   return this;
  }
  CreateShiftVariablesBuilder createdBy(String? t) {
   _createdBy.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.createShift(
  title: title,
  orderId: orderId,
)
.date(date)
.startTime(startTime)
.endTime(endTime)
.hours(hours)
.cost(cost)
.location(location)
.locationAddress(locationAddress)
.latitude(latitude)
.longitude(longitude)
.description(description)
.status(status)
.workersNeeded(workersNeeded)
.filled(filled)
.filledAt(filledAt)
.managers(managers)
.durationDays(durationDays)
.createdBy(createdBy)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<createShiftData, createShiftVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.createShift(
  title: title,
  orderId: orderId,
);
createShiftData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String title = ...;
String orderId = ...;

final ref = ExampleConnector.instance.createShift(
  title: title,
  orderId: orderId,
).ref();
ref.execute();
```


### updateShift
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.updateShift(
  id: id,
).execute();
```

#### Optional Arguments
We return a builder for each query. For updateShift, we created `updateShiftBuilder`. For queries and mutations with optional parameters, we return a builder class.
The builder pattern allows Data Connect to distinguish between fields that haven't been set and fields that have been set to null. A field can be set by calling its respective setter method like below:
```dart
class UpdateShiftVariablesBuilder {
  ...
   UpdateShiftVariablesBuilder title(String? t) {
   _title.value = t;
   return this;
  }
  UpdateShiftVariablesBuilder orderId(String? t) {
   _orderId.value = t;
   return this;
  }
  UpdateShiftVariablesBuilder date(Timestamp? t) {
   _date.value = t;
   return this;
  }
  UpdateShiftVariablesBuilder startTime(Timestamp? t) {
   _startTime.value = t;
   return this;
  }
  UpdateShiftVariablesBuilder endTime(Timestamp? t) {
   _endTime.value = t;
   return this;
  }
  UpdateShiftVariablesBuilder hours(double? t) {
   _hours.value = t;
   return this;
  }
  UpdateShiftVariablesBuilder cost(double? t) {
   _cost.value = t;
   return this;
  }
  UpdateShiftVariablesBuilder location(String? t) {
   _location.value = t;
   return this;
  }
  UpdateShiftVariablesBuilder locationAddress(String? t) {
   _locationAddress.value = t;
   return this;
  }
  UpdateShiftVariablesBuilder latitude(double? t) {
   _latitude.value = t;
   return this;
  }
  UpdateShiftVariablesBuilder longitude(double? t) {
   _longitude.value = t;
   return this;
  }
  UpdateShiftVariablesBuilder description(String? t) {
   _description.value = t;
   return this;
  }
  UpdateShiftVariablesBuilder status(ShiftStatus? t) {
   _status.value = t;
   return this;
  }
  UpdateShiftVariablesBuilder workersNeeded(int? t) {
   _workersNeeded.value = t;
   return this;
  }
  UpdateShiftVariablesBuilder filled(int? t) {
   _filled.value = t;
   return this;
  }
  UpdateShiftVariablesBuilder filledAt(Timestamp? t) {
   _filledAt.value = t;
   return this;
  }
  UpdateShiftVariablesBuilder managers(List<AnyValue>? t) {
   _managers.value = t;
   return this;
  }
  UpdateShiftVariablesBuilder durationDays(int? t) {
   _durationDays.value = t;
   return this;
  }

  ...
}
ExampleConnector.instance.updateShift(
  id: id,
)
.title(title)
.orderId(orderId)
.date(date)
.startTime(startTime)
.endTime(endTime)
.hours(hours)
.cost(cost)
.location(location)
.locationAddress(locationAddress)
.latitude(latitude)
.longitude(longitude)
.description(description)
.status(status)
.workersNeeded(workersNeeded)
.filled(filled)
.filledAt(filledAt)
.managers(managers)
.durationDays(durationDays)
.execute();
```

#### Return Type
`execute()` returns a `OperationResult<updateShiftData, updateShiftVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.updateShift(
  id: id,
);
updateShiftData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.updateShift(
  id: id,
).ref();
ref.execute();
```


### deleteShift
#### Required Arguments
```dart
String id = ...;
ExampleConnector.instance.deleteShift(
  id: id,
).execute();
```



#### Return Type
`execute()` returns a `OperationResult<deleteShiftData, deleteShiftVariables>`
```dart
/// Result of an Operation Request (query/mutation).
class OperationResult<Data, Variables> {
  OperationResult(this.dataConnect, this.data, this.ref);
  Data data;
  OperationRef<Data, Variables> ref;
  FirebaseDataConnect dataConnect;
}

final result = await ExampleConnector.instance.deleteShift(
  id: id,
);
deleteShiftData data = result.data;
final ref = result.ref;
```

#### Getting the Ref
Each builder returns an `execute` function, which is a helper function that creates a `Ref` object, and executes the underlying operation.
An example of how to use the `Ref` object is shown below:
```dart
String id = ...;

final ref = ExampleConnector.instance.deleteShift(
  id: id,
).ref();
ref.execute();
```

