@codiac.io/codiac-cli 1.2.261 → 1.2.262

package/dist/apis/codiac-api/gen/client.d.ts

@@ -1,6 +1,6 @@
 import { IRepoOptions, IBetterLogger } from "@codiac.io/codiac-common";
 import { Result, ListResult, BatchResult, SingleResult, PatchSpecForOne, PatchSpecForMany, IdSpecFor } from "@codiac.io/codiac-common/contracts";
-import { UpdatePartialWhereRequest } from "./contracts";
+import { PartialWithId, UpdatePartialWhereRequest } from "./contracts";
 import { ApiClientBase } from "../common/api-client-base";
 import { ApiUserCreds } from "../common/api-user-creds";
 import { CodiacClientConfig } from "./client-config";
@@ -28,106 +28,106 @@ export declare class CodiacClient extends ApiClientBase {
     Auth: AuthOperations;
     Call: OtherOperations;
     ActivityBase: ActivityBaseCruds;
-    CabinetCreateActivity: CabinetCreateActivityCruds;
-    ConfigDeploymentActivity: ConfigDeploymentActivityCruds;
-    DeploymentActivity: DeploymentActivityCruds;
-    VersionCreateActivity: VersionCreateActivityCruds;
-    AssetVersionConfig: AssetVersionConfigCruds;
     Asset: AssetCruds;
-    EntityAcl: EntityAclCruds;
+    AssetVersionConfig: AssetVersionConfigCruds;
     AuthRole: AuthRoleCruds;
-    CodiacUser: CodiacUserCruds;
-    BuildPipeline: BuildPipelineCruds;
     Build: BuildCruds;
+    BuildPipeline: BuildPipelineCruds;
     Cabinet: CabinetCruds;
+    CabinetCreateActivity: CabinetCreateActivityCruds;
+    Cluster: ClusterCruds;
     ClusterDef: ClusterDefCruds;
     ClusterGrant: ClusterGrantCruds;
-    Cluster: ClusterCruds;
+    CodiacTenant: CodiacTenantCruds;
+    CodiacUser: CodiacUserCruds;
     Comment: CommentCruds;
     ConfigChange: ConfigChangeCruds;
+    ConfigDeploymentActivity: ConfigDeploymentActivityCruds;
     ContainerFootprint: ContainerFootprintCruds;
     CspTenantProfile: CspTenantProfileCruds;
     DeployAttempt: DeployAttemptCruds;
     DeployPipeline: DeployPipelineCruds;
     Deployment: DeploymentCruds;
+    DeploymentActivity: DeploymentActivityCruds;
+    Enterprise: EnterpriseCruds;
     EnterpriseRunState: EnterpriseRunStateCruds;
     EnterpriseVersionConfig: EnterpriseVersionConfigCruds;
-    Enterprise: EnterpriseCruds;
+    EntityAcl: EntityAclCruds;
     Environment: EnvironmentCruds;
     FileStoreDef: FileStoreDefCruds;
-    ScopedHostNameConfig: ScopedHostNameConfigCruds;
-    ImageRegistry: ImageRegistryCruds;
     Image: ImageCruds;
-    SetupJournal: SetupJournalCruds;
+    ImageRegistry: ImageRegistryCruds;
     Kit: KitCruds;
     KvpStoreDef: KvpStoreDefCruds;
     Label: LabelCruds;
     NodePoolDef: NodePoolDefCruds;
     Probe: ProbeCruds;
-    ProductVersionConfig: ProductVersionConfigCruds;
     Product: ProductCruds;
+    ProductVersionConfig: ProductVersionConfigCruds;
+    ScopedHostNameConfig: ScopedHostNameConfigCruds;
     ScopedSetting: ScopedSettingCruds;
+    SetupJournal: SetupJournalCruds;
     Snapshot: SnapshotCruds;
     SourceRepo: SourceRepoCruds;
     Subscription: SubscriptionCruds;
     Tag: TagCruds;
-    CodiacTenant: CodiacTenantCruds;
     VersionConfig: VersionConfigCruds;
+    VersionCreateActivity: VersionCreateActivityCruds;
     WorkFlowStrategy: WorkFlowStrategyCruds;
     ZombiePeriod: ZombiePeriodCruds;
 }
-import { EntityAcl, EntityAclCriteria, TenantSubscriptionCancel, AuthTenant, AuthenticationRequest, TenantUser, MyTenantRequest, ChangePasswordRequest, ResetPasswordRequest, RefreshTokenRequest, AuthRole, AuthRoleCriteria, RoleAssignmentRequest, TenantSubscriptionUpdate, SwitchTenantRequest, TenantRegistrationRequest, CodiacUserCriteria, CodiacUser, CodiacUserPatch, AddTenantUserRequest, WhoAmIRequest, TenantStatusChange, SubscriptionStatus, PartialWithId } from "../contracts";
+import { AddTenantUserRequest, AuthRole, AuthRoleCriteria, AuthTenant, AuthenticationRequest, ChangePasswordRequest, CodiacUser, CodiacUserCriteria, CodiacUserPatch, EntityAcl, EntityAclCriteria, MyTenantRequest, RefreshTokenRequest, ResetPasswordRequest, RoleAssignmentRequest, SubscriptionStatus, SwitchTenantRequest, TenantRegistrationRequest, TenantStatusChange, TenantSubscriptionCancel, TenantSubscriptionUpdate, TenantUser, WhoAmIRequest } from "../contracts";
 declare class AuthOperations {
     private core;
     protected logger: IBetterLogger;
     constructor(core: ApiClientBase, logger: IBetterLogger);
+    RoleCreate(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    RoleCreateMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    RoleDelete(request: IdSpecFor<AuthRole>, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    RoleDeleteWhere(request: AuthRoleCriteria, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    RoleGet(request: IdSpecFor<AuthRole>, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    RoleList(request: AuthRoleCriteria, options?: IRepoOptions): Promise<ListResult<AuthRole>>;
+    RolePatch(request: PatchSpecForOne<AuthRole>, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    RolePatchWhere(request: PatchSpecForMany<AuthRole, AuthRoleCriteria>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    RoleUpdate(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    RoleUpdateMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    RoleUpdatePartial(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<PartialWithId<AuthRole>>>;
+    RoleUpdatePartialMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<AuthRole>>>;
+    RoleUpdatePartialWhere(request: UpdatePartialWhereRequest<AuthRole, AuthRoleCriteria>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    RoleUpsert(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    RoleUpsertMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    CodiacUserGet(request: IdSpecFor<CodiacUser>, options?: IRepoOptions): Promise<SingleResult<CodiacUser>>;
+    CodiacUserList(request: CodiacUserCriteria, options?: IRepoOptions): Promise<ListResult<CodiacUser>>;
+    EntityAclCreate(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
     EntityAclCreateMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
-    EntityAclList(request: EntityAclCriteria, options?: IRepoOptions): Promise<ListResult<EntityAcl>>;
-    EntityAclUpdateMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
-    EntityAclPatchWhere(request: PatchSpecForMany<EntityAcl, EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
+    EntityAclDelete(request: IdSpecFor<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
     EntityAclDeleteWhere(request: EntityAclCriteria, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
     EntityAclGet(request: IdSpecFor<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
-    EntityAclUpdate(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    EntityAclList(request: EntityAclCriteria, options?: IRepoOptions): Promise<ListResult<EntityAcl>>;
     EntityAclPatch(request: PatchSpecForOne<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
-    EntityAclDelete(request: IdSpecFor<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    EntityAclPatchWhere(request: PatchSpecForMany<EntityAcl, EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
+    EntityAclUpdate(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    EntityAclUpdateMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
     EntityAclUpdatePartial(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<PartialWithId<EntityAcl>>>;
-    EntityAclCreate(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
-    EntityAclUpdatePartialWhere(request: UpdatePartialWhereRequest<EntityAcl, EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
     EntityAclUpdatePartialMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<EntityAcl>>>;
-    EntityAclUpsertMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
+    EntityAclUpdatePartialWhere(request: UpdatePartialWhereRequest<EntityAcl, EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
     EntityAclUpsert(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
-    SubscriptionCancel(request: TenantSubscriptionCancel, options?: IRepoOptions): Promise<SingleResult<AuthTenant>>;
+    EntityAclUpsertMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
+    AddTenantUser(request: AddTenantUserRequest, options?: IRepoOptions): Promise<SingleResult<TenantUser>>;
+    ChangePassword(request: ChangePasswordRequest, options?: IRepoOptions): Promise<SingleResult<TenantUser>>;
+    ExpelUser(request: IdSpecFor<TenantUser>, options?: IRepoOptions): Promise<SingleResult<TenantUser>>;
     Login(request: AuthenticationRequest, options?: IRepoOptions): Promise<SingleResult<TenantUser>>;
     MyTenant(request: MyTenantRequest, options?: IRepoOptions): Promise<Result>;
-    ChangePassword(request: ChangePasswordRequest, options?: IRepoOptions): Promise<SingleResult<TenantUser>>;
+    PatchUser(request: CodiacUserPatch, options?: IRepoOptions): Promise<SingleResult<CodiacUser>>;
     ResetPassword(request: ResetPasswordRequest, options?: IRepoOptions): Promise<SingleResult<TenantUser>>;
-    TokenRefresh(request: RefreshTokenRequest, options?: IRepoOptions): Promise<SingleResult<TenantUser>>;
-    RoleCreateMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
-    RoleList(request: AuthRoleCriteria, options?: IRepoOptions): Promise<ListResult<AuthRole>>;
-    RoleUpdateMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
-    RolePatchWhere(request: PatchSpecForMany<AuthRole, AuthRoleCriteria>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
-    RoleDeleteWhere(request: AuthRoleCriteria, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
-    RoleGet(request: IdSpecFor<AuthRole>, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
-    RoleUpdate(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
-    RolePatch(request: PatchSpecForOne<AuthRole>, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
-    RoleDelete(request: IdSpecFor<AuthRole>, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
-    RoleUpdatePartial(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<PartialWithId<AuthRole>>>;
     RoleAssignment(request: RoleAssignmentRequest, options?: IRepoOptions): Promise<SingleResult<TenantUser>>;
-    RoleCreate(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
-    RoleUpdatePartialWhere(request: UpdatePartialWhereRequest<AuthRole, AuthRoleCriteria>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
-    RoleUpdatePartialMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<AuthRole>>>;
-    RoleUpsertMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
-    RoleUpsert(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    SetTenantStatus(request: TenantStatusChange, options?: IRepoOptions): Promise<SingleResult<SubscriptionStatus>>;
+    SubscriptionCancel(request: TenantSubscriptionCancel, options?: IRepoOptions): Promise<SingleResult<AuthTenant>>;
     SubscriptionUpdate(request: TenantSubscriptionUpdate, options?: IRepoOptions): Promise<SingleResult<AuthTenant>>;
     SwitchTenant(request: SwitchTenantRequest, options?: IRepoOptions): Promise<SingleResult<TenantUser>>;
     TenantRegistration(request: TenantRegistrationRequest, options?: IRepoOptions): Promise<SingleResult<AuthTenant>>;
-    CodiacUserList(request: CodiacUserCriteria, options?: IRepoOptions): Promise<ListResult<CodiacUser>>;
-    ExpelUser(request: IdSpecFor<TenantUser>, options?: IRepoOptions): Promise<SingleResult<TenantUser>>;
-    PatchUser(request: CodiacUserPatch, options?: IRepoOptions): Promise<SingleResult<CodiacUser>>;
-    CodiacUserGet(request: IdSpecFor<CodiacUser>, options?: IRepoOptions): Promise<SingleResult<CodiacUser>>;
-    AddTenantUser(request: AddTenantUserRequest, options?: IRepoOptions): Promise<SingleResult<TenantUser>>;
+    TokenRefresh(request: RefreshTokenRequest, options?: IRepoOptions): Promise<SingleResult<TenantUser>>;
     WhoAmI(request: WhoAmIRequest, options?: IRepoOptions): Promise<Result>;
-    SetTenantStatus(request: TenantStatusChange, options?: IRepoOptions): Promise<SingleResult<SubscriptionStatus>>;
     /** Determines whether the given token is expired.
      * @param throwOnError throws any encountered errors, including token parsing errors.
      */
@@ -138,2386 +138,2390 @@ import { ActivityBase, ActivityCriteriaBase } from "../contracts";
 declare class ActivityBaseCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new ActivityBase. */
-    tryCreateMany(request: Array<ActivityBase>, options?: IRepoOptions): Promise<BatchResult<ActivityBase>>;
-    createMany(request: Array<ActivityBase>, options?: IThrowingRepoOptions): Promise<ActivityBase[]>;
+    /** Deletes each existing ActivityBase that satisfies the given criteria. */
+    tryDeleteWhere(request: ActivityCriteriaBase, options?: IRepoOptions): Promise<BatchResult<ActivityBase>>;
+    deleteWhere(request: ActivityCriteriaBase, options?: IThrowingRepoOptions): Promise<ActivityBase[]>;
     /** Retrieves all the existing ActivityBase that satisfy the given criteria. */
     tryReadMany(request: ActivityCriteriaBase, options?: IRepoOptions): Promise<ListResult<ActivityBase>>;
     readMany(request: ActivityCriteriaBase, options?: IThrowingRepoOptions): Promise<ActivityBase[]>;
-    /** Overwrites each existing ActivityBase. */
-    tryUpdateMany(request: Array<ActivityBase>, options?: IRepoOptions): Promise<BatchResult<ActivityBase>>;
-    updateMany(request: Array<ActivityBase>, options?: IThrowingRepoOptions): Promise<ActivityBase[]>;
     /** Performs the given operations on each existing ActivityBase that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<ActivityBase, ActivityCriteriaBase>, options?: IRepoOptions): Promise<BatchResult<ActivityBase>>;
     patchWhere(request: PatchSpecForMany<ActivityBase, ActivityCriteriaBase>, options?: IThrowingRepoOptions): Promise<ActivityBase[]>;
-    /** Deletes each existing ActivityBase that satisfies the given criteria. */
-    tryDeleteWhere(request: ActivityCriteriaBase, options?: IRepoOptions): Promise<BatchResult<ActivityBase>>;
-    deleteWhere(request: ActivityCriteriaBase, options?: IThrowingRepoOptions): Promise<ActivityBase[]>;
+    /** Saves each given input as a new ActivityBase. */
+    tryCreateMany(request: Array<ActivityBase>, options?: IRepoOptions): Promise<BatchResult<ActivityBase>>;
+    createMany(request: Array<ActivityBase>, options?: IThrowingRepoOptions): Promise<ActivityBase[]>;
+    /** Overwrites each existing ActivityBase. */
+    tryUpdateMany(request: Array<ActivityBase>, options?: IRepoOptions): Promise<BatchResult<ActivityBase>>;
+    updateMany(request: Array<ActivityBase>, options?: IThrowingRepoOptions): Promise<ActivityBase[]>;
+    /** Deletes the existing ActivityBase. */
+    tryDelete(request: IdSpecFor<ActivityBase>, options?: IRepoOptions): Promise<SingleResult<ActivityBase>>;
+    delete(request: IdSpecFor<ActivityBase>, options?: IThrowingRepoOptions): Promise<ActivityBase>;
     /** Retrieves the single, uniquely identified ActivityBase. */
     tryRead(request: IdSpecFor<ActivityBase>, options?: IRepoOptions): Promise<SingleResult<ActivityBase>>;
     read(request: IdSpecFor<ActivityBase>, options?: IThrowingRepoOptions): Promise<ActivityBase>;
-    /** Overwrites the existing ActivityBase. */
-    tryUpdate(request: ActivityBase, options?: IRepoOptions): Promise<SingleResult<ActivityBase>>;
-    update(request: ActivityBase, options?: IThrowingRepoOptions): Promise<ActivityBase>;
     /** Performs the given operations on the existing ActivityBase. */
     tryPatch(request: PatchSpecForOne<ActivityBase>, options?: IRepoOptions): Promise<SingleResult<ActivityBase>>;
     patch(request: PatchSpecForOne<ActivityBase>, options?: IThrowingRepoOptions): Promise<ActivityBase>;
-    /** Deletes the existing ActivityBase. */
-    tryDelete(request: IdSpecFor<ActivityBase>, options?: IRepoOptions): Promise<SingleResult<ActivityBase>>;
-    delete(request: IdSpecFor<ActivityBase>, options?: IThrowingRepoOptions): Promise<ActivityBase>;
+    /** Overwrites the existing ActivityBase. */
+    tryUpdate(request: ActivityBase, options?: IRepoOptions): Promise<SingleResult<ActivityBase>>;
+    update(request: ActivityBase, options?: IThrowingRepoOptions): Promise<ActivityBase>;
     /** Overwrites the given properties of the existing ActivityBase. */
     tryUpdatePartial(request: ActivityBase, options?: IRepoOptions): Promise<SingleResult<PartialWithId<ActivityBase>>>;
     updatePartial(request: ActivityBase, options?: IThrowingRepoOptions): Promise<PartialWithId<ActivityBase>>;
     /** Saves the input as a new ActivityBase. */
     tryCreate(request: ActivityBase, options?: IRepoOptions): Promise<SingleResult<ActivityBase>>;
     create(request: ActivityBase, options?: IThrowingRepoOptions): Promise<ActivityBase>;
-    /** Performs the given operation on each existing ActivityBase that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ActivityBase, ActivityCriteriaBase>, options?: IRepoOptions): Promise<BatchResult<ActivityBase>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<ActivityBase, ActivityCriteriaBase>, options?: IThrowingRepoOptions): Promise<ActivityBase[]>;
     /** Overwrites the given properties for each existing ActivityBase. */
     tryUpdatePartialMany(request: Array<ActivityBase>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<ActivityBase>>>;
     updatePartialMany(request: Array<ActivityBase>, options?: IThrowingRepoOptions): Promise<PartialWithId<ActivityBase>[]>;
-    /** Saves each given input as a new ActivityBase, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<ActivityBase>, options?: IRepoOptions): Promise<BatchResult<ActivityBase>>;
-    upsertMany(request: Array<ActivityBase>, options?: IThrowingRepoOptions): Promise<ActivityBase[]>;
+    /** Performs the given operation on each existing ActivityBase that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ActivityBase, ActivityCriteriaBase>, options?: IRepoOptions): Promise<BatchResult<ActivityBase>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<ActivityBase, ActivityCriteriaBase>, options?: IThrowingRepoOptions): Promise<ActivityBase[]>;
     /** Saves the input as a new ActivityBase, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: ActivityBase, options?: IRepoOptions): Promise<SingleResult<ActivityBase>>;
     upsert(request: ActivityBase, options?: IThrowingRepoOptions): Promise<ActivityBase>;
+    /** Saves each given input as a new ActivityBase, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<ActivityBase>, options?: IRepoOptions): Promise<BatchResult<ActivityBase>>;
+    upsertMany(request: Array<ActivityBase>, options?: IThrowingRepoOptions): Promise<ActivityBase[]>;
 }
-import { CabinetCreateActivity, CabinetCreateActivityCriteria } from "../contracts";
-declare class CabinetCreateActivityCruds {
+import { Asset, AssetCriteria } from "../contracts";
+declare class AssetCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new CabinetCreateActivity. */
-    tryCreateMany(request: Array<CabinetCreateActivity>, options?: IRepoOptions): Promise<BatchResult<CabinetCreateActivity>>;
-    createMany(request: Array<CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity[]>;
-    /** Retrieves all the existing CabinetCreateActivity that satisfy the given criteria. */
-    tryReadMany(request: CabinetCreateActivityCriteria, options?: IRepoOptions): Promise<ListResult<CabinetCreateActivity>>;
-    readMany(request: CabinetCreateActivityCriteria, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity[]>;
-    /** Overwrites each existing CabinetCreateActivity. */
-    tryUpdateMany(request: Array<CabinetCreateActivity>, options?: IRepoOptions): Promise<BatchResult<CabinetCreateActivity>>;
-    updateMany(request: Array<CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity[]>;
-    /** Performs the given operations on each existing CabinetCreateActivity that satisfies the given criteria. */
-    tryPatchWhere(request: PatchSpecForMany<CabinetCreateActivity, CabinetCreateActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<CabinetCreateActivity>>;
-    patchWhere(request: PatchSpecForMany<CabinetCreateActivity, CabinetCreateActivityCriteria>, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity[]>;
-    /** Deletes each existing CabinetCreateActivity that satisfies the given criteria. */
-    tryDeleteWhere(request: CabinetCreateActivityCriteria, options?: IRepoOptions): Promise<BatchResult<CabinetCreateActivity>>;
-    deleteWhere(request: CabinetCreateActivityCriteria, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity[]>;
-    /** Retrieves the single, uniquely identified CabinetCreateActivity. */
-    tryRead(request: IdSpecFor<CabinetCreateActivity>, options?: IRepoOptions): Promise<SingleResult<CabinetCreateActivity>>;
-    read(request: IdSpecFor<CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity>;
-    /** Overwrites the existing CabinetCreateActivity. */
-    tryUpdate(request: CabinetCreateActivity, options?: IRepoOptions): Promise<SingleResult<CabinetCreateActivity>>;
-    update(request: CabinetCreateActivity, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity>;
-    /** Performs the given operations on the existing CabinetCreateActivity. */
-    tryPatch(request: PatchSpecForOne<CabinetCreateActivity>, options?: IRepoOptions): Promise<SingleResult<CabinetCreateActivity>>;
-    patch(request: PatchSpecForOne<CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity>;
-    /** Deletes the existing CabinetCreateActivity. */
-    tryDelete(request: IdSpecFor<CabinetCreateActivity>, options?: IRepoOptions): Promise<SingleResult<CabinetCreateActivity>>;
-    delete(request: IdSpecFor<CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity>;
-    /** Overwrites the given properties of the existing CabinetCreateActivity. */
-    tryUpdatePartial(request: CabinetCreateActivity, options?: IRepoOptions): Promise<SingleResult<PartialWithId<CabinetCreateActivity>>>;
-    updatePartial(request: CabinetCreateActivity, options?: IThrowingRepoOptions): Promise<PartialWithId<CabinetCreateActivity>>;
-    /** Saves the input as a new CabinetCreateActivity. */
-    tryCreate(request: CabinetCreateActivity, options?: IRepoOptions): Promise<SingleResult<CabinetCreateActivity>>;
-    create(request: CabinetCreateActivity, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity>;
-    /** Performs the given operation on each existing CabinetCreateActivity that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<CabinetCreateActivity, CabinetCreateActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<CabinetCreateActivity>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<CabinetCreateActivity, CabinetCreateActivityCriteria>, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity[]>;
-    /** Overwrites the given properties for each existing CabinetCreateActivity. */
-    tryUpdatePartialMany(request: Array<CabinetCreateActivity>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<CabinetCreateActivity>>>;
-    updatePartialMany(request: Array<CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<PartialWithId<CabinetCreateActivity>[]>;
-    /** Saves each given input as a new CabinetCreateActivity, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<CabinetCreateActivity>, options?: IRepoOptions): Promise<BatchResult<CabinetCreateActivity>>;
-    upsertMany(request: Array<CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity[]>;
-    /** Saves the input as a new CabinetCreateActivity, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsert(request: CabinetCreateActivity, options?: IRepoOptions): Promise<SingleResult<CabinetCreateActivity>>;
-    upsert(request: CabinetCreateActivity, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity>;
+    /** Deletes each existing Asset that satisfies the given criteria. */
+    tryDeleteWhere(request: AssetCriteria, options?: IRepoOptions): Promise<BatchResult<Asset>>;
+    deleteWhere(request: AssetCriteria, options?: IThrowingRepoOptions): Promise<Asset[]>;
+    /** Retrieves all the existing Asset that satisfy the given criteria. */
+    tryReadMany(request: AssetCriteria, options?: IRepoOptions): Promise<ListResult<Asset>>;
+    readMany(request: AssetCriteria, options?: IThrowingRepoOptions): Promise<Asset[]>;
+    /** Performs the given operations on each existing Asset that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Asset, AssetCriteria>, options?: IRepoOptions): Promise<BatchResult<Asset>>;
+    patchWhere(request: PatchSpecForMany<Asset, AssetCriteria>, options?: IThrowingRepoOptions): Promise<Asset[]>;
+    /** Saves each given input as a new Asset. */
+    tryCreateMany(request: Array<Asset>, options?: IRepoOptions): Promise<BatchResult<Asset>>;
+    createMany(request: Array<Asset>, options?: IThrowingRepoOptions): Promise<Asset[]>;
+    /** Overwrites each existing Asset. */
+    tryUpdateMany(request: Array<Asset>, options?: IRepoOptions): Promise<BatchResult<Asset>>;
+    updateMany(request: Array<Asset>, options?: IThrowingRepoOptions): Promise<Asset[]>;
+    /** Deletes the existing Asset. */
+    tryDelete(request: IdSpecFor<Asset>, options?: IRepoOptions): Promise<SingleResult<Asset>>;
+    delete(request: IdSpecFor<Asset>, options?: IThrowingRepoOptions): Promise<Asset>;
+    /** Retrieves the single, uniquely identified Asset. */
+    tryRead(request: IdSpecFor<Asset>, options?: IRepoOptions): Promise<SingleResult<Asset>>;
+    read(request: IdSpecFor<Asset>, options?: IThrowingRepoOptions): Promise<Asset>;
+    /** Performs the given operations on the existing Asset. */
+    tryPatch(request: PatchSpecForOne<Asset>, options?: IRepoOptions): Promise<SingleResult<Asset>>;
+    patch(request: PatchSpecForOne<Asset>, options?: IThrowingRepoOptions): Promise<Asset>;
+    /** Overwrites the existing Asset. */
+    tryUpdate(request: Asset, options?: IRepoOptions): Promise<SingleResult<Asset>>;
+    update(request: Asset, options?: IThrowingRepoOptions): Promise<Asset>;
+    /** Overwrites the given properties of the existing Asset. */
+    tryUpdatePartial(request: Asset, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Asset>>>;
+    updatePartial(request: Asset, options?: IThrowingRepoOptions): Promise<PartialWithId<Asset>>;
+    /** Saves the input as a new Asset. */
+    tryCreate(request: Asset, options?: IRepoOptions): Promise<SingleResult<Asset>>;
+    create(request: Asset, options?: IThrowingRepoOptions): Promise<Asset>;
+    /** Overwrites the given properties for each existing Asset. */
+    tryUpdatePartialMany(request: Array<Asset>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Asset>>>;
+    updatePartialMany(request: Array<Asset>, options?: IThrowingRepoOptions): Promise<PartialWithId<Asset>[]>;
+    /** Performs the given operation on each existing Asset that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Asset, AssetCriteria>, options?: IRepoOptions): Promise<BatchResult<Asset>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Asset, AssetCriteria>, options?: IThrowingRepoOptions): Promise<Asset[]>;
+    /** Saves the input as a new Asset, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Asset, options?: IRepoOptions): Promise<SingleResult<Asset>>;
+    upsert(request: Asset, options?: IThrowingRepoOptions): Promise<Asset>;
+    /** Saves each given input as a new Asset, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Asset>, options?: IRepoOptions): Promise<BatchResult<Asset>>;
+    upsertMany(request: Array<Asset>, options?: IThrowingRepoOptions): Promise<Asset[]>;
 }
-import { ConfigDeploymentActivity, ConfigDeploymentActivityCriteria } from "../contracts";
-declare class ConfigDeploymentActivityCruds {
+import { AssetVersionConfig, AssetVersionConfigCriteria } from "../contracts";
+declare class AssetVersionConfigCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new ConfigDeploymentActivity. */
-    tryCreateMany(request: Array<ConfigDeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<ConfigDeploymentActivity>>;
-    createMany(request: Array<ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity[]>;
-    /** Retrieves all the existing ConfigDeploymentActivity that satisfy the given criteria. */
-    tryReadMany(request: ConfigDeploymentActivityCriteria, options?: IRepoOptions): Promise<ListResult<ConfigDeploymentActivity>>;
-    readMany(request: ConfigDeploymentActivityCriteria, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity[]>;
-    /** Overwrites each existing ConfigDeploymentActivity. */
-    tryUpdateMany(request: Array<ConfigDeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<ConfigDeploymentActivity>>;
-    updateMany(request: Array<ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity[]>;
-    /** Performs the given operations on each existing ConfigDeploymentActivity that satisfies the given criteria. */
-    tryPatchWhere(request: PatchSpecForMany<ConfigDeploymentActivity, ConfigDeploymentActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<ConfigDeploymentActivity>>;
-    patchWhere(request: PatchSpecForMany<ConfigDeploymentActivity, ConfigDeploymentActivityCriteria>, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity[]>;
-    /** Deletes each existing ConfigDeploymentActivity that satisfies the given criteria. */
-    tryDeleteWhere(request: ConfigDeploymentActivityCriteria, options?: IRepoOptions): Promise<BatchResult<ConfigDeploymentActivity>>;
-    deleteWhere(request: ConfigDeploymentActivityCriteria, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity[]>;
-    /** Retrieves the single, uniquely identified ConfigDeploymentActivity. */
-    tryRead(request: IdSpecFor<ConfigDeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<ConfigDeploymentActivity>>;
-    read(request: IdSpecFor<ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity>;
-    /** Overwrites the existing ConfigDeploymentActivity. */
-    tryUpdate(request: ConfigDeploymentActivity, options?: IRepoOptions): Promise<SingleResult<ConfigDeploymentActivity>>;
-    update(request: ConfigDeploymentActivity, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity>;
-    /** Performs the given operations on the existing ConfigDeploymentActivity. */
-    tryPatch(request: PatchSpecForOne<ConfigDeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<ConfigDeploymentActivity>>;
-    patch(request: PatchSpecForOne<ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity>;
-    /** Deletes the existing ConfigDeploymentActivity. */
-    tryDelete(request: IdSpecFor<ConfigDeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<ConfigDeploymentActivity>>;
-    delete(request: IdSpecFor<ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity>;
-    /** Overwrites the given properties of the existing ConfigDeploymentActivity. */
-    tryUpdatePartial(request: ConfigDeploymentActivity, options?: IRepoOptions): Promise<SingleResult<PartialWithId<ConfigDeploymentActivity>>>;
-    updatePartial(request: ConfigDeploymentActivity, options?: IThrowingRepoOptions): Promise<PartialWithId<ConfigDeploymentActivity>>;
-    /** Saves the input as a new ConfigDeploymentActivity. */
-    tryCreate(request: ConfigDeploymentActivity, options?: IRepoOptions): Promise<SingleResult<ConfigDeploymentActivity>>;
-    create(request: ConfigDeploymentActivity, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity>;
-    /** Performs the given operation on each existing ConfigDeploymentActivity that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ConfigDeploymentActivity, ConfigDeploymentActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<ConfigDeploymentActivity>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<ConfigDeploymentActivity, ConfigDeploymentActivityCriteria>, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity[]>;
-    /** Overwrites the given properties for each existing ConfigDeploymentActivity. */
-    tryUpdatePartialMany(request: Array<ConfigDeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<ConfigDeploymentActivity>>>;
-    updatePartialMany(request: Array<ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<PartialWithId<ConfigDeploymentActivity>[]>;
-    /** Saves each given input as a new ConfigDeploymentActivity, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<ConfigDeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<ConfigDeploymentActivity>>;
-    upsertMany(request: Array<ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity[]>;
-    /** Saves the input as a new ConfigDeploymentActivity, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsert(request: ConfigDeploymentActivity, options?: IRepoOptions): Promise<SingleResult<ConfigDeploymentActivity>>;
-    upsert(request: ConfigDeploymentActivity, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity>;
-}
-import { DeploymentActivity, DeploymentActivityCriteria } from "../contracts";
-declare class DeploymentActivityCruds {
-    private core;
-    constructor(core: ApiClientBase);
-    /** Saves each given input as a new DeploymentActivity. */
-    tryCreateMany(request: Array<DeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<DeploymentActivity>>;
-    createMany(request: Array<DeploymentActivity>, options?: IThrowingRepoOptions): Promise<DeploymentActivity[]>;
-    /** Retrieves all the existing DeploymentActivity that satisfy the given criteria. */
-    tryReadMany(request: DeploymentActivityCriteria, options?: IRepoOptions): Promise<ListResult<DeploymentActivity>>;
-    readMany(request: DeploymentActivityCriteria, options?: IThrowingRepoOptions): Promise<DeploymentActivity[]>;
-    /** Overwrites each existing DeploymentActivity. */
-    tryUpdateMany(request: Array<DeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<DeploymentActivity>>;
-    updateMany(request: Array<DeploymentActivity>, options?: IThrowingRepoOptions): Promise<DeploymentActivity[]>;
-    /** Performs the given operations on each existing DeploymentActivity that satisfies the given criteria. */
-    tryPatchWhere(request: PatchSpecForMany<DeploymentActivity, DeploymentActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<DeploymentActivity>>;
-    patchWhere(request: PatchSpecForMany<DeploymentActivity, DeploymentActivityCriteria>, options?: IThrowingRepoOptions): Promise<DeploymentActivity[]>;
-    /** Deletes each existing DeploymentActivity that satisfies the given criteria. */
-    tryDeleteWhere(request: DeploymentActivityCriteria, options?: IRepoOptions): Promise<BatchResult<DeploymentActivity>>;
-    deleteWhere(request: DeploymentActivityCriteria, options?: IThrowingRepoOptions): Promise<DeploymentActivity[]>;
-    /** Retrieves the single, uniquely identified DeploymentActivity. */
-    tryRead(request: IdSpecFor<DeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<DeploymentActivity>>;
-    read(request: IdSpecFor<DeploymentActivity>, options?: IThrowingRepoOptions): Promise<DeploymentActivity>;
-    /** Overwrites the existing DeploymentActivity. */
-    tryUpdate(request: DeploymentActivity, options?: IRepoOptions): Promise<SingleResult<DeploymentActivity>>;
-    update(request: DeploymentActivity, options?: IThrowingRepoOptions): Promise<DeploymentActivity>;
-    /** Performs the given operations on the existing DeploymentActivity. */
-    tryPatch(request: PatchSpecForOne<DeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<DeploymentActivity>>;
-    patch(request: PatchSpecForOne<DeploymentActivity>, options?: IThrowingRepoOptions): Promise<DeploymentActivity>;
-    /** Deletes the existing DeploymentActivity. */
-    tryDelete(request: IdSpecFor<DeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<DeploymentActivity>>;
-    delete(request: IdSpecFor<DeploymentActivity>, options?: IThrowingRepoOptions): Promise<DeploymentActivity>;
-    /** Overwrites the given properties of the existing DeploymentActivity. */
-    tryUpdatePartial(request: DeploymentActivity, options?: IRepoOptions): Promise<SingleResult<PartialWithId<DeploymentActivity>>>;
-    updatePartial(request: DeploymentActivity, options?: IThrowingRepoOptions): Promise<PartialWithId<DeploymentActivity>>;
-    /** Saves the input as a new DeploymentActivity. */
-    tryCreate(request: DeploymentActivity, options?: IRepoOptions): Promise<SingleResult<DeploymentActivity>>;
-    create(request: DeploymentActivity, options?: IThrowingRepoOptions): Promise<DeploymentActivity>;
-    /** Performs the given operation on each existing DeploymentActivity that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<DeploymentActivity, DeploymentActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<DeploymentActivity>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<DeploymentActivity, DeploymentActivityCriteria>, options?: IThrowingRepoOptions): Promise<DeploymentActivity[]>;
-    /** Overwrites the given properties for each existing DeploymentActivity. */
-    tryUpdatePartialMany(request: Array<DeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<DeploymentActivity>>>;
-    updatePartialMany(request: Array<DeploymentActivity>, options?: IThrowingRepoOptions): Promise<PartialWithId<DeploymentActivity>[]>;
-    /** Saves each given input as a new DeploymentActivity, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<DeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<DeploymentActivity>>;
-    upsertMany(request: Array<DeploymentActivity>, options?: IThrowingRepoOptions): Promise<DeploymentActivity[]>;
-    /** Saves the input as a new DeploymentActivity, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsert(request: DeploymentActivity, options?: IRepoOptions): Promise<SingleResult<DeploymentActivity>>;
-    upsert(request: DeploymentActivity, options?: IThrowingRepoOptions): Promise<DeploymentActivity>;
-}
-import { VersionCreateActivity, VersionCreateActivityCriteria } from "../contracts";
-declare class VersionCreateActivityCruds {
-    private core;
-    constructor(core: ApiClientBase);
-    /** Saves each given input as a new VersionCreateActivity. */
-    tryCreateMany(request: Array<VersionCreateActivity>, options?: IRepoOptions): Promise<BatchResult<VersionCreateActivity>>;
-    createMany(request: Array<VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<VersionCreateActivity[]>;
-    /** Retrieves all the existing VersionCreateActivity that satisfy the given criteria. */
-    tryReadMany(request: VersionCreateActivityCriteria, options?: IRepoOptions): Promise<ListResult<VersionCreateActivity>>;
-    readMany(request: VersionCreateActivityCriteria, options?: IThrowingRepoOptions): Promise<VersionCreateActivity[]>;
-    /** Overwrites each existing VersionCreateActivity. */
-    tryUpdateMany(request: Array<VersionCreateActivity>, options?: IRepoOptions): Promise<BatchResult<VersionCreateActivity>>;
-    updateMany(request: Array<VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<VersionCreateActivity[]>;
-    /** Performs the given operations on each existing VersionCreateActivity that satisfies the given criteria. */
-    tryPatchWhere(request: PatchSpecForMany<VersionCreateActivity, VersionCreateActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<VersionCreateActivity>>;
-    patchWhere(request: PatchSpecForMany<VersionCreateActivity, VersionCreateActivityCriteria>, options?: IThrowingRepoOptions): Promise<VersionCreateActivity[]>;
-    /** Deletes each existing VersionCreateActivity that satisfies the given criteria. */
-    tryDeleteWhere(request: VersionCreateActivityCriteria, options?: IRepoOptions): Promise<BatchResult<VersionCreateActivity>>;
-    deleteWhere(request: VersionCreateActivityCriteria, options?: IThrowingRepoOptions): Promise<VersionCreateActivity[]>;
-    /** Retrieves the single, uniquely identified VersionCreateActivity. */
-    tryRead(request: IdSpecFor<VersionCreateActivity>, options?: IRepoOptions): Promise<SingleResult<VersionCreateActivity>>;
-    read(request: IdSpecFor<VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<VersionCreateActivity>;
-    /** Overwrites the existing VersionCreateActivity. */
-    tryUpdate(request: VersionCreateActivity, options?: IRepoOptions): Promise<SingleResult<VersionCreateActivity>>;
-    update(request: VersionCreateActivity, options?: IThrowingRepoOptions): Promise<VersionCreateActivity>;
-    /** Performs the given operations on the existing VersionCreateActivity. */
-    tryPatch(request: PatchSpecForOne<VersionCreateActivity>, options?: IRepoOptions): Promise<SingleResult<VersionCreateActivity>>;
-    patch(request: PatchSpecForOne<VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<VersionCreateActivity>;
-    /** Deletes the existing VersionCreateActivity. */
-    tryDelete(request: IdSpecFor<VersionCreateActivity>, options?: IRepoOptions): Promise<SingleResult<VersionCreateActivity>>;
-    delete(request: IdSpecFor<VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<VersionCreateActivity>;
-    /** Overwrites the given properties of the existing VersionCreateActivity. */
-    tryUpdatePartial(request: VersionCreateActivity, options?: IRepoOptions): Promise<SingleResult<PartialWithId<VersionCreateActivity>>>;
-    updatePartial(request: VersionCreateActivity, options?: IThrowingRepoOptions): Promise<PartialWithId<VersionCreateActivity>>;
-    /** Saves the input as a new VersionCreateActivity. */
-    tryCreate(request: VersionCreateActivity, options?: IRepoOptions): Promise<SingleResult<VersionCreateActivity>>;
-    create(request: VersionCreateActivity, options?: IThrowingRepoOptions): Promise<VersionCreateActivity>;
-    /** Performs the given operation on each existing VersionCreateActivity that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<VersionCreateActivity, VersionCreateActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<VersionCreateActivity>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<VersionCreateActivity, VersionCreateActivityCriteria>, options?: IThrowingRepoOptions): Promise<VersionCreateActivity[]>;
-    /** Overwrites the given properties for each existing VersionCreateActivity. */
-    tryUpdatePartialMany(request: Array<VersionCreateActivity>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<VersionCreateActivity>>>;
-    updatePartialMany(request: Array<VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<PartialWithId<VersionCreateActivity>[]>;
-    /** Saves each given input as a new VersionCreateActivity, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<VersionCreateActivity>, options?: IRepoOptions): Promise<BatchResult<VersionCreateActivity>>;
-    upsertMany(request: Array<VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<VersionCreateActivity[]>;
-    /** Saves the input as a new VersionCreateActivity, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsert(request: VersionCreateActivity, options?: IRepoOptions): Promise<SingleResult<VersionCreateActivity>>;
-    upsert(request: VersionCreateActivity, options?: IThrowingRepoOptions): Promise<VersionCreateActivity>;
-}
-import { AssetVersionConfig, AssetVersionConfigCriteria } from "../contracts";
-declare class AssetVersionConfigCruds {
-    private core;
-    constructor(core: ApiClientBase);
-    /** Saves each given input as a new AssetVersionConfig. */
-    tryCreateMany(request: Array<AssetVersionConfig>, options?: IRepoOptions): Promise<BatchResult<AssetVersionConfig>>;
-    createMany(request: Array<AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<AssetVersionConfig[]>;
+    /** Deletes each existing AssetVersionConfig that satisfies the given criteria. */
+    tryDeleteWhere(request: AssetVersionConfigCriteria, options?: IRepoOptions): Promise<BatchResult<AssetVersionConfig>>;
+    deleteWhere(request: AssetVersionConfigCriteria, options?: IThrowingRepoOptions): Promise<AssetVersionConfig[]>;
     /** Retrieves all the existing AssetVersionConfig that satisfy the given criteria. */
     tryReadMany(request: AssetVersionConfigCriteria, options?: IRepoOptions): Promise<ListResult<AssetVersionConfig>>;
     readMany(request: AssetVersionConfigCriteria, options?: IThrowingRepoOptions): Promise<AssetVersionConfig[]>;
-    /** Overwrites each existing AssetVersionConfig. */
-    tryUpdateMany(request: Array<AssetVersionConfig>, options?: IRepoOptions): Promise<BatchResult<AssetVersionConfig>>;
-    updateMany(request: Array<AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<AssetVersionConfig[]>;
     /** Performs the given operations on each existing AssetVersionConfig that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<AssetVersionConfig, AssetVersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<AssetVersionConfig>>;
     patchWhere(request: PatchSpecForMany<AssetVersionConfig, AssetVersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<AssetVersionConfig[]>;
-    /** Deletes each existing AssetVersionConfig that satisfies the given criteria. */
-    tryDeleteWhere(request: AssetVersionConfigCriteria, options?: IRepoOptions): Promise<BatchResult<AssetVersionConfig>>;
-    deleteWhere(request: AssetVersionConfigCriteria, options?: IThrowingRepoOptions): Promise<AssetVersionConfig[]>;
+    /** Saves each given input as a new AssetVersionConfig. */
+    tryCreateMany(request: Array<AssetVersionConfig>, options?: IRepoOptions): Promise<BatchResult<AssetVersionConfig>>;
+    createMany(request: Array<AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<AssetVersionConfig[]>;
+    /** Overwrites each existing AssetVersionConfig. */
+    tryUpdateMany(request: Array<AssetVersionConfig>, options?: IRepoOptions): Promise<BatchResult<AssetVersionConfig>>;
+    updateMany(request: Array<AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<AssetVersionConfig[]>;
+    /** Deletes the existing AssetVersionConfig. */
+    tryDelete(request: IdSpecFor<AssetVersionConfig>, options?: IRepoOptions): Promise<SingleResult<AssetVersionConfig>>;
+    delete(request: IdSpecFor<AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<AssetVersionConfig>;
     /** Retrieves the single, uniquely identified AssetVersionConfig. */
     tryRead(request: IdSpecFor<AssetVersionConfig>, options?: IRepoOptions): Promise<SingleResult<AssetVersionConfig>>;
     read(request: IdSpecFor<AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<AssetVersionConfig>;
-    /** Overwrites the existing AssetVersionConfig. */
-    tryUpdate(request: AssetVersionConfig, options?: IRepoOptions): Promise<SingleResult<AssetVersionConfig>>;
-    update(request: AssetVersionConfig, options?: IThrowingRepoOptions): Promise<AssetVersionConfig>;
     /** Performs the given operations on the existing AssetVersionConfig. */
     tryPatch(request: PatchSpecForOne<AssetVersionConfig>, options?: IRepoOptions): Promise<SingleResult<AssetVersionConfig>>;
     patch(request: PatchSpecForOne<AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<AssetVersionConfig>;
-    /** Deletes the existing AssetVersionConfig. */
-    tryDelete(request: IdSpecFor<AssetVersionConfig>, options?: IRepoOptions): Promise<SingleResult<AssetVersionConfig>>;
-    delete(request: IdSpecFor<AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<AssetVersionConfig>;
+    /** Overwrites the existing AssetVersionConfig. */
+    tryUpdate(request: AssetVersionConfig, options?: IRepoOptions): Promise<SingleResult<AssetVersionConfig>>;
+    update(request: AssetVersionConfig, options?: IThrowingRepoOptions): Promise<AssetVersionConfig>;
     /** Overwrites the given properties of the existing AssetVersionConfig. */
     tryUpdatePartial(request: AssetVersionConfig, options?: IRepoOptions): Promise<SingleResult<PartialWithId<AssetVersionConfig>>>;
     updatePartial(request: AssetVersionConfig, options?: IThrowingRepoOptions): Promise<PartialWithId<AssetVersionConfig>>;
     /** Saves the input as a new AssetVersionConfig. */
     tryCreate(request: AssetVersionConfig, options?: IRepoOptions): Promise<SingleResult<AssetVersionConfig>>;
     create(request: AssetVersionConfig, options?: IThrowingRepoOptions): Promise<AssetVersionConfig>;
-    /** Performs the given operation on each existing AssetVersionConfig that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<AssetVersionConfig, AssetVersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<AssetVersionConfig>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<AssetVersionConfig, AssetVersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<AssetVersionConfig[]>;
     /** Overwrites the given properties for each existing AssetVersionConfig. */
     tryUpdatePartialMany(request: Array<AssetVersionConfig>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<AssetVersionConfig>>>;
     updatePartialMany(request: Array<AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<PartialWithId<AssetVersionConfig>[]>;
-    /** Saves each given input as a new AssetVersionConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<AssetVersionConfig>, options?: IRepoOptions): Promise<BatchResult<AssetVersionConfig>>;
-    upsertMany(request: Array<AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<AssetVersionConfig[]>;
+    /** Performs the given operation on each existing AssetVersionConfig that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<AssetVersionConfig, AssetVersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<AssetVersionConfig>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<AssetVersionConfig, AssetVersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<AssetVersionConfig[]>;
     /** Saves the input as a new AssetVersionConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: AssetVersionConfig, options?: IRepoOptions): Promise<SingleResult<AssetVersionConfig>>;
     upsert(request: AssetVersionConfig, options?: IThrowingRepoOptions): Promise<AssetVersionConfig>;
-}
-import { Asset, AssetCriteria } from "../contracts";
-declare class AssetCruds {
-    private core;
-    constructor(core: ApiClientBase);
-    /** Saves each given input as a new Asset. */
-    tryCreateMany(request: Array<Asset>, options?: IRepoOptions): Promise<BatchResult<Asset>>;
-    createMany(request: Array<Asset>, options?: IThrowingRepoOptions): Promise<Asset[]>;
-    /** Retrieves all the existing Asset that satisfy the given criteria. */
-    tryReadMany(request: AssetCriteria, options?: IRepoOptions): Promise<ListResult<Asset>>;
-    readMany(request: AssetCriteria, options?: IThrowingRepoOptions): Promise<Asset[]>;
-    /** Overwrites each existing Asset. */
-    tryUpdateMany(request: Array<Asset>, options?: IRepoOptions): Promise<BatchResult<Asset>>;
-    updateMany(request: Array<Asset>, options?: IThrowingRepoOptions): Promise<Asset[]>;
-    /** Performs the given operations on each existing Asset that satisfies the given criteria. */
-    tryPatchWhere(request: PatchSpecForMany<Asset, AssetCriteria>, options?: IRepoOptions): Promise<BatchResult<Asset>>;
-    patchWhere(request: PatchSpecForMany<Asset, AssetCriteria>, options?: IThrowingRepoOptions): Promise<Asset[]>;
-    /** Deletes each existing Asset that satisfies the given criteria. */
-    tryDeleteWhere(request: AssetCriteria, options?: IRepoOptions): Promise<BatchResult<Asset>>;
-    deleteWhere(request: AssetCriteria, options?: IThrowingRepoOptions): Promise<Asset[]>;
-    /** Retrieves the single, uniquely identified Asset. */
-    tryRead(request: IdSpecFor<Asset>, options?: IRepoOptions): Promise<SingleResult<Asset>>;
-    read(request: IdSpecFor<Asset>, options?: IThrowingRepoOptions): Promise<Asset>;
-    /** Overwrites the existing Asset. */
-    tryUpdate(request: Asset, options?: IRepoOptions): Promise<SingleResult<Asset>>;
-    update(request: Asset, options?: IThrowingRepoOptions): Promise<Asset>;
-    /** Performs the given operations on the existing Asset. */
-    tryPatch(request: PatchSpecForOne<Asset>, options?: IRepoOptions): Promise<SingleResult<Asset>>;
-    patch(request: PatchSpecForOne<Asset>, options?: IThrowingRepoOptions): Promise<Asset>;
-    /** Deletes the existing Asset. */
-    tryDelete(request: IdSpecFor<Asset>, options?: IRepoOptions): Promise<SingleResult<Asset>>;
-    delete(request: IdSpecFor<Asset>, options?: IThrowingRepoOptions): Promise<Asset>;
-    /** Overwrites the given properties of the existing Asset. */
-    tryUpdatePartial(request: Asset, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Asset>>>;
-    updatePartial(request: Asset, options?: IThrowingRepoOptions): Promise<PartialWithId<Asset>>;
-    /** Saves the input as a new Asset. */
-    tryCreate(request: Asset, options?: IRepoOptions): Promise<SingleResult<Asset>>;
-    create(request: Asset, options?: IThrowingRepoOptions): Promise<Asset>;
-    /** Performs the given operation on each existing Asset that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Asset, AssetCriteria>, options?: IRepoOptions): Promise<BatchResult<Asset>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<Asset, AssetCriteria>, options?: IThrowingRepoOptions): Promise<Asset[]>;
-    /** Overwrites the given properties for each existing Asset. */
-    tryUpdatePartialMany(request: Array<Asset>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Asset>>>;
-    updatePartialMany(request: Array<Asset>, options?: IThrowingRepoOptions): Promise<PartialWithId<Asset>[]>;
-    /** Saves each given input as a new Asset, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<Asset>, options?: IRepoOptions): Promise<BatchResult<Asset>>;
-    upsertMany(request: Array<Asset>, options?: IThrowingRepoOptions): Promise<Asset[]>;
-    /** Saves the input as a new Asset, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsert(request: Asset, options?: IRepoOptions): Promise<SingleResult<Asset>>;
-    upsert(request: Asset, options?: IThrowingRepoOptions): Promise<Asset>;
-}
-declare class EntityAclCruds {
-    private core;
-    constructor(core: ApiClientBase);
-    /** Saves each given input as a new EntityAcl. */
-    tryCreateMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
-    createMany(request: Array<EntityAcl>, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
-    /** Retrieves all the existing EntityAcl that satisfy the given criteria. */
-    tryReadMany(request: EntityAclCriteria, options?: IRepoOptions): Promise<ListResult<EntityAcl>>;
-    readMany(request: EntityAclCriteria, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
-    /** Overwrites each existing EntityAcl. */
-    tryUpdateMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
-    updateMany(request: Array<EntityAcl>, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
-    /** Performs the given operations on each existing EntityAcl that satisfies the given criteria. */
-    tryPatchWhere(request: PatchSpecForMany<EntityAcl, EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
-    patchWhere(request: PatchSpecForMany<EntityAcl, EntityAclCriteria>, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
-    /** Deletes each existing EntityAcl that satisfies the given criteria. */
-    tryDeleteWhere(request: EntityAclCriteria, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
-    deleteWhere(request: EntityAclCriteria, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
-    /** Retrieves the single, uniquely identified EntityAcl. */
-    tryRead(request: IdSpecFor<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
-    read(request: IdSpecFor<EntityAcl>, options?: IThrowingRepoOptions): Promise<EntityAcl>;
-    /** Overwrites the existing EntityAcl. */
-    tryUpdate(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
-    update(request: EntityAcl, options?: IThrowingRepoOptions): Promise<EntityAcl>;
-    /** Performs the given operations on the existing EntityAcl. */
-    tryPatch(request: PatchSpecForOne<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
-    patch(request: PatchSpecForOne<EntityAcl>, options?: IThrowingRepoOptions): Promise<EntityAcl>;
-    /** Deletes the existing EntityAcl. */
-    tryDelete(request: IdSpecFor<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
-    delete(request: IdSpecFor<EntityAcl>, options?: IThrowingRepoOptions): Promise<EntityAcl>;
-    /** Overwrites the given properties of the existing EntityAcl. */
-    tryUpdatePartial(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<PartialWithId<EntityAcl>>>;
-    updatePartial(request: EntityAcl, options?: IThrowingRepoOptions): Promise<PartialWithId<EntityAcl>>;
-    /** Saves the input as a new EntityAcl. */
-    tryCreate(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
-    create(request: EntityAcl, options?: IThrowingRepoOptions): Promise<EntityAcl>;
-    /** Performs the given operation on each existing EntityAcl that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<EntityAcl, EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<EntityAcl, EntityAclCriteria>, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
-    /** Overwrites the given properties for each existing EntityAcl. */
-    tryUpdatePartialMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<EntityAcl>>>;
-    updatePartialMany(request: Array<EntityAcl>, options?: IThrowingRepoOptions): Promise<PartialWithId<EntityAcl>[]>;
-    /** Saves each given input as a new EntityAcl, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
-    upsertMany(request: Array<EntityAcl>, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
-    /** Saves the input as a new EntityAcl, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsert(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
-    upsert(request: EntityAcl, options?: IThrowingRepoOptions): Promise<EntityAcl>;
+    /** Saves each given input as a new AssetVersionConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<AssetVersionConfig>, options?: IRepoOptions): Promise<BatchResult<AssetVersionConfig>>;
+    upsertMany(request: Array<AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<AssetVersionConfig[]>;
 }
 declare class AuthRoleCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new AuthRole. */
-    tryCreateMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
-    createMany(request: Array<AuthRole>, options?: IThrowingRepoOptions): Promise<AuthRole[]>;
+    /** Deletes each existing AuthRole that satisfies the given criteria. */
+    tryDeleteWhere(request: AuthRoleCriteria, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    deleteWhere(request: AuthRoleCriteria, options?: IThrowingRepoOptions): Promise<AuthRole[]>;
     /** Retrieves all the existing AuthRole that satisfy the given criteria. */
     tryReadMany(request: AuthRoleCriteria, options?: IRepoOptions): Promise<ListResult<AuthRole>>;
     readMany(request: AuthRoleCriteria, options?: IThrowingRepoOptions): Promise<AuthRole[]>;
-    /** Overwrites each existing AuthRole. */
-    tryUpdateMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
-    updateMany(request: Array<AuthRole>, options?: IThrowingRepoOptions): Promise<AuthRole[]>;
     /** Performs the given operations on each existing AuthRole that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<AuthRole, AuthRoleCriteria>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
     patchWhere(request: PatchSpecForMany<AuthRole, AuthRoleCriteria>, options?: IThrowingRepoOptions): Promise<AuthRole[]>;
-    /** Deletes each existing AuthRole that satisfies the given criteria. */
-    tryDeleteWhere(request: AuthRoleCriteria, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
-    deleteWhere(request: AuthRoleCriteria, options?: IThrowingRepoOptions): Promise<AuthRole[]>;
+    /** Saves each given input as a new AuthRole. */
+    tryCreateMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    createMany(request: Array<AuthRole>, options?: IThrowingRepoOptions): Promise<AuthRole[]>;
+    /** Overwrites each existing AuthRole. */
+    tryUpdateMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    updateMany(request: Array<AuthRole>, options?: IThrowingRepoOptions): Promise<AuthRole[]>;
+    /** Deletes the existing AuthRole. */
+    tryDelete(request: IdSpecFor<AuthRole>, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    delete(request: IdSpecFor<AuthRole>, options?: IThrowingRepoOptions): Promise<AuthRole>;
     /** Retrieves the single, uniquely identified AuthRole. */
     tryRead(request: IdSpecFor<AuthRole>, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
     read(request: IdSpecFor<AuthRole>, options?: IThrowingRepoOptions): Promise<AuthRole>;
-    /** Overwrites the existing AuthRole. */
-    tryUpdate(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
-    update(request: AuthRole, options?: IThrowingRepoOptions): Promise<AuthRole>;
     /** Performs the given operations on the existing AuthRole. */
     tryPatch(request: PatchSpecForOne<AuthRole>, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
     patch(request: PatchSpecForOne<AuthRole>, options?: IThrowingRepoOptions): Promise<AuthRole>;
-    /** Deletes the existing AuthRole. */
-    tryDelete(request: IdSpecFor<AuthRole>, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
-    delete(request: IdSpecFor<AuthRole>, options?: IThrowingRepoOptions): Promise<AuthRole>;
-    /** Overwrites the given properties of the existing AuthRole. */
-    tryUpdatePartial(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<PartialWithId<AuthRole>>>;
-    updatePartial(request: AuthRole, options?: IThrowingRepoOptions): Promise<PartialWithId<AuthRole>>;
-    /** Saves the input as a new AuthRole. */
-    tryCreate(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
-    create(request: AuthRole, options?: IThrowingRepoOptions): Promise<AuthRole>;
-    /** Performs the given operation on each existing AuthRole that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<AuthRole, AuthRoleCriteria>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<AuthRole, AuthRoleCriteria>, options?: IThrowingRepoOptions): Promise<AuthRole[]>;
-    /** Overwrites the given properties for each existing AuthRole. */
-    tryUpdatePartialMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<AuthRole>>>;
-    updatePartialMany(request: Array<AuthRole>, options?: IThrowingRepoOptions): Promise<PartialWithId<AuthRole>[]>;
-    /** Saves each given input as a new AuthRole, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
-    upsertMany(request: Array<AuthRole>, options?: IThrowingRepoOptions): Promise<AuthRole[]>;
-    /** Saves the input as a new AuthRole, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsert(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
-    upsert(request: AuthRole, options?: IThrowingRepoOptions): Promise<AuthRole>;
-}
-declare class CodiacUserCruds {
-    private core;
-    constructor(core: ApiClientBase);
-    /** Retrieves all the existing CodiacUser that satisfy the given criteria. */
-    tryReadMany(request: CodiacUserCriteria, options?: IRepoOptions): Promise<ListResult<CodiacUser>>;
-    readMany(request: CodiacUserCriteria, options?: IThrowingRepoOptions): Promise<CodiacUser[]>;
-    /** Retrieves the single, uniquely identified CodiacUser. */
-    tryRead(request: IdSpecFor<CodiacUser>, options?: IRepoOptions): Promise<SingleResult<CodiacUser>>;
-    read(request: IdSpecFor<CodiacUser>, options?: IThrowingRepoOptions): Promise<CodiacUser>;
-}
-import { BuildPipeline, BuildPipelineCriteria } from "../contracts";
-declare class BuildPipelineCruds {
-    private core;
-    constructor(core: ApiClientBase);
-    /** Saves each given input as a new BuildPipeline. */
-    tryCreateMany(request: Array<BuildPipeline>, options?: IRepoOptions): Promise<BatchResult<BuildPipeline>>;
-    createMany(request: Array<BuildPipeline>, options?: IThrowingRepoOptions): Promise<BuildPipeline[]>;
-    /** Retrieves all the existing BuildPipeline that satisfy the given criteria. */
-    tryReadMany(request: BuildPipelineCriteria, options?: IRepoOptions): Promise<ListResult<BuildPipeline>>;
-    readMany(request: BuildPipelineCriteria, options?: IThrowingRepoOptions): Promise<BuildPipeline[]>;
-    /** Overwrites each existing BuildPipeline. */
-    tryUpdateMany(request: Array<BuildPipeline>, options?: IRepoOptions): Promise<BatchResult<BuildPipeline>>;
-    updateMany(request: Array<BuildPipeline>, options?: IThrowingRepoOptions): Promise<BuildPipeline[]>;
-    /** Performs the given operations on each existing BuildPipeline that satisfies the given criteria. */
-    tryPatchWhere(request: PatchSpecForMany<BuildPipeline, BuildPipelineCriteria>, options?: IRepoOptions): Promise<BatchResult<BuildPipeline>>;
-    patchWhere(request: PatchSpecForMany<BuildPipeline, BuildPipelineCriteria>, options?: IThrowingRepoOptions): Promise<BuildPipeline[]>;
-    /** Deletes each existing BuildPipeline that satisfies the given criteria. */
-    tryDeleteWhere(request: BuildPipelineCriteria, options?: IRepoOptions): Promise<BatchResult<BuildPipeline>>;
-    deleteWhere(request: BuildPipelineCriteria, options?: IThrowingRepoOptions): Promise<BuildPipeline[]>;
-    /** Retrieves the single, uniquely identified BuildPipeline. */
-    tryRead(request: IdSpecFor<BuildPipeline>, options?: IRepoOptions): Promise<SingleResult<BuildPipeline>>;
-    read(request: IdSpecFor<BuildPipeline>, options?: IThrowingRepoOptions): Promise<BuildPipeline>;
-    /** Overwrites the existing BuildPipeline. */
-    tryUpdate(request: BuildPipeline, options?: IRepoOptions): Promise<SingleResult<BuildPipeline>>;
-    update(request: BuildPipeline, options?: IThrowingRepoOptions): Promise<BuildPipeline>;
-    /** Performs the given operations on the existing BuildPipeline. */
-    tryPatch(request: PatchSpecForOne<BuildPipeline>, options?: IRepoOptions): Promise<SingleResult<BuildPipeline>>;
-    patch(request: PatchSpecForOne<BuildPipeline>, options?: IThrowingRepoOptions): Promise<BuildPipeline>;
-    /** Deletes the existing BuildPipeline. */
-    tryDelete(request: IdSpecFor<BuildPipeline>, options?: IRepoOptions): Promise<SingleResult<BuildPipeline>>;
-    delete(request: IdSpecFor<BuildPipeline>, options?: IThrowingRepoOptions): Promise<BuildPipeline>;
-    /** Overwrites the given properties of the existing BuildPipeline. */
-    tryUpdatePartial(request: BuildPipeline, options?: IRepoOptions): Promise<SingleResult<PartialWithId<BuildPipeline>>>;
-    updatePartial(request: BuildPipeline, options?: IThrowingRepoOptions): Promise<PartialWithId<BuildPipeline>>;
-    /** Saves the input as a new BuildPipeline. */
-    tryCreate(request: BuildPipeline, options?: IRepoOptions): Promise<SingleResult<BuildPipeline>>;
-    create(request: BuildPipeline, options?: IThrowingRepoOptions): Promise<BuildPipeline>;
-    /** Performs the given operation on each existing BuildPipeline that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<BuildPipeline, BuildPipelineCriteria>, options?: IRepoOptions): Promise<BatchResult<BuildPipeline>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<BuildPipeline, BuildPipelineCriteria>, options?: IThrowingRepoOptions): Promise<BuildPipeline[]>;
-    /** Overwrites the given properties for each existing BuildPipeline. */
-    tryUpdatePartialMany(request: Array<BuildPipeline>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<BuildPipeline>>>;
-    updatePartialMany(request: Array<BuildPipeline>, options?: IThrowingRepoOptions): Promise<PartialWithId<BuildPipeline>[]>;
-    /** Saves each given input as a new BuildPipeline, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<BuildPipeline>, options?: IRepoOptions): Promise<BatchResult<BuildPipeline>>;
-    upsertMany(request: Array<BuildPipeline>, options?: IThrowingRepoOptions): Promise<BuildPipeline[]>;
-    /** Saves the input as a new BuildPipeline, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsert(request: BuildPipeline, options?: IRepoOptions): Promise<SingleResult<BuildPipeline>>;
-    upsert(request: BuildPipeline, options?: IThrowingRepoOptions): Promise<BuildPipeline>;
+    /** Overwrites the existing AuthRole. */
+    tryUpdate(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    update(request: AuthRole, options?: IThrowingRepoOptions): Promise<AuthRole>;
+    /** Overwrites the given properties of the existing AuthRole. */
+    tryUpdatePartial(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<PartialWithId<AuthRole>>>;
+    updatePartial(request: AuthRole, options?: IThrowingRepoOptions): Promise<PartialWithId<AuthRole>>;
+    /** Saves the input as a new AuthRole. */
+    tryCreate(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    create(request: AuthRole, options?: IThrowingRepoOptions): Promise<AuthRole>;
+    /** Overwrites the given properties for each existing AuthRole. */
+    tryUpdatePartialMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<AuthRole>>>;
+    updatePartialMany(request: Array<AuthRole>, options?: IThrowingRepoOptions): Promise<PartialWithId<AuthRole>[]>;
+    /** Performs the given operation on each existing AuthRole that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<AuthRole, AuthRoleCriteria>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<AuthRole, AuthRoleCriteria>, options?: IThrowingRepoOptions): Promise<AuthRole[]>;
+    /** Saves the input as a new AuthRole, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: AuthRole, options?: IRepoOptions): Promise<SingleResult<AuthRole>>;
+    upsert(request: AuthRole, options?: IThrowingRepoOptions): Promise<AuthRole>;
+    /** Saves each given input as a new AuthRole, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<AuthRole>, options?: IRepoOptions): Promise<BatchResult<AuthRole>>;
+    upsertMany(request: Array<AuthRole>, options?: IThrowingRepoOptions): Promise<AuthRole[]>;
 }
 import { Build, BuildCriteria } from "../contracts";
 declare class BuildCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new Build. */
-    tryCreateMany(request: Array<Build>, options?: IRepoOptions): Promise<BatchResult<Build>>;
-    createMany(request: Array<Build>, options?: IThrowingRepoOptions): Promise<Build[]>;
+    /** Deletes each existing Build that satisfies the given criteria. */
+    tryDeleteWhere(request: BuildCriteria, options?: IRepoOptions): Promise<BatchResult<Build>>;
+    deleteWhere(request: BuildCriteria, options?: IThrowingRepoOptions): Promise<Build[]>;
     /** Retrieves all the existing Build that satisfy the given criteria. */
     tryReadMany(request: BuildCriteria, options?: IRepoOptions): Promise<ListResult<Build>>;
     readMany(request: BuildCriteria, options?: IThrowingRepoOptions): Promise<Build[]>;
-    /** Overwrites each existing Build. */
-    tryUpdateMany(request: Array<Build>, options?: IRepoOptions): Promise<BatchResult<Build>>;
-    updateMany(request: Array<Build>, options?: IThrowingRepoOptions): Promise<Build[]>;
     /** Performs the given operations on each existing Build that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<Build, BuildCriteria>, options?: IRepoOptions): Promise<BatchResult<Build>>;
     patchWhere(request: PatchSpecForMany<Build, BuildCriteria>, options?: IThrowingRepoOptions): Promise<Build[]>;
-    /** Deletes each existing Build that satisfies the given criteria. */
-    tryDeleteWhere(request: BuildCriteria, options?: IRepoOptions): Promise<BatchResult<Build>>;
-    deleteWhere(request: BuildCriteria, options?: IThrowingRepoOptions): Promise<Build[]>;
+    /** Saves each given input as a new Build. */
+    tryCreateMany(request: Array<Build>, options?: IRepoOptions): Promise<BatchResult<Build>>;
+    createMany(request: Array<Build>, options?: IThrowingRepoOptions): Promise<Build[]>;
+    /** Overwrites each existing Build. */
+    tryUpdateMany(request: Array<Build>, options?: IRepoOptions): Promise<BatchResult<Build>>;
+    updateMany(request: Array<Build>, options?: IThrowingRepoOptions): Promise<Build[]>;
+    /** Deletes the existing Build. */
+    tryDelete(request: IdSpecFor<Build>, options?: IRepoOptions): Promise<SingleResult<Build>>;
+    delete(request: IdSpecFor<Build>, options?: IThrowingRepoOptions): Promise<Build>;
     /** Retrieves the single, uniquely identified Build. */
     tryRead(request: IdSpecFor<Build>, options?: IRepoOptions): Promise<SingleResult<Build>>;
     read(request: IdSpecFor<Build>, options?: IThrowingRepoOptions): Promise<Build>;
-    /** Overwrites the existing Build. */
-    tryUpdate(request: Build, options?: IRepoOptions): Promise<SingleResult<Build>>;
-    update(request: Build, options?: IThrowingRepoOptions): Promise<Build>;
     /** Performs the given operations on the existing Build. */
     tryPatch(request: PatchSpecForOne<Build>, options?: IRepoOptions): Promise<SingleResult<Build>>;
     patch(request: PatchSpecForOne<Build>, options?: IThrowingRepoOptions): Promise<Build>;
-    /** Deletes the existing Build. */
-    tryDelete(request: IdSpecFor<Build>, options?: IRepoOptions): Promise<SingleResult<Build>>;
-    delete(request: IdSpecFor<Build>, options?: IThrowingRepoOptions): Promise<Build>;
+    /** Overwrites the existing Build. */
+    tryUpdate(request: Build, options?: IRepoOptions): Promise<SingleResult<Build>>;
+    update(request: Build, options?: IThrowingRepoOptions): Promise<Build>;
     /** Overwrites the given properties of the existing Build. */
     tryUpdatePartial(request: Build, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Build>>>;
     updatePartial(request: Build, options?: IThrowingRepoOptions): Promise<PartialWithId<Build>>;
     /** Saves the input as a new Build. */
     tryCreate(request: Build, options?: IRepoOptions): Promise<SingleResult<Build>>;
     create(request: Build, options?: IThrowingRepoOptions): Promise<Build>;
-    /** Performs the given operation on each existing Build that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Build, BuildCriteria>, options?: IRepoOptions): Promise<BatchResult<Build>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<Build, BuildCriteria>, options?: IThrowingRepoOptions): Promise<Build[]>;
     /** Overwrites the given properties for each existing Build. */
     tryUpdatePartialMany(request: Array<Build>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Build>>>;
     updatePartialMany(request: Array<Build>, options?: IThrowingRepoOptions): Promise<PartialWithId<Build>[]>;
-    /** Saves each given input as a new Build, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<Build>, options?: IRepoOptions): Promise<BatchResult<Build>>;
-    upsertMany(request: Array<Build>, options?: IThrowingRepoOptions): Promise<Build[]>;
+    /** Performs the given operation on each existing Build that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Build, BuildCriteria>, options?: IRepoOptions): Promise<BatchResult<Build>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Build, BuildCriteria>, options?: IThrowingRepoOptions): Promise<Build[]>;
     /** Saves the input as a new Build, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: Build, options?: IRepoOptions): Promise<SingleResult<Build>>;
     upsert(request: Build, options?: IThrowingRepoOptions): Promise<Build>;
+    /** Saves each given input as a new Build, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Build>, options?: IRepoOptions): Promise<BatchResult<Build>>;
+    upsertMany(request: Array<Build>, options?: IThrowingRepoOptions): Promise<Build[]>;
+}
+import { BuildPipeline, BuildPipelineCriteria } from "../contracts";
+declare class BuildPipelineCruds {
+    private core;
+    constructor(core: ApiClientBase);
+    /** Deletes each existing BuildPipeline that satisfies the given criteria. */
+    tryDeleteWhere(request: BuildPipelineCriteria, options?: IRepoOptions): Promise<BatchResult<BuildPipeline>>;
+    deleteWhere(request: BuildPipelineCriteria, options?: IThrowingRepoOptions): Promise<BuildPipeline[]>;
+    /** Retrieves all the existing BuildPipeline that satisfy the given criteria. */
+    tryReadMany(request: BuildPipelineCriteria, options?: IRepoOptions): Promise<ListResult<BuildPipeline>>;
+    readMany(request: BuildPipelineCriteria, options?: IThrowingRepoOptions): Promise<BuildPipeline[]>;
+    /** Performs the given operations on each existing BuildPipeline that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<BuildPipeline, BuildPipelineCriteria>, options?: IRepoOptions): Promise<BatchResult<BuildPipeline>>;
+    patchWhere(request: PatchSpecForMany<BuildPipeline, BuildPipelineCriteria>, options?: IThrowingRepoOptions): Promise<BuildPipeline[]>;
+    /** Saves each given input as a new BuildPipeline. */
+    tryCreateMany(request: Array<BuildPipeline>, options?: IRepoOptions): Promise<BatchResult<BuildPipeline>>;
+    createMany(request: Array<BuildPipeline>, options?: IThrowingRepoOptions): Promise<BuildPipeline[]>;
+    /** Overwrites each existing BuildPipeline. */
+    tryUpdateMany(request: Array<BuildPipeline>, options?: IRepoOptions): Promise<BatchResult<BuildPipeline>>;
+    updateMany(request: Array<BuildPipeline>, options?: IThrowingRepoOptions): Promise<BuildPipeline[]>;
+    /** Deletes the existing BuildPipeline. */
+    tryDelete(request: IdSpecFor<BuildPipeline>, options?: IRepoOptions): Promise<SingleResult<BuildPipeline>>;
+    delete(request: IdSpecFor<BuildPipeline>, options?: IThrowingRepoOptions): Promise<BuildPipeline>;
+    /** Retrieves the single, uniquely identified BuildPipeline. */
+    tryRead(request: IdSpecFor<BuildPipeline>, options?: IRepoOptions): Promise<SingleResult<BuildPipeline>>;
+    read(request: IdSpecFor<BuildPipeline>, options?: IThrowingRepoOptions): Promise<BuildPipeline>;
+    /** Performs the given operations on the existing BuildPipeline. */
+    tryPatch(request: PatchSpecForOne<BuildPipeline>, options?: IRepoOptions): Promise<SingleResult<BuildPipeline>>;
+    patch(request: PatchSpecForOne<BuildPipeline>, options?: IThrowingRepoOptions): Promise<BuildPipeline>;
+    /** Overwrites the existing BuildPipeline. */
+    tryUpdate(request: BuildPipeline, options?: IRepoOptions): Promise<SingleResult<BuildPipeline>>;
+    update(request: BuildPipeline, options?: IThrowingRepoOptions): Promise<BuildPipeline>;
+    /** Overwrites the given properties of the existing BuildPipeline. */
+    tryUpdatePartial(request: BuildPipeline, options?: IRepoOptions): Promise<SingleResult<PartialWithId<BuildPipeline>>>;
+    updatePartial(request: BuildPipeline, options?: IThrowingRepoOptions): Promise<PartialWithId<BuildPipeline>>;
+    /** Saves the input as a new BuildPipeline. */
+    tryCreate(request: BuildPipeline, options?: IRepoOptions): Promise<SingleResult<BuildPipeline>>;
+    create(request: BuildPipeline, options?: IThrowingRepoOptions): Promise<BuildPipeline>;
+    /** Overwrites the given properties for each existing BuildPipeline. */
+    tryUpdatePartialMany(request: Array<BuildPipeline>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<BuildPipeline>>>;
+    updatePartialMany(request: Array<BuildPipeline>, options?: IThrowingRepoOptions): Promise<PartialWithId<BuildPipeline>[]>;
+    /** Performs the given operation on each existing BuildPipeline that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<BuildPipeline, BuildPipelineCriteria>, options?: IRepoOptions): Promise<BatchResult<BuildPipeline>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<BuildPipeline, BuildPipelineCriteria>, options?: IThrowingRepoOptions): Promise<BuildPipeline[]>;
+    /** Saves the input as a new BuildPipeline, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: BuildPipeline, options?: IRepoOptions): Promise<SingleResult<BuildPipeline>>;
+    upsert(request: BuildPipeline, options?: IThrowingRepoOptions): Promise<BuildPipeline>;
+    /** Saves each given input as a new BuildPipeline, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<BuildPipeline>, options?: IRepoOptions): Promise<BatchResult<BuildPipeline>>;
+    upsertMany(request: Array<BuildPipeline>, options?: IThrowingRepoOptions): Promise<BuildPipeline[]>;
 }
 import { Cabinet, CabinetCriteria } from "../contracts";
 declare class CabinetCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new Cabinet. */
-    tryCreateMany(request: Array<Cabinet>, options?: IRepoOptions): Promise<BatchResult<Cabinet>>;
-    createMany(request: Array<Cabinet>, options?: IThrowingRepoOptions): Promise<Cabinet[]>;
+    /** Deletes each existing Cabinet that satisfies the given criteria. */
+    tryDeleteWhere(request: CabinetCriteria, options?: IRepoOptions): Promise<BatchResult<Cabinet>>;
+    deleteWhere(request: CabinetCriteria, options?: IThrowingRepoOptions): Promise<Cabinet[]>;
     /** Retrieves all the existing Cabinet that satisfy the given criteria. */
     tryReadMany(request: CabinetCriteria, options?: IRepoOptions): Promise<ListResult<Cabinet>>;
     readMany(request: CabinetCriteria, options?: IThrowingRepoOptions): Promise<Cabinet[]>;
-    /** Overwrites each existing Cabinet. */
-    tryUpdateMany(request: Array<Cabinet>, options?: IRepoOptions): Promise<BatchResult<Cabinet>>;
-    updateMany(request: Array<Cabinet>, options?: IThrowingRepoOptions): Promise<Cabinet[]>;
     /** Performs the given operations on each existing Cabinet that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<Cabinet, CabinetCriteria>, options?: IRepoOptions): Promise<BatchResult<Cabinet>>;
     patchWhere(request: PatchSpecForMany<Cabinet, CabinetCriteria>, options?: IThrowingRepoOptions): Promise<Cabinet[]>;
-    /** Deletes each existing Cabinet that satisfies the given criteria. */
-    tryDeleteWhere(request: CabinetCriteria, options?: IRepoOptions): Promise<BatchResult<Cabinet>>;
-    deleteWhere(request: CabinetCriteria, options?: IThrowingRepoOptions): Promise<Cabinet[]>;
+    /** Saves each given input as a new Cabinet. */
+    tryCreateMany(request: Array<Cabinet>, options?: IRepoOptions): Promise<BatchResult<Cabinet>>;
+    createMany(request: Array<Cabinet>, options?: IThrowingRepoOptions): Promise<Cabinet[]>;
+    /** Overwrites each existing Cabinet. */
+    tryUpdateMany(request: Array<Cabinet>, options?: IRepoOptions): Promise<BatchResult<Cabinet>>;
+    updateMany(request: Array<Cabinet>, options?: IThrowingRepoOptions): Promise<Cabinet[]>;
+    /** Deletes the existing Cabinet. */
+    tryDelete(request: IdSpecFor<Cabinet>, options?: IRepoOptions): Promise<SingleResult<Cabinet>>;
+    delete(request: IdSpecFor<Cabinet>, options?: IThrowingRepoOptions): Promise<Cabinet>;
     /** Retrieves the single, uniquely identified Cabinet. */
     tryRead(request: IdSpecFor<Cabinet>, options?: IRepoOptions): Promise<SingleResult<Cabinet>>;
     read(request: IdSpecFor<Cabinet>, options?: IThrowingRepoOptions): Promise<Cabinet>;
-    /** Overwrites the existing Cabinet. */
-    tryUpdate(request: Cabinet, options?: IRepoOptions): Promise<SingleResult<Cabinet>>;
-    update(request: Cabinet, options?: IThrowingRepoOptions): Promise<Cabinet>;
     /** Performs the given operations on the existing Cabinet. */
     tryPatch(request: PatchSpecForOne<Cabinet>, options?: IRepoOptions): Promise<SingleResult<Cabinet>>;
     patch(request: PatchSpecForOne<Cabinet>, options?: IThrowingRepoOptions): Promise<Cabinet>;
-    /** Deletes the existing Cabinet. */
-    tryDelete(request: IdSpecFor<Cabinet>, options?: IRepoOptions): Promise<SingleResult<Cabinet>>;
-    delete(request: IdSpecFor<Cabinet>, options?: IThrowingRepoOptions): Promise<Cabinet>;
+    /** Overwrites the existing Cabinet. */
+    tryUpdate(request: Cabinet, options?: IRepoOptions): Promise<SingleResult<Cabinet>>;
+    update(request: Cabinet, options?: IThrowingRepoOptions): Promise<Cabinet>;
     /** Overwrites the given properties of the existing Cabinet. */
     tryUpdatePartial(request: Cabinet, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Cabinet>>>;
     updatePartial(request: Cabinet, options?: IThrowingRepoOptions): Promise<PartialWithId<Cabinet>>;
     /** Saves the input as a new Cabinet. */
     tryCreate(request: Cabinet, options?: IRepoOptions): Promise<SingleResult<Cabinet>>;
     create(request: Cabinet, options?: IThrowingRepoOptions): Promise<Cabinet>;
-    /** Performs the given operation on each existing Cabinet that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Cabinet, CabinetCriteria>, options?: IRepoOptions): Promise<BatchResult<Cabinet>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<Cabinet, CabinetCriteria>, options?: IThrowingRepoOptions): Promise<Cabinet[]>;
     /** Overwrites the given properties for each existing Cabinet. */
     tryUpdatePartialMany(request: Array<Cabinet>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Cabinet>>>;
     updatePartialMany(request: Array<Cabinet>, options?: IThrowingRepoOptions): Promise<PartialWithId<Cabinet>[]>;
-    /** Saves each given input as a new Cabinet, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<Cabinet>, options?: IRepoOptions): Promise<BatchResult<Cabinet>>;
-    upsertMany(request: Array<Cabinet>, options?: IThrowingRepoOptions): Promise<Cabinet[]>;
+    /** Performs the given operation on each existing Cabinet that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Cabinet, CabinetCriteria>, options?: IRepoOptions): Promise<BatchResult<Cabinet>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Cabinet, CabinetCriteria>, options?: IThrowingRepoOptions): Promise<Cabinet[]>;
     /** Saves the input as a new Cabinet, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: Cabinet, options?: IRepoOptions): Promise<SingleResult<Cabinet>>;
     upsert(request: Cabinet, options?: IThrowingRepoOptions): Promise<Cabinet>;
+    /** Saves each given input as a new Cabinet, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Cabinet>, options?: IRepoOptions): Promise<BatchResult<Cabinet>>;
+    upsertMany(request: Array<Cabinet>, options?: IThrowingRepoOptions): Promise<Cabinet[]>;
+}
+import { CabinetCreateActivity, CabinetCreateActivityCriteria } from "../contracts";
+declare class CabinetCreateActivityCruds {
+    private core;
+    constructor(core: ApiClientBase);
+    /** Deletes each existing CabinetCreateActivity that satisfies the given criteria. */
+    tryDeleteWhere(request: CabinetCreateActivityCriteria, options?: IRepoOptions): Promise<BatchResult<CabinetCreateActivity>>;
+    deleteWhere(request: CabinetCreateActivityCriteria, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity[]>;
+    /** Retrieves all the existing CabinetCreateActivity that satisfy the given criteria. */
+    tryReadMany(request: CabinetCreateActivityCriteria, options?: IRepoOptions): Promise<ListResult<CabinetCreateActivity>>;
+    readMany(request: CabinetCreateActivityCriteria, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity[]>;
+    /** Performs the given operations on each existing CabinetCreateActivity that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<CabinetCreateActivity, CabinetCreateActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<CabinetCreateActivity>>;
+    patchWhere(request: PatchSpecForMany<CabinetCreateActivity, CabinetCreateActivityCriteria>, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity[]>;
+    /** Saves each given input as a new CabinetCreateActivity. */
+    tryCreateMany(request: Array<CabinetCreateActivity>, options?: IRepoOptions): Promise<BatchResult<CabinetCreateActivity>>;
+    createMany(request: Array<CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity[]>;
+    /** Overwrites each existing CabinetCreateActivity. */
+    tryUpdateMany(request: Array<CabinetCreateActivity>, options?: IRepoOptions): Promise<BatchResult<CabinetCreateActivity>>;
+    updateMany(request: Array<CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity[]>;
+    /** Deletes the existing CabinetCreateActivity. */
+    tryDelete(request: IdSpecFor<CabinetCreateActivity>, options?: IRepoOptions): Promise<SingleResult<CabinetCreateActivity>>;
+    delete(request: IdSpecFor<CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity>;
+    /** Retrieves the single, uniquely identified CabinetCreateActivity. */
+    tryRead(request: IdSpecFor<CabinetCreateActivity>, options?: IRepoOptions): Promise<SingleResult<CabinetCreateActivity>>;
+    read(request: IdSpecFor<CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity>;
+    /** Performs the given operations on the existing CabinetCreateActivity. */
+    tryPatch(request: PatchSpecForOne<CabinetCreateActivity>, options?: IRepoOptions): Promise<SingleResult<CabinetCreateActivity>>;
+    patch(request: PatchSpecForOne<CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity>;
+    /** Overwrites the existing CabinetCreateActivity. */
+    tryUpdate(request: CabinetCreateActivity, options?: IRepoOptions): Promise<SingleResult<CabinetCreateActivity>>;
+    update(request: CabinetCreateActivity, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity>;
+    /** Overwrites the given properties of the existing CabinetCreateActivity. */
+    tryUpdatePartial(request: CabinetCreateActivity, options?: IRepoOptions): Promise<SingleResult<PartialWithId<CabinetCreateActivity>>>;
+    updatePartial(request: CabinetCreateActivity, options?: IThrowingRepoOptions): Promise<PartialWithId<CabinetCreateActivity>>;
+    /** Saves the input as a new CabinetCreateActivity. */
+    tryCreate(request: CabinetCreateActivity, options?: IRepoOptions): Promise<SingleResult<CabinetCreateActivity>>;
+    create(request: CabinetCreateActivity, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity>;
+    /** Overwrites the given properties for each existing CabinetCreateActivity. */
+    tryUpdatePartialMany(request: Array<CabinetCreateActivity>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<CabinetCreateActivity>>>;
+    updatePartialMany(request: Array<CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<PartialWithId<CabinetCreateActivity>[]>;
+    /** Performs the given operation on each existing CabinetCreateActivity that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<CabinetCreateActivity, CabinetCreateActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<CabinetCreateActivity>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<CabinetCreateActivity, CabinetCreateActivityCriteria>, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity[]>;
+    /** Saves the input as a new CabinetCreateActivity, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: CabinetCreateActivity, options?: IRepoOptions): Promise<SingleResult<CabinetCreateActivity>>;
+    upsert(request: CabinetCreateActivity, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity>;
+    /** Saves each given input as a new CabinetCreateActivity, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<CabinetCreateActivity>, options?: IRepoOptions): Promise<BatchResult<CabinetCreateActivity>>;
+    upsertMany(request: Array<CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<CabinetCreateActivity[]>;
+}
+import { Cluster, ClusterCriteria } from "../contracts";
+declare class ClusterCruds {
+    private core;
+    constructor(core: ApiClientBase);
+    /** Deletes each existing Cluster that satisfies the given criteria. */
+    tryDeleteWhere(request: ClusterCriteria, options?: IRepoOptions): Promise<BatchResult<Cluster>>;
+    deleteWhere(request: ClusterCriteria, options?: IThrowingRepoOptions): Promise<Cluster[]>;
+    /** Retrieves all the existing Cluster that satisfy the given criteria. */
+    tryReadMany(request: ClusterCriteria, options?: IRepoOptions): Promise<ListResult<Cluster>>;
+    readMany(request: ClusterCriteria, options?: IThrowingRepoOptions): Promise<Cluster[]>;
+    /** Performs the given operations on each existing Cluster that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Cluster, ClusterCriteria>, options?: IRepoOptions): Promise<BatchResult<Cluster>>;
+    patchWhere(request: PatchSpecForMany<Cluster, ClusterCriteria>, options?: IThrowingRepoOptions): Promise<Cluster[]>;
+    /** Saves each given input as a new Cluster. */
+    tryCreateMany(request: Array<Cluster>, options?: IRepoOptions): Promise<BatchResult<Cluster>>;
+    createMany(request: Array<Cluster>, options?: IThrowingRepoOptions): Promise<Cluster[]>;
+    /** Overwrites each existing Cluster. */
+    tryUpdateMany(request: Array<Cluster>, options?: IRepoOptions): Promise<BatchResult<Cluster>>;
+    updateMany(request: Array<Cluster>, options?: IThrowingRepoOptions): Promise<Cluster[]>;
+    /** Deletes the existing Cluster. */
+    tryDelete(request: IdSpecFor<Cluster>, options?: IRepoOptions): Promise<SingleResult<Cluster>>;
+    delete(request: IdSpecFor<Cluster>, options?: IThrowingRepoOptions): Promise<Cluster>;
+    /** Retrieves the single, uniquely identified Cluster. */
+    tryRead(request: IdSpecFor<Cluster>, options?: IRepoOptions): Promise<SingleResult<Cluster>>;
+    read(request: IdSpecFor<Cluster>, options?: IThrowingRepoOptions): Promise<Cluster>;
+    /** Performs the given operations on the existing Cluster. */
+    tryPatch(request: PatchSpecForOne<Cluster>, options?: IRepoOptions): Promise<SingleResult<Cluster>>;
+    patch(request: PatchSpecForOne<Cluster>, options?: IThrowingRepoOptions): Promise<Cluster>;
+    /** Overwrites the existing Cluster. */
+    tryUpdate(request: Cluster, options?: IRepoOptions): Promise<SingleResult<Cluster>>;
+    update(request: Cluster, options?: IThrowingRepoOptions): Promise<Cluster>;
+    /** Overwrites the given properties of the existing Cluster. */
+    tryUpdatePartial(request: Cluster, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Cluster>>>;
+    updatePartial(request: Cluster, options?: IThrowingRepoOptions): Promise<PartialWithId<Cluster>>;
+    /** Saves the input as a new Cluster. */
+    tryCreate(request: Cluster, options?: IRepoOptions): Promise<SingleResult<Cluster>>;
+    create(request: Cluster, options?: IThrowingRepoOptions): Promise<Cluster>;
+    /** Overwrites the given properties for each existing Cluster. */
+    tryUpdatePartialMany(request: Array<Cluster>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Cluster>>>;
+    updatePartialMany(request: Array<Cluster>, options?: IThrowingRepoOptions): Promise<PartialWithId<Cluster>[]>;
+    /** Performs the given operation on each existing Cluster that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Cluster, ClusterCriteria>, options?: IRepoOptions): Promise<BatchResult<Cluster>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Cluster, ClusterCriteria>, options?: IThrowingRepoOptions): Promise<Cluster[]>;
+    /** Saves the input as a new Cluster, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Cluster, options?: IRepoOptions): Promise<SingleResult<Cluster>>;
+    upsert(request: Cluster, options?: IThrowingRepoOptions): Promise<Cluster>;
+    /** Saves each given input as a new Cluster, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Cluster>, options?: IRepoOptions): Promise<BatchResult<Cluster>>;
+    upsertMany(request: Array<Cluster>, options?: IThrowingRepoOptions): Promise<Cluster[]>;
 }
 import { ClusterDef, ClusterDefCriteria } from "../contracts";
 declare class ClusterDefCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new ClusterDef. */
-    tryCreateMany(request: Array<ClusterDef>, options?: IRepoOptions): Promise<BatchResult<ClusterDef>>;
-    createMany(request: Array<ClusterDef>, options?: IThrowingRepoOptions): Promise<ClusterDef[]>;
+    /** Deletes each existing ClusterDef that satisfies the given criteria. */
+    tryDeleteWhere(request: ClusterDefCriteria, options?: IRepoOptions): Promise<BatchResult<ClusterDef>>;
+    deleteWhere(request: ClusterDefCriteria, options?: IThrowingRepoOptions): Promise<ClusterDef[]>;
     /** Retrieves all the existing ClusterDef that satisfy the given criteria. */
     tryReadMany(request: ClusterDefCriteria, options?: IRepoOptions): Promise<ListResult<ClusterDef>>;
     readMany(request: ClusterDefCriteria, options?: IThrowingRepoOptions): Promise<ClusterDef[]>;
-    /** Overwrites each existing ClusterDef. */
-    tryUpdateMany(request: Array<ClusterDef>, options?: IRepoOptions): Promise<BatchResult<ClusterDef>>;
-    updateMany(request: Array<ClusterDef>, options?: IThrowingRepoOptions): Promise<ClusterDef[]>;
     /** Performs the given operations on each existing ClusterDef that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<ClusterDef, ClusterDefCriteria>, options?: IRepoOptions): Promise<BatchResult<ClusterDef>>;
     patchWhere(request: PatchSpecForMany<ClusterDef, ClusterDefCriteria>, options?: IThrowingRepoOptions): Promise<ClusterDef[]>;
-    /** Deletes each existing ClusterDef that satisfies the given criteria. */
-    tryDeleteWhere(request: ClusterDefCriteria, options?: IRepoOptions): Promise<BatchResult<ClusterDef>>;
-    deleteWhere(request: ClusterDefCriteria, options?: IThrowingRepoOptions): Promise<ClusterDef[]>;
+    /** Saves each given input as a new ClusterDef. */
+    tryCreateMany(request: Array<ClusterDef>, options?: IRepoOptions): Promise<BatchResult<ClusterDef>>;
+    createMany(request: Array<ClusterDef>, options?: IThrowingRepoOptions): Promise<ClusterDef[]>;
+    /** Overwrites each existing ClusterDef. */
+    tryUpdateMany(request: Array<ClusterDef>, options?: IRepoOptions): Promise<BatchResult<ClusterDef>>;
+    updateMany(request: Array<ClusterDef>, options?: IThrowingRepoOptions): Promise<ClusterDef[]>;
+    /** Deletes the existing ClusterDef. */
+    tryDelete(request: IdSpecFor<ClusterDef>, options?: IRepoOptions): Promise<SingleResult<ClusterDef>>;
+    delete(request: IdSpecFor<ClusterDef>, options?: IThrowingRepoOptions): Promise<ClusterDef>;
     /** Retrieves the single, uniquely identified ClusterDef. */
     tryRead(request: IdSpecFor<ClusterDef>, options?: IRepoOptions): Promise<SingleResult<ClusterDef>>;
     read(request: IdSpecFor<ClusterDef>, options?: IThrowingRepoOptions): Promise<ClusterDef>;
-    /** Overwrites the existing ClusterDef. */
-    tryUpdate(request: ClusterDef, options?: IRepoOptions): Promise<SingleResult<ClusterDef>>;
-    update(request: ClusterDef, options?: IThrowingRepoOptions): Promise<ClusterDef>;
     /** Performs the given operations on the existing ClusterDef. */
     tryPatch(request: PatchSpecForOne<ClusterDef>, options?: IRepoOptions): Promise<SingleResult<ClusterDef>>;
     patch(request: PatchSpecForOne<ClusterDef>, options?: IThrowingRepoOptions): Promise<ClusterDef>;
-    /** Deletes the existing ClusterDef. */
-    tryDelete(request: IdSpecFor<ClusterDef>, options?: IRepoOptions): Promise<SingleResult<ClusterDef>>;
-    delete(request: IdSpecFor<ClusterDef>, options?: IThrowingRepoOptions): Promise<ClusterDef>;
+    /** Overwrites the existing ClusterDef. */
+    tryUpdate(request: ClusterDef, options?: IRepoOptions): Promise<SingleResult<ClusterDef>>;
+    update(request: ClusterDef, options?: IThrowingRepoOptions): Promise<ClusterDef>;
     /** Overwrites the given properties of the existing ClusterDef. */
-    tryUpdatePartial(request: Partial<ClusterDef>, options?: IRepoOptions): Promise<SingleResult<PartialWithId<ClusterDef>>>;
-    updatePartial(request: Partial<ClusterDef>, options?: IThrowingRepoOptions): Promise<PartialWithId<ClusterDef>>;
+    tryUpdatePartial(request: ClusterDef, options?: IRepoOptions): Promise<SingleResult<PartialWithId<ClusterDef>>>;
+    updatePartial(request: ClusterDef, options?: IThrowingRepoOptions): Promise<PartialWithId<ClusterDef>>;
     /** Saves the input as a new ClusterDef. */
     tryCreate(request: ClusterDef, options?: IRepoOptions): Promise<SingleResult<ClusterDef>>;
     create(request: ClusterDef, options?: IThrowingRepoOptions): Promise<ClusterDef>;
-    /** Performs the given operation on each existing ClusterDef that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ClusterDef, ClusterDefCriteria>, options?: IRepoOptions): Promise<BatchResult<ClusterDef>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<ClusterDef, ClusterDefCriteria>, options?: IThrowingRepoOptions): Promise<ClusterDef[]>;
     /** Overwrites the given properties for each existing ClusterDef. */
     tryUpdatePartialMany(request: Array<ClusterDef>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<ClusterDef>>>;
     updatePartialMany(request: Array<ClusterDef>, options?: IThrowingRepoOptions): Promise<PartialWithId<ClusterDef>[]>;
-    /** Saves each given input as a new ClusterDef, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<ClusterDef>, options?: IRepoOptions): Promise<BatchResult<ClusterDef>>;
-    upsertMany(request: Array<ClusterDef>, options?: IThrowingRepoOptions): Promise<ClusterDef[]>;
+    /** Performs the given operation on each existing ClusterDef that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ClusterDef, ClusterDefCriteria>, options?: IRepoOptions): Promise<BatchResult<ClusterDef>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<ClusterDef, ClusterDefCriteria>, options?: IThrowingRepoOptions): Promise<ClusterDef[]>;
     /** Saves the input as a new ClusterDef, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: ClusterDef, options?: IRepoOptions): Promise<SingleResult<ClusterDef>>;
     upsert(request: ClusterDef, options?: IThrowingRepoOptions): Promise<ClusterDef>;
+    /** Saves each given input as a new ClusterDef, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<ClusterDef>, options?: IRepoOptions): Promise<BatchResult<ClusterDef>>;
+    upsertMany(request: Array<ClusterDef>, options?: IThrowingRepoOptions): Promise<ClusterDef[]>;
 }
 import { ClusterGrant, ClusterGrantCriteria } from "../contracts";
 declare class ClusterGrantCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new ClusterGrant. */
-    tryCreateMany(request: Array<ClusterGrant>, options?: IRepoOptions): Promise<BatchResult<ClusterGrant>>;
-    createMany(request: Array<ClusterGrant>, options?: IThrowingRepoOptions): Promise<ClusterGrant[]>;
+    /** Deletes each existing ClusterGrant that satisfies the given criteria. */
+    tryDeleteWhere(request: ClusterGrantCriteria, options?: IRepoOptions): Promise<BatchResult<ClusterGrant>>;
+    deleteWhere(request: ClusterGrantCriteria, options?: IThrowingRepoOptions): Promise<ClusterGrant[]>;
     /** Retrieves all the existing ClusterGrant that satisfy the given criteria. */
     tryReadMany(request: ClusterGrantCriteria, options?: IRepoOptions): Promise<ListResult<ClusterGrant>>;
     readMany(request: ClusterGrantCriteria, options?: IThrowingRepoOptions): Promise<ClusterGrant[]>;
-    /** Overwrites each existing ClusterGrant. */
-    tryUpdateMany(request: Array<ClusterGrant>, options?: IRepoOptions): Promise<BatchResult<ClusterGrant>>;
-    updateMany(request: Array<ClusterGrant>, options?: IThrowingRepoOptions): Promise<ClusterGrant[]>;
     /** Performs the given operations on each existing ClusterGrant that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<ClusterGrant, ClusterGrantCriteria>, options?: IRepoOptions): Promise<BatchResult<ClusterGrant>>;
     patchWhere(request: PatchSpecForMany<ClusterGrant, ClusterGrantCriteria>, options?: IThrowingRepoOptions): Promise<ClusterGrant[]>;
-    /** Deletes each existing ClusterGrant that satisfies the given criteria. */
-    tryDeleteWhere(request: ClusterGrantCriteria, options?: IRepoOptions): Promise<BatchResult<ClusterGrant>>;
-    deleteWhere(request: ClusterGrantCriteria, options?: IThrowingRepoOptions): Promise<ClusterGrant[]>;
+    /** Saves each given input as a new ClusterGrant. */
+    tryCreateMany(request: Array<ClusterGrant>, options?: IRepoOptions): Promise<BatchResult<ClusterGrant>>;
+    createMany(request: Array<ClusterGrant>, options?: IThrowingRepoOptions): Promise<ClusterGrant[]>;
+    /** Overwrites each existing ClusterGrant. */
+    tryUpdateMany(request: Array<ClusterGrant>, options?: IRepoOptions): Promise<BatchResult<ClusterGrant>>;
+    updateMany(request: Array<ClusterGrant>, options?: IThrowingRepoOptions): Promise<ClusterGrant[]>;
+    /** Deletes the existing ClusterGrant. */
+    tryDelete(request: IdSpecFor<ClusterGrant>, options?: IRepoOptions): Promise<SingleResult<ClusterGrant>>;
+    delete(request: IdSpecFor<ClusterGrant>, options?: IThrowingRepoOptions): Promise<ClusterGrant>;
     /** Retrieves the single, uniquely identified ClusterGrant. */
     tryRead(request: IdSpecFor<ClusterGrant>, options?: IRepoOptions): Promise<SingleResult<ClusterGrant>>;
     read(request: IdSpecFor<ClusterGrant>, options?: IThrowingRepoOptions): Promise<ClusterGrant>;
-    /** Overwrites the existing ClusterGrant. */
-    tryUpdate(request: ClusterGrant, options?: IRepoOptions): Promise<SingleResult<ClusterGrant>>;
-    update(request: ClusterGrant, options?: IThrowingRepoOptions): Promise<ClusterGrant>;
     /** Performs the given operations on the existing ClusterGrant. */
     tryPatch(request: PatchSpecForOne<ClusterGrant>, options?: IRepoOptions): Promise<SingleResult<ClusterGrant>>;
     patch(request: PatchSpecForOne<ClusterGrant>, options?: IThrowingRepoOptions): Promise<ClusterGrant>;
-    /** Deletes the existing ClusterGrant. */
-    tryDelete(request: IdSpecFor<ClusterGrant>, options?: IRepoOptions): Promise<SingleResult<ClusterGrant>>;
-    delete(request: IdSpecFor<ClusterGrant>, options?: IThrowingRepoOptions): Promise<ClusterGrant>;
+    /** Overwrites the existing ClusterGrant. */
+    tryUpdate(request: ClusterGrant, options?: IRepoOptions): Promise<SingleResult<ClusterGrant>>;
+    update(request: ClusterGrant, options?: IThrowingRepoOptions): Promise<ClusterGrant>;
     /** Overwrites the given properties of the existing ClusterGrant. */
     tryUpdatePartial(request: ClusterGrant, options?: IRepoOptions): Promise<SingleResult<PartialWithId<ClusterGrant>>>;
     updatePartial(request: ClusterGrant, options?: IThrowingRepoOptions): Promise<PartialWithId<ClusterGrant>>;
     /** Saves the input as a new ClusterGrant. */
     tryCreate(request: ClusterGrant, options?: IRepoOptions): Promise<SingleResult<ClusterGrant>>;
     create(request: ClusterGrant, options?: IThrowingRepoOptions): Promise<ClusterGrant>;
-    /** Performs the given operation on each existing ClusterGrant that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ClusterGrant, ClusterGrantCriteria>, options?: IRepoOptions): Promise<BatchResult<ClusterGrant>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<ClusterGrant, ClusterGrantCriteria>, options?: IThrowingRepoOptions): Promise<ClusterGrant[]>;
     /** Overwrites the given properties for each existing ClusterGrant. */
     tryUpdatePartialMany(request: Array<ClusterGrant>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<ClusterGrant>>>;
     updatePartialMany(request: Array<ClusterGrant>, options?: IThrowingRepoOptions): Promise<PartialWithId<ClusterGrant>[]>;
-    /** Saves each given input as a new ClusterGrant, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<ClusterGrant>, options?: IRepoOptions): Promise<BatchResult<ClusterGrant>>;
-    upsertMany(request: Array<ClusterGrant>, options?: IThrowingRepoOptions): Promise<ClusterGrant[]>;
+    /** Performs the given operation on each existing ClusterGrant that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ClusterGrant, ClusterGrantCriteria>, options?: IRepoOptions): Promise<BatchResult<ClusterGrant>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<ClusterGrant, ClusterGrantCriteria>, options?: IThrowingRepoOptions): Promise<ClusterGrant[]>;
     /** Saves the input as a new ClusterGrant, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: ClusterGrant, options?: IRepoOptions): Promise<SingleResult<ClusterGrant>>;
     upsert(request: ClusterGrant, options?: IThrowingRepoOptions): Promise<ClusterGrant>;
+    /** Saves each given input as a new ClusterGrant, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<ClusterGrant>, options?: IRepoOptions): Promise<BatchResult<ClusterGrant>>;
+    upsertMany(request: Array<ClusterGrant>, options?: IThrowingRepoOptions): Promise<ClusterGrant[]>;
 }
-import { Cluster, ClusterCriteria } from "../contracts";
-declare class ClusterCruds {
+import { CodiacTenant, CodiacTenantCriteria } from "../contracts";
+declare class CodiacTenantCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new Cluster. */
-    tryCreateMany(request: Array<Cluster>, options?: IRepoOptions): Promise<BatchResult<Cluster>>;
-    createMany(request: Array<Cluster>, options?: IThrowingRepoOptions): Promise<Cluster[]>;
-    /** Retrieves all the existing Cluster that satisfy the given criteria. */
-    tryReadMany(request: ClusterCriteria, options?: IRepoOptions): Promise<ListResult<Cluster>>;
-    readMany(request: ClusterCriteria, options?: IThrowingRepoOptions): Promise<Cluster[]>;
-    /** Overwrites each existing Cluster. */
-    tryUpdateMany(request: Array<Cluster>, options?: IRepoOptions): Promise<BatchResult<Cluster>>;
-    updateMany(request: Array<Cluster>, options?: IThrowingRepoOptions): Promise<Cluster[]>;
-    /** Performs the given operations on each existing Cluster that satisfies the given criteria. */
-    tryPatchWhere(request: PatchSpecForMany<Cluster, ClusterCriteria>, options?: IRepoOptions): Promise<BatchResult<Cluster>>;
-    patchWhere(request: PatchSpecForMany<Cluster, ClusterCriteria>, options?: IThrowingRepoOptions): Promise<Cluster[]>;
-    /** Deletes each existing Cluster that satisfies the given criteria. */
-    tryDeleteWhere(request: ClusterCriteria, options?: IRepoOptions): Promise<BatchResult<Cluster>>;
-    deleteWhere(request: ClusterCriteria, options?: IThrowingRepoOptions): Promise<Cluster[]>;
-    /** Retrieves the single, uniquely identified Cluster. */
-    tryRead(request: IdSpecFor<Cluster>, options?: IRepoOptions): Promise<SingleResult<Cluster>>;
-    read(request: IdSpecFor<Cluster>, options?: IThrowingRepoOptions): Promise<Cluster>;
-    /** Overwrites the existing Cluster. */
-    tryUpdate(request: Cluster, options?: IRepoOptions): Promise<SingleResult<Cluster>>;
-    update(request: Cluster, options?: IThrowingRepoOptions): Promise<Cluster>;
-    /** Performs the given operations on the existing Cluster. */
-    tryPatch(request: PatchSpecForOne<Cluster>, options?: IRepoOptions): Promise<SingleResult<Cluster>>;
-    patch(request: PatchSpecForOne<Cluster>, options?: IThrowingRepoOptions): Promise<Cluster>;
-    /** Deletes the existing Cluster. */
-    tryDelete(request: IdSpecFor<Cluster>, options?: IRepoOptions): Promise<SingleResult<Cluster>>;
-    delete(request: IdSpecFor<Cluster>, options?: IThrowingRepoOptions): Promise<Cluster>;
-    /** Overwrites the given properties of the existing Cluster. */
-    tryUpdatePartial(request: Cluster, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Cluster>>>;
-    updatePartial(request: Cluster, options?: IThrowingRepoOptions): Promise<PartialWithId<Cluster>>;
-    /** Saves the input as a new Cluster. */
-    tryCreate(request: Cluster, options?: IRepoOptions): Promise<SingleResult<Cluster>>;
-    create(request: Cluster, options?: IThrowingRepoOptions): Promise<Cluster>;
-    /** Performs the given operation on each existing Cluster that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Cluster, ClusterCriteria>, options?: IRepoOptions): Promise<BatchResult<Cluster>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<Cluster, ClusterCriteria>, options?: IThrowingRepoOptions): Promise<Cluster[]>;
-    /** Overwrites the given properties for each existing Cluster. */
-    tryUpdatePartialMany(request: Array<Cluster>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Cluster>>>;
-    updatePartialMany(request: Array<Cluster>, options?: IThrowingRepoOptions): Promise<PartialWithId<Cluster>[]>;
-    /** Saves each given input as a new Cluster, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<Cluster>, options?: IRepoOptions): Promise<BatchResult<Cluster>>;
-    upsertMany(request: Array<Cluster>, options?: IThrowingRepoOptions): Promise<Cluster[]>;
-    /** Saves the input as a new Cluster, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsert(request: Cluster, options?: IRepoOptions): Promise<SingleResult<Cluster>>;
-    upsert(request: Cluster, options?: IThrowingRepoOptions): Promise<Cluster>;
+    /** Deletes each existing CodiacTenant that satisfies the given criteria. */
+    tryDeleteWhere(request: CodiacTenantCriteria, options?: IRepoOptions): Promise<BatchResult<CodiacTenant>>;
+    deleteWhere(request: CodiacTenantCriteria, options?: IThrowingRepoOptions): Promise<CodiacTenant[]>;
+    /** Retrieves all the existing CodiacTenant that satisfy the given criteria. */
+    tryReadMany(request: CodiacTenantCriteria, options?: IRepoOptions): Promise<ListResult<CodiacTenant>>;
+    readMany(request: CodiacTenantCriteria, options?: IThrowingRepoOptions): Promise<CodiacTenant[]>;
+    /** Performs the given operations on each existing CodiacTenant that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<CodiacTenant, CodiacTenantCriteria>, options?: IRepoOptions): Promise<BatchResult<CodiacTenant>>;
+    patchWhere(request: PatchSpecForMany<CodiacTenant, CodiacTenantCriteria>, options?: IThrowingRepoOptions): Promise<CodiacTenant[]>;
+    /** Saves each given input as a new CodiacTenant. */
+    tryCreateMany(request: Array<CodiacTenant>, options?: IRepoOptions): Promise<BatchResult<CodiacTenant>>;
+    createMany(request: Array<CodiacTenant>, options?: IThrowingRepoOptions): Promise<CodiacTenant[]>;
+    /** Overwrites each existing CodiacTenant. */
+    tryUpdateMany(request: Array<CodiacTenant>, options?: IRepoOptions): Promise<BatchResult<CodiacTenant>>;
+    updateMany(request: Array<CodiacTenant>, options?: IThrowingRepoOptions): Promise<CodiacTenant[]>;
+    /** Deletes the existing CodiacTenant. */
+    tryDelete(request: IdSpecFor<CodiacTenant>, options?: IRepoOptions): Promise<SingleResult<CodiacTenant>>;
+    delete(request: IdSpecFor<CodiacTenant>, options?: IThrowingRepoOptions): Promise<CodiacTenant>;
+    /** Retrieves the single, uniquely identified CodiacTenant. */
+    tryRead(request: IdSpecFor<CodiacTenant>, options?: IRepoOptions): Promise<SingleResult<CodiacTenant>>;
+    read(request: IdSpecFor<CodiacTenant>, options?: IThrowingRepoOptions): Promise<CodiacTenant>;
+    /** Performs the given operations on the existing CodiacTenant. */
+    tryPatch(request: PatchSpecForOne<CodiacTenant>, options?: IRepoOptions): Promise<SingleResult<CodiacTenant>>;
+    patch(request: PatchSpecForOne<CodiacTenant>, options?: IThrowingRepoOptions): Promise<CodiacTenant>;
+    /** Overwrites the existing CodiacTenant. */
+    tryUpdate(request: CodiacTenant, options?: IRepoOptions): Promise<SingleResult<CodiacTenant>>;
+    update(request: CodiacTenant, options?: IThrowingRepoOptions): Promise<CodiacTenant>;
+    /** Overwrites the given properties of the existing CodiacTenant. */
+    tryUpdatePartial(request: CodiacTenant, options?: IRepoOptions): Promise<SingleResult<PartialWithId<CodiacTenant>>>;
+    updatePartial(request: CodiacTenant, options?: IThrowingRepoOptions): Promise<PartialWithId<CodiacTenant>>;
+    /** Saves the input as a new CodiacTenant. */
+    tryCreate(request: CodiacTenant, options?: IRepoOptions): Promise<SingleResult<CodiacTenant>>;
+    create(request: CodiacTenant, options?: IThrowingRepoOptions): Promise<CodiacTenant>;
+    /** Overwrites the given properties for each existing CodiacTenant. */
+    tryUpdatePartialMany(request: Array<CodiacTenant>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<CodiacTenant>>>;
+    updatePartialMany(request: Array<CodiacTenant>, options?: IThrowingRepoOptions): Promise<PartialWithId<CodiacTenant>[]>;
+    /** Performs the given operation on each existing CodiacTenant that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<CodiacTenant, CodiacTenantCriteria>, options?: IRepoOptions): Promise<BatchResult<CodiacTenant>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<CodiacTenant, CodiacTenantCriteria>, options?: IThrowingRepoOptions): Promise<CodiacTenant[]>;
+    /** Saves the input as a new CodiacTenant, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: CodiacTenant, options?: IRepoOptions): Promise<SingleResult<CodiacTenant>>;
+    upsert(request: CodiacTenant, options?: IThrowingRepoOptions): Promise<CodiacTenant>;
+    /** Saves each given input as a new CodiacTenant, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<CodiacTenant>, options?: IRepoOptions): Promise<BatchResult<CodiacTenant>>;
+    upsertMany(request: Array<CodiacTenant>, options?: IThrowingRepoOptions): Promise<CodiacTenant[]>;
+}
+declare class CodiacUserCruds {
+    private core;
+    constructor(core: ApiClientBase);
+    /** Retrieves all the existing CodiacUser that satisfy the given criteria. */
+    tryReadMany(request: CodiacUserCriteria, options?: IRepoOptions): Promise<ListResult<CodiacUser>>;
+    readMany(request: CodiacUserCriteria, options?: IThrowingRepoOptions): Promise<CodiacUser[]>;
+    /** Retrieves the single, uniquely identified CodiacUser. */
+    tryRead(request: IdSpecFor<CodiacUser>, options?: IRepoOptions): Promise<SingleResult<CodiacUser>>;
+    read(request: IdSpecFor<CodiacUser>, options?: IThrowingRepoOptions): Promise<CodiacUser>;
 }
 import { Comment, CommentCriteria } from "../contracts";
 declare class CommentCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new Comment. */
-    tryCreateMany(request: Array<Comment>, options?: IRepoOptions): Promise<BatchResult<Comment>>;
-    createMany(request: Array<Comment>, options?: IThrowingRepoOptions): Promise<Comment[]>;
+    /** Deletes each existing Comment that satisfies the given criteria. */
+    tryDeleteWhere(request: CommentCriteria, options?: IRepoOptions): Promise<BatchResult<Comment>>;
+    deleteWhere(request: CommentCriteria, options?: IThrowingRepoOptions): Promise<Comment[]>;
     /** Retrieves all the existing Comment that satisfy the given criteria. */
     tryReadMany(request: CommentCriteria, options?: IRepoOptions): Promise<ListResult<Comment>>;
     readMany(request: CommentCriteria, options?: IThrowingRepoOptions): Promise<Comment[]>;
-    /** Overwrites each existing Comment. */
-    tryUpdateMany(request: Array<Comment>, options?: IRepoOptions): Promise<BatchResult<Comment>>;
-    updateMany(request: Array<Comment>, options?: IThrowingRepoOptions): Promise<Comment[]>;
     /** Performs the given operations on each existing Comment that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<Comment, CommentCriteria>, options?: IRepoOptions): Promise<BatchResult<Comment>>;
     patchWhere(request: PatchSpecForMany<Comment, CommentCriteria>, options?: IThrowingRepoOptions): Promise<Comment[]>;
-    /** Deletes each existing Comment that satisfies the given criteria. */
-    tryDeleteWhere(request: CommentCriteria, options?: IRepoOptions): Promise<BatchResult<Comment>>;
-    deleteWhere(request: CommentCriteria, options?: IThrowingRepoOptions): Promise<Comment[]>;
+    /** Saves each given input as a new Comment. */
+    tryCreateMany(request: Array<Comment>, options?: IRepoOptions): Promise<BatchResult<Comment>>;
+    createMany(request: Array<Comment>, options?: IThrowingRepoOptions): Promise<Comment[]>;
+    /** Overwrites each existing Comment. */
+    tryUpdateMany(request: Array<Comment>, options?: IRepoOptions): Promise<BatchResult<Comment>>;
+    updateMany(request: Array<Comment>, options?: IThrowingRepoOptions): Promise<Comment[]>;
+    /** Deletes the existing Comment. */
+    tryDelete(request: IdSpecFor<Comment>, options?: IRepoOptions): Promise<SingleResult<Comment>>;
+    delete(request: IdSpecFor<Comment>, options?: IThrowingRepoOptions): Promise<Comment>;
     /** Retrieves the single, uniquely identified Comment. */
     tryRead(request: IdSpecFor<Comment>, options?: IRepoOptions): Promise<SingleResult<Comment>>;
     read(request: IdSpecFor<Comment>, options?: IThrowingRepoOptions): Promise<Comment>;
-    /** Overwrites the existing Comment. */
-    tryUpdate(request: Comment, options?: IRepoOptions): Promise<SingleResult<Comment>>;
-    update(request: Comment, options?: IThrowingRepoOptions): Promise<Comment>;
     /** Performs the given operations on the existing Comment. */
     tryPatch(request: PatchSpecForOne<Comment>, options?: IRepoOptions): Promise<SingleResult<Comment>>;
     patch(request: PatchSpecForOne<Comment>, options?: IThrowingRepoOptions): Promise<Comment>;
-    /** Deletes the existing Comment. */
-    tryDelete(request: IdSpecFor<Comment>, options?: IRepoOptions): Promise<SingleResult<Comment>>;
-    delete(request: IdSpecFor<Comment>, options?: IThrowingRepoOptions): Promise<Comment>;
+    /** Overwrites the existing Comment. */
+    tryUpdate(request: Comment, options?: IRepoOptions): Promise<SingleResult<Comment>>;
+    update(request: Comment, options?: IThrowingRepoOptions): Promise<Comment>;
     /** Overwrites the given properties of the existing Comment. */
     tryUpdatePartial(request: Comment, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Comment>>>;
     updatePartial(request: Comment, options?: IThrowingRepoOptions): Promise<PartialWithId<Comment>>;
     /** Saves the input as a new Comment. */
     tryCreate(request: Comment, options?: IRepoOptions): Promise<SingleResult<Comment>>;
     create(request: Comment, options?: IThrowingRepoOptions): Promise<Comment>;
-    /** Performs the given operation on each existing Comment that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Comment, CommentCriteria>, options?: IRepoOptions): Promise<BatchResult<Comment>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<Comment, CommentCriteria>, options?: IThrowingRepoOptions): Promise<Comment[]>;
     /** Overwrites the given properties for each existing Comment. */
     tryUpdatePartialMany(request: Array<Comment>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Comment>>>;
     updatePartialMany(request: Array<Comment>, options?: IThrowingRepoOptions): Promise<PartialWithId<Comment>[]>;
-    /** Saves each given input as a new Comment, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<Comment>, options?: IRepoOptions): Promise<BatchResult<Comment>>;
-    upsertMany(request: Array<Comment>, options?: IThrowingRepoOptions): Promise<Comment[]>;
+    /** Performs the given operation on each existing Comment that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Comment, CommentCriteria>, options?: IRepoOptions): Promise<BatchResult<Comment>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Comment, CommentCriteria>, options?: IThrowingRepoOptions): Promise<Comment[]>;
     /** Saves the input as a new Comment, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: Comment, options?: IRepoOptions): Promise<SingleResult<Comment>>;
     upsert(request: Comment, options?: IThrowingRepoOptions): Promise<Comment>;
+    /** Saves each given input as a new Comment, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Comment>, options?: IRepoOptions): Promise<BatchResult<Comment>>;
+    upsertMany(request: Array<Comment>, options?: IThrowingRepoOptions): Promise<Comment[]>;
 }
 import { ConfigChange, ConfigChangeCriteria } from "../contracts";
 declare class ConfigChangeCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new ConfigChange. */
-    tryCreateMany(request: Array<ConfigChange>, options?: IRepoOptions): Promise<BatchResult<ConfigChange>>;
-    createMany(request: Array<ConfigChange>, options?: IThrowingRepoOptions): Promise<ConfigChange[]>;
+    /** Deletes each existing ConfigChange that satisfies the given criteria. */
+    tryDeleteWhere(request: ConfigChangeCriteria, options?: IRepoOptions): Promise<BatchResult<ConfigChange>>;
+    deleteWhere(request: ConfigChangeCriteria, options?: IThrowingRepoOptions): Promise<ConfigChange[]>;
     /** Retrieves all the existing ConfigChange that satisfy the given criteria. */
     tryReadMany(request: ConfigChangeCriteria, options?: IRepoOptions): Promise<ListResult<ConfigChange>>;
     readMany(request: ConfigChangeCriteria, options?: IThrowingRepoOptions): Promise<ConfigChange[]>;
-    /** Overwrites each existing ConfigChange. */
-    tryUpdateMany(request: Array<ConfigChange>, options?: IRepoOptions): Promise<BatchResult<ConfigChange>>;
-    updateMany(request: Array<ConfigChange>, options?: IThrowingRepoOptions): Promise<ConfigChange[]>;
     /** Performs the given operations on each existing ConfigChange that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<ConfigChange, ConfigChangeCriteria>, options?: IRepoOptions): Promise<BatchResult<ConfigChange>>;
     patchWhere(request: PatchSpecForMany<ConfigChange, ConfigChangeCriteria>, options?: IThrowingRepoOptions): Promise<ConfigChange[]>;
-    /** Deletes each existing ConfigChange that satisfies the given criteria. */
-    tryDeleteWhere(request: ConfigChangeCriteria, options?: IRepoOptions): Promise<BatchResult<ConfigChange>>;
-    deleteWhere(request: ConfigChangeCriteria, options?: IThrowingRepoOptions): Promise<ConfigChange[]>;
+    /** Saves each given input as a new ConfigChange. */
+    tryCreateMany(request: Array<ConfigChange>, options?: IRepoOptions): Promise<BatchResult<ConfigChange>>;
+    createMany(request: Array<ConfigChange>, options?: IThrowingRepoOptions): Promise<ConfigChange[]>;
+    /** Overwrites each existing ConfigChange. */
+    tryUpdateMany(request: Array<ConfigChange>, options?: IRepoOptions): Promise<BatchResult<ConfigChange>>;
+    updateMany(request: Array<ConfigChange>, options?: IThrowingRepoOptions): Promise<ConfigChange[]>;
+    /** Deletes the existing ConfigChange. */
+    tryDelete(request: IdSpecFor<ConfigChange>, options?: IRepoOptions): Promise<SingleResult<ConfigChange>>;
+    delete(request: IdSpecFor<ConfigChange>, options?: IThrowingRepoOptions): Promise<ConfigChange>;
     /** Retrieves the single, uniquely identified ConfigChange. */
     tryRead(request: IdSpecFor<ConfigChange>, options?: IRepoOptions): Promise<SingleResult<ConfigChange>>;
     read(request: IdSpecFor<ConfigChange>, options?: IThrowingRepoOptions): Promise<ConfigChange>;
-    /** Overwrites the existing ConfigChange. */
-    tryUpdate(request: ConfigChange, options?: IRepoOptions): Promise<SingleResult<ConfigChange>>;
-    update(request: ConfigChange, options?: IThrowingRepoOptions): Promise<ConfigChange>;
     /** Performs the given operations on the existing ConfigChange. */
-    tryPatch(request: PatchSpecForOne<ConfigChange>, options?: IRepoOptions): Promise<SingleResult<ConfigChange>>;
-    patch(request: PatchSpecForOne<ConfigChange>, options?: IThrowingRepoOptions): Promise<ConfigChange>;
-    /** Deletes the existing ConfigChange. */
-    tryDelete(request: IdSpecFor<ConfigChange>, options?: IRepoOptions): Promise<SingleResult<ConfigChange>>;
-    delete(request: IdSpecFor<ConfigChange>, options?: IThrowingRepoOptions): Promise<ConfigChange>;
+    tryPatch(request: PatchSpecForOne<ConfigChange>, options?: IRepoOptions): Promise<SingleResult<ConfigChange>>;
+    patch(request: PatchSpecForOne<ConfigChange>, options?: IThrowingRepoOptions): Promise<ConfigChange>;
+    /** Overwrites the existing ConfigChange. */
+    tryUpdate(request: ConfigChange, options?: IRepoOptions): Promise<SingleResult<ConfigChange>>;
+    update(request: ConfigChange, options?: IThrowingRepoOptions): Promise<ConfigChange>;
     /** Overwrites the given properties of the existing ConfigChange. */
     tryUpdatePartial(request: ConfigChange, options?: IRepoOptions): Promise<SingleResult<PartialWithId<ConfigChange>>>;
     updatePartial(request: ConfigChange, options?: IThrowingRepoOptions): Promise<PartialWithId<ConfigChange>>;
     /** Saves the input as a new ConfigChange. */
     tryCreate(request: ConfigChange, options?: IRepoOptions): Promise<SingleResult<ConfigChange>>;
     create(request: ConfigChange, options?: IThrowingRepoOptions): Promise<ConfigChange>;
-    /** Performs the given operation on each existing ConfigChange that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ConfigChange, ConfigChangeCriteria>, options?: IRepoOptions): Promise<BatchResult<ConfigChange>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<ConfigChange, ConfigChangeCriteria>, options?: IThrowingRepoOptions): Promise<ConfigChange[]>;
     /** Overwrites the given properties for each existing ConfigChange. */
     tryUpdatePartialMany(request: Array<ConfigChange>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<ConfigChange>>>;
     updatePartialMany(request: Array<ConfigChange>, options?: IThrowingRepoOptions): Promise<PartialWithId<ConfigChange>[]>;
-    /** Saves each given input as a new ConfigChange, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<ConfigChange>, options?: IRepoOptions): Promise<BatchResult<ConfigChange>>;
-    upsertMany(request: Array<ConfigChange>, options?: IThrowingRepoOptions): Promise<ConfigChange[]>;
+    /** Performs the given operation on each existing ConfigChange that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ConfigChange, ConfigChangeCriteria>, options?: IRepoOptions): Promise<BatchResult<ConfigChange>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<ConfigChange, ConfigChangeCriteria>, options?: IThrowingRepoOptions): Promise<ConfigChange[]>;
     /** Saves the input as a new ConfigChange, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: ConfigChange, options?: IRepoOptions): Promise<SingleResult<ConfigChange>>;
     upsert(request: ConfigChange, options?: IThrowingRepoOptions): Promise<ConfigChange>;
+    /** Saves each given input as a new ConfigChange, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<ConfigChange>, options?: IRepoOptions): Promise<BatchResult<ConfigChange>>;
+    upsertMany(request: Array<ConfigChange>, options?: IThrowingRepoOptions): Promise<ConfigChange[]>;
+}
+import { ConfigDeploymentActivity, ConfigDeploymentActivityCriteria } from "../contracts";
+declare class ConfigDeploymentActivityCruds {
+    private core;
+    constructor(core: ApiClientBase);
+    /** Deletes each existing ConfigDeploymentActivity that satisfies the given criteria. */
+    tryDeleteWhere(request: ConfigDeploymentActivityCriteria, options?: IRepoOptions): Promise<BatchResult<ConfigDeploymentActivity>>;
+    deleteWhere(request: ConfigDeploymentActivityCriteria, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity[]>;
+    /** Retrieves all the existing ConfigDeploymentActivity that satisfy the given criteria. */
+    tryReadMany(request: ConfigDeploymentActivityCriteria, options?: IRepoOptions): Promise<ListResult<ConfigDeploymentActivity>>;
+    readMany(request: ConfigDeploymentActivityCriteria, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity[]>;
+    /** Performs the given operations on each existing ConfigDeploymentActivity that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<ConfigDeploymentActivity, ConfigDeploymentActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<ConfigDeploymentActivity>>;
+    patchWhere(request: PatchSpecForMany<ConfigDeploymentActivity, ConfigDeploymentActivityCriteria>, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity[]>;
+    /** Saves each given input as a new ConfigDeploymentActivity. */
+    tryCreateMany(request: Array<ConfigDeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<ConfigDeploymentActivity>>;
+    createMany(request: Array<ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity[]>;
+    /** Overwrites each existing ConfigDeploymentActivity. */
+    tryUpdateMany(request: Array<ConfigDeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<ConfigDeploymentActivity>>;
+    updateMany(request: Array<ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity[]>;
+    /** Deletes the existing ConfigDeploymentActivity. */
+    tryDelete(request: IdSpecFor<ConfigDeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<ConfigDeploymentActivity>>;
+    delete(request: IdSpecFor<ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity>;
+    /** Retrieves the single, uniquely identified ConfigDeploymentActivity. */
+    tryRead(request: IdSpecFor<ConfigDeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<ConfigDeploymentActivity>>;
+    read(request: IdSpecFor<ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity>;
+    /** Performs the given operations on the existing ConfigDeploymentActivity. */
+    tryPatch(request: PatchSpecForOne<ConfigDeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<ConfigDeploymentActivity>>;
+    patch(request: PatchSpecForOne<ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity>;
+    /** Overwrites the existing ConfigDeploymentActivity. */
+    tryUpdate(request: ConfigDeploymentActivity, options?: IRepoOptions): Promise<SingleResult<ConfigDeploymentActivity>>;
+    update(request: ConfigDeploymentActivity, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity>;
+    /** Overwrites the given properties of the existing ConfigDeploymentActivity. */
+    tryUpdatePartial(request: ConfigDeploymentActivity, options?: IRepoOptions): Promise<SingleResult<PartialWithId<ConfigDeploymentActivity>>>;
+    updatePartial(request: ConfigDeploymentActivity, options?: IThrowingRepoOptions): Promise<PartialWithId<ConfigDeploymentActivity>>;
+    /** Saves the input as a new ConfigDeploymentActivity. */
+    tryCreate(request: ConfigDeploymentActivity, options?: IRepoOptions): Promise<SingleResult<ConfigDeploymentActivity>>;
+    create(request: ConfigDeploymentActivity, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity>;
+    /** Overwrites the given properties for each existing ConfigDeploymentActivity. */
+    tryUpdatePartialMany(request: Array<ConfigDeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<ConfigDeploymentActivity>>>;
+    updatePartialMany(request: Array<ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<PartialWithId<ConfigDeploymentActivity>[]>;
+    /** Performs the given operation on each existing ConfigDeploymentActivity that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ConfigDeploymentActivity, ConfigDeploymentActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<ConfigDeploymentActivity>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<ConfigDeploymentActivity, ConfigDeploymentActivityCriteria>, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity[]>;
+    /** Saves the input as a new ConfigDeploymentActivity, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: ConfigDeploymentActivity, options?: IRepoOptions): Promise<SingleResult<ConfigDeploymentActivity>>;
+    upsert(request: ConfigDeploymentActivity, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity>;
+    /** Saves each given input as a new ConfigDeploymentActivity, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<ConfigDeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<ConfigDeploymentActivity>>;
+    upsertMany(request: Array<ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<ConfigDeploymentActivity[]>;
 }
 import { ContainerFootprint, ContainerFootprintCriteria } from "../contracts";
 declare class ContainerFootprintCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new ContainerFootprint. */
-    tryCreateMany(request: Array<ContainerFootprint>, options?: IRepoOptions): Promise<BatchResult<ContainerFootprint>>;
-    createMany(request: Array<ContainerFootprint>, options?: IThrowingRepoOptions): Promise<ContainerFootprint[]>;
+    /** Deletes each existing ContainerFootprint that satisfies the given criteria. */
+    tryDeleteWhere(request: ContainerFootprintCriteria, options?: IRepoOptions): Promise<BatchResult<ContainerFootprint>>;
+    deleteWhere(request: ContainerFootprintCriteria, options?: IThrowingRepoOptions): Promise<ContainerFootprint[]>;
     /** Retrieves all the existing ContainerFootprint that satisfy the given criteria. */
     tryReadMany(request: ContainerFootprintCriteria, options?: IRepoOptions): Promise<ListResult<ContainerFootprint>>;
     readMany(request: ContainerFootprintCriteria, options?: IThrowingRepoOptions): Promise<ContainerFootprint[]>;
-    /** Overwrites each existing ContainerFootprint. */
-    tryUpdateMany(request: Array<ContainerFootprint>, options?: IRepoOptions): Promise<BatchResult<ContainerFootprint>>;
-    updateMany(request: Array<ContainerFootprint>, options?: IThrowingRepoOptions): Promise<ContainerFootprint[]>;
     /** Performs the given operations on each existing ContainerFootprint that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<ContainerFootprint, ContainerFootprintCriteria>, options?: IRepoOptions): Promise<BatchResult<ContainerFootprint>>;
     patchWhere(request: PatchSpecForMany<ContainerFootprint, ContainerFootprintCriteria>, options?: IThrowingRepoOptions): Promise<ContainerFootprint[]>;
-    /** Deletes each existing ContainerFootprint that satisfies the given criteria. */
-    tryDeleteWhere(request: ContainerFootprintCriteria, options?: IRepoOptions): Promise<BatchResult<ContainerFootprint>>;
-    deleteWhere(request: ContainerFootprintCriteria, options?: IThrowingRepoOptions): Promise<ContainerFootprint[]>;
+    /** Saves each given input as a new ContainerFootprint. */
+    tryCreateMany(request: Array<ContainerFootprint>, options?: IRepoOptions): Promise<BatchResult<ContainerFootprint>>;
+    createMany(request: Array<ContainerFootprint>, options?: IThrowingRepoOptions): Promise<ContainerFootprint[]>;
+    /** Overwrites each existing ContainerFootprint. */
+    tryUpdateMany(request: Array<ContainerFootprint>, options?: IRepoOptions): Promise<BatchResult<ContainerFootprint>>;
+    updateMany(request: Array<ContainerFootprint>, options?: IThrowingRepoOptions): Promise<ContainerFootprint[]>;
+    /** Deletes the existing ContainerFootprint. */
+    tryDelete(request: IdSpecFor<ContainerFootprint>, options?: IRepoOptions): Promise<SingleResult<ContainerFootprint>>;
+    delete(request: IdSpecFor<ContainerFootprint>, options?: IThrowingRepoOptions): Promise<ContainerFootprint>;
     /** Retrieves the single, uniquely identified ContainerFootprint. */
     tryRead(request: IdSpecFor<ContainerFootprint>, options?: IRepoOptions): Promise<SingleResult<ContainerFootprint>>;
     read(request: IdSpecFor<ContainerFootprint>, options?: IThrowingRepoOptions): Promise<ContainerFootprint>;
-    /** Overwrites the existing ContainerFootprint. */
-    tryUpdate(request: ContainerFootprint, options?: IRepoOptions): Promise<SingleResult<ContainerFootprint>>;
-    update(request: ContainerFootprint, options?: IThrowingRepoOptions): Promise<ContainerFootprint>;
     /** Performs the given operations on the existing ContainerFootprint. */
     tryPatch(request: PatchSpecForOne<ContainerFootprint>, options?: IRepoOptions): Promise<SingleResult<ContainerFootprint>>;
     patch(request: PatchSpecForOne<ContainerFootprint>, options?: IThrowingRepoOptions): Promise<ContainerFootprint>;
-    /** Deletes the existing ContainerFootprint. */
-    tryDelete(request: IdSpecFor<ContainerFootprint>, options?: IRepoOptions): Promise<SingleResult<ContainerFootprint>>;
-    delete(request: IdSpecFor<ContainerFootprint>, options?: IThrowingRepoOptions): Promise<ContainerFootprint>;
+    /** Overwrites the existing ContainerFootprint. */
+    tryUpdate(request: ContainerFootprint, options?: IRepoOptions): Promise<SingleResult<ContainerFootprint>>;
+    update(request: ContainerFootprint, options?: IThrowingRepoOptions): Promise<ContainerFootprint>;
     /** Overwrites the given properties of the existing ContainerFootprint. */
     tryUpdatePartial(request: ContainerFootprint, options?: IRepoOptions): Promise<SingleResult<PartialWithId<ContainerFootprint>>>;
     updatePartial(request: ContainerFootprint, options?: IThrowingRepoOptions): Promise<PartialWithId<ContainerFootprint>>;
     /** Saves the input as a new ContainerFootprint. */
     tryCreate(request: ContainerFootprint, options?: IRepoOptions): Promise<SingleResult<ContainerFootprint>>;
     create(request: ContainerFootprint, options?: IThrowingRepoOptions): Promise<ContainerFootprint>;
-    /** Performs the given operation on each existing ContainerFootprint that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ContainerFootprint, ContainerFootprintCriteria>, options?: IRepoOptions): Promise<BatchResult<ContainerFootprint>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<ContainerFootprint, ContainerFootprintCriteria>, options?: IThrowingRepoOptions): Promise<ContainerFootprint[]>;
     /** Overwrites the given properties for each existing ContainerFootprint. */
     tryUpdatePartialMany(request: Array<ContainerFootprint>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<ContainerFootprint>>>;
     updatePartialMany(request: Array<ContainerFootprint>, options?: IThrowingRepoOptions): Promise<PartialWithId<ContainerFootprint>[]>;
-    /** Saves each given input as a new ContainerFootprint, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<ContainerFootprint>, options?: IRepoOptions): Promise<BatchResult<ContainerFootprint>>;
-    upsertMany(request: Array<ContainerFootprint>, options?: IThrowingRepoOptions): Promise<ContainerFootprint[]>;
+    /** Performs the given operation on each existing ContainerFootprint that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ContainerFootprint, ContainerFootprintCriteria>, options?: IRepoOptions): Promise<BatchResult<ContainerFootprint>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<ContainerFootprint, ContainerFootprintCriteria>, options?: IThrowingRepoOptions): Promise<ContainerFootprint[]>;
     /** Saves the input as a new ContainerFootprint, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: ContainerFootprint, options?: IRepoOptions): Promise<SingleResult<ContainerFootprint>>;
     upsert(request: ContainerFootprint, options?: IThrowingRepoOptions): Promise<ContainerFootprint>;
+    /** Saves each given input as a new ContainerFootprint, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<ContainerFootprint>, options?: IRepoOptions): Promise<BatchResult<ContainerFootprint>>;
+    upsertMany(request: Array<ContainerFootprint>, options?: IThrowingRepoOptions): Promise<ContainerFootprint[]>;
 }
 import { CspTenantProfile, CspTenantProfileCriteria } from "../contracts";
 declare class CspTenantProfileCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new CspTenantProfile. */
-    tryCreateMany(request: Array<CspTenantProfile>, options?: IRepoOptions): Promise<BatchResult<CspTenantProfile>>;
-    createMany(request: Array<CspTenantProfile>, options?: IThrowingRepoOptions): Promise<CspTenantProfile[]>;
+    /** Deletes each existing CspTenantProfile that satisfies the given criteria. */
+    tryDeleteWhere(request: CspTenantProfileCriteria, options?: IRepoOptions): Promise<BatchResult<CspTenantProfile>>;
+    deleteWhere(request: CspTenantProfileCriteria, options?: IThrowingRepoOptions): Promise<CspTenantProfile[]>;
     /** Retrieves all the existing CspTenantProfile that satisfy the given criteria. */
     tryReadMany(request: CspTenantProfileCriteria, options?: IRepoOptions): Promise<ListResult<CspTenantProfile>>;
     readMany(request: CspTenantProfileCriteria, options?: IThrowingRepoOptions): Promise<CspTenantProfile[]>;
-    /** Overwrites each existing CspTenantProfile. */
-    tryUpdateMany(request: Array<CspTenantProfile>, options?: IRepoOptions): Promise<BatchResult<CspTenantProfile>>;
-    updateMany(request: Array<CspTenantProfile>, options?: IThrowingRepoOptions): Promise<CspTenantProfile[]>;
     /** Performs the given operations on each existing CspTenantProfile that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<CspTenantProfile, CspTenantProfileCriteria>, options?: IRepoOptions): Promise<BatchResult<CspTenantProfile>>;
     patchWhere(request: PatchSpecForMany<CspTenantProfile, CspTenantProfileCriteria>, options?: IThrowingRepoOptions): Promise<CspTenantProfile[]>;
-    /** Deletes each existing CspTenantProfile that satisfies the given criteria. */
-    tryDeleteWhere(request: CspTenantProfileCriteria, options?: IRepoOptions): Promise<BatchResult<CspTenantProfile>>;
-    deleteWhere(request: CspTenantProfileCriteria, options?: IThrowingRepoOptions): Promise<CspTenantProfile[]>;
+    /** Saves each given input as a new CspTenantProfile. */
+    tryCreateMany(request: Array<CspTenantProfile>, options?: IRepoOptions): Promise<BatchResult<CspTenantProfile>>;
+    createMany(request: Array<CspTenantProfile>, options?: IThrowingRepoOptions): Promise<CspTenantProfile[]>;
+    /** Overwrites each existing CspTenantProfile. */
+    tryUpdateMany(request: Array<CspTenantProfile>, options?: IRepoOptions): Promise<BatchResult<CspTenantProfile>>;
+    updateMany(request: Array<CspTenantProfile>, options?: IThrowingRepoOptions): Promise<CspTenantProfile[]>;
+    /** Deletes the existing CspTenantProfile. */
+    tryDelete(request: IdSpecFor<CspTenantProfile>, options?: IRepoOptions): Promise<SingleResult<CspTenantProfile>>;
+    delete(request: IdSpecFor<CspTenantProfile>, options?: IThrowingRepoOptions): Promise<CspTenantProfile>;
     /** Retrieves the single, uniquely identified CspTenantProfile. */
     tryRead(request: IdSpecFor<CspTenantProfile>, options?: IRepoOptions): Promise<SingleResult<CspTenantProfile>>;
     read(request: IdSpecFor<CspTenantProfile>, options?: IThrowingRepoOptions): Promise<CspTenantProfile>;
-    /** Overwrites the existing CspTenantProfile. */
-    tryUpdate(request: CspTenantProfile, options?: IRepoOptions): Promise<SingleResult<CspTenantProfile>>;
-    update(request: CspTenantProfile, options?: IThrowingRepoOptions): Promise<CspTenantProfile>;
     /** Performs the given operations on the existing CspTenantProfile. */
     tryPatch(request: PatchSpecForOne<CspTenantProfile>, options?: IRepoOptions): Promise<SingleResult<CspTenantProfile>>;
     patch(request: PatchSpecForOne<CspTenantProfile>, options?: IThrowingRepoOptions): Promise<CspTenantProfile>;
-    /** Deletes the existing CspTenantProfile. */
-    tryDelete(request: IdSpecFor<CspTenantProfile>, options?: IRepoOptions): Promise<SingleResult<CspTenantProfile>>;
-    delete(request: IdSpecFor<CspTenantProfile>, options?: IThrowingRepoOptions): Promise<CspTenantProfile>;
+    /** Overwrites the existing CspTenantProfile. */
+    tryUpdate(request: CspTenantProfile, options?: IRepoOptions): Promise<SingleResult<CspTenantProfile>>;
+    update(request: CspTenantProfile, options?: IThrowingRepoOptions): Promise<CspTenantProfile>;
     /** Overwrites the given properties of the existing CspTenantProfile. */
     tryUpdatePartial(request: CspTenantProfile, options?: IRepoOptions): Promise<SingleResult<PartialWithId<CspTenantProfile>>>;
     updatePartial(request: CspTenantProfile, options?: IThrowingRepoOptions): Promise<PartialWithId<CspTenantProfile>>;
     /** Saves the input as a new CspTenantProfile. */
     tryCreate(request: CspTenantProfile, options?: IRepoOptions): Promise<SingleResult<CspTenantProfile>>;
     create(request: CspTenantProfile, options?: IThrowingRepoOptions): Promise<CspTenantProfile>;
-    /** Performs the given operation on each existing CspTenantProfile that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<CspTenantProfile, CspTenantProfileCriteria>, options?: IRepoOptions): Promise<BatchResult<CspTenantProfile>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<CspTenantProfile, CspTenantProfileCriteria>, options?: IThrowingRepoOptions): Promise<CspTenantProfile[]>;
     /** Overwrites the given properties for each existing CspTenantProfile. */
     tryUpdatePartialMany(request: Array<CspTenantProfile>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<CspTenantProfile>>>;
     updatePartialMany(request: Array<CspTenantProfile>, options?: IThrowingRepoOptions): Promise<PartialWithId<CspTenantProfile>[]>;
-    /** Saves each given input as a new CspTenantProfile, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<CspTenantProfile>, options?: IRepoOptions): Promise<BatchResult<CspTenantProfile>>;
-    upsertMany(request: Array<CspTenantProfile>, options?: IThrowingRepoOptions): Promise<CspTenantProfile[]>;
+    /** Performs the given operation on each existing CspTenantProfile that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<CspTenantProfile, CspTenantProfileCriteria>, options?: IRepoOptions): Promise<BatchResult<CspTenantProfile>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<CspTenantProfile, CspTenantProfileCriteria>, options?: IThrowingRepoOptions): Promise<CspTenantProfile[]>;
     /** Saves the input as a new CspTenantProfile, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: CspTenantProfile, options?: IRepoOptions): Promise<SingleResult<CspTenantProfile>>;
     upsert(request: CspTenantProfile, options?: IThrowingRepoOptions): Promise<CspTenantProfile>;
+    /** Saves each given input as a new CspTenantProfile, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<CspTenantProfile>, options?: IRepoOptions): Promise<BatchResult<CspTenantProfile>>;
+    upsertMany(request: Array<CspTenantProfile>, options?: IThrowingRepoOptions): Promise<CspTenantProfile[]>;
 }
 import { DeployAttempt, DeployAttemptCriteria } from "../contracts";
 declare class DeployAttemptCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new DeployAttempt. */
-    tryCreateMany(request: Array<DeployAttempt>, options?: IRepoOptions): Promise<BatchResult<DeployAttempt>>;
-    createMany(request: Array<DeployAttempt>, options?: IThrowingRepoOptions): Promise<DeployAttempt[]>;
+    /** Deletes each existing DeployAttempt that satisfies the given criteria. */
+    tryDeleteWhere(request: DeployAttemptCriteria, options?: IRepoOptions): Promise<BatchResult<DeployAttempt>>;
+    deleteWhere(request: DeployAttemptCriteria, options?: IThrowingRepoOptions): Promise<DeployAttempt[]>;
     /** Retrieves all the existing DeployAttempt that satisfy the given criteria. */
     tryReadMany(request: DeployAttemptCriteria, options?: IRepoOptions): Promise<ListResult<DeployAttempt>>;
     readMany(request: DeployAttemptCriteria, options?: IThrowingRepoOptions): Promise<DeployAttempt[]>;
-    /** Overwrites each existing DeployAttempt. */
-    tryUpdateMany(request: Array<DeployAttempt>, options?: IRepoOptions): Promise<BatchResult<DeployAttempt>>;
-    updateMany(request: Array<DeployAttempt>, options?: IThrowingRepoOptions): Promise<DeployAttempt[]>;
     /** Performs the given operations on each existing DeployAttempt that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<DeployAttempt, DeployAttemptCriteria>, options?: IRepoOptions): Promise<BatchResult<DeployAttempt>>;
     patchWhere(request: PatchSpecForMany<DeployAttempt, DeployAttemptCriteria>, options?: IThrowingRepoOptions): Promise<DeployAttempt[]>;
-    /** Deletes each existing DeployAttempt that satisfies the given criteria. */
-    tryDeleteWhere(request: DeployAttemptCriteria, options?: IRepoOptions): Promise<BatchResult<DeployAttempt>>;
-    deleteWhere(request: DeployAttemptCriteria, options?: IThrowingRepoOptions): Promise<DeployAttempt[]>;
+    /** Saves each given input as a new DeployAttempt. */
+    tryCreateMany(request: Array<DeployAttempt>, options?: IRepoOptions): Promise<BatchResult<DeployAttempt>>;
+    createMany(request: Array<DeployAttempt>, options?: IThrowingRepoOptions): Promise<DeployAttempt[]>;
+    /** Overwrites each existing DeployAttempt. */
+    tryUpdateMany(request: Array<DeployAttempt>, options?: IRepoOptions): Promise<BatchResult<DeployAttempt>>;
+    updateMany(request: Array<DeployAttempt>, options?: IThrowingRepoOptions): Promise<DeployAttempt[]>;
+    /** Deletes the existing DeployAttempt. */
+    tryDelete(request: IdSpecFor<DeployAttempt>, options?: IRepoOptions): Promise<SingleResult<DeployAttempt>>;
+    delete(request: IdSpecFor<DeployAttempt>, options?: IThrowingRepoOptions): Promise<DeployAttempt>;
     /** Retrieves the single, uniquely identified DeployAttempt. */
     tryRead(request: IdSpecFor<DeployAttempt>, options?: IRepoOptions): Promise<SingleResult<DeployAttempt>>;
     read(request: IdSpecFor<DeployAttempt>, options?: IThrowingRepoOptions): Promise<DeployAttempt>;
-    /** Overwrites the existing DeployAttempt. */
-    tryUpdate(request: DeployAttempt, options?: IRepoOptions): Promise<SingleResult<DeployAttempt>>;
-    update(request: DeployAttempt, options?: IThrowingRepoOptions): Promise<DeployAttempt>;
     /** Performs the given operations on the existing DeployAttempt. */
     tryPatch(request: PatchSpecForOne<DeployAttempt>, options?: IRepoOptions): Promise<SingleResult<DeployAttempt>>;
     patch(request: PatchSpecForOne<DeployAttempt>, options?: IThrowingRepoOptions): Promise<DeployAttempt>;
-    /** Deletes the existing DeployAttempt. */
-    tryDelete(request: IdSpecFor<DeployAttempt>, options?: IRepoOptions): Promise<SingleResult<DeployAttempt>>;
-    delete(request: IdSpecFor<DeployAttempt>, options?: IThrowingRepoOptions): Promise<DeployAttempt>;
+    /** Overwrites the existing DeployAttempt. */
+    tryUpdate(request: DeployAttempt, options?: IRepoOptions): Promise<SingleResult<DeployAttempt>>;
+    update(request: DeployAttempt, options?: IThrowingRepoOptions): Promise<DeployAttempt>;
     /** Overwrites the given properties of the existing DeployAttempt. */
     tryUpdatePartial(request: DeployAttempt, options?: IRepoOptions): Promise<SingleResult<PartialWithId<DeployAttempt>>>;
     updatePartial(request: DeployAttempt, options?: IThrowingRepoOptions): Promise<PartialWithId<DeployAttempt>>;
     /** Saves the input as a new DeployAttempt. */
     tryCreate(request: DeployAttempt, options?: IRepoOptions): Promise<SingleResult<DeployAttempt>>;
     create(request: DeployAttempt, options?: IThrowingRepoOptions): Promise<DeployAttempt>;
-    /** Performs the given operation on each existing DeployAttempt that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<DeployAttempt, DeployAttemptCriteria>, options?: IRepoOptions): Promise<BatchResult<DeployAttempt>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<DeployAttempt, DeployAttemptCriteria>, options?: IThrowingRepoOptions): Promise<DeployAttempt[]>;
     /** Overwrites the given properties for each existing DeployAttempt. */
     tryUpdatePartialMany(request: Array<DeployAttempt>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<DeployAttempt>>>;
     updatePartialMany(request: Array<DeployAttempt>, options?: IThrowingRepoOptions): Promise<PartialWithId<DeployAttempt>[]>;
-    /** Saves each given input as a new DeployAttempt, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<DeployAttempt>, options?: IRepoOptions): Promise<BatchResult<DeployAttempt>>;
-    upsertMany(request: Array<DeployAttempt>, options?: IThrowingRepoOptions): Promise<DeployAttempt[]>;
+    /** Performs the given operation on each existing DeployAttempt that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<DeployAttempt, DeployAttemptCriteria>, options?: IRepoOptions): Promise<BatchResult<DeployAttempt>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<DeployAttempt, DeployAttemptCriteria>, options?: IThrowingRepoOptions): Promise<DeployAttempt[]>;
     /** Saves the input as a new DeployAttempt, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: DeployAttempt, options?: IRepoOptions): Promise<SingleResult<DeployAttempt>>;
     upsert(request: DeployAttempt, options?: IThrowingRepoOptions): Promise<DeployAttempt>;
+    /** Saves each given input as a new DeployAttempt, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<DeployAttempt>, options?: IRepoOptions): Promise<BatchResult<DeployAttempt>>;
+    upsertMany(request: Array<DeployAttempt>, options?: IThrowingRepoOptions): Promise<DeployAttempt[]>;
 }
 import { DeployPipeline, DeployPipelineCriteria } from "../contracts";
 declare class DeployPipelineCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new DeployPipeline. */
-    tryCreateMany(request: Array<DeployPipeline>, options?: IRepoOptions): Promise<BatchResult<DeployPipeline>>;
-    createMany(request: Array<DeployPipeline>, options?: IThrowingRepoOptions): Promise<DeployPipeline[]>;
+    /** Deletes each existing DeployPipeline that satisfies the given criteria. */
+    tryDeleteWhere(request: DeployPipelineCriteria, options?: IRepoOptions): Promise<BatchResult<DeployPipeline>>;
+    deleteWhere(request: DeployPipelineCriteria, options?: IThrowingRepoOptions): Promise<DeployPipeline[]>;
     /** Retrieves all the existing DeployPipeline that satisfy the given criteria. */
     tryReadMany(request: DeployPipelineCriteria, options?: IRepoOptions): Promise<ListResult<DeployPipeline>>;
     readMany(request: DeployPipelineCriteria, options?: IThrowingRepoOptions): Promise<DeployPipeline[]>;
-    /** Overwrites each existing DeployPipeline. */
-    tryUpdateMany(request: Array<DeployPipeline>, options?: IRepoOptions): Promise<BatchResult<DeployPipeline>>;
-    updateMany(request: Array<DeployPipeline>, options?: IThrowingRepoOptions): Promise<DeployPipeline[]>;
     /** Performs the given operations on each existing DeployPipeline that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<DeployPipeline, DeployPipelineCriteria>, options?: IRepoOptions): Promise<BatchResult<DeployPipeline>>;
     patchWhere(request: PatchSpecForMany<DeployPipeline, DeployPipelineCriteria>, options?: IThrowingRepoOptions): Promise<DeployPipeline[]>;
-    /** Deletes each existing DeployPipeline that satisfies the given criteria. */
-    tryDeleteWhere(request: DeployPipelineCriteria, options?: IRepoOptions): Promise<BatchResult<DeployPipeline>>;
-    deleteWhere(request: DeployPipelineCriteria, options?: IThrowingRepoOptions): Promise<DeployPipeline[]>;
+    /** Saves each given input as a new DeployPipeline. */
+    tryCreateMany(request: Array<DeployPipeline>, options?: IRepoOptions): Promise<BatchResult<DeployPipeline>>;
+    createMany(request: Array<DeployPipeline>, options?: IThrowingRepoOptions): Promise<DeployPipeline[]>;
+    /** Overwrites each existing DeployPipeline. */
+    tryUpdateMany(request: Array<DeployPipeline>, options?: IRepoOptions): Promise<BatchResult<DeployPipeline>>;
+    updateMany(request: Array<DeployPipeline>, options?: IThrowingRepoOptions): Promise<DeployPipeline[]>;
+    /** Deletes the existing DeployPipeline. */
+    tryDelete(request: IdSpecFor<DeployPipeline>, options?: IRepoOptions): Promise<SingleResult<DeployPipeline>>;
+    delete(request: IdSpecFor<DeployPipeline>, options?: IThrowingRepoOptions): Promise<DeployPipeline>;
     /** Retrieves the single, uniquely identified DeployPipeline. */
     tryRead(request: IdSpecFor<DeployPipeline>, options?: IRepoOptions): Promise<SingleResult<DeployPipeline>>;
     read(request: IdSpecFor<DeployPipeline>, options?: IThrowingRepoOptions): Promise<DeployPipeline>;
-    /** Overwrites the existing DeployPipeline. */
-    tryUpdate(request: DeployPipeline, options?: IRepoOptions): Promise<SingleResult<DeployPipeline>>;
-    update(request: DeployPipeline, options?: IThrowingRepoOptions): Promise<DeployPipeline>;
     /** Performs the given operations on the existing DeployPipeline. */
     tryPatch(request: PatchSpecForOne<DeployPipeline>, options?: IRepoOptions): Promise<SingleResult<DeployPipeline>>;
     patch(request: PatchSpecForOne<DeployPipeline>, options?: IThrowingRepoOptions): Promise<DeployPipeline>;
-    /** Deletes the existing DeployPipeline. */
-    tryDelete(request: IdSpecFor<DeployPipeline>, options?: IRepoOptions): Promise<SingleResult<DeployPipeline>>;
-    delete(request: IdSpecFor<DeployPipeline>, options?: IThrowingRepoOptions): Promise<DeployPipeline>;
+    /** Overwrites the existing DeployPipeline. */
+    tryUpdate(request: DeployPipeline, options?: IRepoOptions): Promise<SingleResult<DeployPipeline>>;
+    update(request: DeployPipeline, options?: IThrowingRepoOptions): Promise<DeployPipeline>;
     /** Overwrites the given properties of the existing DeployPipeline. */
     tryUpdatePartial(request: DeployPipeline, options?: IRepoOptions): Promise<SingleResult<PartialWithId<DeployPipeline>>>;
     updatePartial(request: DeployPipeline, options?: IThrowingRepoOptions): Promise<PartialWithId<DeployPipeline>>;
     /** Saves the input as a new DeployPipeline. */
     tryCreate(request: DeployPipeline, options?: IRepoOptions): Promise<SingleResult<DeployPipeline>>;
     create(request: DeployPipeline, options?: IThrowingRepoOptions): Promise<DeployPipeline>;
-    /** Performs the given operation on each existing DeployPipeline that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<DeployPipeline, DeployPipelineCriteria>, options?: IRepoOptions): Promise<BatchResult<DeployPipeline>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<DeployPipeline, DeployPipelineCriteria>, options?: IThrowingRepoOptions): Promise<DeployPipeline[]>;
     /** Overwrites the given properties for each existing DeployPipeline. */
     tryUpdatePartialMany(request: Array<DeployPipeline>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<DeployPipeline>>>;
     updatePartialMany(request: Array<DeployPipeline>, options?: IThrowingRepoOptions): Promise<PartialWithId<DeployPipeline>[]>;
-    /** Saves each given input as a new DeployPipeline, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<DeployPipeline>, options?: IRepoOptions): Promise<BatchResult<DeployPipeline>>;
-    upsertMany(request: Array<DeployPipeline>, options?: IThrowingRepoOptions): Promise<DeployPipeline[]>;
+    /** Performs the given operation on each existing DeployPipeline that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<DeployPipeline, DeployPipelineCriteria>, options?: IRepoOptions): Promise<BatchResult<DeployPipeline>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<DeployPipeline, DeployPipelineCriteria>, options?: IThrowingRepoOptions): Promise<DeployPipeline[]>;
     /** Saves the input as a new DeployPipeline, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: DeployPipeline, options?: IRepoOptions): Promise<SingleResult<DeployPipeline>>;
     upsert(request: DeployPipeline, options?: IThrowingRepoOptions): Promise<DeployPipeline>;
+    /** Saves each given input as a new DeployPipeline, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<DeployPipeline>, options?: IRepoOptions): Promise<BatchResult<DeployPipeline>>;
+    upsertMany(request: Array<DeployPipeline>, options?: IThrowingRepoOptions): Promise<DeployPipeline[]>;
 }
 import { Deployment, DeploymentCriteria } from "../contracts";
 declare class DeploymentCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new Deployment. */
-    tryCreateMany(request: Array<Deployment>, options?: IRepoOptions): Promise<BatchResult<Deployment>>;
-    createMany(request: Array<Deployment>, options?: IThrowingRepoOptions): Promise<Deployment[]>;
+    /** Deletes each existing Deployment that satisfies the given criteria. */
+    tryDeleteWhere(request: DeploymentCriteria, options?: IRepoOptions): Promise<BatchResult<Deployment>>;
+    deleteWhere(request: DeploymentCriteria, options?: IThrowingRepoOptions): Promise<Deployment[]>;
     /** Retrieves all the existing Deployment that satisfy the given criteria. */
     tryReadMany(request: DeploymentCriteria, options?: IRepoOptions): Promise<ListResult<Deployment>>;
     readMany(request: DeploymentCriteria, options?: IThrowingRepoOptions): Promise<Deployment[]>;
-    /** Overwrites each existing Deployment. */
-    tryUpdateMany(request: Array<Deployment>, options?: IRepoOptions): Promise<BatchResult<Deployment>>;
-    updateMany(request: Array<Deployment>, options?: IThrowingRepoOptions): Promise<Deployment[]>;
     /** Performs the given operations on each existing Deployment that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<Deployment, DeploymentCriteria>, options?: IRepoOptions): Promise<BatchResult<Deployment>>;
     patchWhere(request: PatchSpecForMany<Deployment, DeploymentCriteria>, options?: IThrowingRepoOptions): Promise<Deployment[]>;
-    /** Deletes each existing Deployment that satisfies the given criteria. */
-    tryDeleteWhere(request: DeploymentCriteria, options?: IRepoOptions): Promise<BatchResult<Deployment>>;
-    deleteWhere(request: DeploymentCriteria, options?: IThrowingRepoOptions): Promise<Deployment[]>;
+    /** Saves each given input as a new Deployment. */
+    tryCreateMany(request: Array<Deployment>, options?: IRepoOptions): Promise<BatchResult<Deployment>>;
+    createMany(request: Array<Deployment>, options?: IThrowingRepoOptions): Promise<Deployment[]>;
+    /** Overwrites each existing Deployment. */
+    tryUpdateMany(request: Array<Deployment>, options?: IRepoOptions): Promise<BatchResult<Deployment>>;
+    updateMany(request: Array<Deployment>, options?: IThrowingRepoOptions): Promise<Deployment[]>;
+    /** Deletes the existing Deployment. */
+    tryDelete(request: IdSpecFor<Deployment>, options?: IRepoOptions): Promise<SingleResult<Deployment>>;
+    delete(request: IdSpecFor<Deployment>, options?: IThrowingRepoOptions): Promise<Deployment>;
     /** Retrieves the single, uniquely identified Deployment. */
     tryRead(request: IdSpecFor<Deployment>, options?: IRepoOptions): Promise<SingleResult<Deployment>>;
     read(request: IdSpecFor<Deployment>, options?: IThrowingRepoOptions): Promise<Deployment>;
-    /** Overwrites the existing Deployment. */
-    tryUpdate(request: Deployment, options?: IRepoOptions): Promise<SingleResult<Deployment>>;
-    update(request: Deployment, options?: IThrowingRepoOptions): Promise<Deployment>;
     /** Performs the given operations on the existing Deployment. */
     tryPatch(request: PatchSpecForOne<Deployment>, options?: IRepoOptions): Promise<SingleResult<Deployment>>;
     patch(request: PatchSpecForOne<Deployment>, options?: IThrowingRepoOptions): Promise<Deployment>;
-    /** Deletes the existing Deployment. */
-    tryDelete(request: IdSpecFor<Deployment>, options?: IRepoOptions): Promise<SingleResult<Deployment>>;
-    delete(request: IdSpecFor<Deployment>, options?: IThrowingRepoOptions): Promise<Deployment>;
+    /** Overwrites the existing Deployment. */
+    tryUpdate(request: Deployment, options?: IRepoOptions): Promise<SingleResult<Deployment>>;
+    update(request: Deployment, options?: IThrowingRepoOptions): Promise<Deployment>;
     /** Overwrites the given properties of the existing Deployment. */
     tryUpdatePartial(request: Deployment, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Deployment>>>;
     updatePartial(request: Deployment, options?: IThrowingRepoOptions): Promise<PartialWithId<Deployment>>;
     /** Saves the input as a new Deployment. */
     tryCreate(request: Deployment, options?: IRepoOptions): Promise<SingleResult<Deployment>>;
     create(request: Deployment, options?: IThrowingRepoOptions): Promise<Deployment>;
-    /** Performs the given operation on each existing Deployment that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Deployment, DeploymentCriteria>, options?: IRepoOptions): Promise<BatchResult<Deployment>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<Deployment, DeploymentCriteria>, options?: IThrowingRepoOptions): Promise<Deployment[]>;
     /** Overwrites the given properties for each existing Deployment. */
     tryUpdatePartialMany(request: Array<Deployment>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Deployment>>>;
     updatePartialMany(request: Array<Deployment>, options?: IThrowingRepoOptions): Promise<PartialWithId<Deployment>[]>;
-    /** Saves each given input as a new Deployment, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<Deployment>, options?: IRepoOptions): Promise<BatchResult<Deployment>>;
-    upsertMany(request: Array<Deployment>, options?: IThrowingRepoOptions): Promise<Deployment[]>;
+    /** Performs the given operation on each existing Deployment that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Deployment, DeploymentCriteria>, options?: IRepoOptions): Promise<BatchResult<Deployment>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Deployment, DeploymentCriteria>, options?: IThrowingRepoOptions): Promise<Deployment[]>;
     /** Saves the input as a new Deployment, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: Deployment, options?: IRepoOptions): Promise<SingleResult<Deployment>>;
     upsert(request: Deployment, options?: IThrowingRepoOptions): Promise<Deployment>;
+    /** Saves each given input as a new Deployment, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Deployment>, options?: IRepoOptions): Promise<BatchResult<Deployment>>;
+    upsertMany(request: Array<Deployment>, options?: IThrowingRepoOptions): Promise<Deployment[]>;
+}
+import { DeploymentActivity, DeploymentActivityCriteria } from "../contracts";
+declare class DeploymentActivityCruds {
+    private core;
+    constructor(core: ApiClientBase);
+    /** Deletes each existing DeploymentActivity that satisfies the given criteria. */
+    tryDeleteWhere(request: DeploymentActivityCriteria, options?: IRepoOptions): Promise<BatchResult<DeploymentActivity>>;
+    deleteWhere(request: DeploymentActivityCriteria, options?: IThrowingRepoOptions): Promise<DeploymentActivity[]>;
+    /** Retrieves all the existing DeploymentActivity that satisfy the given criteria. */
+    tryReadMany(request: DeploymentActivityCriteria, options?: IRepoOptions): Promise<ListResult<DeploymentActivity>>;
+    readMany(request: DeploymentActivityCriteria, options?: IThrowingRepoOptions): Promise<DeploymentActivity[]>;
+    /** Performs the given operations on each existing DeploymentActivity that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<DeploymentActivity, DeploymentActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<DeploymentActivity>>;
+    patchWhere(request: PatchSpecForMany<DeploymentActivity, DeploymentActivityCriteria>, options?: IThrowingRepoOptions): Promise<DeploymentActivity[]>;
+    /** Saves each given input as a new DeploymentActivity. */
+    tryCreateMany(request: Array<DeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<DeploymentActivity>>;
+    createMany(request: Array<DeploymentActivity>, options?: IThrowingRepoOptions): Promise<DeploymentActivity[]>;
+    /** Overwrites each existing DeploymentActivity. */
+    tryUpdateMany(request: Array<DeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<DeploymentActivity>>;
+    updateMany(request: Array<DeploymentActivity>, options?: IThrowingRepoOptions): Promise<DeploymentActivity[]>;
+    /** Deletes the existing DeploymentActivity. */
+    tryDelete(request: IdSpecFor<DeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<DeploymentActivity>>;
+    delete(request: IdSpecFor<DeploymentActivity>, options?: IThrowingRepoOptions): Promise<DeploymentActivity>;
+    /** Retrieves the single, uniquely identified DeploymentActivity. */
+    tryRead(request: IdSpecFor<DeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<DeploymentActivity>>;
+    read(request: IdSpecFor<DeploymentActivity>, options?: IThrowingRepoOptions): Promise<DeploymentActivity>;
+    /** Performs the given operations on the existing DeploymentActivity. */
+    tryPatch(request: PatchSpecForOne<DeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<DeploymentActivity>>;
+    patch(request: PatchSpecForOne<DeploymentActivity>, options?: IThrowingRepoOptions): Promise<DeploymentActivity>;
+    /** Overwrites the existing DeploymentActivity. */
+    tryUpdate(request: DeploymentActivity, options?: IRepoOptions): Promise<SingleResult<DeploymentActivity>>;
+    update(request: DeploymentActivity, options?: IThrowingRepoOptions): Promise<DeploymentActivity>;
+    /** Overwrites the given properties of the existing DeploymentActivity. */
+    tryUpdatePartial(request: DeploymentActivity, options?: IRepoOptions): Promise<SingleResult<PartialWithId<DeploymentActivity>>>;
+    updatePartial(request: DeploymentActivity, options?: IThrowingRepoOptions): Promise<PartialWithId<DeploymentActivity>>;
+    /** Saves the input as a new DeploymentActivity. */
+    tryCreate(request: DeploymentActivity, options?: IRepoOptions): Promise<SingleResult<DeploymentActivity>>;
+    create(request: DeploymentActivity, options?: IThrowingRepoOptions): Promise<DeploymentActivity>;
+    /** Overwrites the given properties for each existing DeploymentActivity. */
+    tryUpdatePartialMany(request: Array<DeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<DeploymentActivity>>>;
+    updatePartialMany(request: Array<DeploymentActivity>, options?: IThrowingRepoOptions): Promise<PartialWithId<DeploymentActivity>[]>;
+    /** Performs the given operation on each existing DeploymentActivity that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<DeploymentActivity, DeploymentActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<DeploymentActivity>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<DeploymentActivity, DeploymentActivityCriteria>, options?: IThrowingRepoOptions): Promise<DeploymentActivity[]>;
+    /** Saves the input as a new DeploymentActivity, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: DeploymentActivity, options?: IRepoOptions): Promise<SingleResult<DeploymentActivity>>;
+    upsert(request: DeploymentActivity, options?: IThrowingRepoOptions): Promise<DeploymentActivity>;
+    /** Saves each given input as a new DeploymentActivity, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<DeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<DeploymentActivity>>;
+    upsertMany(request: Array<DeploymentActivity>, options?: IThrowingRepoOptions): Promise<DeploymentActivity[]>;
+}
+import { Enterprise, EnterpriseCriteria } from "../contracts";
+declare class EnterpriseCruds {
+    private core;
+    constructor(core: ApiClientBase);
+    /** Deletes each existing Enterprise that satisfies the given criteria. */
+    tryDeleteWhere(request: EnterpriseCriteria, options?: IRepoOptions): Promise<BatchResult<Enterprise>>;
+    deleteWhere(request: EnterpriseCriteria, options?: IThrowingRepoOptions): Promise<Enterprise[]>;
+    /** Retrieves all the existing Enterprise that satisfy the given criteria. */
+    tryReadMany(request: EnterpriseCriteria, options?: IRepoOptions): Promise<ListResult<Enterprise>>;
+    readMany(request: EnterpriseCriteria, options?: IThrowingRepoOptions): Promise<Enterprise[]>;
+    /** Performs the given operations on each existing Enterprise that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Enterprise, EnterpriseCriteria>, options?: IRepoOptions): Promise<BatchResult<Enterprise>>;
+    patchWhere(request: PatchSpecForMany<Enterprise, EnterpriseCriteria>, options?: IThrowingRepoOptions): Promise<Enterprise[]>;
+    /** Saves each given input as a new Enterprise. */
+    tryCreateMany(request: Array<Enterprise>, options?: IRepoOptions): Promise<BatchResult<Enterprise>>;
+    createMany(request: Array<Enterprise>, options?: IThrowingRepoOptions): Promise<Enterprise[]>;
+    /** Overwrites each existing Enterprise. */
+    tryUpdateMany(request: Array<Enterprise>, options?: IRepoOptions): Promise<BatchResult<Enterprise>>;
+    updateMany(request: Array<Enterprise>, options?: IThrowingRepoOptions): Promise<Enterprise[]>;
+    /** Deletes the existing Enterprise. */
+    tryDelete(request: IdSpecFor<Enterprise>, options?: IRepoOptions): Promise<SingleResult<Enterprise>>;
+    delete(request: IdSpecFor<Enterprise>, options?: IThrowingRepoOptions): Promise<Enterprise>;
+    /** Retrieves the single, uniquely identified Enterprise. */
+    tryRead(request: IdSpecFor<Enterprise>, options?: IRepoOptions): Promise<SingleResult<Enterprise>>;
+    read(request: IdSpecFor<Enterprise>, options?: IThrowingRepoOptions): Promise<Enterprise>;
+    /** Performs the given operations on the existing Enterprise. */
+    tryPatch(request: PatchSpecForOne<Enterprise>, options?: IRepoOptions): Promise<SingleResult<Enterprise>>;
+    patch(request: PatchSpecForOne<Enterprise>, options?: IThrowingRepoOptions): Promise<Enterprise>;
+    /** Overwrites the existing Enterprise. */
+    tryUpdate(request: Enterprise, options?: IRepoOptions): Promise<SingleResult<Enterprise>>;
+    update(request: Enterprise, options?: IThrowingRepoOptions): Promise<Enterprise>;
+    /** Overwrites the given properties of the existing Enterprise. */
+    tryUpdatePartial(request: Enterprise, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Enterprise>>>;
+    updatePartial(request: Enterprise, options?: IThrowingRepoOptions): Promise<PartialWithId<Enterprise>>;
+    /** Saves the input as a new Enterprise. */
+    tryCreate(request: Enterprise, options?: IRepoOptions): Promise<SingleResult<Enterprise>>;
+    create(request: Enterprise, options?: IThrowingRepoOptions): Promise<Enterprise>;
+    /** Overwrites the given properties for each existing Enterprise. */
+    tryUpdatePartialMany(request: Array<Enterprise>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Enterprise>>>;
+    updatePartialMany(request: Array<Enterprise>, options?: IThrowingRepoOptions): Promise<PartialWithId<Enterprise>[]>;
+    /** Performs the given operation on each existing Enterprise that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Enterprise, EnterpriseCriteria>, options?: IRepoOptions): Promise<BatchResult<Enterprise>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Enterprise, EnterpriseCriteria>, options?: IThrowingRepoOptions): Promise<Enterprise[]>;
+    /** Saves the input as a new Enterprise, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Enterprise, options?: IRepoOptions): Promise<SingleResult<Enterprise>>;
+    upsert(request: Enterprise, options?: IThrowingRepoOptions): Promise<Enterprise>;
+    /** Saves each given input as a new Enterprise, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Enterprise>, options?: IRepoOptions): Promise<BatchResult<Enterprise>>;
+    upsertMany(request: Array<Enterprise>, options?: IThrowingRepoOptions): Promise<Enterprise[]>;
 }
 import { EnterpriseRunState, EnterpriseRunStateCriteria } from "../contracts";
 declare class EnterpriseRunStateCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new EnterpriseRunState. */
-    tryCreateMany(request: Array<EnterpriseRunState>, options?: IRepoOptions): Promise<BatchResult<EnterpriseRunState>>;
-    createMany(request: Array<EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<EnterpriseRunState[]>;
+    /** Deletes each existing EnterpriseRunState that satisfies the given criteria. */
+    tryDeleteWhere(request: EnterpriseRunStateCriteria, options?: IRepoOptions): Promise<BatchResult<EnterpriseRunState>>;
+    deleteWhere(request: EnterpriseRunStateCriteria, options?: IThrowingRepoOptions): Promise<EnterpriseRunState[]>;
     /** Retrieves all the existing EnterpriseRunState that satisfy the given criteria. */
     tryReadMany(request: EnterpriseRunStateCriteria, options?: IRepoOptions): Promise<ListResult<EnterpriseRunState>>;
     readMany(request: EnterpriseRunStateCriteria, options?: IThrowingRepoOptions): Promise<EnterpriseRunState[]>;
-    /** Overwrites each existing EnterpriseRunState. */
-    tryUpdateMany(request: Array<EnterpriseRunState>, options?: IRepoOptions): Promise<BatchResult<EnterpriseRunState>>;
-    updateMany(request: Array<EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<EnterpriseRunState[]>;
     /** Performs the given operations on each existing EnterpriseRunState that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<EnterpriseRunState, EnterpriseRunStateCriteria>, options?: IRepoOptions): Promise<BatchResult<EnterpriseRunState>>;
     patchWhere(request: PatchSpecForMany<EnterpriseRunState, EnterpriseRunStateCriteria>, options?: IThrowingRepoOptions): Promise<EnterpriseRunState[]>;
-    /** Deletes each existing EnterpriseRunState that satisfies the given criteria. */
-    tryDeleteWhere(request: EnterpriseRunStateCriteria, options?: IRepoOptions): Promise<BatchResult<EnterpriseRunState>>;
-    deleteWhere(request: EnterpriseRunStateCriteria, options?: IThrowingRepoOptions): Promise<EnterpriseRunState[]>;
+    /** Saves each given input as a new EnterpriseRunState. */
+    tryCreateMany(request: Array<EnterpriseRunState>, options?: IRepoOptions): Promise<BatchResult<EnterpriseRunState>>;
+    createMany(request: Array<EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<EnterpriseRunState[]>;
+    /** Overwrites each existing EnterpriseRunState. */
+    tryUpdateMany(request: Array<EnterpriseRunState>, options?: IRepoOptions): Promise<BatchResult<EnterpriseRunState>>;
+    updateMany(request: Array<EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<EnterpriseRunState[]>;
+    /** Deletes the existing EnterpriseRunState. */
+    tryDelete(request: IdSpecFor<EnterpriseRunState>, options?: IRepoOptions): Promise<SingleResult<EnterpriseRunState>>;
+    delete(request: IdSpecFor<EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<EnterpriseRunState>;
     /** Retrieves the single, uniquely identified EnterpriseRunState. */
     tryRead(request: IdSpecFor<EnterpriseRunState>, options?: IRepoOptions): Promise<SingleResult<EnterpriseRunState>>;
     read(request: IdSpecFor<EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<EnterpriseRunState>;
-    /** Overwrites the existing EnterpriseRunState. */
-    tryUpdate(request: EnterpriseRunState, options?: IRepoOptions): Promise<SingleResult<EnterpriseRunState>>;
-    update(request: EnterpriseRunState, options?: IThrowingRepoOptions): Promise<EnterpriseRunState>;
     /** Performs the given operations on the existing EnterpriseRunState. */
     tryPatch(request: PatchSpecForOne<EnterpriseRunState>, options?: IRepoOptions): Promise<SingleResult<EnterpriseRunState>>;
     patch(request: PatchSpecForOne<EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<EnterpriseRunState>;
-    /** Deletes the existing EnterpriseRunState. */
-    tryDelete(request: IdSpecFor<EnterpriseRunState>, options?: IRepoOptions): Promise<SingleResult<EnterpriseRunState>>;
-    delete(request: IdSpecFor<EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<EnterpriseRunState>;
+    /** Overwrites the existing EnterpriseRunState. */
+    tryUpdate(request: EnterpriseRunState, options?: IRepoOptions): Promise<SingleResult<EnterpriseRunState>>;
+    update(request: EnterpriseRunState, options?: IThrowingRepoOptions): Promise<EnterpriseRunState>;
     /** Overwrites the given properties of the existing EnterpriseRunState. */
     tryUpdatePartial(request: EnterpriseRunState, options?: IRepoOptions): Promise<SingleResult<PartialWithId<EnterpriseRunState>>>;
     updatePartial(request: EnterpriseRunState, options?: IThrowingRepoOptions): Promise<PartialWithId<EnterpriseRunState>>;
     /** Saves the input as a new EnterpriseRunState. */
     tryCreate(request: EnterpriseRunState, options?: IRepoOptions): Promise<SingleResult<EnterpriseRunState>>;
     create(request: EnterpriseRunState, options?: IThrowingRepoOptions): Promise<EnterpriseRunState>;
-    /** Performs the given operation on each existing EnterpriseRunState that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<EnterpriseRunState, EnterpriseRunStateCriteria>, options?: IRepoOptions): Promise<BatchResult<EnterpriseRunState>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<EnterpriseRunState, EnterpriseRunStateCriteria>, options?: IThrowingRepoOptions): Promise<EnterpriseRunState[]>;
     /** Overwrites the given properties for each existing EnterpriseRunState. */
     tryUpdatePartialMany(request: Array<EnterpriseRunState>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<EnterpriseRunState>>>;
     updatePartialMany(request: Array<EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<PartialWithId<EnterpriseRunState>[]>;
-    /** Saves each given input as a new EnterpriseRunState, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<EnterpriseRunState>, options?: IRepoOptions): Promise<BatchResult<EnterpriseRunState>>;
-    upsertMany(request: Array<EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<EnterpriseRunState[]>;
+    /** Performs the given operation on each existing EnterpriseRunState that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<EnterpriseRunState, EnterpriseRunStateCriteria>, options?: IRepoOptions): Promise<BatchResult<EnterpriseRunState>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<EnterpriseRunState, EnterpriseRunStateCriteria>, options?: IThrowingRepoOptions): Promise<EnterpriseRunState[]>;
     /** Saves the input as a new EnterpriseRunState, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: EnterpriseRunState, options?: IRepoOptions): Promise<SingleResult<EnterpriseRunState>>;
     upsert(request: EnterpriseRunState, options?: IThrowingRepoOptions): Promise<EnterpriseRunState>;
+    /** Saves each given input as a new EnterpriseRunState, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<EnterpriseRunState>, options?: IRepoOptions): Promise<BatchResult<EnterpriseRunState>>;
+    upsertMany(request: Array<EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<EnterpriseRunState[]>;
 }
 import { EnterpriseVersionConfig, EnterpriseVersionConfigCriteria } from "../contracts";
 declare class EnterpriseVersionConfigCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new EnterpriseVersionConfig. */
-    tryCreateMany(request: Array<EnterpriseVersionConfig>, options?: IRepoOptions): Promise<BatchResult<EnterpriseVersionConfig>>;
-    createMany(request: Array<EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig[]>;
+    /** Deletes each existing EnterpriseVersionConfig that satisfies the given criteria. */
+    tryDeleteWhere(request: EnterpriseVersionConfigCriteria, options?: IRepoOptions): Promise<BatchResult<EnterpriseVersionConfig>>;
+    deleteWhere(request: EnterpriseVersionConfigCriteria, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig[]>;
     /** Retrieves all the existing EnterpriseVersionConfig that satisfy the given criteria. */
     tryReadMany(request: EnterpriseVersionConfigCriteria, options?: IRepoOptions): Promise<ListResult<EnterpriseVersionConfig>>;
     readMany(request: EnterpriseVersionConfigCriteria, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig[]>;
-    /** Overwrites each existing EnterpriseVersionConfig. */
-    tryUpdateMany(request: Array<EnterpriseVersionConfig>, options?: IRepoOptions): Promise<BatchResult<EnterpriseVersionConfig>>;
-    updateMany(request: Array<EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig[]>;
     /** Performs the given operations on each existing EnterpriseVersionConfig that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<EnterpriseVersionConfig, EnterpriseVersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<EnterpriseVersionConfig>>;
     patchWhere(request: PatchSpecForMany<EnterpriseVersionConfig, EnterpriseVersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig[]>;
-    /** Deletes each existing EnterpriseVersionConfig that satisfies the given criteria. */
-    tryDeleteWhere(request: EnterpriseVersionConfigCriteria, options?: IRepoOptions): Promise<BatchResult<EnterpriseVersionConfig>>;
-    deleteWhere(request: EnterpriseVersionConfigCriteria, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig[]>;
+    /** Saves each given input as a new EnterpriseVersionConfig. */
+    tryCreateMany(request: Array<EnterpriseVersionConfig>, options?: IRepoOptions): Promise<BatchResult<EnterpriseVersionConfig>>;
+    createMany(request: Array<EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig[]>;
+    /** Overwrites each existing EnterpriseVersionConfig. */
+    tryUpdateMany(request: Array<EnterpriseVersionConfig>, options?: IRepoOptions): Promise<BatchResult<EnterpriseVersionConfig>>;
+    updateMany(request: Array<EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig[]>;
+    /** Deletes the existing EnterpriseVersionConfig. */
+    tryDelete(request: IdSpecFor<EnterpriseVersionConfig>, options?: IRepoOptions): Promise<SingleResult<EnterpriseVersionConfig>>;
+    delete(request: IdSpecFor<EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig>;
     /** Retrieves the single, uniquely identified EnterpriseVersionConfig. */
     tryRead(request: IdSpecFor<EnterpriseVersionConfig>, options?: IRepoOptions): Promise<SingleResult<EnterpriseVersionConfig>>;
     read(request: IdSpecFor<EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig>;
-    /** Overwrites the existing EnterpriseVersionConfig. */
-    tryUpdate(request: EnterpriseVersionConfig, options?: IRepoOptions): Promise<SingleResult<EnterpriseVersionConfig>>;
-    update(request: EnterpriseVersionConfig, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig>;
     /** Performs the given operations on the existing EnterpriseVersionConfig. */
     tryPatch(request: PatchSpecForOne<EnterpriseVersionConfig>, options?: IRepoOptions): Promise<SingleResult<EnterpriseVersionConfig>>;
     patch(request: PatchSpecForOne<EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig>;
-    /** Deletes the existing EnterpriseVersionConfig. */
-    tryDelete(request: IdSpecFor<EnterpriseVersionConfig>, options?: IRepoOptions): Promise<SingleResult<EnterpriseVersionConfig>>;
-    delete(request: IdSpecFor<EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig>;
+    /** Overwrites the existing EnterpriseVersionConfig. */
+    tryUpdate(request: EnterpriseVersionConfig, options?: IRepoOptions): Promise<SingleResult<EnterpriseVersionConfig>>;
+    update(request: EnterpriseVersionConfig, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig>;
     /** Overwrites the given properties of the existing EnterpriseVersionConfig. */
     tryUpdatePartial(request: EnterpriseVersionConfig, options?: IRepoOptions): Promise<SingleResult<PartialWithId<EnterpriseVersionConfig>>>;
     updatePartial(request: EnterpriseVersionConfig, options?: IThrowingRepoOptions): Promise<PartialWithId<EnterpriseVersionConfig>>;
     /** Saves the input as a new EnterpriseVersionConfig. */
     tryCreate(request: EnterpriseVersionConfig, options?: IRepoOptions): Promise<SingleResult<EnterpriseVersionConfig>>;
-    create(request: EnterpriseVersionConfig, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig>;
-    /** Performs the given operation on each existing EnterpriseVersionConfig that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<EnterpriseVersionConfig, EnterpriseVersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<EnterpriseVersionConfig>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<EnterpriseVersionConfig, EnterpriseVersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig[]>;
-    /** Overwrites the given properties for each existing EnterpriseVersionConfig. */
-    tryUpdatePartialMany(request: Array<EnterpriseVersionConfig>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<EnterpriseVersionConfig>>>;
-    updatePartialMany(request: Array<EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<PartialWithId<EnterpriseVersionConfig>[]>;
-    /** Saves each given input as a new EnterpriseVersionConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<EnterpriseVersionConfig>, options?: IRepoOptions): Promise<BatchResult<EnterpriseVersionConfig>>;
-    upsertMany(request: Array<EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig[]>;
-    /** Saves the input as a new EnterpriseVersionConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsert(request: EnterpriseVersionConfig, options?: IRepoOptions): Promise<SingleResult<EnterpriseVersionConfig>>;
-    upsert(request: EnterpriseVersionConfig, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig>;
-}
-import { Enterprise, EnterpriseCriteria } from "../contracts";
-declare class EnterpriseCruds {
-    private core;
-    constructor(core: ApiClientBase);
-    /** Saves each given input as a new Enterprise. */
-    tryCreateMany(request: Array<Enterprise>, options?: IRepoOptions): Promise<BatchResult<Enterprise>>;
-    createMany(request: Array<Enterprise>, options?: IThrowingRepoOptions): Promise<Enterprise[]>;
-    /** Retrieves all the existing Enterprise that satisfy the given criteria. */
-    tryReadMany(request: EnterpriseCriteria, options?: IRepoOptions): Promise<ListResult<Enterprise>>;
-    readMany(request: EnterpriseCriteria, options?: IThrowingRepoOptions): Promise<Enterprise[]>;
-    /** Overwrites each existing Enterprise. */
-    tryUpdateMany(request: Array<Enterprise>, options?: IRepoOptions): Promise<BatchResult<Enterprise>>;
-    updateMany(request: Array<Enterprise>, options?: IThrowingRepoOptions): Promise<Enterprise[]>;
-    /** Performs the given operations on each existing Enterprise that satisfies the given criteria. */
-    tryPatchWhere(request: PatchSpecForMany<Enterprise, EnterpriseCriteria>, options?: IRepoOptions): Promise<BatchResult<Enterprise>>;
-    patchWhere(request: PatchSpecForMany<Enterprise, EnterpriseCriteria>, options?: IThrowingRepoOptions): Promise<Enterprise[]>;
-    /** Deletes each existing Enterprise that satisfies the given criteria. */
-    tryDeleteWhere(request: EnterpriseCriteria, options?: IRepoOptions): Promise<BatchResult<Enterprise>>;
-    deleteWhere(request: EnterpriseCriteria, options?: IThrowingRepoOptions): Promise<Enterprise[]>;
-    /** Retrieves the single, uniquely identified Enterprise. */
-    tryRead(request: IdSpecFor<Enterprise>, options?: IRepoOptions): Promise<SingleResult<Enterprise>>;
-    read(request: IdSpecFor<Enterprise>, options?: IThrowingRepoOptions): Promise<Enterprise>;
-    /** Overwrites the existing Enterprise. */
-    tryUpdate(request: Enterprise, options?: IRepoOptions): Promise<SingleResult<Enterprise>>;
-    update(request: Enterprise, options?: IThrowingRepoOptions): Promise<Enterprise>;
-    /** Performs the given operations on the existing Enterprise. */
-    tryPatch(request: PatchSpecForOne<Enterprise>, options?: IRepoOptions): Promise<SingleResult<Enterprise>>;
-    patch(request: PatchSpecForOne<Enterprise>, options?: IThrowingRepoOptions): Promise<Enterprise>;
-    /** Deletes the existing Enterprise. */
-    tryDelete(request: IdSpecFor<Enterprise>, options?: IRepoOptions): Promise<SingleResult<Enterprise>>;
-    delete(request: IdSpecFor<Enterprise>, options?: IThrowingRepoOptions): Promise<Enterprise>;
-    /** Overwrites the given properties of the existing Enterprise. */
-    tryUpdatePartial(request: Enterprise, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Enterprise>>>;
-    updatePartial(request: Enterprise, options?: IThrowingRepoOptions): Promise<PartialWithId<Enterprise>>;
-    /** Saves the input as a new Enterprise. */
-    tryCreate(request: Enterprise, options?: IRepoOptions): Promise<SingleResult<Enterprise>>;
-    create(request: Enterprise, options?: IThrowingRepoOptions): Promise<Enterprise>;
-    /** Performs the given operation on each existing Enterprise that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Enterprise, EnterpriseCriteria>, options?: IRepoOptions): Promise<BatchResult<Enterprise>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<Enterprise, EnterpriseCriteria>, options?: IThrowingRepoOptions): Promise<Enterprise[]>;
-    /** Overwrites the given properties for each existing Enterprise. */
-    tryUpdatePartialMany(request: Array<Enterprise>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Enterprise>>>;
-    updatePartialMany(request: Array<Enterprise>, options?: IThrowingRepoOptions): Promise<PartialWithId<Enterprise>[]>;
-    /** Saves each given input as a new Enterprise, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<Enterprise>, options?: IRepoOptions): Promise<BatchResult<Enterprise>>;
-    upsertMany(request: Array<Enterprise>, options?: IThrowingRepoOptions): Promise<Enterprise[]>;
-    /** Saves the input as a new Enterprise, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsert(request: Enterprise, options?: IRepoOptions): Promise<SingleResult<Enterprise>>;
-    upsert(request: Enterprise, options?: IThrowingRepoOptions): Promise<Enterprise>;
+    create(request: EnterpriseVersionConfig, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig>;
+    /** Overwrites the given properties for each existing EnterpriseVersionConfig. */
+    tryUpdatePartialMany(request: Array<EnterpriseVersionConfig>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<EnterpriseVersionConfig>>>;
+    updatePartialMany(request: Array<EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<PartialWithId<EnterpriseVersionConfig>[]>;
+    /** Performs the given operation on each existing EnterpriseVersionConfig that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<EnterpriseVersionConfig, EnterpriseVersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<EnterpriseVersionConfig>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<EnterpriseVersionConfig, EnterpriseVersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig[]>;
+    /** Saves the input as a new EnterpriseVersionConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: EnterpriseVersionConfig, options?: IRepoOptions): Promise<SingleResult<EnterpriseVersionConfig>>;
+    upsert(request: EnterpriseVersionConfig, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig>;
+    /** Saves each given input as a new EnterpriseVersionConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<EnterpriseVersionConfig>, options?: IRepoOptions): Promise<BatchResult<EnterpriseVersionConfig>>;
+    upsertMany(request: Array<EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<EnterpriseVersionConfig[]>;
+}
+declare class EntityAclCruds {
+    private core;
+    constructor(core: ApiClientBase);
+    /** Deletes each existing EntityAcl that satisfies the given criteria. */
+    tryDeleteWhere(request: EntityAclCriteria, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
+    deleteWhere(request: EntityAclCriteria, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
+    /** Retrieves all the existing EntityAcl that satisfy the given criteria. */
+    tryReadMany(request: EntityAclCriteria, options?: IRepoOptions): Promise<ListResult<EntityAcl>>;
+    readMany(request: EntityAclCriteria, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
+    /** Performs the given operations on each existing EntityAcl that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<EntityAcl, EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
+    patchWhere(request: PatchSpecForMany<EntityAcl, EntityAclCriteria>, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
+    /** Saves each given input as a new EntityAcl. */
+    tryCreateMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
+    createMany(request: Array<EntityAcl>, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
+    /** Overwrites each existing EntityAcl. */
+    tryUpdateMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
+    updateMany(request: Array<EntityAcl>, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
+    /** Deletes the existing EntityAcl. */
+    tryDelete(request: IdSpecFor<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    delete(request: IdSpecFor<EntityAcl>, options?: IThrowingRepoOptions): Promise<EntityAcl>;
+    /** Retrieves the single, uniquely identified EntityAcl. */
+    tryRead(request: IdSpecFor<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    read(request: IdSpecFor<EntityAcl>, options?: IThrowingRepoOptions): Promise<EntityAcl>;
+    /** Performs the given operations on the existing EntityAcl. */
+    tryPatch(request: PatchSpecForOne<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    patch(request: PatchSpecForOne<EntityAcl>, options?: IThrowingRepoOptions): Promise<EntityAcl>;
+    /** Overwrites the existing EntityAcl. */
+    tryUpdate(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    update(request: EntityAcl, options?: IThrowingRepoOptions): Promise<EntityAcl>;
+    /** Overwrites the given properties of the existing EntityAcl. */
+    tryUpdatePartial(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<PartialWithId<EntityAcl>>>;
+    updatePartial(request: EntityAcl, options?: IThrowingRepoOptions): Promise<PartialWithId<EntityAcl>>;
+    /** Saves the input as a new EntityAcl. */
+    tryCreate(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    create(request: EntityAcl, options?: IThrowingRepoOptions): Promise<EntityAcl>;
+    /** Overwrites the given properties for each existing EntityAcl. */
+    tryUpdatePartialMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<EntityAcl>>>;
+    updatePartialMany(request: Array<EntityAcl>, options?: IThrowingRepoOptions): Promise<PartialWithId<EntityAcl>[]>;
+    /** Performs the given operation on each existing EntityAcl that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<EntityAcl, EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<EntityAcl, EntityAclCriteria>, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
+    /** Saves the input as a new EntityAcl, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    upsert(request: EntityAcl, options?: IThrowingRepoOptions): Promise<EntityAcl>;
+    /** Saves each given input as a new EntityAcl, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
+    upsertMany(request: Array<EntityAcl>, options?: IThrowingRepoOptions): Promise<EntityAcl[]>;
 }
 import { Environment, EnvironmentCriteria } from "../contracts";
 declare class EnvironmentCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new Environment. */
-    tryCreateMany(request: Array<Environment>, options?: IRepoOptions): Promise<BatchResult<Environment>>;
-    createMany(request: Array<Environment>, options?: IThrowingRepoOptions): Promise<Environment[]>;
+    /** Deletes each existing Environment that satisfies the given criteria. */
+    tryDeleteWhere(request: EnvironmentCriteria, options?: IRepoOptions): Promise<BatchResult<Environment>>;
+    deleteWhere(request: EnvironmentCriteria, options?: IThrowingRepoOptions): Promise<Environment[]>;
     /** Retrieves all the existing Environment that satisfy the given criteria. */
     tryReadMany(request: EnvironmentCriteria, options?: IRepoOptions): Promise<ListResult<Environment>>;
     readMany(request: EnvironmentCriteria, options?: IThrowingRepoOptions): Promise<Environment[]>;
-    /** Overwrites each existing Environment. */
-    tryUpdateMany(request: Array<Environment>, options?: IRepoOptions): Promise<BatchResult<Environment>>;
-    updateMany(request: Array<Environment>, options?: IThrowingRepoOptions): Promise<Environment[]>;
     /** Performs the given operations on each existing Environment that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<Environment, EnvironmentCriteria>, options?: IRepoOptions): Promise<BatchResult<Environment>>;
     patchWhere(request: PatchSpecForMany<Environment, EnvironmentCriteria>, options?: IThrowingRepoOptions): Promise<Environment[]>;
-    /** Deletes each existing Environment that satisfies the given criteria. */
-    tryDeleteWhere(request: EnvironmentCriteria, options?: IRepoOptions): Promise<BatchResult<Environment>>;
-    deleteWhere(request: EnvironmentCriteria, options?: IThrowingRepoOptions): Promise<Environment[]>;
+    /** Saves each given input as a new Environment. */
+    tryCreateMany(request: Array<Environment>, options?: IRepoOptions): Promise<BatchResult<Environment>>;
+    createMany(request: Array<Environment>, options?: IThrowingRepoOptions): Promise<Environment[]>;
+    /** Overwrites each existing Environment. */
+    tryUpdateMany(request: Array<Environment>, options?: IRepoOptions): Promise<BatchResult<Environment>>;
+    updateMany(request: Array<Environment>, options?: IThrowingRepoOptions): Promise<Environment[]>;
+    /** Deletes the existing Environment. */
+    tryDelete(request: IdSpecFor<Environment>, options?: IRepoOptions): Promise<SingleResult<Environment>>;
+    delete(request: IdSpecFor<Environment>, options?: IThrowingRepoOptions): Promise<Environment>;
     /** Retrieves the single, uniquely identified Environment. */
     tryRead(request: IdSpecFor<Environment>, options?: IRepoOptions): Promise<SingleResult<Environment>>;
     read(request: IdSpecFor<Environment>, options?: IThrowingRepoOptions): Promise<Environment>;
-    /** Overwrites the existing Environment. */
-    tryUpdate(request: Environment, options?: IRepoOptions): Promise<SingleResult<Environment>>;
-    update(request: Environment, options?: IThrowingRepoOptions): Promise<Environment>;
     /** Performs the given operations on the existing Environment. */
     tryPatch(request: PatchSpecForOne<Environment>, options?: IRepoOptions): Promise<SingleResult<Environment>>;
     patch(request: PatchSpecForOne<Environment>, options?: IThrowingRepoOptions): Promise<Environment>;
-    /** Deletes the existing Environment. */
-    tryDelete(request: IdSpecFor<Environment>, options?: IRepoOptions): Promise<SingleResult<Environment>>;
-    delete(request: IdSpecFor<Environment>, options?: IThrowingRepoOptions): Promise<Environment>;
+    /** Overwrites the existing Environment. */
+    tryUpdate(request: Environment, options?: IRepoOptions): Promise<SingleResult<Environment>>;
+    update(request: Environment, options?: IThrowingRepoOptions): Promise<Environment>;
     /** Overwrites the given properties of the existing Environment. */
     tryUpdatePartial(request: Environment, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Environment>>>;
     updatePartial(request: Environment, options?: IThrowingRepoOptions): Promise<PartialWithId<Environment>>;
     /** Saves the input as a new Environment. */
     tryCreate(request: Environment, options?: IRepoOptions): Promise<SingleResult<Environment>>;
     create(request: Environment, options?: IThrowingRepoOptions): Promise<Environment>;
-    /** Performs the given operation on each existing Environment that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Environment, EnvironmentCriteria>, options?: IRepoOptions): Promise<BatchResult<Environment>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<Environment, EnvironmentCriteria>, options?: IThrowingRepoOptions): Promise<Environment[]>;
     /** Overwrites the given properties for each existing Environment. */
     tryUpdatePartialMany(request: Array<Environment>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Environment>>>;
     updatePartialMany(request: Array<Environment>, options?: IThrowingRepoOptions): Promise<PartialWithId<Environment>[]>;
-    /** Saves each given input as a new Environment, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<Environment>, options?: IRepoOptions): Promise<BatchResult<Environment>>;
-    upsertMany(request: Array<Environment>, options?: IThrowingRepoOptions): Promise<Environment[]>;
+    /** Performs the given operation on each existing Environment that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Environment, EnvironmentCriteria>, options?: IRepoOptions): Promise<BatchResult<Environment>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Environment, EnvironmentCriteria>, options?: IThrowingRepoOptions): Promise<Environment[]>;
     /** Saves the input as a new Environment, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: Environment, options?: IRepoOptions): Promise<SingleResult<Environment>>;
     upsert(request: Environment, options?: IThrowingRepoOptions): Promise<Environment>;
+    /** Saves each given input as a new Environment, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Environment>, options?: IRepoOptions): Promise<BatchResult<Environment>>;
+    upsertMany(request: Array<Environment>, options?: IThrowingRepoOptions): Promise<Environment[]>;
 }
 import { FileStoreDef, FileStoreDefCriteria } from "../contracts";
 declare class FileStoreDefCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new FileStoreDef. */
-    tryCreateMany(request: Array<FileStoreDef>, options?: IRepoOptions): Promise<BatchResult<FileStoreDef>>;
-    createMany(request: Array<FileStoreDef>, options?: IThrowingRepoOptions): Promise<FileStoreDef[]>;
+    /** Deletes each existing FileStoreDef that satisfies the given criteria. */
+    tryDeleteWhere(request: FileStoreDefCriteria, options?: IRepoOptions): Promise<BatchResult<FileStoreDef>>;
+    deleteWhere(request: FileStoreDefCriteria, options?: IThrowingRepoOptions): Promise<FileStoreDef[]>;
     /** Retrieves all the existing FileStoreDef that satisfy the given criteria. */
     tryReadMany(request: FileStoreDefCriteria, options?: IRepoOptions): Promise<ListResult<FileStoreDef>>;
     readMany(request: FileStoreDefCriteria, options?: IThrowingRepoOptions): Promise<FileStoreDef[]>;
-    /** Overwrites each existing FileStoreDef. */
-    tryUpdateMany(request: Array<FileStoreDef>, options?: IRepoOptions): Promise<BatchResult<FileStoreDef>>;
-    updateMany(request: Array<FileStoreDef>, options?: IThrowingRepoOptions): Promise<FileStoreDef[]>;
     /** Performs the given operations on each existing FileStoreDef that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<FileStoreDef, FileStoreDefCriteria>, options?: IRepoOptions): Promise<BatchResult<FileStoreDef>>;
     patchWhere(request: PatchSpecForMany<FileStoreDef, FileStoreDefCriteria>, options?: IThrowingRepoOptions): Promise<FileStoreDef[]>;
-    /** Deletes each existing FileStoreDef that satisfies the given criteria. */
-    tryDeleteWhere(request: FileStoreDefCriteria, options?: IRepoOptions): Promise<BatchResult<FileStoreDef>>;
-    deleteWhere(request: FileStoreDefCriteria, options?: IThrowingRepoOptions): Promise<FileStoreDef[]>;
+    /** Saves each given input as a new FileStoreDef. */
+    tryCreateMany(request: Array<FileStoreDef>, options?: IRepoOptions): Promise<BatchResult<FileStoreDef>>;
+    createMany(request: Array<FileStoreDef>, options?: IThrowingRepoOptions): Promise<FileStoreDef[]>;
+    /** Overwrites each existing FileStoreDef. */
+    tryUpdateMany(request: Array<FileStoreDef>, options?: IRepoOptions): Promise<BatchResult<FileStoreDef>>;
+    updateMany(request: Array<FileStoreDef>, options?: IThrowingRepoOptions): Promise<FileStoreDef[]>;
+    /** Deletes the existing FileStoreDef. */
+    tryDelete(request: IdSpecFor<FileStoreDef>, options?: IRepoOptions): Promise<SingleResult<FileStoreDef>>;
+    delete(request: IdSpecFor<FileStoreDef>, options?: IThrowingRepoOptions): Promise<FileStoreDef>;
     /** Retrieves the single, uniquely identified FileStoreDef. */
     tryRead(request: IdSpecFor<FileStoreDef>, options?: IRepoOptions): Promise<SingleResult<FileStoreDef>>;
     read(request: IdSpecFor<FileStoreDef>, options?: IThrowingRepoOptions): Promise<FileStoreDef>;
-    /** Overwrites the existing FileStoreDef. */
-    tryUpdate(request: FileStoreDef, options?: IRepoOptions): Promise<SingleResult<FileStoreDef>>;
-    update(request: FileStoreDef, options?: IThrowingRepoOptions): Promise<FileStoreDef>;
     /** Performs the given operations on the existing FileStoreDef. */
     tryPatch(request: PatchSpecForOne<FileStoreDef>, options?: IRepoOptions): Promise<SingleResult<FileStoreDef>>;
     patch(request: PatchSpecForOne<FileStoreDef>, options?: IThrowingRepoOptions): Promise<FileStoreDef>;
-    /** Deletes the existing FileStoreDef. */
-    tryDelete(request: IdSpecFor<FileStoreDef>, options?: IRepoOptions): Promise<SingleResult<FileStoreDef>>;
-    delete(request: IdSpecFor<FileStoreDef>, options?: IThrowingRepoOptions): Promise<FileStoreDef>;
+    /** Overwrites the existing FileStoreDef. */
+    tryUpdate(request: FileStoreDef, options?: IRepoOptions): Promise<SingleResult<FileStoreDef>>;
+    update(request: FileStoreDef, options?: IThrowingRepoOptions): Promise<FileStoreDef>;
     /** Overwrites the given properties of the existing FileStoreDef. */
     tryUpdatePartial(request: FileStoreDef, options?: IRepoOptions): Promise<SingleResult<PartialWithId<FileStoreDef>>>;
     updatePartial(request: FileStoreDef, options?: IThrowingRepoOptions): Promise<PartialWithId<FileStoreDef>>;
     /** Saves the input as a new FileStoreDef. */
     tryCreate(request: FileStoreDef, options?: IRepoOptions): Promise<SingleResult<FileStoreDef>>;
     create(request: FileStoreDef, options?: IThrowingRepoOptions): Promise<FileStoreDef>;
-    /** Performs the given operation on each existing FileStoreDef that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<FileStoreDef, FileStoreDefCriteria>, options?: IRepoOptions): Promise<BatchResult<FileStoreDef>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<FileStoreDef, FileStoreDefCriteria>, options?: IThrowingRepoOptions): Promise<FileStoreDef[]>;
     /** Overwrites the given properties for each existing FileStoreDef. */
     tryUpdatePartialMany(request: Array<FileStoreDef>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<FileStoreDef>>>;
     updatePartialMany(request: Array<FileStoreDef>, options?: IThrowingRepoOptions): Promise<PartialWithId<FileStoreDef>[]>;
-    /** Saves each given input as a new FileStoreDef, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<FileStoreDef>, options?: IRepoOptions): Promise<BatchResult<FileStoreDef>>;
-    upsertMany(request: Array<FileStoreDef>, options?: IThrowingRepoOptions): Promise<FileStoreDef[]>;
+    /** Performs the given operation on each existing FileStoreDef that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<FileStoreDef, FileStoreDefCriteria>, options?: IRepoOptions): Promise<BatchResult<FileStoreDef>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<FileStoreDef, FileStoreDefCriteria>, options?: IThrowingRepoOptions): Promise<FileStoreDef[]>;
     /** Saves the input as a new FileStoreDef, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: FileStoreDef, options?: IRepoOptions): Promise<SingleResult<FileStoreDef>>;
     upsert(request: FileStoreDef, options?: IThrowingRepoOptions): Promise<FileStoreDef>;
-}
-import { ScopedHostNameConfig, ScopedHostNameConfigCriteria } from "../contracts";
-declare class ScopedHostNameConfigCruds {
-    private core;
-    constructor(core: ApiClientBase);
-    /** Saves each given input as a new ScopedHostNameConfig. */
-    tryCreateMany(request: Array<ScopedHostNameConfig>, options?: IRepoOptions): Promise<BatchResult<ScopedHostNameConfig>>;
-    createMany(request: Array<ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig[]>;
-    /** Retrieves all the existing ScopedHostNameConfig that satisfy the given criteria. */
-    tryReadMany(request: ScopedHostNameConfigCriteria, options?: IRepoOptions): Promise<ListResult<ScopedHostNameConfig>>;
-    readMany(request: ScopedHostNameConfigCriteria, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig[]>;
-    /** Overwrites each existing ScopedHostNameConfig. */
-    tryUpdateMany(request: Array<ScopedHostNameConfig>, options?: IRepoOptions): Promise<BatchResult<ScopedHostNameConfig>>;
-    updateMany(request: Array<ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig[]>;
-    /** Performs the given operations on each existing ScopedHostNameConfig that satisfies the given criteria. */
-    tryPatchWhere(request: PatchSpecForMany<ScopedHostNameConfig, ScopedHostNameConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<ScopedHostNameConfig>>;
-    patchWhere(request: PatchSpecForMany<ScopedHostNameConfig, ScopedHostNameConfigCriteria>, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig[]>;
-    /** Deletes each existing ScopedHostNameConfig that satisfies the given criteria. */
-    tryDeleteWhere(request: ScopedHostNameConfigCriteria, options?: IRepoOptions): Promise<BatchResult<ScopedHostNameConfig>>;
-    deleteWhere(request: ScopedHostNameConfigCriteria, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig[]>;
-    /** Retrieves the single, uniquely identified ScopedHostNameConfig. */
-    tryRead(request: IdSpecFor<ScopedHostNameConfig>, options?: IRepoOptions): Promise<SingleResult<ScopedHostNameConfig>>;
-    read(request: IdSpecFor<ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig>;
-    /** Overwrites the existing ScopedHostNameConfig. */
-    tryUpdate(request: ScopedHostNameConfig, options?: IRepoOptions): Promise<SingleResult<ScopedHostNameConfig>>;
-    update(request: ScopedHostNameConfig, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig>;
-    /** Performs the given operations on the existing ScopedHostNameConfig. */
-    tryPatch(request: PatchSpecForOne<ScopedHostNameConfig>, options?: IRepoOptions): Promise<SingleResult<ScopedHostNameConfig>>;
-    patch(request: PatchSpecForOne<ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig>;
-    /** Deletes the existing ScopedHostNameConfig. */
-    tryDelete(request: IdSpecFor<ScopedHostNameConfig>, options?: IRepoOptions): Promise<SingleResult<ScopedHostNameConfig>>;
-    delete(request: IdSpecFor<ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig>;
-    /** Overwrites the given properties of the existing ScopedHostNameConfig. */
-    tryUpdatePartial(request: ScopedHostNameConfig, options?: IRepoOptions): Promise<SingleResult<PartialWithId<ScopedHostNameConfig>>>;
-    updatePartial(request: ScopedHostNameConfig, options?: IThrowingRepoOptions): Promise<PartialWithId<ScopedHostNameConfig>>;
-    /** Saves the input as a new ScopedHostNameConfig. */
-    tryCreate(request: ScopedHostNameConfig, options?: IRepoOptions): Promise<SingleResult<ScopedHostNameConfig>>;
-    create(request: ScopedHostNameConfig, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig>;
-    /** Performs the given operation on each existing ScopedHostNameConfig that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ScopedHostNameConfig, ScopedHostNameConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<ScopedHostNameConfig>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<ScopedHostNameConfig, ScopedHostNameConfigCriteria>, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig[]>;
-    /** Overwrites the given properties for each existing ScopedHostNameConfig. */
-    tryUpdatePartialMany(request: Array<ScopedHostNameConfig>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<ScopedHostNameConfig>>>;
-    updatePartialMany(request: Array<ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<PartialWithId<ScopedHostNameConfig>[]>;
-    /** Saves each given input as a new ScopedHostNameConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<ScopedHostNameConfig>, options?: IRepoOptions): Promise<BatchResult<ScopedHostNameConfig>>;
-    upsertMany(request: Array<ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig[]>;
-    /** Saves the input as a new ScopedHostNameConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsert(request: ScopedHostNameConfig, options?: IRepoOptions): Promise<SingleResult<ScopedHostNameConfig>>;
-    upsert(request: ScopedHostNameConfig, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig>;
-}
-import { ImageRegistry, ImageRegistryCriteria } from "../contracts";
-declare class ImageRegistryCruds {
-    private core;
-    constructor(core: ApiClientBase);
-    /** Saves each given input as a new ImageRegistry. */
-    tryCreateMany(request: Array<ImageRegistry>, options?: IRepoOptions): Promise<BatchResult<ImageRegistry>>;
-    createMany(request: Array<ImageRegistry>, options?: IThrowingRepoOptions): Promise<ImageRegistry[]>;
-    /** Retrieves all the existing ImageRegistry that satisfy the given criteria. */
-    tryReadMany(request: ImageRegistryCriteria, options?: IRepoOptions): Promise<ListResult<ImageRegistry>>;
-    readMany(request: ImageRegistryCriteria, options?: IThrowingRepoOptions): Promise<ImageRegistry[]>;
-    /** Overwrites each existing ImageRegistry. */
-    tryUpdateMany(request: Array<ImageRegistry>, options?: IRepoOptions): Promise<BatchResult<ImageRegistry>>;
-    updateMany(request: Array<ImageRegistry>, options?: IThrowingRepoOptions): Promise<ImageRegistry[]>;
-    /** Performs the given operations on each existing ImageRegistry that satisfies the given criteria. */
-    tryPatchWhere(request: PatchSpecForMany<ImageRegistry, ImageRegistryCriteria>, options?: IRepoOptions): Promise<BatchResult<ImageRegistry>>;
-    patchWhere(request: PatchSpecForMany<ImageRegistry, ImageRegistryCriteria>, options?: IThrowingRepoOptions): Promise<ImageRegistry[]>;
-    /** Deletes each existing ImageRegistry that satisfies the given criteria. */
-    tryDeleteWhere(request: ImageRegistryCriteria, options?: IRepoOptions): Promise<BatchResult<ImageRegistry>>;
-    deleteWhere(request: ImageRegistryCriteria, options?: IThrowingRepoOptions): Promise<ImageRegistry[]>;
-    /** Retrieves the single, uniquely identified ImageRegistry. */
-    tryRead(request: IdSpecFor<ImageRegistry>, options?: IRepoOptions): Promise<SingleResult<ImageRegistry>>;
-    read(request: IdSpecFor<ImageRegistry>, options?: IThrowingRepoOptions): Promise<ImageRegistry>;
-    /** Overwrites the existing ImageRegistry. */
-    tryUpdate(request: ImageRegistry, options?: IRepoOptions): Promise<SingleResult<ImageRegistry>>;
-    update(request: ImageRegistry, options?: IThrowingRepoOptions): Promise<ImageRegistry>;
-    /** Performs the given operations on the existing ImageRegistry. */
-    tryPatch(request: PatchSpecForOne<ImageRegistry>, options?: IRepoOptions): Promise<SingleResult<ImageRegistry>>;
-    patch(request: PatchSpecForOne<ImageRegistry>, options?: IThrowingRepoOptions): Promise<ImageRegistry>;
-    /** Deletes the existing ImageRegistry. */
-    tryDelete(request: IdSpecFor<ImageRegistry>, options?: IRepoOptions): Promise<SingleResult<ImageRegistry>>;
-    delete(request: IdSpecFor<ImageRegistry>, options?: IThrowingRepoOptions): Promise<ImageRegistry>;
-    /** Overwrites the given properties of the existing ImageRegistry. */
-    tryUpdatePartial(request: ImageRegistry, options?: IRepoOptions): Promise<SingleResult<PartialWithId<ImageRegistry>>>;
-    updatePartial(request: ImageRegistry, options?: IThrowingRepoOptions): Promise<PartialWithId<ImageRegistry>>;
-    /** Saves the input as a new ImageRegistry. */
-    tryCreate(request: ImageRegistry, options?: IRepoOptions): Promise<SingleResult<ImageRegistry>>;
-    create(request: ImageRegistry, options?: IThrowingRepoOptions): Promise<ImageRegistry>;
-    /** Performs the given operation on each existing ImageRegistry that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ImageRegistry, ImageRegistryCriteria>, options?: IRepoOptions): Promise<BatchResult<ImageRegistry>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<ImageRegistry, ImageRegistryCriteria>, options?: IThrowingRepoOptions): Promise<ImageRegistry[]>;
-    /** Overwrites the given properties for each existing ImageRegistry. */
-    tryUpdatePartialMany(request: Array<ImageRegistry>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<ImageRegistry>>>;
-    updatePartialMany(request: Array<ImageRegistry>, options?: IThrowingRepoOptions): Promise<PartialWithId<ImageRegistry>[]>;
-    /** Saves each given input as a new ImageRegistry, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<ImageRegistry>, options?: IRepoOptions): Promise<BatchResult<ImageRegistry>>;
-    upsertMany(request: Array<ImageRegistry>, options?: IThrowingRepoOptions): Promise<ImageRegistry[]>;
-    /** Saves the input as a new ImageRegistry, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsert(request: ImageRegistry, options?: IRepoOptions): Promise<SingleResult<ImageRegistry>>;
-    upsert(request: ImageRegistry, options?: IThrowingRepoOptions): Promise<ImageRegistry>;
+    /** Saves each given input as a new FileStoreDef, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<FileStoreDef>, options?: IRepoOptions): Promise<BatchResult<FileStoreDef>>;
+    upsertMany(request: Array<FileStoreDef>, options?: IThrowingRepoOptions): Promise<FileStoreDef[]>;
 }
 import { Image, ImageCriteria } from "../contracts";
 declare class ImageCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new Image. */
-    tryCreateMany(request: Array<Image>, options?: IRepoOptions): Promise<BatchResult<Image>>;
-    createMany(request: Array<Image>, options?: IThrowingRepoOptions): Promise<Image[]>;
+    /** Deletes each existing Image that satisfies the given criteria. */
+    tryDeleteWhere(request: ImageCriteria, options?: IRepoOptions): Promise<BatchResult<Image>>;
+    deleteWhere(request: ImageCriteria, options?: IThrowingRepoOptions): Promise<Image[]>;
     /** Retrieves all the existing Image that satisfy the given criteria. */
     tryReadMany(request: ImageCriteria, options?: IRepoOptions): Promise<ListResult<Image>>;
     readMany(request: ImageCriteria, options?: IThrowingRepoOptions): Promise<Image[]>;
+    /** Performs the given operations on each existing Image that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Image, ImageCriteria>, options?: IRepoOptions): Promise<BatchResult<Image>>;
+    patchWhere(request: PatchSpecForMany<Image, ImageCriteria>, options?: IThrowingRepoOptions): Promise<Image[]>;
+    /** Saves each given input as a new Image. */
+    tryCreateMany(request: Array<Image>, options?: IRepoOptions): Promise<BatchResult<Image>>;
+    createMany(request: Array<Image>, options?: IThrowingRepoOptions): Promise<Image[]>;
     /** Overwrites each existing Image. */
     tryUpdateMany(request: Array<Image>, options?: IRepoOptions): Promise<BatchResult<Image>>;
     updateMany(request: Array<Image>, options?: IThrowingRepoOptions): Promise<Image[]>;
-    /** Performs the given operations on each existing Image that satisfies the given criteria. */
-    tryPatchWhere(request: PatchSpecForMany<Image, ImageCriteria>, options?: IRepoOptions): Promise<BatchResult<Image>>;
-    patchWhere(request: PatchSpecForMany<Image, ImageCriteria>, options?: IThrowingRepoOptions): Promise<Image[]>;
-    /** Deletes each existing Image that satisfies the given criteria. */
-    tryDeleteWhere(request: ImageCriteria, options?: IRepoOptions): Promise<BatchResult<Image>>;
-    deleteWhere(request: ImageCriteria, options?: IThrowingRepoOptions): Promise<Image[]>;
+    /** Deletes the existing Image. */
+    tryDelete(request: IdSpecFor<Image>, options?: IRepoOptions): Promise<SingleResult<Image>>;
+    delete(request: IdSpecFor<Image>, options?: IThrowingRepoOptions): Promise<Image>;
     /** Retrieves the single, uniquely identified Image. */
     tryRead(request: IdSpecFor<Image>, options?: IRepoOptions): Promise<SingleResult<Image>>;
     read(request: IdSpecFor<Image>, options?: IThrowingRepoOptions): Promise<Image>;
-    /** Overwrites the existing Image. */
-    tryUpdate(request: Image, options?: IRepoOptions): Promise<SingleResult<Image>>;
-    update(request: Image, options?: IThrowingRepoOptions): Promise<Image>;
     /** Performs the given operations on the existing Image. */
     tryPatch(request: PatchSpecForOne<Image>, options?: IRepoOptions): Promise<SingleResult<Image>>;
     patch(request: PatchSpecForOne<Image>, options?: IThrowingRepoOptions): Promise<Image>;
-    /** Deletes the existing Image. */
-    tryDelete(request: IdSpecFor<Image>, options?: IRepoOptions): Promise<SingleResult<Image>>;
-    delete(request: IdSpecFor<Image>, options?: IThrowingRepoOptions): Promise<Image>;
+    /** Overwrites the existing Image. */
+    tryUpdate(request: Image, options?: IRepoOptions): Promise<SingleResult<Image>>;
+    update(request: Image, options?: IThrowingRepoOptions): Promise<Image>;
     /** Overwrites the given properties of the existing Image. */
     tryUpdatePartial(request: Image, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Image>>>;
     updatePartial(request: Image, options?: IThrowingRepoOptions): Promise<PartialWithId<Image>>;
     /** Saves the input as a new Image. */
     tryCreate(request: Image, options?: IRepoOptions): Promise<SingleResult<Image>>;
     create(request: Image, options?: IThrowingRepoOptions): Promise<Image>;
-    /** Performs the given operation on each existing Image that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Image, ImageCriteria>, options?: IRepoOptions): Promise<BatchResult<Image>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<Image, ImageCriteria>, options?: IThrowingRepoOptions): Promise<Image[]>;
     /** Overwrites the given properties for each existing Image. */
     tryUpdatePartialMany(request: Array<Image>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Image>>>;
     updatePartialMany(request: Array<Image>, options?: IThrowingRepoOptions): Promise<PartialWithId<Image>[]>;
-    /** Saves each given input as a new Image, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<Image>, options?: IRepoOptions): Promise<BatchResult<Image>>;
-    upsertMany(request: Array<Image>, options?: IThrowingRepoOptions): Promise<Image[]>;
+    /** Performs the given operation on each existing Image that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Image, ImageCriteria>, options?: IRepoOptions): Promise<BatchResult<Image>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Image, ImageCriteria>, options?: IThrowingRepoOptions): Promise<Image[]>;
     /** Saves the input as a new Image, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: Image, options?: IRepoOptions): Promise<SingleResult<Image>>;
     upsert(request: Image, options?: IThrowingRepoOptions): Promise<Image>;
+    /** Saves each given input as a new Image, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Image>, options?: IRepoOptions): Promise<BatchResult<Image>>;
+    upsertMany(request: Array<Image>, options?: IThrowingRepoOptions): Promise<Image[]>;
 }
-import { SetupJournal, SetupJournalCriteria } from "../contracts";
-declare class SetupJournalCruds {
+import { ImageRegistry, ImageRegistryCriteria } from "../contracts";
+declare class ImageRegistryCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new SetupJournal. */
-    tryCreateMany(request: Array<SetupJournal>, options?: IRepoOptions): Promise<BatchResult<SetupJournal>>;
-    createMany(request: Array<SetupJournal>, options?: IThrowingRepoOptions): Promise<SetupJournal[]>;
-    /** Retrieves all the existing SetupJournal that satisfy the given criteria. */
-    tryReadMany(request: SetupJournalCriteria, options?: IRepoOptions): Promise<ListResult<SetupJournal>>;
-    readMany(request: SetupJournalCriteria, options?: IThrowingRepoOptions): Promise<SetupJournal[]>;
-    /** Overwrites each existing SetupJournal. */
-    tryUpdateMany(request: Array<SetupJournal>, options?: IRepoOptions): Promise<BatchResult<SetupJournal>>;
-    updateMany(request: Array<SetupJournal>, options?: IThrowingRepoOptions): Promise<SetupJournal[]>;
-    /** Performs the given operations on each existing SetupJournal that satisfies the given criteria. */
-    tryPatchWhere(request: PatchSpecForMany<SetupJournal, SetupJournalCriteria>, options?: IRepoOptions): Promise<BatchResult<SetupJournal>>;
-    patchWhere(request: PatchSpecForMany<SetupJournal, SetupJournalCriteria>, options?: IThrowingRepoOptions): Promise<SetupJournal[]>;
-    /** Deletes each existing SetupJournal that satisfies the given criteria. */
-    tryDeleteWhere(request: SetupJournalCriteria, options?: IRepoOptions): Promise<BatchResult<SetupJournal>>;
-    deleteWhere(request: SetupJournalCriteria, options?: IThrowingRepoOptions): Promise<SetupJournal[]>;
-    /** Retrieves the single, uniquely identified SetupJournal. */
-    tryRead(request: IdSpecFor<SetupJournal>, options?: IRepoOptions): Promise<SingleResult<SetupJournal>>;
-    read(request: IdSpecFor<SetupJournal>, options?: IThrowingRepoOptions): Promise<SetupJournal>;
-    /** Overwrites the existing SetupJournal. */
-    tryUpdate(request: SetupJournal, options?: IRepoOptions): Promise<SingleResult<SetupJournal>>;
-    update(request: SetupJournal, options?: IThrowingRepoOptions): Promise<SetupJournal>;
-    /** Performs the given operations on the existing SetupJournal. */
-    tryPatch(request: PatchSpecForOne<SetupJournal>, options?: IRepoOptions): Promise<SingleResult<SetupJournal>>;
-    patch(request: PatchSpecForOne<SetupJournal>, options?: IThrowingRepoOptions): Promise<SetupJournal>;
-    /** Deletes the existing SetupJournal. */
-    tryDelete(request: IdSpecFor<SetupJournal>, options?: IRepoOptions): Promise<SingleResult<SetupJournal>>;
-    delete(request: IdSpecFor<SetupJournal>, options?: IThrowingRepoOptions): Promise<SetupJournal>;
-    /** Overwrites the given properties of the existing SetupJournal. */
-    tryUpdatePartial(request: SetupJournal, options?: IRepoOptions): Promise<SingleResult<PartialWithId<SetupJournal>>>;
-    updatePartial(request: SetupJournal, options?: IThrowingRepoOptions): Promise<PartialWithId<SetupJournal>>;
-    /** Saves the input as a new SetupJournal. */
-    tryCreate(request: SetupJournal, options?: IRepoOptions): Promise<SingleResult<SetupJournal>>;
-    create(request: SetupJournal, options?: IThrowingRepoOptions): Promise<SetupJournal>;
-    /** Performs the given operation on each existing SetupJournal that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<SetupJournal, SetupJournalCriteria>, options?: IRepoOptions): Promise<BatchResult<SetupJournal>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<SetupJournal, SetupJournalCriteria>, options?: IThrowingRepoOptions): Promise<SetupJournal[]>;
-    /** Overwrites the given properties for each existing SetupJournal. */
-    tryUpdatePartialMany(request: Array<SetupJournal>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<SetupJournal>>>;
-    updatePartialMany(request: Array<SetupJournal>, options?: IThrowingRepoOptions): Promise<PartialWithId<SetupJournal>[]>;
-    /** Saves each given input as a new SetupJournal, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<SetupJournal>, options?: IRepoOptions): Promise<BatchResult<SetupJournal>>;
-    upsertMany(request: Array<SetupJournal>, options?: IThrowingRepoOptions): Promise<SetupJournal[]>;
-    /** Saves the input as a new SetupJournal, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsert(request: SetupJournal, options?: IRepoOptions): Promise<SingleResult<SetupJournal>>;
-    upsert(request: SetupJournal, options?: IThrowingRepoOptions): Promise<SetupJournal>;
+    /** Deletes each existing ImageRegistry that satisfies the given criteria. */
+    tryDeleteWhere(request: ImageRegistryCriteria, options?: IRepoOptions): Promise<BatchResult<ImageRegistry>>;
+    deleteWhere(request: ImageRegistryCriteria, options?: IThrowingRepoOptions): Promise<ImageRegistry[]>;
+    /** Retrieves all the existing ImageRegistry that satisfy the given criteria. */
+    tryReadMany(request: ImageRegistryCriteria, options?: IRepoOptions): Promise<ListResult<ImageRegistry>>;
+    readMany(request: ImageRegistryCriteria, options?: IThrowingRepoOptions): Promise<ImageRegistry[]>;
+    /** Performs the given operations on each existing ImageRegistry that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<ImageRegistry, ImageRegistryCriteria>, options?: IRepoOptions): Promise<BatchResult<ImageRegistry>>;
+    patchWhere(request: PatchSpecForMany<ImageRegistry, ImageRegistryCriteria>, options?: IThrowingRepoOptions): Promise<ImageRegistry[]>;
+    /** Saves each given input as a new ImageRegistry. */
+    tryCreateMany(request: Array<ImageRegistry>, options?: IRepoOptions): Promise<BatchResult<ImageRegistry>>;
+    createMany(request: Array<ImageRegistry>, options?: IThrowingRepoOptions): Promise<ImageRegistry[]>;
+    /** Overwrites each existing ImageRegistry. */
+    tryUpdateMany(request: Array<ImageRegistry>, options?: IRepoOptions): Promise<BatchResult<ImageRegistry>>;
+    updateMany(request: Array<ImageRegistry>, options?: IThrowingRepoOptions): Promise<ImageRegistry[]>;
+    /** Deletes the existing ImageRegistry. */
+    tryDelete(request: IdSpecFor<ImageRegistry>, options?: IRepoOptions): Promise<SingleResult<ImageRegistry>>;
+    delete(request: IdSpecFor<ImageRegistry>, options?: IThrowingRepoOptions): Promise<ImageRegistry>;
+    /** Retrieves the single, uniquely identified ImageRegistry. */
+    tryRead(request: IdSpecFor<ImageRegistry>, options?: IRepoOptions): Promise<SingleResult<ImageRegistry>>;
+    read(request: IdSpecFor<ImageRegistry>, options?: IThrowingRepoOptions): Promise<ImageRegistry>;
+    /** Performs the given operations on the existing ImageRegistry. */
+    tryPatch(request: PatchSpecForOne<ImageRegistry>, options?: IRepoOptions): Promise<SingleResult<ImageRegistry>>;
+    patch(request: PatchSpecForOne<ImageRegistry>, options?: IThrowingRepoOptions): Promise<ImageRegistry>;
+    /** Overwrites the existing ImageRegistry. */
+    tryUpdate(request: ImageRegistry, options?: IRepoOptions): Promise<SingleResult<ImageRegistry>>;
+    update(request: ImageRegistry, options?: IThrowingRepoOptions): Promise<ImageRegistry>;
+    /** Overwrites the given properties of the existing ImageRegistry. */
+    tryUpdatePartial(request: ImageRegistry, options?: IRepoOptions): Promise<SingleResult<PartialWithId<ImageRegistry>>>;
+    updatePartial(request: ImageRegistry, options?: IThrowingRepoOptions): Promise<PartialWithId<ImageRegistry>>;
+    /** Saves the input as a new ImageRegistry. */
+    tryCreate(request: ImageRegistry, options?: IRepoOptions): Promise<SingleResult<ImageRegistry>>;
+    create(request: ImageRegistry, options?: IThrowingRepoOptions): Promise<ImageRegistry>;
+    /** Overwrites the given properties for each existing ImageRegistry. */
+    tryUpdatePartialMany(request: Array<ImageRegistry>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<ImageRegistry>>>;
+    updatePartialMany(request: Array<ImageRegistry>, options?: IThrowingRepoOptions): Promise<PartialWithId<ImageRegistry>[]>;
+    /** Performs the given operation on each existing ImageRegistry that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ImageRegistry, ImageRegistryCriteria>, options?: IRepoOptions): Promise<BatchResult<ImageRegistry>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<ImageRegistry, ImageRegistryCriteria>, options?: IThrowingRepoOptions): Promise<ImageRegistry[]>;
+    /** Saves the input as a new ImageRegistry, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: ImageRegistry, options?: IRepoOptions): Promise<SingleResult<ImageRegistry>>;
+    upsert(request: ImageRegistry, options?: IThrowingRepoOptions): Promise<ImageRegistry>;
+    /** Saves each given input as a new ImageRegistry, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<ImageRegistry>, options?: IRepoOptions): Promise<BatchResult<ImageRegistry>>;
+    upsertMany(request: Array<ImageRegistry>, options?: IThrowingRepoOptions): Promise<ImageRegistry[]>;
 }
 import { Kit, KitCriteria } from "../contracts";
 declare class KitCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new Kit. */
-    tryCreateMany(request: Array<Kit>, options?: IRepoOptions): Promise<BatchResult<Kit>>;
-    createMany(request: Array<Kit>, options?: IThrowingRepoOptions): Promise<Kit[]>;
+    /** Deletes each existing Kit that satisfies the given criteria. */
+    tryDeleteWhere(request: KitCriteria, options?: IRepoOptions): Promise<BatchResult<Kit>>;
+    deleteWhere(request: KitCriteria, options?: IThrowingRepoOptions): Promise<Kit[]>;
     /** Retrieves all the existing Kit that satisfy the given criteria. */
     tryReadMany(request: KitCriteria, options?: IRepoOptions): Promise<ListResult<Kit>>;
     readMany(request: KitCriteria, options?: IThrowingRepoOptions): Promise<Kit[]>;
-    /** Overwrites each existing Kit. */
-    tryUpdateMany(request: Array<Kit>, options?: IRepoOptions): Promise<BatchResult<Kit>>;
-    updateMany(request: Array<Kit>, options?: IThrowingRepoOptions): Promise<Kit[]>;
     /** Performs the given operations on each existing Kit that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<Kit, KitCriteria>, options?: IRepoOptions): Promise<BatchResult<Kit>>;
     patchWhere(request: PatchSpecForMany<Kit, KitCriteria>, options?: IThrowingRepoOptions): Promise<Kit[]>;
-    /** Deletes each existing Kit that satisfies the given criteria. */
-    tryDeleteWhere(request: KitCriteria, options?: IRepoOptions): Promise<BatchResult<Kit>>;
-    deleteWhere(request: KitCriteria, options?: IThrowingRepoOptions): Promise<Kit[]>;
+    /** Saves each given input as a new Kit. */
+    tryCreateMany(request: Array<Kit>, options?: IRepoOptions): Promise<BatchResult<Kit>>;
+    createMany(request: Array<Kit>, options?: IThrowingRepoOptions): Promise<Kit[]>;
+    /** Overwrites each existing Kit. */
+    tryUpdateMany(request: Array<Kit>, options?: IRepoOptions): Promise<BatchResult<Kit>>;
+    updateMany(request: Array<Kit>, options?: IThrowingRepoOptions): Promise<Kit[]>;
+    /** Deletes the existing Kit. */
+    tryDelete(request: IdSpecFor<Kit>, options?: IRepoOptions): Promise<SingleResult<Kit>>;
+    delete(request: IdSpecFor<Kit>, options?: IThrowingRepoOptions): Promise<Kit>;
     /** Retrieves the single, uniquely identified Kit. */
     tryRead(request: IdSpecFor<Kit>, options?: IRepoOptions): Promise<SingleResult<Kit>>;
     read(request: IdSpecFor<Kit>, options?: IThrowingRepoOptions): Promise<Kit>;
-    /** Overwrites the existing Kit. */
-    tryUpdate(request: Kit, options?: IRepoOptions): Promise<SingleResult<Kit>>;
-    update(request: Kit, options?: IThrowingRepoOptions): Promise<Kit>;
     /** Performs the given operations on the existing Kit. */
     tryPatch(request: PatchSpecForOne<Kit>, options?: IRepoOptions): Promise<SingleResult<Kit>>;
     patch(request: PatchSpecForOne<Kit>, options?: IThrowingRepoOptions): Promise<Kit>;
-    /** Deletes the existing Kit. */
-    tryDelete(request: IdSpecFor<Kit>, options?: IRepoOptions): Promise<SingleResult<Kit>>;
-    delete(request: IdSpecFor<Kit>, options?: IThrowingRepoOptions): Promise<Kit>;
+    /** Overwrites the existing Kit. */
+    tryUpdate(request: Kit, options?: IRepoOptions): Promise<SingleResult<Kit>>;
+    update(request: Kit, options?: IThrowingRepoOptions): Promise<Kit>;
     /** Overwrites the given properties of the existing Kit. */
     tryUpdatePartial(request: Kit, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Kit>>>;
     updatePartial(request: Kit, options?: IThrowingRepoOptions): Promise<PartialWithId<Kit>>;
     /** Saves the input as a new Kit. */
     tryCreate(request: Kit, options?: IRepoOptions): Promise<SingleResult<Kit>>;
     create(request: Kit, options?: IThrowingRepoOptions): Promise<Kit>;
-    /** Performs the given operation on each existing Kit that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Kit, KitCriteria>, options?: IRepoOptions): Promise<BatchResult<Kit>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<Kit, KitCriteria>, options?: IThrowingRepoOptions): Promise<Kit[]>;
     /** Overwrites the given properties for each existing Kit. */
     tryUpdatePartialMany(request: Array<Kit>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Kit>>>;
     updatePartialMany(request: Array<Kit>, options?: IThrowingRepoOptions): Promise<PartialWithId<Kit>[]>;
-    /** Saves each given input as a new Kit, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<Kit>, options?: IRepoOptions): Promise<BatchResult<Kit>>;
-    upsertMany(request: Array<Kit>, options?: IThrowingRepoOptions): Promise<Kit[]>;
+    /** Performs the given operation on each existing Kit that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Kit, KitCriteria>, options?: IRepoOptions): Promise<BatchResult<Kit>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Kit, KitCriteria>, options?: IThrowingRepoOptions): Promise<Kit[]>;
     /** Saves the input as a new Kit, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: Kit, options?: IRepoOptions): Promise<SingleResult<Kit>>;
     upsert(request: Kit, options?: IThrowingRepoOptions): Promise<Kit>;
+    /** Saves each given input as a new Kit, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Kit>, options?: IRepoOptions): Promise<BatchResult<Kit>>;
+    upsertMany(request: Array<Kit>, options?: IThrowingRepoOptions): Promise<Kit[]>;
 }
 import { KvpStoreDef, KvpStoreDefCriteria } from "../contracts";
 declare class KvpStoreDefCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new KvpStoreDef. */
-    tryCreateMany(request: Array<KvpStoreDef>, options?: IRepoOptions): Promise<BatchResult<KvpStoreDef>>;
-    createMany(request: Array<KvpStoreDef>, options?: IThrowingRepoOptions): Promise<KvpStoreDef[]>;
+    /** Deletes each existing KvpStoreDef that satisfies the given criteria. */
+    tryDeleteWhere(request: KvpStoreDefCriteria, options?: IRepoOptions): Promise<BatchResult<KvpStoreDef>>;
+    deleteWhere(request: KvpStoreDefCriteria, options?: IThrowingRepoOptions): Promise<KvpStoreDef[]>;
     /** Retrieves all the existing KvpStoreDef that satisfy the given criteria. */
     tryReadMany(request: KvpStoreDefCriteria, options?: IRepoOptions): Promise<ListResult<KvpStoreDef>>;
     readMany(request: KvpStoreDefCriteria, options?: IThrowingRepoOptions): Promise<KvpStoreDef[]>;
-    /** Overwrites each existing KvpStoreDef. */
-    tryUpdateMany(request: Array<KvpStoreDef>, options?: IRepoOptions): Promise<BatchResult<KvpStoreDef>>;
-    updateMany(request: Array<KvpStoreDef>, options?: IThrowingRepoOptions): Promise<KvpStoreDef[]>;
     /** Performs the given operations on each existing KvpStoreDef that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<KvpStoreDef, KvpStoreDefCriteria>, options?: IRepoOptions): Promise<BatchResult<KvpStoreDef>>;
     patchWhere(request: PatchSpecForMany<KvpStoreDef, KvpStoreDefCriteria>, options?: IThrowingRepoOptions): Promise<KvpStoreDef[]>;
-    /** Deletes each existing KvpStoreDef that satisfies the given criteria. */
-    tryDeleteWhere(request: KvpStoreDefCriteria, options?: IRepoOptions): Promise<BatchResult<KvpStoreDef>>;
-    deleteWhere(request: KvpStoreDefCriteria, options?: IThrowingRepoOptions): Promise<KvpStoreDef[]>;
+    /** Saves each given input as a new KvpStoreDef. */
+    tryCreateMany(request: Array<KvpStoreDef>, options?: IRepoOptions): Promise<BatchResult<KvpStoreDef>>;
+    createMany(request: Array<KvpStoreDef>, options?: IThrowingRepoOptions): Promise<KvpStoreDef[]>;
+    /** Overwrites each existing KvpStoreDef. */
+    tryUpdateMany(request: Array<KvpStoreDef>, options?: IRepoOptions): Promise<BatchResult<KvpStoreDef>>;
+    updateMany(request: Array<KvpStoreDef>, options?: IThrowingRepoOptions): Promise<KvpStoreDef[]>;
+    /** Deletes the existing KvpStoreDef. */
+    tryDelete(request: IdSpecFor<KvpStoreDef>, options?: IRepoOptions): Promise<SingleResult<KvpStoreDef>>;
+    delete(request: IdSpecFor<KvpStoreDef>, options?: IThrowingRepoOptions): Promise<KvpStoreDef>;
     /** Retrieves the single, uniquely identified KvpStoreDef. */
     tryRead(request: IdSpecFor<KvpStoreDef>, options?: IRepoOptions): Promise<SingleResult<KvpStoreDef>>;
     read(request: IdSpecFor<KvpStoreDef>, options?: IThrowingRepoOptions): Promise<KvpStoreDef>;
-    /** Overwrites the existing KvpStoreDef. */
-    tryUpdate(request: KvpStoreDef, options?: IRepoOptions): Promise<SingleResult<KvpStoreDef>>;
-    update(request: KvpStoreDef, options?: IThrowingRepoOptions): Promise<KvpStoreDef>;
     /** Performs the given operations on the existing KvpStoreDef. */
     tryPatch(request: PatchSpecForOne<KvpStoreDef>, options?: IRepoOptions): Promise<SingleResult<KvpStoreDef>>;
     patch(request: PatchSpecForOne<KvpStoreDef>, options?: IThrowingRepoOptions): Promise<KvpStoreDef>;
-    /** Deletes the existing KvpStoreDef. */
-    tryDelete(request: IdSpecFor<KvpStoreDef>, options?: IRepoOptions): Promise<SingleResult<KvpStoreDef>>;
-    delete(request: IdSpecFor<KvpStoreDef>, options?: IThrowingRepoOptions): Promise<KvpStoreDef>;
+    /** Overwrites the existing KvpStoreDef. */
+    tryUpdate(request: KvpStoreDef, options?: IRepoOptions): Promise<SingleResult<KvpStoreDef>>;
+    update(request: KvpStoreDef, options?: IThrowingRepoOptions): Promise<KvpStoreDef>;
     /** Overwrites the given properties of the existing KvpStoreDef. */
     tryUpdatePartial(request: KvpStoreDef, options?: IRepoOptions): Promise<SingleResult<PartialWithId<KvpStoreDef>>>;
     updatePartial(request: KvpStoreDef, options?: IThrowingRepoOptions): Promise<PartialWithId<KvpStoreDef>>;
     /** Saves the input as a new KvpStoreDef. */
     tryCreate(request: KvpStoreDef, options?: IRepoOptions): Promise<SingleResult<KvpStoreDef>>;
     create(request: KvpStoreDef, options?: IThrowingRepoOptions): Promise<KvpStoreDef>;
-    /** Performs the given operation on each existing KvpStoreDef that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<KvpStoreDef, KvpStoreDefCriteria>, options?: IRepoOptions): Promise<BatchResult<KvpStoreDef>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<KvpStoreDef, KvpStoreDefCriteria>, options?: IThrowingRepoOptions): Promise<KvpStoreDef[]>;
     /** Overwrites the given properties for each existing KvpStoreDef. */
     tryUpdatePartialMany(request: Array<KvpStoreDef>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<KvpStoreDef>>>;
     updatePartialMany(request: Array<KvpStoreDef>, options?: IThrowingRepoOptions): Promise<PartialWithId<KvpStoreDef>[]>;
-    /** Saves each given input as a new KvpStoreDef, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<KvpStoreDef>, options?: IRepoOptions): Promise<BatchResult<KvpStoreDef>>;
-    upsertMany(request: Array<KvpStoreDef>, options?: IThrowingRepoOptions): Promise<KvpStoreDef[]>;
+    /** Performs the given operation on each existing KvpStoreDef that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<KvpStoreDef, KvpStoreDefCriteria>, options?: IRepoOptions): Promise<BatchResult<KvpStoreDef>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<KvpStoreDef, KvpStoreDefCriteria>, options?: IThrowingRepoOptions): Promise<KvpStoreDef[]>;
     /** Saves the input as a new KvpStoreDef, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: KvpStoreDef, options?: IRepoOptions): Promise<SingleResult<KvpStoreDef>>;
     upsert(request: KvpStoreDef, options?: IThrowingRepoOptions): Promise<KvpStoreDef>;
+    /** Saves each given input as a new KvpStoreDef, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<KvpStoreDef>, options?: IRepoOptions): Promise<BatchResult<KvpStoreDef>>;
+    upsertMany(request: Array<KvpStoreDef>, options?: IThrowingRepoOptions): Promise<KvpStoreDef[]>;
 }
 import { Label, LabelCriteria } from "../contracts";
 declare class LabelCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new Label. */
-    tryCreateMany(request: Array<Label>, options?: IRepoOptions): Promise<BatchResult<Label>>;
-    createMany(request: Array<Label>, options?: IThrowingRepoOptions): Promise<Label[]>;
+    /** Deletes each existing Label that satisfies the given criteria. */
+    tryDeleteWhere(request: LabelCriteria, options?: IRepoOptions): Promise<BatchResult<Label>>;
+    deleteWhere(request: LabelCriteria, options?: IThrowingRepoOptions): Promise<Label[]>;
     /** Retrieves all the existing Label that satisfy the given criteria. */
     tryReadMany(request: LabelCriteria, options?: IRepoOptions): Promise<ListResult<Label>>;
     readMany(request: LabelCriteria, options?: IThrowingRepoOptions): Promise<Label[]>;
-    /** Overwrites each existing Label. */
-    tryUpdateMany(request: Array<Label>, options?: IRepoOptions): Promise<BatchResult<Label>>;
-    updateMany(request: Array<Label>, options?: IThrowingRepoOptions): Promise<Label[]>;
     /** Performs the given operations on each existing Label that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<Label, LabelCriteria>, options?: IRepoOptions): Promise<BatchResult<Label>>;
     patchWhere(request: PatchSpecForMany<Label, LabelCriteria>, options?: IThrowingRepoOptions): Promise<Label[]>;
-    /** Deletes each existing Label that satisfies the given criteria. */
-    tryDeleteWhere(request: LabelCriteria, options?: IRepoOptions): Promise<BatchResult<Label>>;
-    deleteWhere(request: LabelCriteria, options?: IThrowingRepoOptions): Promise<Label[]>;
+    /** Saves each given input as a new Label. */
+    tryCreateMany(request: Array<Label>, options?: IRepoOptions): Promise<BatchResult<Label>>;
+    createMany(request: Array<Label>, options?: IThrowingRepoOptions): Promise<Label[]>;
+    /** Overwrites each existing Label. */
+    tryUpdateMany(request: Array<Label>, options?: IRepoOptions): Promise<BatchResult<Label>>;
+    updateMany(request: Array<Label>, options?: IThrowingRepoOptions): Promise<Label[]>;
+    /** Deletes the existing Label. */
+    tryDelete(request: IdSpecFor<Label>, options?: IRepoOptions): Promise<SingleResult<Label>>;
+    delete(request: IdSpecFor<Label>, options?: IThrowingRepoOptions): Promise<Label>;
     /** Retrieves the single, uniquely identified Label. */
     tryRead(request: IdSpecFor<Label>, options?: IRepoOptions): Promise<SingleResult<Label>>;
     read(request: IdSpecFor<Label>, options?: IThrowingRepoOptions): Promise<Label>;
-    /** Overwrites the existing Label. */
-    tryUpdate(request: Label, options?: IRepoOptions): Promise<SingleResult<Label>>;
-    update(request: Label, options?: IThrowingRepoOptions): Promise<Label>;
     /** Performs the given operations on the existing Label. */
     tryPatch(request: PatchSpecForOne<Label>, options?: IRepoOptions): Promise<SingleResult<Label>>;
     patch(request: PatchSpecForOne<Label>, options?: IThrowingRepoOptions): Promise<Label>;
-    /** Deletes the existing Label. */
-    tryDelete(request: IdSpecFor<Label>, options?: IRepoOptions): Promise<SingleResult<Label>>;
-    delete(request: IdSpecFor<Label>, options?: IThrowingRepoOptions): Promise<Label>;
+    /** Overwrites the existing Label. */
+    tryUpdate(request: Label, options?: IRepoOptions): Promise<SingleResult<Label>>;
+    update(request: Label, options?: IThrowingRepoOptions): Promise<Label>;
     /** Overwrites the given properties of the existing Label. */
     tryUpdatePartial(request: Label, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Label>>>;
     updatePartial(request: Label, options?: IThrowingRepoOptions): Promise<PartialWithId<Label>>;
     /** Saves the input as a new Label. */
     tryCreate(request: Label, options?: IRepoOptions): Promise<SingleResult<Label>>;
     create(request: Label, options?: IThrowingRepoOptions): Promise<Label>;
-    /** Performs the given operation on each existing Label that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Label, LabelCriteria>, options?: IRepoOptions): Promise<BatchResult<Label>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<Label, LabelCriteria>, options?: IThrowingRepoOptions): Promise<Label[]>;
     /** Overwrites the given properties for each existing Label. */
     tryUpdatePartialMany(request: Array<Label>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Label>>>;
     updatePartialMany(request: Array<Label>, options?: IThrowingRepoOptions): Promise<PartialWithId<Label>[]>;
-    /** Saves each given input as a new Label, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<Label>, options?: IRepoOptions): Promise<BatchResult<Label>>;
-    upsertMany(request: Array<Label>, options?: IThrowingRepoOptions): Promise<Label[]>;
+    /** Performs the given operation on each existing Label that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Label, LabelCriteria>, options?: IRepoOptions): Promise<BatchResult<Label>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Label, LabelCriteria>, options?: IThrowingRepoOptions): Promise<Label[]>;
     /** Saves the input as a new Label, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: Label, options?: IRepoOptions): Promise<SingleResult<Label>>;
     upsert(request: Label, options?: IThrowingRepoOptions): Promise<Label>;
+    /** Saves each given input as a new Label, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Label>, options?: IRepoOptions): Promise<BatchResult<Label>>;
+    upsertMany(request: Array<Label>, options?: IThrowingRepoOptions): Promise<Label[]>;
 }
 import { NodePoolDef, NodePoolDefCriteria } from "../contracts";
 declare class NodePoolDefCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new NodePoolDef. */
-    tryCreateMany(request: Array<NodePoolDef>, options?: IRepoOptions): Promise<BatchResult<NodePoolDef>>;
-    createMany(request: Array<NodePoolDef>, options?: IThrowingRepoOptions): Promise<NodePoolDef[]>;
+    /** Deletes each existing NodePoolDef that satisfies the given criteria. */
+    tryDeleteWhere(request: NodePoolDefCriteria, options?: IRepoOptions): Promise<BatchResult<NodePoolDef>>;
+    deleteWhere(request: NodePoolDefCriteria, options?: IThrowingRepoOptions): Promise<NodePoolDef[]>;
     /** Retrieves all the existing NodePoolDef that satisfy the given criteria. */
     tryReadMany(request: NodePoolDefCriteria, options?: IRepoOptions): Promise<ListResult<NodePoolDef>>;
     readMany(request: NodePoolDefCriteria, options?: IThrowingRepoOptions): Promise<NodePoolDef[]>;
-    /** Overwrites each existing NodePoolDef. */
-    tryUpdateMany(request: Array<NodePoolDef>, options?: IRepoOptions): Promise<BatchResult<NodePoolDef>>;
-    updateMany(request: Array<NodePoolDef>, options?: IThrowingRepoOptions): Promise<NodePoolDef[]>;
     /** Performs the given operations on each existing NodePoolDef that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<NodePoolDef, NodePoolDefCriteria>, options?: IRepoOptions): Promise<BatchResult<NodePoolDef>>;
     patchWhere(request: PatchSpecForMany<NodePoolDef, NodePoolDefCriteria>, options?: IThrowingRepoOptions): Promise<NodePoolDef[]>;
-    /** Deletes each existing NodePoolDef that satisfies the given criteria. */
-    tryDeleteWhere(request: NodePoolDefCriteria, options?: IRepoOptions): Promise<BatchResult<NodePoolDef>>;
-    deleteWhere(request: NodePoolDefCriteria, options?: IThrowingRepoOptions): Promise<NodePoolDef[]>;
+    /** Saves each given input as a new NodePoolDef. */
+    tryCreateMany(request: Array<NodePoolDef>, options?: IRepoOptions): Promise<BatchResult<NodePoolDef>>;
+    createMany(request: Array<NodePoolDef>, options?: IThrowingRepoOptions): Promise<NodePoolDef[]>;
+    /** Overwrites each existing NodePoolDef. */
+    tryUpdateMany(request: Array<NodePoolDef>, options?: IRepoOptions): Promise<BatchResult<NodePoolDef>>;
+    updateMany(request: Array<NodePoolDef>, options?: IThrowingRepoOptions): Promise<NodePoolDef[]>;
+    /** Deletes the existing NodePoolDef. */
+    tryDelete(request: IdSpecFor<NodePoolDef>, options?: IRepoOptions): Promise<SingleResult<NodePoolDef>>;
+    delete(request: IdSpecFor<NodePoolDef>, options?: IThrowingRepoOptions): Promise<NodePoolDef>;
     /** Retrieves the single, uniquely identified NodePoolDef. */
     tryRead(request: IdSpecFor<NodePoolDef>, options?: IRepoOptions): Promise<SingleResult<NodePoolDef>>;
     read(request: IdSpecFor<NodePoolDef>, options?: IThrowingRepoOptions): Promise<NodePoolDef>;
-    /** Overwrites the existing NodePoolDef. */
-    tryUpdate(request: NodePoolDef, options?: IRepoOptions): Promise<SingleResult<NodePoolDef>>;
-    update(request: NodePoolDef, options?: IThrowingRepoOptions): Promise<NodePoolDef>;
     /** Performs the given operations on the existing NodePoolDef. */
     tryPatch(request: PatchSpecForOne<NodePoolDef>, options?: IRepoOptions): Promise<SingleResult<NodePoolDef>>;
     patch(request: PatchSpecForOne<NodePoolDef>, options?: IThrowingRepoOptions): Promise<NodePoolDef>;
-    /** Deletes the existing NodePoolDef. */
-    tryDelete(request: IdSpecFor<NodePoolDef>, options?: IRepoOptions): Promise<SingleResult<NodePoolDef>>;
-    delete(request: IdSpecFor<NodePoolDef>, options?: IThrowingRepoOptions): Promise<NodePoolDef>;
+    /** Overwrites the existing NodePoolDef. */
+    tryUpdate(request: NodePoolDef, options?: IRepoOptions): Promise<SingleResult<NodePoolDef>>;
+    update(request: NodePoolDef, options?: IThrowingRepoOptions): Promise<NodePoolDef>;
     /** Overwrites the given properties of the existing NodePoolDef. */
     tryUpdatePartial(request: NodePoolDef, options?: IRepoOptions): Promise<SingleResult<PartialWithId<NodePoolDef>>>;
     updatePartial(request: NodePoolDef, options?: IThrowingRepoOptions): Promise<PartialWithId<NodePoolDef>>;
     /** Saves the input as a new NodePoolDef. */
     tryCreate(request: NodePoolDef, options?: IRepoOptions): Promise<SingleResult<NodePoolDef>>;
     create(request: NodePoolDef, options?: IThrowingRepoOptions): Promise<NodePoolDef>;
-    /** Performs the given operation on each existing NodePoolDef that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<NodePoolDef, NodePoolDefCriteria>, options?: IRepoOptions): Promise<BatchResult<NodePoolDef>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<NodePoolDef, NodePoolDefCriteria>, options?: IThrowingRepoOptions): Promise<NodePoolDef[]>;
     /** Overwrites the given properties for each existing NodePoolDef. */
     tryUpdatePartialMany(request: Array<NodePoolDef>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<NodePoolDef>>>;
     updatePartialMany(request: Array<NodePoolDef>, options?: IThrowingRepoOptions): Promise<PartialWithId<NodePoolDef>[]>;
-    /** Saves each given input as a new NodePoolDef, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<NodePoolDef>, options?: IRepoOptions): Promise<BatchResult<NodePoolDef>>;
-    upsertMany(request: Array<NodePoolDef>, options?: IThrowingRepoOptions): Promise<NodePoolDef[]>;
+    /** Performs the given operation on each existing NodePoolDef that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<NodePoolDef, NodePoolDefCriteria>, options?: IRepoOptions): Promise<BatchResult<NodePoolDef>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<NodePoolDef, NodePoolDefCriteria>, options?: IThrowingRepoOptions): Promise<NodePoolDef[]>;
     /** Saves the input as a new NodePoolDef, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: NodePoolDef, options?: IRepoOptions): Promise<SingleResult<NodePoolDef>>;
     upsert(request: NodePoolDef, options?: IThrowingRepoOptions): Promise<NodePoolDef>;
+    /** Saves each given input as a new NodePoolDef, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<NodePoolDef>, options?: IRepoOptions): Promise<BatchResult<NodePoolDef>>;
+    upsertMany(request: Array<NodePoolDef>, options?: IThrowingRepoOptions): Promise<NodePoolDef[]>;
 }
 import { Probe, ProbeCriteria } from "../contracts";
 declare class ProbeCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new Probe. */
-    tryCreateMany(request: Array<Probe>, options?: IRepoOptions): Promise<BatchResult<Probe>>;
-    createMany(request: Array<Probe>, options?: IThrowingRepoOptions): Promise<Probe[]>;
+    /** Deletes each existing Probe that satisfies the given criteria. */
+    tryDeleteWhere(request: ProbeCriteria, options?: IRepoOptions): Promise<BatchResult<Probe>>;
+    deleteWhere(request: ProbeCriteria, options?: IThrowingRepoOptions): Promise<Probe[]>;
     /** Retrieves all the existing Probe that satisfy the given criteria. */
     tryReadMany(request: ProbeCriteria, options?: IRepoOptions): Promise<ListResult<Probe>>;
     readMany(request: ProbeCriteria, options?: IThrowingRepoOptions): Promise<Probe[]>;
-    /** Overwrites each existing Probe. */
-    tryUpdateMany(request: Array<Probe>, options?: IRepoOptions): Promise<BatchResult<Probe>>;
-    updateMany(request: Array<Probe>, options?: IThrowingRepoOptions): Promise<Probe[]>;
     /** Performs the given operations on each existing Probe that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<Probe, ProbeCriteria>, options?: IRepoOptions): Promise<BatchResult<Probe>>;
     patchWhere(request: PatchSpecForMany<Probe, ProbeCriteria>, options?: IThrowingRepoOptions): Promise<Probe[]>;
-    /** Deletes each existing Probe that satisfies the given criteria. */
-    tryDeleteWhere(request: ProbeCriteria, options?: IRepoOptions): Promise<BatchResult<Probe>>;
-    deleteWhere(request: ProbeCriteria, options?: IThrowingRepoOptions): Promise<Probe[]>;
+    /** Saves each given input as a new Probe. */
+    tryCreateMany(request: Array<Probe>, options?: IRepoOptions): Promise<BatchResult<Probe>>;
+    createMany(request: Array<Probe>, options?: IThrowingRepoOptions): Promise<Probe[]>;
+    /** Overwrites each existing Probe. */
+    tryUpdateMany(request: Array<Probe>, options?: IRepoOptions): Promise<BatchResult<Probe>>;
+    updateMany(request: Array<Probe>, options?: IThrowingRepoOptions): Promise<Probe[]>;
+    /** Deletes the existing Probe. */
+    tryDelete(request: IdSpecFor<Probe>, options?: IRepoOptions): Promise<SingleResult<Probe>>;
+    delete(request: IdSpecFor<Probe>, options?: IThrowingRepoOptions): Promise<Probe>;
     /** Retrieves the single, uniquely identified Probe. */
     tryRead(request: IdSpecFor<Probe>, options?: IRepoOptions): Promise<SingleResult<Probe>>;
     read(request: IdSpecFor<Probe>, options?: IThrowingRepoOptions): Promise<Probe>;
-    /** Overwrites the existing Probe. */
-    tryUpdate(request: Probe, options?: IRepoOptions): Promise<SingleResult<Probe>>;
-    update(request: Probe, options?: IThrowingRepoOptions): Promise<Probe>;
     /** Performs the given operations on the existing Probe. */
     tryPatch(request: PatchSpecForOne<Probe>, options?: IRepoOptions): Promise<SingleResult<Probe>>;
     patch(request: PatchSpecForOne<Probe>, options?: IThrowingRepoOptions): Promise<Probe>;
-    /** Deletes the existing Probe. */
-    tryDelete(request: IdSpecFor<Probe>, options?: IRepoOptions): Promise<SingleResult<Probe>>;
-    delete(request: IdSpecFor<Probe>, options?: IThrowingRepoOptions): Promise<Probe>;
+    /** Overwrites the existing Probe. */
+    tryUpdate(request: Probe, options?: IRepoOptions): Promise<SingleResult<Probe>>;
+    update(request: Probe, options?: IThrowingRepoOptions): Promise<Probe>;
     /** Overwrites the given properties of the existing Probe. */
     tryUpdatePartial(request: Probe, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Probe>>>;
     updatePartial(request: Probe, options?: IThrowingRepoOptions): Promise<PartialWithId<Probe>>;
     /** Saves the input as a new Probe. */
     tryCreate(request: Probe, options?: IRepoOptions): Promise<SingleResult<Probe>>;
     create(request: Probe, options?: IThrowingRepoOptions): Promise<Probe>;
-    /** Performs the given operation on each existing Probe that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Probe, ProbeCriteria>, options?: IRepoOptions): Promise<BatchResult<Probe>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<Probe, ProbeCriteria>, options?: IThrowingRepoOptions): Promise<Probe[]>;
     /** Overwrites the given properties for each existing Probe. */
     tryUpdatePartialMany(request: Array<Probe>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Probe>>>;
     updatePartialMany(request: Array<Probe>, options?: IThrowingRepoOptions): Promise<PartialWithId<Probe>[]>;
-    /** Saves each given input as a new Probe, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<Probe>, options?: IRepoOptions): Promise<BatchResult<Probe>>;
-    upsertMany(request: Array<Probe>, options?: IThrowingRepoOptions): Promise<Probe[]>;
+    /** Performs the given operation on each existing Probe that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Probe, ProbeCriteria>, options?: IRepoOptions): Promise<BatchResult<Probe>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Probe, ProbeCriteria>, options?: IThrowingRepoOptions): Promise<Probe[]>;
     /** Saves the input as a new Probe, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: Probe, options?: IRepoOptions): Promise<SingleResult<Probe>>;
     upsert(request: Probe, options?: IThrowingRepoOptions): Promise<Probe>;
+    /** Saves each given input as a new Probe, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Probe>, options?: IRepoOptions): Promise<BatchResult<Probe>>;
+    upsertMany(request: Array<Probe>, options?: IThrowingRepoOptions): Promise<Probe[]>;
+}
+import { Product, ProductCriteria } from "../contracts";
+declare class ProductCruds {
+    private core;
+    constructor(core: ApiClientBase);
+    /** Deletes each existing Product that satisfies the given criteria. */
+    tryDeleteWhere(request: ProductCriteria, options?: IRepoOptions): Promise<BatchResult<Product>>;
+    deleteWhere(request: ProductCriteria, options?: IThrowingRepoOptions): Promise<Product[]>;
+    /** Retrieves all the existing Product that satisfy the given criteria. */
+    tryReadMany(request: ProductCriteria, options?: IRepoOptions): Promise<ListResult<Product>>;
+    readMany(request: ProductCriteria, options?: IThrowingRepoOptions): Promise<Product[]>;
+    /** Performs the given operations on each existing Product that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Product, ProductCriteria>, options?: IRepoOptions): Promise<BatchResult<Product>>;
+    patchWhere(request: PatchSpecForMany<Product, ProductCriteria>, options?: IThrowingRepoOptions): Promise<Product[]>;
+    /** Saves each given input as a new Product. */
+    tryCreateMany(request: Array<Product>, options?: IRepoOptions): Promise<BatchResult<Product>>;
+    createMany(request: Array<Product>, options?: IThrowingRepoOptions): Promise<Product[]>;
+    /** Overwrites each existing Product. */
+    tryUpdateMany(request: Array<Product>, options?: IRepoOptions): Promise<BatchResult<Product>>;
+    updateMany(request: Array<Product>, options?: IThrowingRepoOptions): Promise<Product[]>;
+    /** Deletes the existing Product. */
+    tryDelete(request: IdSpecFor<Product>, options?: IRepoOptions): Promise<SingleResult<Product>>;
+    delete(request: IdSpecFor<Product>, options?: IThrowingRepoOptions): Promise<Product>;
+    /** Retrieves the single, uniquely identified Product. */
+    tryRead(request: IdSpecFor<Product>, options?: IRepoOptions): Promise<SingleResult<Product>>;
+    read(request: IdSpecFor<Product>, options?: IThrowingRepoOptions): Promise<Product>;
+    /** Performs the given operations on the existing Product. */
+    tryPatch(request: PatchSpecForOne<Product>, options?: IRepoOptions): Promise<SingleResult<Product>>;
+    patch(request: PatchSpecForOne<Product>, options?: IThrowingRepoOptions): Promise<Product>;
+    /** Overwrites the existing Product. */
+    tryUpdate(request: Product, options?: IRepoOptions): Promise<SingleResult<Product>>;
+    update(request: Product, options?: IThrowingRepoOptions): Promise<Product>;
+    /** Overwrites the given properties of the existing Product. */
+    tryUpdatePartial(request: Product, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Product>>>;
+    updatePartial(request: Product, options?: IThrowingRepoOptions): Promise<PartialWithId<Product>>;
+    /** Saves the input as a new Product. */
+    tryCreate(request: Product, options?: IRepoOptions): Promise<SingleResult<Product>>;
+    create(request: Product, options?: IThrowingRepoOptions): Promise<Product>;
+    /** Overwrites the given properties for each existing Product. */
+    tryUpdatePartialMany(request: Array<Product>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Product>>>;
+    updatePartialMany(request: Array<Product>, options?: IThrowingRepoOptions): Promise<PartialWithId<Product>[]>;
+    /** Performs the given operation on each existing Product that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Product, ProductCriteria>, options?: IRepoOptions): Promise<BatchResult<Product>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Product, ProductCriteria>, options?: IThrowingRepoOptions): Promise<Product[]>;
+    /** Saves the input as a new Product, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: Product, options?: IRepoOptions): Promise<SingleResult<Product>>;
+    upsert(request: Product, options?: IThrowingRepoOptions): Promise<Product>;
+    /** Saves each given input as a new Product, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Product>, options?: IRepoOptions): Promise<BatchResult<Product>>;
+    upsertMany(request: Array<Product>, options?: IThrowingRepoOptions): Promise<Product[]>;
 }
 import { ProductVersionConfig, ProductVersionConfigCriteria } from "../contracts";
 declare class ProductVersionConfigCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new ProductVersionConfig. */
-    tryCreateMany(request: Array<ProductVersionConfig>, options?: IRepoOptions): Promise<BatchResult<ProductVersionConfig>>;
-    createMany(request: Array<ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<ProductVersionConfig[]>;
+    /** Deletes each existing ProductVersionConfig that satisfies the given criteria. */
+    tryDeleteWhere(request: ProductVersionConfigCriteria, options?: IRepoOptions): Promise<BatchResult<ProductVersionConfig>>;
+    deleteWhere(request: ProductVersionConfigCriteria, options?: IThrowingRepoOptions): Promise<ProductVersionConfig[]>;
     /** Retrieves all the existing ProductVersionConfig that satisfy the given criteria. */
     tryReadMany(request: ProductVersionConfigCriteria, options?: IRepoOptions): Promise<ListResult<ProductVersionConfig>>;
     readMany(request: ProductVersionConfigCriteria, options?: IThrowingRepoOptions): Promise<ProductVersionConfig[]>;
-    /** Overwrites each existing ProductVersionConfig. */
-    tryUpdateMany(request: Array<ProductVersionConfig>, options?: IRepoOptions): Promise<BatchResult<ProductVersionConfig>>;
-    updateMany(request: Array<ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<ProductVersionConfig[]>;
     /** Performs the given operations on each existing ProductVersionConfig that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<ProductVersionConfig, ProductVersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<ProductVersionConfig>>;
     patchWhere(request: PatchSpecForMany<ProductVersionConfig, ProductVersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<ProductVersionConfig[]>;
-    /** Deletes each existing ProductVersionConfig that satisfies the given criteria. */
-    tryDeleteWhere(request: ProductVersionConfigCriteria, options?: IRepoOptions): Promise<BatchResult<ProductVersionConfig>>;
-    deleteWhere(request: ProductVersionConfigCriteria, options?: IThrowingRepoOptions): Promise<ProductVersionConfig[]>;
+    /** Saves each given input as a new ProductVersionConfig. */
+    tryCreateMany(request: Array<ProductVersionConfig>, options?: IRepoOptions): Promise<BatchResult<ProductVersionConfig>>;
+    createMany(request: Array<ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<ProductVersionConfig[]>;
+    /** Overwrites each existing ProductVersionConfig. */
+    tryUpdateMany(request: Array<ProductVersionConfig>, options?: IRepoOptions): Promise<BatchResult<ProductVersionConfig>>;
+    updateMany(request: Array<ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<ProductVersionConfig[]>;
+    /** Deletes the existing ProductVersionConfig. */
+    tryDelete(request: IdSpecFor<ProductVersionConfig>, options?: IRepoOptions): Promise<SingleResult<ProductVersionConfig>>;
+    delete(request: IdSpecFor<ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<ProductVersionConfig>;
     /** Retrieves the single, uniquely identified ProductVersionConfig. */
     tryRead(request: IdSpecFor<ProductVersionConfig>, options?: IRepoOptions): Promise<SingleResult<ProductVersionConfig>>;
     read(request: IdSpecFor<ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<ProductVersionConfig>;
-    /** Overwrites the existing ProductVersionConfig. */
-    tryUpdate(request: ProductVersionConfig, options?: IRepoOptions): Promise<SingleResult<ProductVersionConfig>>;
-    update(request: ProductVersionConfig, options?: IThrowingRepoOptions): Promise<ProductVersionConfig>;
     /** Performs the given operations on the existing ProductVersionConfig. */
     tryPatch(request: PatchSpecForOne<ProductVersionConfig>, options?: IRepoOptions): Promise<SingleResult<ProductVersionConfig>>;
     patch(request: PatchSpecForOne<ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<ProductVersionConfig>;
-    /** Deletes the existing ProductVersionConfig. */
-    tryDelete(request: IdSpecFor<ProductVersionConfig>, options?: IRepoOptions): Promise<SingleResult<ProductVersionConfig>>;
-    delete(request: IdSpecFor<ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<ProductVersionConfig>;
+    /** Overwrites the existing ProductVersionConfig. */
+    tryUpdate(request: ProductVersionConfig, options?: IRepoOptions): Promise<SingleResult<ProductVersionConfig>>;
+    update(request: ProductVersionConfig, options?: IThrowingRepoOptions): Promise<ProductVersionConfig>;
     /** Overwrites the given properties of the existing ProductVersionConfig. */
     tryUpdatePartial(request: ProductVersionConfig, options?: IRepoOptions): Promise<SingleResult<PartialWithId<ProductVersionConfig>>>;
     updatePartial(request: ProductVersionConfig, options?: IThrowingRepoOptions): Promise<PartialWithId<ProductVersionConfig>>;
     /** Saves the input as a new ProductVersionConfig. */
     tryCreate(request: ProductVersionConfig, options?: IRepoOptions): Promise<SingleResult<ProductVersionConfig>>;
     create(request: ProductVersionConfig, options?: IThrowingRepoOptions): Promise<ProductVersionConfig>;
-    /** Performs the given operation on each existing ProductVersionConfig that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ProductVersionConfig, ProductVersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<ProductVersionConfig>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<ProductVersionConfig, ProductVersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<ProductVersionConfig[]>;
     /** Overwrites the given properties for each existing ProductVersionConfig. */
     tryUpdatePartialMany(request: Array<ProductVersionConfig>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<ProductVersionConfig>>>;
     updatePartialMany(request: Array<ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<PartialWithId<ProductVersionConfig>[]>;
-    /** Saves each given input as a new ProductVersionConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<ProductVersionConfig>, options?: IRepoOptions): Promise<BatchResult<ProductVersionConfig>>;
-    upsertMany(request: Array<ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<ProductVersionConfig[]>;
+    /** Performs the given operation on each existing ProductVersionConfig that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ProductVersionConfig, ProductVersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<ProductVersionConfig>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<ProductVersionConfig, ProductVersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<ProductVersionConfig[]>;
     /** Saves the input as a new ProductVersionConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: ProductVersionConfig, options?: IRepoOptions): Promise<SingleResult<ProductVersionConfig>>;
     upsert(request: ProductVersionConfig, options?: IThrowingRepoOptions): Promise<ProductVersionConfig>;
+    /** Saves each given input as a new ProductVersionConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<ProductVersionConfig>, options?: IRepoOptions): Promise<BatchResult<ProductVersionConfig>>;
+    upsertMany(request: Array<ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<ProductVersionConfig[]>;
 }
-import { Product, ProductCriteria } from "../contracts";
-declare class ProductCruds {
+import { ScopedHostNameConfig, ScopedHostNameConfigCriteria } from "../contracts";
+declare class ScopedHostNameConfigCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new Product. */
-    tryCreateMany(request: Array<Product>, options?: IRepoOptions): Promise<BatchResult<Product>>;
-    createMany(request: Array<Product>, options?: IThrowingRepoOptions): Promise<Product[]>;
-    /** Retrieves all the existing Product that satisfy the given criteria. */
-    tryReadMany(request: ProductCriteria, options?: IRepoOptions): Promise<ListResult<Product>>;
-    readMany(request: ProductCriteria, options?: IThrowingRepoOptions): Promise<Product[]>;
-    /** Overwrites each existing Product. */
-    tryUpdateMany(request: Array<Product>, options?: IRepoOptions): Promise<BatchResult<Product>>;
-    updateMany(request: Array<Product>, options?: IThrowingRepoOptions): Promise<Product[]>;
-    /** Performs the given operations on each existing Product that satisfies the given criteria. */
-    tryPatchWhere(request: PatchSpecForMany<Product, ProductCriteria>, options?: IRepoOptions): Promise<BatchResult<Product>>;
-    patchWhere(request: PatchSpecForMany<Product, ProductCriteria>, options?: IThrowingRepoOptions): Promise<Product[]>;
-    /** Deletes each existing Product that satisfies the given criteria. */
-    tryDeleteWhere(request: ProductCriteria, options?: IRepoOptions): Promise<BatchResult<Product>>;
-    deleteWhere(request: ProductCriteria, options?: IThrowingRepoOptions): Promise<Product[]>;
-    /** Retrieves the single, uniquely identified Product. */
-    tryRead(request: IdSpecFor<Product>, options?: IRepoOptions): Promise<SingleResult<Product>>;
-    read(request: IdSpecFor<Product>, options?: IThrowingRepoOptions): Promise<Product>;
-    /** Overwrites the existing Product. */
-    tryUpdate(request: Product, options?: IRepoOptions): Promise<SingleResult<Product>>;
-    update(request: Product, options?: IThrowingRepoOptions): Promise<Product>;
-    /** Performs the given operations on the existing Product. */
-    tryPatch(request: PatchSpecForOne<Product>, options?: IRepoOptions): Promise<SingleResult<Product>>;
-    patch(request: PatchSpecForOne<Product>, options?: IThrowingRepoOptions): Promise<Product>;
-    /** Deletes the existing Product. */
-    tryDelete(request: IdSpecFor<Product>, options?: IRepoOptions): Promise<SingleResult<Product>>;
-    delete(request: IdSpecFor<Product>, options?: IThrowingRepoOptions): Promise<Product>;
-    /** Overwrites the given properties of the existing Product. */
-    tryUpdatePartial(request: Product, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Product>>>;
-    updatePartial(request: Product, options?: IThrowingRepoOptions): Promise<PartialWithId<Product>>;
-    /** Saves the input as a new Product. */
-    tryCreate(request: Product, options?: IRepoOptions): Promise<SingleResult<Product>>;
-    create(request: Product, options?: IThrowingRepoOptions): Promise<Product>;
-    /** Performs the given operation on each existing Product that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Product, ProductCriteria>, options?: IRepoOptions): Promise<BatchResult<Product>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<Product, ProductCriteria>, options?: IThrowingRepoOptions): Promise<Product[]>;
-    /** Overwrites the given properties for each existing Product. */
-    tryUpdatePartialMany(request: Array<Product>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Product>>>;
-    updatePartialMany(request: Array<Product>, options?: IThrowingRepoOptions): Promise<PartialWithId<Product>[]>;
-    /** Saves each given input as a new Product, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<Product>, options?: IRepoOptions): Promise<BatchResult<Product>>;
-    upsertMany(request: Array<Product>, options?: IThrowingRepoOptions): Promise<Product[]>;
-    /** Saves the input as a new Product, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsert(request: Product, options?: IRepoOptions): Promise<SingleResult<Product>>;
-    upsert(request: Product, options?: IThrowingRepoOptions): Promise<Product>;
+    /** Deletes each existing ScopedHostNameConfig that satisfies the given criteria. */
+    tryDeleteWhere(request: ScopedHostNameConfigCriteria, options?: IRepoOptions): Promise<BatchResult<ScopedHostNameConfig>>;
+    deleteWhere(request: ScopedHostNameConfigCriteria, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig[]>;
+    /** Retrieves all the existing ScopedHostNameConfig that satisfy the given criteria. */
+    tryReadMany(request: ScopedHostNameConfigCriteria, options?: IRepoOptions): Promise<ListResult<ScopedHostNameConfig>>;
+    readMany(request: ScopedHostNameConfigCriteria, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig[]>;
+    /** Performs the given operations on each existing ScopedHostNameConfig that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<ScopedHostNameConfig, ScopedHostNameConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<ScopedHostNameConfig>>;
+    patchWhere(request: PatchSpecForMany<ScopedHostNameConfig, ScopedHostNameConfigCriteria>, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig[]>;
+    /** Saves each given input as a new ScopedHostNameConfig. */
+    tryCreateMany(request: Array<ScopedHostNameConfig>, options?: IRepoOptions): Promise<BatchResult<ScopedHostNameConfig>>;
+    createMany(request: Array<ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig[]>;
+    /** Overwrites each existing ScopedHostNameConfig. */
+    tryUpdateMany(request: Array<ScopedHostNameConfig>, options?: IRepoOptions): Promise<BatchResult<ScopedHostNameConfig>>;
+    updateMany(request: Array<ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig[]>;
+    /** Deletes the existing ScopedHostNameConfig. */
+    tryDelete(request: IdSpecFor<ScopedHostNameConfig>, options?: IRepoOptions): Promise<SingleResult<ScopedHostNameConfig>>;
+    delete(request: IdSpecFor<ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig>;
+    /** Retrieves the single, uniquely identified ScopedHostNameConfig. */
+    tryRead(request: IdSpecFor<ScopedHostNameConfig>, options?: IRepoOptions): Promise<SingleResult<ScopedHostNameConfig>>;
+    read(request: IdSpecFor<ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig>;
+    /** Performs the given operations on the existing ScopedHostNameConfig. */
+    tryPatch(request: PatchSpecForOne<ScopedHostNameConfig>, options?: IRepoOptions): Promise<SingleResult<ScopedHostNameConfig>>;
+    patch(request: PatchSpecForOne<ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig>;
+    /** Overwrites the existing ScopedHostNameConfig. */
+    tryUpdate(request: ScopedHostNameConfig, options?: IRepoOptions): Promise<SingleResult<ScopedHostNameConfig>>;
+    update(request: ScopedHostNameConfig, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig>;
+    /** Overwrites the given properties of the existing ScopedHostNameConfig. */
+    tryUpdatePartial(request: ScopedHostNameConfig, options?: IRepoOptions): Promise<SingleResult<PartialWithId<ScopedHostNameConfig>>>;
+    updatePartial(request: ScopedHostNameConfig, options?: IThrowingRepoOptions): Promise<PartialWithId<ScopedHostNameConfig>>;
+    /** Saves the input as a new ScopedHostNameConfig. */
+    tryCreate(request: ScopedHostNameConfig, options?: IRepoOptions): Promise<SingleResult<ScopedHostNameConfig>>;
+    create(request: ScopedHostNameConfig, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig>;
+    /** Overwrites the given properties for each existing ScopedHostNameConfig. */
+    tryUpdatePartialMany(request: Array<ScopedHostNameConfig>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<ScopedHostNameConfig>>>;
+    updatePartialMany(request: Array<ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<PartialWithId<ScopedHostNameConfig>[]>;
+    /** Performs the given operation on each existing ScopedHostNameConfig that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ScopedHostNameConfig, ScopedHostNameConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<ScopedHostNameConfig>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<ScopedHostNameConfig, ScopedHostNameConfigCriteria>, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig[]>;
+    /** Saves the input as a new ScopedHostNameConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: ScopedHostNameConfig, options?: IRepoOptions): Promise<SingleResult<ScopedHostNameConfig>>;
+    upsert(request: ScopedHostNameConfig, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig>;
+    /** Saves each given input as a new ScopedHostNameConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<ScopedHostNameConfig>, options?: IRepoOptions): Promise<BatchResult<ScopedHostNameConfig>>;
+    upsertMany(request: Array<ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<ScopedHostNameConfig[]>;
 }
 import { ScopedSetting, ScopedSettingCriteria } from "../contracts";
 declare class ScopedSettingCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new ScopedSetting. */
-    tryCreateMany(request: Array<ScopedSetting>, options?: IRepoOptions): Promise<BatchResult<ScopedSetting>>;
-    createMany(request: Array<ScopedSetting>, options?: IThrowingRepoOptions): Promise<ScopedSetting[]>;
+    /** Deletes each existing ScopedSetting that satisfies the given criteria. */
+    tryDeleteWhere(request: ScopedSettingCriteria, options?: IRepoOptions): Promise<BatchResult<ScopedSetting>>;
+    deleteWhere(request: ScopedSettingCriteria, options?: IThrowingRepoOptions): Promise<ScopedSetting[]>;
     /** Retrieves all the existing ScopedSetting that satisfy the given criteria. */
     tryReadMany(request: ScopedSettingCriteria, options?: IRepoOptions): Promise<ListResult<ScopedSetting>>;
     readMany(request: ScopedSettingCriteria, options?: IThrowingRepoOptions): Promise<ScopedSetting[]>;
-    /** Overwrites each existing ScopedSetting. */
-    tryUpdateMany(request: Array<ScopedSetting>, options?: IRepoOptions): Promise<BatchResult<ScopedSetting>>;
-    updateMany(request: Array<ScopedSetting>, options?: IThrowingRepoOptions): Promise<ScopedSetting[]>;
     /** Performs the given operations on each existing ScopedSetting that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<ScopedSetting, ScopedSettingCriteria>, options?: IRepoOptions): Promise<BatchResult<ScopedSetting>>;
     patchWhere(request: PatchSpecForMany<ScopedSetting, ScopedSettingCriteria>, options?: IThrowingRepoOptions): Promise<ScopedSetting[]>;
-    /** Deletes each existing ScopedSetting that satisfies the given criteria. */
-    tryDeleteWhere(request: ScopedSettingCriteria, options?: IRepoOptions): Promise<BatchResult<ScopedSetting>>;
-    deleteWhere(request: ScopedSettingCriteria, options?: IThrowingRepoOptions): Promise<ScopedSetting[]>;
+    /** Saves each given input as a new ScopedSetting. */
+    tryCreateMany(request: Array<ScopedSetting>, options?: IRepoOptions): Promise<BatchResult<ScopedSetting>>;
+    createMany(request: Array<ScopedSetting>, options?: IThrowingRepoOptions): Promise<ScopedSetting[]>;
+    /** Overwrites each existing ScopedSetting. */
+    tryUpdateMany(request: Array<ScopedSetting>, options?: IRepoOptions): Promise<BatchResult<ScopedSetting>>;
+    updateMany(request: Array<ScopedSetting>, options?: IThrowingRepoOptions): Promise<ScopedSetting[]>;
+    /** Deletes the existing ScopedSetting. */
+    tryDelete(request: IdSpecFor<ScopedSetting>, options?: IRepoOptions): Promise<SingleResult<ScopedSetting>>;
+    delete(request: IdSpecFor<ScopedSetting>, options?: IThrowingRepoOptions): Promise<ScopedSetting>;
     /** Retrieves the single, uniquely identified ScopedSetting. */
     tryRead(request: IdSpecFor<ScopedSetting>, options?: IRepoOptions): Promise<SingleResult<ScopedSetting>>;
     read(request: IdSpecFor<ScopedSetting>, options?: IThrowingRepoOptions): Promise<ScopedSetting>;
-    /** Overwrites the existing ScopedSetting. */
-    tryUpdate(request: ScopedSetting, options?: IRepoOptions): Promise<SingleResult<ScopedSetting>>;
-    update(request: ScopedSetting, options?: IThrowingRepoOptions): Promise<ScopedSetting>;
     /** Performs the given operations on the existing ScopedSetting. */
     tryPatch(request: PatchSpecForOne<ScopedSetting>, options?: IRepoOptions): Promise<SingleResult<ScopedSetting>>;
     patch(request: PatchSpecForOne<ScopedSetting>, options?: IThrowingRepoOptions): Promise<ScopedSetting>;
-    /** Deletes the existing ScopedSetting. */
-    tryDelete(request: IdSpecFor<ScopedSetting>, options?: IRepoOptions): Promise<SingleResult<ScopedSetting>>;
-    delete(request: IdSpecFor<ScopedSetting>, options?: IThrowingRepoOptions): Promise<ScopedSetting>;
+    /** Overwrites the existing ScopedSetting. */
+    tryUpdate(request: ScopedSetting, options?: IRepoOptions): Promise<SingleResult<ScopedSetting>>;
+    update(request: ScopedSetting, options?: IThrowingRepoOptions): Promise<ScopedSetting>;
     /** Overwrites the given properties of the existing ScopedSetting. */
     tryUpdatePartial(request: ScopedSetting, options?: IRepoOptions): Promise<SingleResult<PartialWithId<ScopedSetting>>>;
     updatePartial(request: ScopedSetting, options?: IThrowingRepoOptions): Promise<PartialWithId<ScopedSetting>>;
     /** Saves the input as a new ScopedSetting. */
     tryCreate(request: ScopedSetting, options?: IRepoOptions): Promise<SingleResult<ScopedSetting>>;
     create(request: ScopedSetting, options?: IThrowingRepoOptions): Promise<ScopedSetting>;
-    /** Performs the given operation on each existing ScopedSetting that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ScopedSetting, ScopedSettingCriteria>, options?: IRepoOptions): Promise<BatchResult<ScopedSetting>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<ScopedSetting, ScopedSettingCriteria>, options?: IThrowingRepoOptions): Promise<ScopedSetting[]>;
     /** Overwrites the given properties for each existing ScopedSetting. */
     tryUpdatePartialMany(request: Array<ScopedSetting>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<ScopedSetting>>>;
     updatePartialMany(request: Array<ScopedSetting>, options?: IThrowingRepoOptions): Promise<PartialWithId<ScopedSetting>[]>;
-    /** Saves each given input as a new ScopedSetting, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<ScopedSetting>, options?: IRepoOptions): Promise<BatchResult<ScopedSetting>>;
-    upsertMany(request: Array<ScopedSetting>, options?: IThrowingRepoOptions): Promise<ScopedSetting[]>;
+    /** Performs the given operation on each existing ScopedSetting that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ScopedSetting, ScopedSettingCriteria>, options?: IRepoOptions): Promise<BatchResult<ScopedSetting>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<ScopedSetting, ScopedSettingCriteria>, options?: IThrowingRepoOptions): Promise<ScopedSetting[]>;
     /** Saves the input as a new ScopedSetting, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: ScopedSetting, options?: IRepoOptions): Promise<SingleResult<ScopedSetting>>;
     upsert(request: ScopedSetting, options?: IThrowingRepoOptions): Promise<ScopedSetting>;
+    /** Saves each given input as a new ScopedSetting, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<ScopedSetting>, options?: IRepoOptions): Promise<BatchResult<ScopedSetting>>;
+    upsertMany(request: Array<ScopedSetting>, options?: IThrowingRepoOptions): Promise<ScopedSetting[]>;
+}
+import { SetupJournal, SetupJournalCriteria } from "../contracts";
+declare class SetupJournalCruds {
+    private core;
+    constructor(core: ApiClientBase);
+    /** Deletes each existing SetupJournal that satisfies the given criteria. */
+    tryDeleteWhere(request: SetupJournalCriteria, options?: IRepoOptions): Promise<BatchResult<SetupJournal>>;
+    deleteWhere(request: SetupJournalCriteria, options?: IThrowingRepoOptions): Promise<SetupJournal[]>;
+    /** Retrieves all the existing SetupJournal that satisfy the given criteria. */
+    tryReadMany(request: SetupJournalCriteria, options?: IRepoOptions): Promise<ListResult<SetupJournal>>;
+    readMany(request: SetupJournalCriteria, options?: IThrowingRepoOptions): Promise<SetupJournal[]>;
+    /** Performs the given operations on each existing SetupJournal that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<SetupJournal, SetupJournalCriteria>, options?: IRepoOptions): Promise<BatchResult<SetupJournal>>;
+    patchWhere(request: PatchSpecForMany<SetupJournal, SetupJournalCriteria>, options?: IThrowingRepoOptions): Promise<SetupJournal[]>;
+    /** Saves each given input as a new SetupJournal. */
+    tryCreateMany(request: Array<SetupJournal>, options?: IRepoOptions): Promise<BatchResult<SetupJournal>>;
+    createMany(request: Array<SetupJournal>, options?: IThrowingRepoOptions): Promise<SetupJournal[]>;
+    /** Overwrites each existing SetupJournal. */
+    tryUpdateMany(request: Array<SetupJournal>, options?: IRepoOptions): Promise<BatchResult<SetupJournal>>;
+    updateMany(request: Array<SetupJournal>, options?: IThrowingRepoOptions): Promise<SetupJournal[]>;
+    /** Deletes the existing SetupJournal. */
+    tryDelete(request: IdSpecFor<SetupJournal>, options?: IRepoOptions): Promise<SingleResult<SetupJournal>>;
+    delete(request: IdSpecFor<SetupJournal>, options?: IThrowingRepoOptions): Promise<SetupJournal>;
+    /** Retrieves the single, uniquely identified SetupJournal. */
+    tryRead(request: IdSpecFor<SetupJournal>, options?: IRepoOptions): Promise<SingleResult<SetupJournal>>;
+    read(request: IdSpecFor<SetupJournal>, options?: IThrowingRepoOptions): Promise<SetupJournal>;
+    /** Performs the given operations on the existing SetupJournal. */
+    tryPatch(request: PatchSpecForOne<SetupJournal>, options?: IRepoOptions): Promise<SingleResult<SetupJournal>>;
+    patch(request: PatchSpecForOne<SetupJournal>, options?: IThrowingRepoOptions): Promise<SetupJournal>;
+    /** Overwrites the existing SetupJournal. */
+    tryUpdate(request: SetupJournal, options?: IRepoOptions): Promise<SingleResult<SetupJournal>>;
+    update(request: SetupJournal, options?: IThrowingRepoOptions): Promise<SetupJournal>;
+    /** Overwrites the given properties of the existing SetupJournal. */
+    tryUpdatePartial(request: SetupJournal, options?: IRepoOptions): Promise<SingleResult<PartialWithId<SetupJournal>>>;
+    updatePartial(request: SetupJournal, options?: IThrowingRepoOptions): Promise<PartialWithId<SetupJournal>>;
+    /** Saves the input as a new SetupJournal. */
+    tryCreate(request: SetupJournal, options?: IRepoOptions): Promise<SingleResult<SetupJournal>>;
+    create(request: SetupJournal, options?: IThrowingRepoOptions): Promise<SetupJournal>;
+    /** Overwrites the given properties for each existing SetupJournal. */
+    tryUpdatePartialMany(request: Array<SetupJournal>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<SetupJournal>>>;
+    updatePartialMany(request: Array<SetupJournal>, options?: IThrowingRepoOptions): Promise<PartialWithId<SetupJournal>[]>;
+    /** Performs the given operation on each existing SetupJournal that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<SetupJournal, SetupJournalCriteria>, options?: IRepoOptions): Promise<BatchResult<SetupJournal>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<SetupJournal, SetupJournalCriteria>, options?: IThrowingRepoOptions): Promise<SetupJournal[]>;
+    /** Saves the input as a new SetupJournal, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: SetupJournal, options?: IRepoOptions): Promise<SingleResult<SetupJournal>>;
+    upsert(request: SetupJournal, options?: IThrowingRepoOptions): Promise<SetupJournal>;
+    /** Saves each given input as a new SetupJournal, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<SetupJournal>, options?: IRepoOptions): Promise<BatchResult<SetupJournal>>;
+    upsertMany(request: Array<SetupJournal>, options?: IThrowingRepoOptions): Promise<SetupJournal[]>;
 }
 import { Snapshot, SnapshotCriteria } from "../contracts";
 declare class SnapshotCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new Snapshot. */
-    tryCreateMany(request: Array<Snapshot>, options?: IRepoOptions): Promise<BatchResult<Snapshot>>;
-    createMany(request: Array<Snapshot>, options?: IThrowingRepoOptions): Promise<Snapshot[]>;
+    /** Deletes each existing Snapshot that satisfies the given criteria. */
+    tryDeleteWhere(request: SnapshotCriteria, options?: IRepoOptions): Promise<BatchResult<Snapshot>>;
+    deleteWhere(request: SnapshotCriteria, options?: IThrowingRepoOptions): Promise<Snapshot[]>;
     /** Retrieves all the existing Snapshot that satisfy the given criteria. */
     tryReadMany(request: SnapshotCriteria, options?: IRepoOptions): Promise<ListResult<Snapshot>>;
     readMany(request: SnapshotCriteria, options?: IThrowingRepoOptions): Promise<Snapshot[]>;
-    /** Overwrites each existing Snapshot. */
-    tryUpdateMany(request: Array<Snapshot>, options?: IRepoOptions): Promise<BatchResult<Snapshot>>;
-    updateMany(request: Array<Snapshot>, options?: IThrowingRepoOptions): Promise<Snapshot[]>;
     /** Performs the given operations on each existing Snapshot that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<Snapshot, SnapshotCriteria>, options?: IRepoOptions): Promise<BatchResult<Snapshot>>;
     patchWhere(request: PatchSpecForMany<Snapshot, SnapshotCriteria>, options?: IThrowingRepoOptions): Promise<Snapshot[]>;
-    /** Deletes each existing Snapshot that satisfies the given criteria. */
-    tryDeleteWhere(request: SnapshotCriteria, options?: IRepoOptions): Promise<BatchResult<Snapshot>>;
-    deleteWhere(request: SnapshotCriteria, options?: IThrowingRepoOptions): Promise<Snapshot[]>;
+    /** Saves each given input as a new Snapshot. */
+    tryCreateMany(request: Array<Snapshot>, options?: IRepoOptions): Promise<BatchResult<Snapshot>>;
+    createMany(request: Array<Snapshot>, options?: IThrowingRepoOptions): Promise<Snapshot[]>;
+    /** Overwrites each existing Snapshot. */
+    tryUpdateMany(request: Array<Snapshot>, options?: IRepoOptions): Promise<BatchResult<Snapshot>>;
+    updateMany(request: Array<Snapshot>, options?: IThrowingRepoOptions): Promise<Snapshot[]>;
+    /** Deletes the existing Snapshot. */
+    tryDelete(request: IdSpecFor<Snapshot>, options?: IRepoOptions): Promise<SingleResult<Snapshot>>;
+    delete(request: IdSpecFor<Snapshot>, options?: IThrowingRepoOptions): Promise<Snapshot>;
     /** Retrieves the single, uniquely identified Snapshot. */
     tryRead(request: IdSpecFor<Snapshot>, options?: IRepoOptions): Promise<SingleResult<Snapshot>>;
     read(request: IdSpecFor<Snapshot>, options?: IThrowingRepoOptions): Promise<Snapshot>;
-    /** Overwrites the existing Snapshot. */
-    tryUpdate(request: Snapshot, options?: IRepoOptions): Promise<SingleResult<Snapshot>>;
-    update(request: Snapshot, options?: IThrowingRepoOptions): Promise<Snapshot>;
     /** Performs the given operations on the existing Snapshot. */
     tryPatch(request: PatchSpecForOne<Snapshot>, options?: IRepoOptions): Promise<SingleResult<Snapshot>>;
     patch(request: PatchSpecForOne<Snapshot>, options?: IThrowingRepoOptions): Promise<Snapshot>;
-    /** Deletes the existing Snapshot. */
-    tryDelete(request: IdSpecFor<Snapshot>, options?: IRepoOptions): Promise<SingleResult<Snapshot>>;
-    delete(request: IdSpecFor<Snapshot>, options?: IThrowingRepoOptions): Promise<Snapshot>;
+    /** Overwrites the existing Snapshot. */
+    tryUpdate(request: Snapshot, options?: IRepoOptions): Promise<SingleResult<Snapshot>>;
+    update(request: Snapshot, options?: IThrowingRepoOptions): Promise<Snapshot>;
     /** Overwrites the given properties of the existing Snapshot. */
     tryUpdatePartial(request: Snapshot, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Snapshot>>>;
     updatePartial(request: Snapshot, options?: IThrowingRepoOptions): Promise<PartialWithId<Snapshot>>;
     /** Saves the input as a new Snapshot. */
     tryCreate(request: Snapshot, options?: IRepoOptions): Promise<SingleResult<Snapshot>>;
     create(request: Snapshot, options?: IThrowingRepoOptions): Promise<Snapshot>;
-    /** Performs the given operation on each existing Snapshot that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Snapshot, SnapshotCriteria>, options?: IRepoOptions): Promise<BatchResult<Snapshot>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<Snapshot, SnapshotCriteria>, options?: IThrowingRepoOptions): Promise<Snapshot[]>;
     /** Overwrites the given properties for each existing Snapshot. */
     tryUpdatePartialMany(request: Array<Snapshot>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Snapshot>>>;
     updatePartialMany(request: Array<Snapshot>, options?: IThrowingRepoOptions): Promise<PartialWithId<Snapshot>[]>;
-    /** Saves each given input as a new Snapshot, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<Snapshot>, options?: IRepoOptions): Promise<BatchResult<Snapshot>>;
-    upsertMany(request: Array<Snapshot>, options?: IThrowingRepoOptions): Promise<Snapshot[]>;
+    /** Performs the given operation on each existing Snapshot that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Snapshot, SnapshotCriteria>, options?: IRepoOptions): Promise<BatchResult<Snapshot>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Snapshot, SnapshotCriteria>, options?: IThrowingRepoOptions): Promise<Snapshot[]>;
     /** Saves the input as a new Snapshot, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: Snapshot, options?: IRepoOptions): Promise<SingleResult<Snapshot>>;
     upsert(request: Snapshot, options?: IThrowingRepoOptions): Promise<Snapshot>;
+    /** Saves each given input as a new Snapshot, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Snapshot>, options?: IRepoOptions): Promise<BatchResult<Snapshot>>;
+    upsertMany(request: Array<Snapshot>, options?: IThrowingRepoOptions): Promise<Snapshot[]>;
 }
 import { SourceRepo, SourceRepoCriteria } from "../contracts";
 declare class SourceRepoCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new SourceRepo. */
-    tryCreateMany(request: Array<SourceRepo>, options?: IRepoOptions): Promise<BatchResult<SourceRepo>>;
-    createMany(request: Array<SourceRepo>, options?: IThrowingRepoOptions): Promise<SourceRepo[]>;
+    /** Deletes each existing SourceRepo that satisfies the given criteria. */
+    tryDeleteWhere(request: SourceRepoCriteria, options?: IRepoOptions): Promise<BatchResult<SourceRepo>>;
+    deleteWhere(request: SourceRepoCriteria, options?: IThrowingRepoOptions): Promise<SourceRepo[]>;
     /** Retrieves all the existing SourceRepo that satisfy the given criteria. */
     tryReadMany(request: SourceRepoCriteria, options?: IRepoOptions): Promise<ListResult<SourceRepo>>;
     readMany(request: SourceRepoCriteria, options?: IThrowingRepoOptions): Promise<SourceRepo[]>;
-    /** Overwrites each existing SourceRepo. */
-    tryUpdateMany(request: Array<SourceRepo>, options?: IRepoOptions): Promise<BatchResult<SourceRepo>>;
-    updateMany(request: Array<SourceRepo>, options?: IThrowingRepoOptions): Promise<SourceRepo[]>;
     /** Performs the given operations on each existing SourceRepo that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<SourceRepo, SourceRepoCriteria>, options?: IRepoOptions): Promise<BatchResult<SourceRepo>>;
     patchWhere(request: PatchSpecForMany<SourceRepo, SourceRepoCriteria>, options?: IThrowingRepoOptions): Promise<SourceRepo[]>;
-    /** Deletes each existing SourceRepo that satisfies the given criteria. */
-    tryDeleteWhere(request: SourceRepoCriteria, options?: IRepoOptions): Promise<BatchResult<SourceRepo>>;
-    deleteWhere(request: SourceRepoCriteria, options?: IThrowingRepoOptions): Promise<SourceRepo[]>;
+    /** Saves each given input as a new SourceRepo. */
+    tryCreateMany(request: Array<SourceRepo>, options?: IRepoOptions): Promise<BatchResult<SourceRepo>>;
+    createMany(request: Array<SourceRepo>, options?: IThrowingRepoOptions): Promise<SourceRepo[]>;
+    /** Overwrites each existing SourceRepo. */
+    tryUpdateMany(request: Array<SourceRepo>, options?: IRepoOptions): Promise<BatchResult<SourceRepo>>;
+    updateMany(request: Array<SourceRepo>, options?: IThrowingRepoOptions): Promise<SourceRepo[]>;
+    /** Deletes the existing SourceRepo. */
+    tryDelete(request: IdSpecFor<SourceRepo>, options?: IRepoOptions): Promise<SingleResult<SourceRepo>>;
+    delete(request: IdSpecFor<SourceRepo>, options?: IThrowingRepoOptions): Promise<SourceRepo>;
     /** Retrieves the single, uniquely identified SourceRepo. */
     tryRead(request: IdSpecFor<SourceRepo>, options?: IRepoOptions): Promise<SingleResult<SourceRepo>>;
     read(request: IdSpecFor<SourceRepo>, options?: IThrowingRepoOptions): Promise<SourceRepo>;
-    /** Overwrites the existing SourceRepo. */
-    tryUpdate(request: SourceRepo, options?: IRepoOptions): Promise<SingleResult<SourceRepo>>;
-    update(request: SourceRepo, options?: IThrowingRepoOptions): Promise<SourceRepo>;
     /** Performs the given operations on the existing SourceRepo. */
     tryPatch(request: PatchSpecForOne<SourceRepo>, options?: IRepoOptions): Promise<SingleResult<SourceRepo>>;
     patch(request: PatchSpecForOne<SourceRepo>, options?: IThrowingRepoOptions): Promise<SourceRepo>;
-    /** Deletes the existing SourceRepo. */
-    tryDelete(request: IdSpecFor<SourceRepo>, options?: IRepoOptions): Promise<SingleResult<SourceRepo>>;
-    delete(request: IdSpecFor<SourceRepo>, options?: IThrowingRepoOptions): Promise<SourceRepo>;
+    /** Overwrites the existing SourceRepo. */
+    tryUpdate(request: SourceRepo, options?: IRepoOptions): Promise<SingleResult<SourceRepo>>;
+    update(request: SourceRepo, options?: IThrowingRepoOptions): Promise<SourceRepo>;
     /** Overwrites the given properties of the existing SourceRepo. */
     tryUpdatePartial(request: SourceRepo, options?: IRepoOptions): Promise<SingleResult<PartialWithId<SourceRepo>>>;
     updatePartial(request: SourceRepo, options?: IThrowingRepoOptions): Promise<PartialWithId<SourceRepo>>;
     /** Saves the input as a new SourceRepo. */
     tryCreate(request: SourceRepo, options?: IRepoOptions): Promise<SingleResult<SourceRepo>>;
     create(request: SourceRepo, options?: IThrowingRepoOptions): Promise<SourceRepo>;
-    /** Performs the given operation on each existing SourceRepo that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<SourceRepo, SourceRepoCriteria>, options?: IRepoOptions): Promise<BatchResult<SourceRepo>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<SourceRepo, SourceRepoCriteria>, options?: IThrowingRepoOptions): Promise<SourceRepo[]>;
     /** Overwrites the given properties for each existing SourceRepo. */
     tryUpdatePartialMany(request: Array<SourceRepo>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<SourceRepo>>>;
     updatePartialMany(request: Array<SourceRepo>, options?: IThrowingRepoOptions): Promise<PartialWithId<SourceRepo>[]>;
-    /** Saves each given input as a new SourceRepo, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<SourceRepo>, options?: IRepoOptions): Promise<BatchResult<SourceRepo>>;
-    upsertMany(request: Array<SourceRepo>, options?: IThrowingRepoOptions): Promise<SourceRepo[]>;
+    /** Performs the given operation on each existing SourceRepo that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<SourceRepo, SourceRepoCriteria>, options?: IRepoOptions): Promise<BatchResult<SourceRepo>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<SourceRepo, SourceRepoCriteria>, options?: IThrowingRepoOptions): Promise<SourceRepo[]>;
     /** Saves the input as a new SourceRepo, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: SourceRepo, options?: IRepoOptions): Promise<SingleResult<SourceRepo>>;
     upsert(request: SourceRepo, options?: IThrowingRepoOptions): Promise<SourceRepo>;
+    /** Saves each given input as a new SourceRepo, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<SourceRepo>, options?: IRepoOptions): Promise<BatchResult<SourceRepo>>;
+    upsertMany(request: Array<SourceRepo>, options?: IThrowingRepoOptions): Promise<SourceRepo[]>;
 }
 import { Subscription, SubscriptionCriteria } from "../contracts";
 declare class SubscriptionCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new Subscription. */
-    tryCreateMany(request: Array<Subscription>, options?: IRepoOptions): Promise<BatchResult<Subscription>>;
-    createMany(request: Array<Subscription>, options?: IThrowingRepoOptions): Promise<Subscription[]>;
+    /** Deletes each existing Subscription that satisfies the given criteria. */
+    tryDeleteWhere(request: SubscriptionCriteria, options?: IRepoOptions): Promise<BatchResult<Subscription>>;
+    deleteWhere(request: SubscriptionCriteria, options?: IThrowingRepoOptions): Promise<Subscription[]>;
     /** Retrieves all the existing Subscription that satisfy the given criteria. */
     tryReadMany(request: SubscriptionCriteria, options?: IRepoOptions): Promise<ListResult<Subscription>>;
     readMany(request: SubscriptionCriteria, options?: IThrowingRepoOptions): Promise<Subscription[]>;
-    /** Overwrites each existing Subscription. */
-    tryUpdateMany(request: Array<Subscription>, options?: IRepoOptions): Promise<BatchResult<Subscription>>;
-    updateMany(request: Array<Subscription>, options?: IThrowingRepoOptions): Promise<Subscription[]>;
     /** Performs the given operations on each existing Subscription that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<Subscription, SubscriptionCriteria>, options?: IRepoOptions): Promise<BatchResult<Subscription>>;
     patchWhere(request: PatchSpecForMany<Subscription, SubscriptionCriteria>, options?: IThrowingRepoOptions): Promise<Subscription[]>;
-    /** Deletes each existing Subscription that satisfies the given criteria. */
-    tryDeleteWhere(request: SubscriptionCriteria, options?: IRepoOptions): Promise<BatchResult<Subscription>>;
-    deleteWhere(request: SubscriptionCriteria, options?: IThrowingRepoOptions): Promise<Subscription[]>;
+    /** Saves each given input as a new Subscription. */
+    tryCreateMany(request: Array<Subscription>, options?: IRepoOptions): Promise<BatchResult<Subscription>>;
+    createMany(request: Array<Subscription>, options?: IThrowingRepoOptions): Promise<Subscription[]>;
+    /** Overwrites each existing Subscription. */
+    tryUpdateMany(request: Array<Subscription>, options?: IRepoOptions): Promise<BatchResult<Subscription>>;
+    updateMany(request: Array<Subscription>, options?: IThrowingRepoOptions): Promise<Subscription[]>;
+    /** Deletes the existing Subscription. */
+    tryDelete(request: IdSpecFor<Subscription>, options?: IRepoOptions): Promise<SingleResult<Subscription>>;
+    delete(request: IdSpecFor<Subscription>, options?: IThrowingRepoOptions): Promise<Subscription>;
     /** Retrieves the single, uniquely identified Subscription. */
     tryRead(request: IdSpecFor<Subscription>, options?: IRepoOptions): Promise<SingleResult<Subscription>>;
     read(request: IdSpecFor<Subscription>, options?: IThrowingRepoOptions): Promise<Subscription>;
-    /** Overwrites the existing Subscription. */
-    tryUpdate(request: Subscription, options?: IRepoOptions): Promise<SingleResult<Subscription>>;
-    update(request: Subscription, options?: IThrowingRepoOptions): Promise<Subscription>;
     /** Performs the given operations on the existing Subscription. */
     tryPatch(request: PatchSpecForOne<Subscription>, options?: IRepoOptions): Promise<SingleResult<Subscription>>;
     patch(request: PatchSpecForOne<Subscription>, options?: IThrowingRepoOptions): Promise<Subscription>;
-    /** Deletes the existing Subscription. */
-    tryDelete(request: IdSpecFor<Subscription>, options?: IRepoOptions): Promise<SingleResult<Subscription>>;
-    delete(request: IdSpecFor<Subscription>, options?: IThrowingRepoOptions): Promise<Subscription>;
+    /** Overwrites the existing Subscription. */
+    tryUpdate(request: Subscription, options?: IRepoOptions): Promise<SingleResult<Subscription>>;
+    update(request: Subscription, options?: IThrowingRepoOptions): Promise<Subscription>;
     /** Overwrites the given properties of the existing Subscription. */
     tryUpdatePartial(request: Subscription, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Subscription>>>;
     updatePartial(request: Subscription, options?: IThrowingRepoOptions): Promise<PartialWithId<Subscription>>;
     /** Saves the input as a new Subscription. */
     tryCreate(request: Subscription, options?: IRepoOptions): Promise<SingleResult<Subscription>>;
     create(request: Subscription, options?: IThrowingRepoOptions): Promise<Subscription>;
-    /** Performs the given operation on each existing Subscription that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Subscription, SubscriptionCriteria>, options?: IRepoOptions): Promise<BatchResult<Subscription>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<Subscription, SubscriptionCriteria>, options?: IThrowingRepoOptions): Promise<Subscription[]>;
     /** Overwrites the given properties for each existing Subscription. */
     tryUpdatePartialMany(request: Array<Subscription>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Subscription>>>;
     updatePartialMany(request: Array<Subscription>, options?: IThrowingRepoOptions): Promise<PartialWithId<Subscription>[]>;
-    /** Saves each given input as a new Subscription, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<Subscription>, options?: IRepoOptions): Promise<BatchResult<Subscription>>;
-    upsertMany(request: Array<Subscription>, options?: IThrowingRepoOptions): Promise<Subscription[]>;
+    /** Performs the given operation on each existing Subscription that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Subscription, SubscriptionCriteria>, options?: IRepoOptions): Promise<BatchResult<Subscription>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Subscription, SubscriptionCriteria>, options?: IThrowingRepoOptions): Promise<Subscription[]>;
     /** Saves the input as a new Subscription, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: Subscription, options?: IRepoOptions): Promise<SingleResult<Subscription>>;
     upsert(request: Subscription, options?: IThrowingRepoOptions): Promise<Subscription>;
+    /** Saves each given input as a new Subscription, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Subscription>, options?: IRepoOptions): Promise<BatchResult<Subscription>>;
+    upsertMany(request: Array<Subscription>, options?: IThrowingRepoOptions): Promise<Subscription[]>;
 }
 import { Tag, TagCriteria } from "../contracts";
 declare class TagCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new Tag. */
-    tryCreateMany(request: Array<Tag>, options?: IRepoOptions): Promise<BatchResult<Tag>>;
-    createMany(request: Array<Tag>, options?: IThrowingRepoOptions): Promise<Tag[]>;
+    /** Deletes each existing Tag that satisfies the given criteria. */
+    tryDeleteWhere(request: TagCriteria, options?: IRepoOptions): Promise<BatchResult<Tag>>;
+    deleteWhere(request: TagCriteria, options?: IThrowingRepoOptions): Promise<Tag[]>;
     /** Retrieves all the existing Tag that satisfy the given criteria. */
     tryReadMany(request: TagCriteria, options?: IRepoOptions): Promise<ListResult<Tag>>;
     readMany(request: TagCriteria, options?: IThrowingRepoOptions): Promise<Tag[]>;
-    /** Overwrites each existing Tag. */
-    tryUpdateMany(request: Array<Tag>, options?: IRepoOptions): Promise<BatchResult<Tag>>;
-    updateMany(request: Array<Tag>, options?: IThrowingRepoOptions): Promise<Tag[]>;
     /** Performs the given operations on each existing Tag that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<Tag, TagCriteria>, options?: IRepoOptions): Promise<BatchResult<Tag>>;
     patchWhere(request: PatchSpecForMany<Tag, TagCriteria>, options?: IThrowingRepoOptions): Promise<Tag[]>;
-    /** Deletes each existing Tag that satisfies the given criteria. */
-    tryDeleteWhere(request: TagCriteria, options?: IRepoOptions): Promise<BatchResult<Tag>>;
-    deleteWhere(request: TagCriteria, options?: IThrowingRepoOptions): Promise<Tag[]>;
+    /** Saves each given input as a new Tag. */
+    tryCreateMany(request: Array<Tag>, options?: IRepoOptions): Promise<BatchResult<Tag>>;
+    createMany(request: Array<Tag>, options?: IThrowingRepoOptions): Promise<Tag[]>;
+    /** Overwrites each existing Tag. */
+    tryUpdateMany(request: Array<Tag>, options?: IRepoOptions): Promise<BatchResult<Tag>>;
+    updateMany(request: Array<Tag>, options?: IThrowingRepoOptions): Promise<Tag[]>;
+    /** Deletes the existing Tag. */
+    tryDelete(request: IdSpecFor<Tag>, options?: IRepoOptions): Promise<SingleResult<Tag>>;
+    delete(request: IdSpecFor<Tag>, options?: IThrowingRepoOptions): Promise<Tag>;
     /** Retrieves the single, uniquely identified Tag. */
     tryRead(request: IdSpecFor<Tag>, options?: IRepoOptions): Promise<SingleResult<Tag>>;
     read(request: IdSpecFor<Tag>, options?: IThrowingRepoOptions): Promise<Tag>;
-    /** Overwrites the existing Tag. */
-    tryUpdate(request: Tag, options?: IRepoOptions): Promise<SingleResult<Tag>>;
-    update(request: Tag, options?: IThrowingRepoOptions): Promise<Tag>;
     /** Performs the given operations on the existing Tag. */
     tryPatch(request: PatchSpecForOne<Tag>, options?: IRepoOptions): Promise<SingleResult<Tag>>;
     patch(request: PatchSpecForOne<Tag>, options?: IThrowingRepoOptions): Promise<Tag>;
-    /** Deletes the existing Tag. */
-    tryDelete(request: IdSpecFor<Tag>, options?: IRepoOptions): Promise<SingleResult<Tag>>;
-    delete(request: IdSpecFor<Tag>, options?: IThrowingRepoOptions): Promise<Tag>;
+    /** Overwrites the existing Tag. */
+    tryUpdate(request: Tag, options?: IRepoOptions): Promise<SingleResult<Tag>>;
+    update(request: Tag, options?: IThrowingRepoOptions): Promise<Tag>;
     /** Overwrites the given properties of the existing Tag. */
     tryUpdatePartial(request: Tag, options?: IRepoOptions): Promise<SingleResult<PartialWithId<Tag>>>;
     updatePartial(request: Tag, options?: IThrowingRepoOptions): Promise<PartialWithId<Tag>>;
     /** Saves the input as a new Tag. */
     tryCreate(request: Tag, options?: IRepoOptions): Promise<SingleResult<Tag>>;
     create(request: Tag, options?: IThrowingRepoOptions): Promise<Tag>;
-    /** Performs the given operation on each existing Tag that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Tag, TagCriteria>, options?: IRepoOptions): Promise<BatchResult<Tag>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<Tag, TagCriteria>, options?: IThrowingRepoOptions): Promise<Tag[]>;
     /** Overwrites the given properties for each existing Tag. */
     tryUpdatePartialMany(request: Array<Tag>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<Tag>>>;
     updatePartialMany(request: Array<Tag>, options?: IThrowingRepoOptions): Promise<PartialWithId<Tag>[]>;
-    /** Saves each given input as a new Tag, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<Tag>, options?: IRepoOptions): Promise<BatchResult<Tag>>;
-    upsertMany(request: Array<Tag>, options?: IThrowingRepoOptions): Promise<Tag[]>;
+    /** Performs the given operation on each existing Tag that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Tag, TagCriteria>, options?: IRepoOptions): Promise<BatchResult<Tag>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Tag, TagCriteria>, options?: IThrowingRepoOptions): Promise<Tag[]>;
     /** Saves the input as a new Tag, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: Tag, options?: IRepoOptions): Promise<SingleResult<Tag>>;
     upsert(request: Tag, options?: IThrowingRepoOptions): Promise<Tag>;
-}
-import { CodiacTenant, CodiacTenantCriteria } from "../contracts";
-declare class CodiacTenantCruds {
-    private core;
-    constructor(core: ApiClientBase);
-    /** Saves each given input as a new CodiacTenant. */
-    tryCreateMany(request: Array<CodiacTenant>, options?: IRepoOptions): Promise<BatchResult<CodiacTenant>>;
-    createMany(request: Array<CodiacTenant>, options?: IThrowingRepoOptions): Promise<CodiacTenant[]>;
-    /** Retrieves all the existing CodiacTenant that satisfy the given criteria. */
-    tryReadMany(request: CodiacTenantCriteria, options?: IRepoOptions): Promise<ListResult<CodiacTenant>>;
-    readMany(request: CodiacTenantCriteria, options?: IThrowingRepoOptions): Promise<CodiacTenant[]>;
-    /** Overwrites each existing CodiacTenant. */
-    tryUpdateMany(request: Array<CodiacTenant>, options?: IRepoOptions): Promise<BatchResult<CodiacTenant>>;
-    updateMany(request: Array<CodiacTenant>, options?: IThrowingRepoOptions): Promise<CodiacTenant[]>;
-    /** Performs the given operations on each existing CodiacTenant that satisfies the given criteria. */
-    tryPatchWhere(request: PatchSpecForMany<CodiacTenant, CodiacTenantCriteria>, options?: IRepoOptions): Promise<BatchResult<CodiacTenant>>;
-    patchWhere(request: PatchSpecForMany<CodiacTenant, CodiacTenantCriteria>, options?: IThrowingRepoOptions): Promise<CodiacTenant[]>;
-    /** Deletes each existing CodiacTenant that satisfies the given criteria. */
-    tryDeleteWhere(request: CodiacTenantCriteria, options?: IRepoOptions): Promise<BatchResult<CodiacTenant>>;
-    deleteWhere(request: CodiacTenantCriteria, options?: IThrowingRepoOptions): Promise<CodiacTenant[]>;
-    /** Retrieves the single, uniquely identified CodiacTenant. */
-    tryRead(request: IdSpecFor<CodiacTenant>, options?: IRepoOptions): Promise<SingleResult<CodiacTenant>>;
-    read(request: IdSpecFor<CodiacTenant>, options?: IThrowingRepoOptions): Promise<CodiacTenant>;
-    /** Overwrites the existing CodiacTenant. */
-    tryUpdate(request: CodiacTenant, options?: IRepoOptions): Promise<SingleResult<CodiacTenant>>;
-    update(request: CodiacTenant, options?: IThrowingRepoOptions): Promise<CodiacTenant>;
-    /** Performs the given operations on the existing CodiacTenant. */
-    tryPatch(request: PatchSpecForOne<CodiacTenant>, options?: IRepoOptions): Promise<SingleResult<CodiacTenant>>;
-    patch(request: PatchSpecForOne<CodiacTenant>, options?: IThrowingRepoOptions): Promise<CodiacTenant>;
-    /** Deletes the existing CodiacTenant. */
-    tryDelete(request: IdSpecFor<CodiacTenant>, options?: IRepoOptions): Promise<SingleResult<CodiacTenant>>;
-    delete(request: IdSpecFor<CodiacTenant>, options?: IThrowingRepoOptions): Promise<CodiacTenant>;
-    /** Overwrites the given properties of the existing CodiacTenant. */
-    tryUpdatePartial(request: CodiacTenant, options?: IRepoOptions): Promise<SingleResult<PartialWithId<CodiacTenant>>>;
-    updatePartial(request: CodiacTenant, options?: IThrowingRepoOptions): Promise<PartialWithId<CodiacTenant>>;
-    /** Saves the input as a new CodiacTenant. */
-    tryCreate(request: CodiacTenant, options?: IRepoOptions): Promise<SingleResult<CodiacTenant>>;
-    create(request: CodiacTenant, options?: IThrowingRepoOptions): Promise<CodiacTenant>;
-    /** Performs the given operation on each existing CodiacTenant that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<CodiacTenant, CodiacTenantCriteria>, options?: IRepoOptions): Promise<BatchResult<CodiacTenant>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<CodiacTenant, CodiacTenantCriteria>, options?: IThrowingRepoOptions): Promise<CodiacTenant[]>;
-    /** Overwrites the given properties for each existing CodiacTenant. */
-    tryUpdatePartialMany(request: Array<CodiacTenant>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<CodiacTenant>>>;
-    updatePartialMany(request: Array<CodiacTenant>, options?: IThrowingRepoOptions): Promise<PartialWithId<CodiacTenant>[]>;
-    /** Saves each given input as a new CodiacTenant, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<CodiacTenant>, options?: IRepoOptions): Promise<BatchResult<CodiacTenant>>;
-    upsertMany(request: Array<CodiacTenant>, options?: IThrowingRepoOptions): Promise<CodiacTenant[]>;
-    /** Saves the input as a new CodiacTenant, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsert(request: CodiacTenant, options?: IRepoOptions): Promise<SingleResult<CodiacTenant>>;
-    upsert(request: CodiacTenant, options?: IThrowingRepoOptions): Promise<CodiacTenant>;
+    /** Saves each given input as a new Tag, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<Tag>, options?: IRepoOptions): Promise<BatchResult<Tag>>;
+    upsertMany(request: Array<Tag>, options?: IThrowingRepoOptions): Promise<Tag[]>;
 }
 import { VersionConfig, VersionConfigCriteria } from "../contracts";
 declare class VersionConfigCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new VersionConfig. */
-    tryCreateMany(request: Array<VersionConfig>, options?: IRepoOptions): Promise<BatchResult<VersionConfig>>;
-    createMany(request: Array<VersionConfig>, options?: IThrowingRepoOptions): Promise<VersionConfig[]>;
+    /** Deletes each existing VersionConfig that satisfies the given criteria. */
+    tryDeleteWhere(request: VersionConfigCriteria, options?: IRepoOptions): Promise<BatchResult<VersionConfig>>;
+    deleteWhere(request: VersionConfigCriteria, options?: IThrowingRepoOptions): Promise<VersionConfig[]>;
     /** Retrieves all the existing VersionConfig that satisfy the given criteria. */
     tryReadMany(request: VersionConfigCriteria, options?: IRepoOptions): Promise<ListResult<VersionConfig>>;
     readMany(request: VersionConfigCriteria, options?: IThrowingRepoOptions): Promise<VersionConfig[]>;
-    /** Overwrites each existing VersionConfig. */
-    tryUpdateMany(request: Array<VersionConfig>, options?: IRepoOptions): Promise<BatchResult<VersionConfig>>;
-    updateMany(request: Array<VersionConfig>, options?: IThrowingRepoOptions): Promise<VersionConfig[]>;
     /** Performs the given operations on each existing VersionConfig that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<VersionConfig, VersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<VersionConfig>>;
     patchWhere(request: PatchSpecForMany<VersionConfig, VersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<VersionConfig[]>;
-    /** Deletes each existing VersionConfig that satisfies the given criteria. */
-    tryDeleteWhere(request: VersionConfigCriteria, options?: IRepoOptions): Promise<BatchResult<VersionConfig>>;
-    deleteWhere(request: VersionConfigCriteria, options?: IThrowingRepoOptions): Promise<VersionConfig[]>;
+    /** Saves each given input as a new VersionConfig. */
+    tryCreateMany(request: Array<VersionConfig>, options?: IRepoOptions): Promise<BatchResult<VersionConfig>>;
+    createMany(request: Array<VersionConfig>, options?: IThrowingRepoOptions): Promise<VersionConfig[]>;
+    /** Overwrites each existing VersionConfig. */
+    tryUpdateMany(request: Array<VersionConfig>, options?: IRepoOptions): Promise<BatchResult<VersionConfig>>;
+    updateMany(request: Array<VersionConfig>, options?: IThrowingRepoOptions): Promise<VersionConfig[]>;
+    /** Deletes the existing VersionConfig. */
+    tryDelete(request: IdSpecFor<VersionConfig>, options?: IRepoOptions): Promise<SingleResult<VersionConfig>>;
+    delete(request: IdSpecFor<VersionConfig>, options?: IThrowingRepoOptions): Promise<VersionConfig>;
     /** Retrieves the single, uniquely identified VersionConfig. */
     tryRead(request: IdSpecFor<VersionConfig>, options?: IRepoOptions): Promise<SingleResult<VersionConfig>>;
     read(request: IdSpecFor<VersionConfig>, options?: IThrowingRepoOptions): Promise<VersionConfig>;
-    /** Overwrites the existing VersionConfig. */
-    tryUpdate(request: VersionConfig, options?: IRepoOptions): Promise<SingleResult<VersionConfig>>;
-    update(request: VersionConfig, options?: IThrowingRepoOptions): Promise<VersionConfig>;
     /** Performs the given operations on the existing VersionConfig. */
     tryPatch(request: PatchSpecForOne<VersionConfig>, options?: IRepoOptions): Promise<SingleResult<VersionConfig>>;
     patch(request: PatchSpecForOne<VersionConfig>, options?: IThrowingRepoOptions): Promise<VersionConfig>;
-    /** Deletes the existing VersionConfig. */
-    tryDelete(request: IdSpecFor<VersionConfig>, options?: IRepoOptions): Promise<SingleResult<VersionConfig>>;
-    delete(request: IdSpecFor<VersionConfig>, options?: IThrowingRepoOptions): Promise<VersionConfig>;
+    /** Overwrites the existing VersionConfig. */
+    tryUpdate(request: VersionConfig, options?: IRepoOptions): Promise<SingleResult<VersionConfig>>;
+    update(request: VersionConfig, options?: IThrowingRepoOptions): Promise<VersionConfig>;
     /** Overwrites the given properties of the existing VersionConfig. */
     tryUpdatePartial(request: VersionConfig, options?: IRepoOptions): Promise<SingleResult<PartialWithId<VersionConfig>>>;
     updatePartial(request: VersionConfig, options?: IThrowingRepoOptions): Promise<PartialWithId<VersionConfig>>;
     /** Saves the input as a new VersionConfig. */
     tryCreate(request: VersionConfig, options?: IRepoOptions): Promise<SingleResult<VersionConfig>>;
     create(request: VersionConfig, options?: IThrowingRepoOptions): Promise<VersionConfig>;
-    /** Performs the given operation on each existing VersionConfig that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<VersionConfig, VersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<VersionConfig>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<VersionConfig, VersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<VersionConfig[]>;
     /** Overwrites the given properties for each existing VersionConfig. */
     tryUpdatePartialMany(request: Array<VersionConfig>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<VersionConfig>>>;
     updatePartialMany(request: Array<VersionConfig>, options?: IThrowingRepoOptions): Promise<PartialWithId<VersionConfig>[]>;
-    /** Saves each given input as a new VersionConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<VersionConfig>, options?: IRepoOptions): Promise<BatchResult<VersionConfig>>;
-    upsertMany(request: Array<VersionConfig>, options?: IThrowingRepoOptions): Promise<VersionConfig[]>;
+    /** Performs the given operation on each existing VersionConfig that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<VersionConfig, VersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<VersionConfig>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<VersionConfig, VersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<VersionConfig[]>;
     /** Saves the input as a new VersionConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: VersionConfig, options?: IRepoOptions): Promise<SingleResult<VersionConfig>>;
     upsert(request: VersionConfig, options?: IThrowingRepoOptions): Promise<VersionConfig>;
+    /** Saves each given input as a new VersionConfig, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<VersionConfig>, options?: IRepoOptions): Promise<BatchResult<VersionConfig>>;
+    upsertMany(request: Array<VersionConfig>, options?: IThrowingRepoOptions): Promise<VersionConfig[]>;
+}
+import { VersionCreateActivity, VersionCreateActivityCriteria } from "../contracts";
+declare class VersionCreateActivityCruds {
+    private core;
+    constructor(core: ApiClientBase);
+    /** Deletes each existing VersionCreateActivity that satisfies the given criteria. */
+    tryDeleteWhere(request: VersionCreateActivityCriteria, options?: IRepoOptions): Promise<BatchResult<VersionCreateActivity>>;
+    deleteWhere(request: VersionCreateActivityCriteria, options?: IThrowingRepoOptions): Promise<VersionCreateActivity[]>;
+    /** Retrieves all the existing VersionCreateActivity that satisfy the given criteria. */
+    tryReadMany(request: VersionCreateActivityCriteria, options?: IRepoOptions): Promise<ListResult<VersionCreateActivity>>;
+    readMany(request: VersionCreateActivityCriteria, options?: IThrowingRepoOptions): Promise<VersionCreateActivity[]>;
+    /** Performs the given operations on each existing VersionCreateActivity that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<VersionCreateActivity, VersionCreateActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<VersionCreateActivity>>;
+    patchWhere(request: PatchSpecForMany<VersionCreateActivity, VersionCreateActivityCriteria>, options?: IThrowingRepoOptions): Promise<VersionCreateActivity[]>;
+    /** Saves each given input as a new VersionCreateActivity. */
+    tryCreateMany(request: Array<VersionCreateActivity>, options?: IRepoOptions): Promise<BatchResult<VersionCreateActivity>>;
+    createMany(request: Array<VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<VersionCreateActivity[]>;
+    /** Overwrites each existing VersionCreateActivity. */
+    tryUpdateMany(request: Array<VersionCreateActivity>, options?: IRepoOptions): Promise<BatchResult<VersionCreateActivity>>;
+    updateMany(request: Array<VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<VersionCreateActivity[]>;
+    /** Deletes the existing VersionCreateActivity. */
+    tryDelete(request: IdSpecFor<VersionCreateActivity>, options?: IRepoOptions): Promise<SingleResult<VersionCreateActivity>>;
+    delete(request: IdSpecFor<VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<VersionCreateActivity>;
+    /** Retrieves the single, uniquely identified VersionCreateActivity. */
+    tryRead(request: IdSpecFor<VersionCreateActivity>, options?: IRepoOptions): Promise<SingleResult<VersionCreateActivity>>;
+    read(request: IdSpecFor<VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<VersionCreateActivity>;
+    /** Performs the given operations on the existing VersionCreateActivity. */
+    tryPatch(request: PatchSpecForOne<VersionCreateActivity>, options?: IRepoOptions): Promise<SingleResult<VersionCreateActivity>>;
+    patch(request: PatchSpecForOne<VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<VersionCreateActivity>;
+    /** Overwrites the existing VersionCreateActivity. */
+    tryUpdate(request: VersionCreateActivity, options?: IRepoOptions): Promise<SingleResult<VersionCreateActivity>>;
+    update(request: VersionCreateActivity, options?: IThrowingRepoOptions): Promise<VersionCreateActivity>;
+    /** Overwrites the given properties of the existing VersionCreateActivity. */
+    tryUpdatePartial(request: VersionCreateActivity, options?: IRepoOptions): Promise<SingleResult<PartialWithId<VersionCreateActivity>>>;
+    updatePartial(request: VersionCreateActivity, options?: IThrowingRepoOptions): Promise<PartialWithId<VersionCreateActivity>>;
+    /** Saves the input as a new VersionCreateActivity. */
+    tryCreate(request: VersionCreateActivity, options?: IRepoOptions): Promise<SingleResult<VersionCreateActivity>>;
+    create(request: VersionCreateActivity, options?: IThrowingRepoOptions): Promise<VersionCreateActivity>;
+    /** Overwrites the given properties for each existing VersionCreateActivity. */
+    tryUpdatePartialMany(request: Array<VersionCreateActivity>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<VersionCreateActivity>>>;
+    updatePartialMany(request: Array<VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<PartialWithId<VersionCreateActivity>[]>;
+    /** Performs the given operation on each existing VersionCreateActivity that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<VersionCreateActivity, VersionCreateActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<VersionCreateActivity>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<VersionCreateActivity, VersionCreateActivityCriteria>, options?: IThrowingRepoOptions): Promise<VersionCreateActivity[]>;
+    /** Saves the input as a new VersionCreateActivity, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsert(request: VersionCreateActivity, options?: IRepoOptions): Promise<SingleResult<VersionCreateActivity>>;
+    upsert(request: VersionCreateActivity, options?: IThrowingRepoOptions): Promise<VersionCreateActivity>;
+    /** Saves each given input as a new VersionCreateActivity, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<VersionCreateActivity>, options?: IRepoOptions): Promise<BatchResult<VersionCreateActivity>>;
+    upsertMany(request: Array<VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<VersionCreateActivity[]>;
 }
 import { WorkFlowStrategy, WorkFlowStrategyCriteria } from "../contracts";
 declare class WorkFlowStrategyCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new WorkFlowStrategy. */
-    tryCreateMany(request: Array<WorkFlowStrategy>, options?: IRepoOptions): Promise<BatchResult<WorkFlowStrategy>>;
-    createMany(request: Array<WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy[]>;
+    /** Deletes each existing WorkFlowStrategy that satisfies the given criteria. */
+    tryDeleteWhere(request: WorkFlowStrategyCriteria, options?: IRepoOptions): Promise<BatchResult<WorkFlowStrategy>>;
+    deleteWhere(request: WorkFlowStrategyCriteria, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy[]>;
     /** Retrieves all the existing WorkFlowStrategy that satisfy the given criteria. */
     tryReadMany(request: WorkFlowStrategyCriteria, options?: IRepoOptions): Promise<ListResult<WorkFlowStrategy>>;
     readMany(request: WorkFlowStrategyCriteria, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy[]>;
-    /** Overwrites each existing WorkFlowStrategy. */
-    tryUpdateMany(request: Array<WorkFlowStrategy>, options?: IRepoOptions): Promise<BatchResult<WorkFlowStrategy>>;
-    updateMany(request: Array<WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy[]>;
     /** Performs the given operations on each existing WorkFlowStrategy that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<WorkFlowStrategy, WorkFlowStrategyCriteria>, options?: IRepoOptions): Promise<BatchResult<WorkFlowStrategy>>;
     patchWhere(request: PatchSpecForMany<WorkFlowStrategy, WorkFlowStrategyCriteria>, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy[]>;
-    /** Deletes each existing WorkFlowStrategy that satisfies the given criteria. */
-    tryDeleteWhere(request: WorkFlowStrategyCriteria, options?: IRepoOptions): Promise<BatchResult<WorkFlowStrategy>>;
-    deleteWhere(request: WorkFlowStrategyCriteria, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy[]>;
+    /** Saves each given input as a new WorkFlowStrategy. */
+    tryCreateMany(request: Array<WorkFlowStrategy>, options?: IRepoOptions): Promise<BatchResult<WorkFlowStrategy>>;
+    createMany(request: Array<WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy[]>;
+    /** Overwrites each existing WorkFlowStrategy. */
+    tryUpdateMany(request: Array<WorkFlowStrategy>, options?: IRepoOptions): Promise<BatchResult<WorkFlowStrategy>>;
+    updateMany(request: Array<WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy[]>;
+    /** Deletes the existing WorkFlowStrategy. */
+    tryDelete(request: IdSpecFor<WorkFlowStrategy>, options?: IRepoOptions): Promise<SingleResult<WorkFlowStrategy>>;
+    delete(request: IdSpecFor<WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy>;
     /** Retrieves the single, uniquely identified WorkFlowStrategy. */
     tryRead(request: IdSpecFor<WorkFlowStrategy>, options?: IRepoOptions): Promise<SingleResult<WorkFlowStrategy>>;
     read(request: IdSpecFor<WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy>;
-    /** Overwrites the existing WorkFlowStrategy. */
-    tryUpdate(request: WorkFlowStrategy, options?: IRepoOptions): Promise<SingleResult<WorkFlowStrategy>>;
-    update(request: WorkFlowStrategy, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy>;
     /** Performs the given operations on the existing WorkFlowStrategy. */
     tryPatch(request: PatchSpecForOne<WorkFlowStrategy>, options?: IRepoOptions): Promise<SingleResult<WorkFlowStrategy>>;
     patch(request: PatchSpecForOne<WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy>;
-    /** Deletes the existing WorkFlowStrategy. */
-    tryDelete(request: IdSpecFor<WorkFlowStrategy>, options?: IRepoOptions): Promise<SingleResult<WorkFlowStrategy>>;
-    delete(request: IdSpecFor<WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy>;
+    /** Overwrites the existing WorkFlowStrategy. */
+    tryUpdate(request: WorkFlowStrategy, options?: IRepoOptions): Promise<SingleResult<WorkFlowStrategy>>;
+    update(request: WorkFlowStrategy, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy>;
     /** Overwrites the given properties of the existing WorkFlowStrategy. */
     tryUpdatePartial(request: WorkFlowStrategy, options?: IRepoOptions): Promise<SingleResult<PartialWithId<WorkFlowStrategy>>>;
     updatePartial(request: WorkFlowStrategy, options?: IThrowingRepoOptions): Promise<PartialWithId<WorkFlowStrategy>>;
     /** Saves the input as a new WorkFlowStrategy. */
     tryCreate(request: WorkFlowStrategy, options?: IRepoOptions): Promise<SingleResult<WorkFlowStrategy>>;
     create(request: WorkFlowStrategy, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy>;
-    /** Performs the given operation on each existing WorkFlowStrategy that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<WorkFlowStrategy, WorkFlowStrategyCriteria>, options?: IRepoOptions): Promise<BatchResult<WorkFlowStrategy>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<WorkFlowStrategy, WorkFlowStrategyCriteria>, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy[]>;
     /** Overwrites the given properties for each existing WorkFlowStrategy. */
     tryUpdatePartialMany(request: Array<WorkFlowStrategy>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<WorkFlowStrategy>>>;
     updatePartialMany(request: Array<WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<PartialWithId<WorkFlowStrategy>[]>;
-    /** Saves each given input as a new WorkFlowStrategy, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<WorkFlowStrategy>, options?: IRepoOptions): Promise<BatchResult<WorkFlowStrategy>>;
-    upsertMany(request: Array<WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy[]>;
+    /** Performs the given operation on each existing WorkFlowStrategy that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<WorkFlowStrategy, WorkFlowStrategyCriteria>, options?: IRepoOptions): Promise<BatchResult<WorkFlowStrategy>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<WorkFlowStrategy, WorkFlowStrategyCriteria>, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy[]>;
     /** Saves the input as a new WorkFlowStrategy, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: WorkFlowStrategy, options?: IRepoOptions): Promise<SingleResult<WorkFlowStrategy>>;
     upsert(request: WorkFlowStrategy, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy>;
+    /** Saves each given input as a new WorkFlowStrategy, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<WorkFlowStrategy>, options?: IRepoOptions): Promise<BatchResult<WorkFlowStrategy>>;
+    upsertMany(request: Array<WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<WorkFlowStrategy[]>;
 }
 import { ZombiePeriod, ZombiePeriodCriteria } from "../contracts";
 declare class ZombiePeriodCruds {
     private core;
     constructor(core: ApiClientBase);
-    /** Saves each given input as a new ZombiePeriod. */
-    tryCreateMany(request: Array<ZombiePeriod>, options?: IRepoOptions): Promise<BatchResult<ZombiePeriod>>;
-    createMany(request: Array<ZombiePeriod>, options?: IThrowingRepoOptions): Promise<ZombiePeriod[]>;
+    /** Deletes each existing ZombiePeriod that satisfies the given criteria. */
+    tryDeleteWhere(request: ZombiePeriodCriteria, options?: IRepoOptions): Promise<BatchResult<ZombiePeriod>>;
+    deleteWhere(request: ZombiePeriodCriteria, options?: IThrowingRepoOptions): Promise<ZombiePeriod[]>;
     /** Retrieves all the existing ZombiePeriod that satisfy the given criteria. */
     tryReadMany(request: ZombiePeriodCriteria, options?: IRepoOptions): Promise<ListResult<ZombiePeriod>>;
     readMany(request: ZombiePeriodCriteria, options?: IThrowingRepoOptions): Promise<ZombiePeriod[]>;
-    /** Overwrites each existing ZombiePeriod. */
-    tryUpdateMany(request: Array<ZombiePeriod>, options?: IRepoOptions): Promise<BatchResult<ZombiePeriod>>;
-    updateMany(request: Array<ZombiePeriod>, options?: IThrowingRepoOptions): Promise<ZombiePeriod[]>;
     /** Performs the given operations on each existing ZombiePeriod that satisfies the given criteria. */
     tryPatchWhere(request: PatchSpecForMany<ZombiePeriod, ZombiePeriodCriteria>, options?: IRepoOptions): Promise<BatchResult<ZombiePeriod>>;
     patchWhere(request: PatchSpecForMany<ZombiePeriod, ZombiePeriodCriteria>, options?: IThrowingRepoOptions): Promise<ZombiePeriod[]>;
-    /** Deletes each existing ZombiePeriod that satisfies the given criteria. */
-    tryDeleteWhere(request: ZombiePeriodCriteria, options?: IRepoOptions): Promise<BatchResult<ZombiePeriod>>;
-    deleteWhere(request: ZombiePeriodCriteria, options?: IThrowingRepoOptions): Promise<ZombiePeriod[]>;
+    /** Saves each given input as a new ZombiePeriod. */
+    tryCreateMany(request: Array<ZombiePeriod>, options?: IRepoOptions): Promise<BatchResult<ZombiePeriod>>;
+    createMany(request: Array<ZombiePeriod>, options?: IThrowingRepoOptions): Promise<ZombiePeriod[]>;
+    /** Overwrites each existing ZombiePeriod. */
+    tryUpdateMany(request: Array<ZombiePeriod>, options?: IRepoOptions): Promise<BatchResult<ZombiePeriod>>;
+    updateMany(request: Array<ZombiePeriod>, options?: IThrowingRepoOptions): Promise<ZombiePeriod[]>;
+    /** Deletes the existing ZombiePeriod. */
+    tryDelete(request: IdSpecFor<ZombiePeriod>, options?: IRepoOptions): Promise<SingleResult<ZombiePeriod>>;
+    delete(request: IdSpecFor<ZombiePeriod>, options?: IThrowingRepoOptions): Promise<ZombiePeriod>;
     /** Retrieves the single, uniquely identified ZombiePeriod. */
     tryRead(request: IdSpecFor<ZombiePeriod>, options?: IRepoOptions): Promise<SingleResult<ZombiePeriod>>;
     read(request: IdSpecFor<ZombiePeriod>, options?: IThrowingRepoOptions): Promise<ZombiePeriod>;
-    /** Overwrites the existing ZombiePeriod. */
-    tryUpdate(request: ZombiePeriod, options?: IRepoOptions): Promise<SingleResult<ZombiePeriod>>;
-    update(request: ZombiePeriod, options?: IThrowingRepoOptions): Promise<ZombiePeriod>;
     /** Performs the given operations on the existing ZombiePeriod. */
     tryPatch(request: PatchSpecForOne<ZombiePeriod>, options?: IRepoOptions): Promise<SingleResult<ZombiePeriod>>;
     patch(request: PatchSpecForOne<ZombiePeriod>, options?: IThrowingRepoOptions): Promise<ZombiePeriod>;
-    /** Deletes the existing ZombiePeriod. */
-    tryDelete(request: IdSpecFor<ZombiePeriod>, options?: IRepoOptions): Promise<SingleResult<ZombiePeriod>>;
-    delete(request: IdSpecFor<ZombiePeriod>, options?: IThrowingRepoOptions): Promise<ZombiePeriod>;
+    /** Overwrites the existing ZombiePeriod. */
+    tryUpdate(request: ZombiePeriod, options?: IRepoOptions): Promise<SingleResult<ZombiePeriod>>;
+    update(request: ZombiePeriod, options?: IThrowingRepoOptions): Promise<ZombiePeriod>;
     /** Overwrites the given properties of the existing ZombiePeriod. */
     tryUpdatePartial(request: ZombiePeriod, options?: IRepoOptions): Promise<SingleResult<PartialWithId<ZombiePeriod>>>;
     updatePartial(request: ZombiePeriod, options?: IThrowingRepoOptions): Promise<PartialWithId<ZombiePeriod>>;
     /** Saves the input as a new ZombiePeriod. */
     tryCreate(request: ZombiePeriod, options?: IRepoOptions): Promise<SingleResult<ZombiePeriod>>;
     create(request: ZombiePeriod, options?: IThrowingRepoOptions): Promise<ZombiePeriod>;
-    /** Performs the given operation on each existing ZombiePeriod that satisfies the given criteria. */
-    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ZombiePeriod, ZombiePeriodCriteria>, options?: IRepoOptions): Promise<BatchResult<ZombiePeriod>>;
-    UpdatePartialWhere(request: UpdatePartialWhereRequest<ZombiePeriod, ZombiePeriodCriteria>, options?: IThrowingRepoOptions): Promise<ZombiePeriod[]>;
     /** Overwrites the given properties for each existing ZombiePeriod. */
     tryUpdatePartialMany(request: Array<ZombiePeriod>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<ZombiePeriod>>>;
     updatePartialMany(request: Array<ZombiePeriod>, options?: IThrowingRepoOptions): Promise<PartialWithId<ZombiePeriod>[]>;
-    /** Saves each given input as a new ZombiePeriod, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
-    tryUpsertMany(request: Array<ZombiePeriod>, options?: IRepoOptions): Promise<BatchResult<ZombiePeriod>>;
-    upsertMany(request: Array<ZombiePeriod>, options?: IThrowingRepoOptions): Promise<ZombiePeriod[]>;
+    /** Performs the given operation on each existing ZombiePeriod that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<ZombiePeriod, ZombiePeriodCriteria>, options?: IRepoOptions): Promise<BatchResult<ZombiePeriod>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<ZombiePeriod, ZombiePeriodCriteria>, options?: IThrowingRepoOptions): Promise<ZombiePeriod[]>;
     /** Saves the input as a new ZombiePeriod, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
     tryUpsert(request: ZombiePeriod, options?: IRepoOptions): Promise<SingleResult<ZombiePeriod>>;
     upsert(request: ZombiePeriod, options?: IThrowingRepoOptions): Promise<ZombiePeriod>;
+    /** Saves each given input as a new ZombiePeriod, or updates existing if it already exists.  Identity is based either on the existence of a valid id property on the entity submitted or the response from the database (based on unique indexes / primary keys). */
+    tryUpsertMany(request: Array<ZombiePeriod>, options?: IRepoOptions): Promise<BatchResult<ZombiePeriod>>;
+    upsertMany(request: Array<ZombiePeriod>, options?: IThrowingRepoOptions): Promise<ZombiePeriod[]>;
 }
-import { CabinetHostNameConfigCriteria, CabinetHostNameConfig, ConfigDefCriteria, ConfigDef, ConfigDocSpecForOne, ConfigDoc, CabinetConfigStateRequest, CabinetConfigState, ReadyStateRequest, ApiReadyState, FileRequest, Buffer, RootMapCriteria, RootMap, ScopedConfigCriteria, ScopedConfig, CabinetScopesCriteria, EnterpriseScope, VersionGetsertRequest } from "../contracts";
+import { ApiReadyState, Buffer, CabinetConfigState, CabinetConfigStateRequest, CabinetHostNameConfig, CabinetHostNameConfigCriteria, CabinetScopesCriteria, ClusterAttachRequest, ClusterDetachRequest, ConfigDef, ConfigDefCriteria, ConfigDoc, ConfigDocSpecForOne, EnterpriseScope, FileRequest, ReadyStateRequest, RootMap, RootMapCriteria, ScopedConfig, ScopedConfigCriteria, VersionGetsertRequest } from "../contracts";
 declare class OtherOperations {
     private core;
     constructor(core: ApiClientBase);
+    /** Includes the given cluster within the given environment. */
+    EnvironmentClusterAttach(request: ClusterAttachRequest, options?: IRepoOptions): Promise<Result>;
+    /** Removes the linkage between the given environment and the given cluster. */
+    EnvironmentClusterDetach(request: ClusterDetachRequest, options?: IRepoOptions): Promise<Result>;
     GetCabinetHostNameConfig(request: CabinetHostNameConfigCriteria, options?: IRepoOptions): Promise<ListResult<CabinetHostNameConfig>>;
-    /** Retrieves the list of currently declared config files for the given enterprise asset. */
-    getConfigDefs(request: ConfigDefCriteria, options?: IRepoOptions): Promise<ListResult<ConfigDef>>;
-    getConfigDoc(request: ConfigDocSpecForOne, options?: IRepoOptions): Promise<ConfigDoc>;
     /** Retrieves the enterprise configuration currently in play in a single given cabinet,
         in terms of versions of the enterprise and its assets.
         This is a composite/hybrid object made up of a Cabinet, EnterpriseVersionConfig and an EnterpriseRunState.
         Compares versions of each asset between the version specified in the assigned enterprise version config
         and the version that is actually physically running in the cabinet. */
     getCabinetConfigState(request: CabinetConfigStateRequest, options?: IRepoOptions): Promise<CabinetConfigState>;
-    readyState(request: ReadyStateRequest, options?: IRepoOptions): Promise<ApiReadyState>;
-    /** File serve for the relay service. */
-    relayResources(request: FileRequest, options?: IRepoOptions): Promise<Buffer>;
+    /** Retrieves all available enterprises, environments, cabinets, and clusters for the given tenant. */
+    getCabinetScopes(request: CabinetScopesCriteria, options?: IRepoOptions): Promise<ListResult<EnterpriseScope>>;
+    /** Retrieves the list of currently declared config files for the given enterprise asset. */
+    getConfigDefs(request: ConfigDefCriteria, options?: IRepoOptions): Promise<ListResult<ConfigDef>>;
+    getConfigDoc(request: ConfigDocSpecForOne, options?: IRepoOptions): Promise<ConfigDoc>;
     /** All the enterprises, assets, cabinets, environments, and clusters for the current tenant. That is, retrieves a semi-detailed list of all the primary entities of a tenant's software organization.  Originally designed for use in ingress routing. */
     getRootMap(request: RootMapCriteria, options?: IRepoOptions): Promise<SingleResult<RootMap>>;
     /** Assembles (via smashMerge) a single config doc for the given enterprise asset, scoped for the given cabinet. */
     getScopedConfigs(request: ScopedConfigCriteria, options?: IRepoOptions): Promise<ScopedConfig>;
-    /** Retrieves all available enterprises, environments, cabinets, and clusters for the given tenant. */
-    getCabinetScopes(request: CabinetScopesCriteria, options?: IRepoOptions): Promise<ListResult<EnterpriseScope>>;
     /** (generated operationId) */
     getSwaggerUiPath(request: FileRequest, options?: IRepoOptions): Promise<Buffer>;
     /** Assembles an enterprise version configuration by overlaying the given assets onto an optional existing enterprise version, and either creates a new version record for it or retrieves one if that configuration already exists.  Assets are automatically placed within their respective products if applicable. */
     getsertVersion(request: VersionGetsertRequest, options?: IRepoOptions): Promise<SingleResult<EnterpriseVersionConfig>>;
+    readyState(request: ReadyStateRequest, options?: IRepoOptions): Promise<ApiReadyState>;
+    /** File serve for the relay service. */
+    relayResources(request: FileRequest, options?: IRepoOptions): Promise<Buffer>;
 }
 export {};