@codiac.io/codiac-cli 1.2.223 → 1.2.225

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

@@ -40,9 +40,12 @@ export declare class CodiacClient extends ApiClientBase {
     Build: BuildCruds;
     Cabinet: CabinetCruds;
     ClusterDef: ClusterDefCruds;
+    ClusterGrant: ClusterGrantCruds;
     Cluster: ClusterCruds;
+    Comment: CommentCruds;
     ConfigChange: ConfigChangeCruds;
     ContainerFootprint: ContainerFootprintCruds;
+    CspTenantProfile: CspTenantProfileCruds;
     DeployAttempt: DeployAttemptCruds;
     DeployPipeline: DeployPipelineCruds;
     Deployment: DeploymentCruds;
@@ -57,6 +60,7 @@ export declare class CodiacClient extends ApiClientBase {
     SetupJournal: SetupJournalCruds;
     Kit: KitCruds;
     KvpStoreDef: KvpStoreDefCruds;
+    Label: LabelCruds;
     NodePoolDef: NodePoolDefCruds;
     Probe: ProbeCruds;
     ProductVersionConfig: ProductVersionConfigCruds;
@@ -71,7 +75,7 @@ export declare class CodiacClient extends ApiClientBase {
     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 } from "../contracts";
+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";
 declare class AuthOperations {
     private core;
     protected logger: IBetterLogger;
@@ -85,7 +89,11 @@ declare class AuthOperations {
     EntityAclUpdate(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
     EntityAclPatch(request: PatchSpecForOne<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
     EntityAclDelete(request: IdSpecFor<EntityAcl>, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    EntityAclUpdatePartial(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<PartialWithId<EntityAcl>>>;
     EntityAclCreate(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
+    EntityAclUpdatePartialMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<PartialWithId<EntityAcl>>>;
+    EntityAclUpsertMany(request: Array<EntityAcl>, options?: IRepoOptions): Promise<BatchResult<EntityAcl>>;
+    EntityAclUpsert(request: EntityAcl, options?: IRepoOptions): Promise<SingleResult<EntityAcl>>;
     SubscriptionCancel(request: TenantSubscriptionCancel, options?: IRepoOptions): Promise<SingleResult<AuthTenant>>;
     Login(request: AuthenticationRequest, options?: IRepoOptions): Promise<SingleResult<TenantUser>>;
     MyTenant(request: MyTenantRequest, options?: IRepoOptions): Promise<Result>;
@@ -101,8 +109,12 @@ declare class AuthOperations {
     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>>;
+    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>>;
     SubscriptionUpdate(request: TenantSubscriptionUpdate, options?: IRepoOptions): Promise<SingleResult<AuthTenant>>;
     SwitchTenant(request: SwitchTenantRequest, options?: IRepoOptions): Promise<SingleResult<TenantUser>>;
     TenantRegistration(request: TenantRegistrationRequest, options?: IRepoOptions): Promise<SingleResult<AuthTenant>>;
@@ -150,9 +162,21 @@ declare class ActivityBaseCruds {
     /** Deletes the existing ActivityBase. */
     tryDelete(request: IdSpecFor<ActivityBase>, options?: IRepoOptions): Promise<SingleResult<ActivityBase>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { CabinetCreateActivity, CabinetCreateActivityCriteria } from "../contracts";
 declare class CabinetCreateActivityCruds {
@@ -185,9 +209,21 @@ declare class CabinetCreateActivityCruds {
     /** 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>;
+    /** 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>;
 }
 import { ConfigDeploymentActivity, ConfigDeploymentActivityCriteria } from "../contracts";
 declare class ConfigDeploymentActivityCruds {
@@ -220,9 +256,21 @@ declare class ConfigDeploymentActivityCruds {
     /** 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>;
+    /** 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 {
@@ -255,9 +303,21 @@ declare class DeploymentActivityCruds {
     /** 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>;
+    /** 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 {
@@ -290,9 +350,21 @@ declare class VersionCreateActivityCruds {
     /** 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>;
+    /** 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 {
@@ -325,9 +397,21 @@ declare class AssetVersionConfigCruds {
     /** Deletes the existing AssetVersionConfig. */
     tryDelete(request: IdSpecFor<AssetVersionConfig>, options?: IRepoOptions): Promise<SingleResult<AssetVersionConfig>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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 {
@@ -360,9 +444,21 @@ declare class AssetCruds {
     /** 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>;
+    /** 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;
@@ -394,9 +490,21 @@ declare class EntityAclCruds {
     /** 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>;
+    /** 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>;
 }
 declare class AuthRoleCruds {
     private core;
@@ -428,9 +536,21 @@ declare class AuthRoleCruds {
     /** 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>;
+    /** 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;
@@ -473,9 +593,21 @@ declare class BuildPipelineCruds {
     /** 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>;
+    /** 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>;
 }
 import { Build, BuildCriteria } from "../contracts";
 declare class BuildCruds {
@@ -508,9 +640,21 @@ declare class BuildCruds {
     /** Deletes the existing Build. */
     tryDelete(request: IdSpecFor<Build>, options?: IRepoOptions): Promise<SingleResult<Build>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { Cabinet, CabinetCriteria } from "../contracts";
 declare class CabinetCruds {
@@ -543,9 +687,21 @@ declare class CabinetCruds {
     /** Deletes the existing Cabinet. */
     tryDelete(request: IdSpecFor<Cabinet>, options?: IRepoOptions): Promise<SingleResult<Cabinet>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { ClusterDef, ClusterDefCriteria } from "../contracts";
 declare class ClusterDefCruds {
@@ -578,9 +734,68 @@ declare class ClusterDefCruds {
     /** Deletes the existing ClusterDef. */
     tryDelete(request: IdSpecFor<ClusterDef>, options?: IRepoOptions): Promise<SingleResult<ClusterDef>>;
     delete(request: IdSpecFor<ClusterDef>, options?: IThrowingRepoOptions): Promise<ClusterDef>;
+    /** Overwrites the given properties of the existing 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>;
+    /** 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[]>;
+    /** 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>;
+}
+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[]>;
+    /** 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[]>;
+    /** 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 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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { Cluster, ClusterCriteria } from "../contracts";
 declare class ClusterCruds {
@@ -613,9 +828,68 @@ declare class ClusterCruds {
     /** 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>;
+    /** 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>;
+}
+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[]>;
+    /** 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[]>;
+    /** 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 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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { ConfigChange, ConfigChangeCriteria } from "../contracts";
 declare class ConfigChangeCruds {
@@ -648,9 +922,21 @@ declare class ConfigChangeCruds {
     /** Deletes the existing ConfigChange. */
     tryDelete(request: IdSpecFor<ConfigChange>, options?: IRepoOptions): Promise<SingleResult<ConfigChange>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { ContainerFootprint, ContainerFootprintCriteria } from "../contracts";
 declare class ContainerFootprintCruds {
@@ -683,9 +969,68 @@ declare class ContainerFootprintCruds {
     /** Deletes the existing ContainerFootprint. */
     tryDelete(request: IdSpecFor<ContainerFootprint>, options?: IRepoOptions): Promise<SingleResult<ContainerFootprint>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
+}
+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[]>;
+    /** 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[]>;
+    /** 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 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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { DeployAttempt, DeployAttemptCriteria } from "../contracts";
 declare class DeployAttemptCruds {
@@ -718,9 +1063,21 @@ declare class DeployAttemptCruds {
     /** Deletes the existing DeployAttempt. */
     tryDelete(request: IdSpecFor<DeployAttempt>, options?: IRepoOptions): Promise<SingleResult<DeployAttempt>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { DeployPipeline, DeployPipelineCriteria } from "../contracts";
 declare class DeployPipelineCruds {
@@ -753,9 +1110,21 @@ declare class DeployPipelineCruds {
     /** Deletes the existing DeployPipeline. */
     tryDelete(request: IdSpecFor<DeployPipeline>, options?: IRepoOptions): Promise<SingleResult<DeployPipeline>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { Deployment, DeploymentCriteria } from "../contracts";
 declare class DeploymentCruds {
@@ -788,9 +1157,21 @@ declare class DeploymentCruds {
     /** Deletes the existing Deployment. */
     tryDelete(request: IdSpecFor<Deployment>, options?: IRepoOptions): Promise<SingleResult<Deployment>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { EnterpriseRunState, EnterpriseRunStateCriteria } from "../contracts";
 declare class EnterpriseRunStateCruds {
@@ -823,9 +1204,21 @@ declare class EnterpriseRunStateCruds {
     /** Deletes the existing EnterpriseRunState. */
     tryDelete(request: IdSpecFor<EnterpriseRunState>, options?: IRepoOptions): Promise<SingleResult<EnterpriseRunState>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { EnterpriseVersionConfig, EnterpriseVersionConfigCriteria } from "../contracts";
 declare class EnterpriseVersionConfigCruds {
@@ -858,9 +1251,21 @@ declare class EnterpriseVersionConfigCruds {
     /** Deletes the existing EnterpriseVersionConfig. */
     tryDelete(request: IdSpecFor<EnterpriseVersionConfig>, options?: IRepoOptions): Promise<SingleResult<EnterpriseVersionConfig>>;
     delete(request: IdSpecFor<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>;
+    /** 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 {
@@ -893,9 +1298,21 @@ declare class EnterpriseCruds {
     /** 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>;
+    /** 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>;
 }
 import { Environment, EnvironmentCriteria } from "../contracts";
 declare class EnvironmentCruds {
@@ -928,9 +1345,21 @@ declare class EnvironmentCruds {
     /** Deletes the existing Environment. */
     tryDelete(request: IdSpecFor<Environment>, options?: IRepoOptions): Promise<SingleResult<Environment>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { FileStoreDef, FileStoreDefCriteria } from "../contracts";
 declare class FileStoreDefCruds {
@@ -963,9 +1392,21 @@ declare class FileStoreDefCruds {
     /** Deletes the existing FileStoreDef. */
     tryDelete(request: IdSpecFor<FileStoreDef>, options?: IRepoOptions): Promise<SingleResult<FileStoreDef>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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 {
@@ -998,9 +1439,21 @@ declare class ScopedHostNameConfigCruds {
     /** 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>;
+    /** 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 {
@@ -1033,9 +1486,21 @@ declare class ImageRegistryCruds {
     /** 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>;
+    /** 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>;
 }
 import { Image, ImageCriteria } from "../contracts";
 declare class ImageCruds {
@@ -1068,9 +1533,21 @@ declare class ImageCruds {
     /** Deletes the existing Image. */
     tryDelete(request: IdSpecFor<Image>, options?: IRepoOptions): Promise<SingleResult<Image>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { SetupJournal, SetupJournalCriteria } from "../contracts";
 declare class SetupJournalCruds {
@@ -1103,9 +1580,21 @@ declare class SetupJournalCruds {
     /** 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>;
+    /** 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>;
 }
 import { Kit, KitCriteria } from "../contracts";
 declare class KitCruds {
@@ -1138,9 +1627,21 @@ declare class KitCruds {
     /** Deletes the existing Kit. */
     tryDelete(request: IdSpecFor<Kit>, options?: IRepoOptions): Promise<SingleResult<Kit>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { KvpStoreDef, KvpStoreDefCriteria } from "../contracts";
 declare class KvpStoreDefCruds {
@@ -1173,9 +1674,68 @@ declare class KvpStoreDefCruds {
     /** Deletes the existing KvpStoreDef. */
     tryDelete(request: IdSpecFor<KvpStoreDef>, options?: IRepoOptions): Promise<SingleResult<KvpStoreDef>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
+}
+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[]>;
+    /** 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[]>;
+    /** 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 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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { NodePoolDef, NodePoolDefCriteria } from "../contracts";
 declare class NodePoolDefCruds {
@@ -1208,9 +1768,21 @@ declare class NodePoolDefCruds {
     /** Deletes the existing NodePoolDef. */
     tryDelete(request: IdSpecFor<NodePoolDef>, options?: IRepoOptions): Promise<SingleResult<NodePoolDef>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { Probe, ProbeCriteria } from "../contracts";
 declare class ProbeCruds {
@@ -1243,9 +1815,21 @@ declare class ProbeCruds {
     /** Deletes the existing Probe. */
     tryDelete(request: IdSpecFor<Probe>, options?: IRepoOptions): Promise<SingleResult<Probe>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { ProductVersionConfig, ProductVersionConfigCriteria } from "../contracts";
 declare class ProductVersionConfigCruds {
@@ -1278,9 +1862,21 @@ declare class ProductVersionConfigCruds {
     /** Deletes the existing ProductVersionConfig. */
     tryDelete(request: IdSpecFor<ProductVersionConfig>, options?: IRepoOptions): Promise<SingleResult<ProductVersionConfig>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { Product, ProductCriteria } from "../contracts";
 declare class ProductCruds {
@@ -1313,9 +1909,21 @@ declare class ProductCruds {
     /** 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>;
+    /** 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>;
 }
 import { ScopedSetting, ScopedSettingCriteria } from "../contracts";
 declare class ScopedSettingCruds {
@@ -1348,9 +1956,21 @@ declare class ScopedSettingCruds {
     /** Deletes the existing ScopedSetting. */
     tryDelete(request: IdSpecFor<ScopedSetting>, options?: IRepoOptions): Promise<SingleResult<ScopedSetting>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { Snapshot, SnapshotCriteria } from "../contracts";
 declare class SnapshotCruds {
@@ -1383,9 +2003,21 @@ declare class SnapshotCruds {
     /** Deletes the existing Snapshot. */
     tryDelete(request: IdSpecFor<Snapshot>, options?: IRepoOptions): Promise<SingleResult<Snapshot>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { SourceRepo, SourceRepoCriteria } from "../contracts";
 declare class SourceRepoCruds {
@@ -1418,9 +2050,21 @@ declare class SourceRepoCruds {
     /** Deletes the existing SourceRepo. */
     tryDelete(request: IdSpecFor<SourceRepo>, options?: IRepoOptions): Promise<SingleResult<SourceRepo>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { Subscription, SubscriptionCriteria } from "../contracts";
 declare class SubscriptionCruds {
@@ -1453,9 +2097,21 @@ declare class SubscriptionCruds {
     /** Deletes the existing Subscription. */
     tryDelete(request: IdSpecFor<Subscription>, options?: IRepoOptions): Promise<SingleResult<Subscription>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { Tag, TagCriteria } from "../contracts";
 declare class TagCruds {
@@ -1488,9 +2144,21 @@ declare class TagCruds {
     /** Deletes the existing Tag. */
     tryDelete(request: IdSpecFor<Tag>, options?: IRepoOptions): Promise<SingleResult<Tag>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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 {
@@ -1523,9 +2191,21 @@ declare class CodiacTenantCruds {
     /** 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>;
+    /** 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>;
 }
 import { VersionConfig, VersionConfigCriteria } from "../contracts";
 declare class VersionConfigCruds {
@@ -1558,9 +2238,21 @@ declare class VersionConfigCruds {
     /** Deletes the existing VersionConfig. */
     tryDelete(request: IdSpecFor<VersionConfig>, options?: IRepoOptions): Promise<SingleResult<VersionConfig>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { WorkFlowStrategy, WorkFlowStrategyCriteria } from "../contracts";
 declare class WorkFlowStrategyCruds {
@@ -1593,9 +2285,21 @@ declare class WorkFlowStrategyCruds {
     /** Deletes the existing WorkFlowStrategy. */
     tryDelete(request: IdSpecFor<WorkFlowStrategy>, options?: IRepoOptions): Promise<SingleResult<WorkFlowStrategy>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { ZombiePeriod, ZombiePeriodCriteria } from "../contracts";
 declare class ZombiePeriodCruds {
@@ -1628,9 +2332,21 @@ declare class ZombiePeriodCruds {
     /** Deletes the existing ZombiePeriod. */
     tryDelete(request: IdSpecFor<ZombiePeriod>, options?: IRepoOptions): Promise<SingleResult<ZombiePeriod>>;
     delete(request: IdSpecFor<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>;
+    /** 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[]>;
+    /** 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>;
 }
 import { CabinetHostNameConfigCriteria, CabinetHostNameConfig, ConfigDefCriteria, ConfigDef, ConfigDocSpecForOne, ConfigDoc, CabinetConfigStateRequest, CabinetConfigState, ReadyStateRequest, ApiReadyState, FileRequest, Buffer, RootMapCriteria, RootMap, ScopedConfigCriteria, ScopedConfig, CabinetScopesCriteria, EnterpriseScope, VersionGetsertRequest } from "../contracts";
 declare class OtherOperations {