@codiac.io/codiac-cli 1.3.82 → 1.3.84

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

@@ -0,0 +1,2571 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { interfaces } from "inversify";
+import { Buffer } from "buffer";
+import { IRepoOptions, IBetterLogger } from "@codiac.io/codiac-common";
+import { ListResult, BatchResult, SingleResult, PatchSpecForOne, PatchSpecForMany, IdSpecFor } from "@codiac.io/codiac-common/contracts";
+import { TokenCreds } from "../common/token";
+import { CodiacNatsClientConfig } from "./config";
+import { UpdatePartialWhereRequest, IThrowingRepoOptions } from "../common/types";
+import * as Contracts from './contracts';
+import * as Nats from "@nats-io/nats-core";
+import { TokenUtils } from "../common/token-utils";
+export declare class CodiacNatsClient {
+    logger: IBetterLogger;
+    private _settings;
+    private _tokenCredentials?;
+    static readonly DEFAULT_TOKEN_HEADER_PARAM = "authorization";
+    /** Version of the remote api from which this client was generated */
+    static apiVersion: string;
+    /** The name of the jwt claim in the codiac token that holds the nats credentials.  */
+    private static readonly CLAIM_FOR_GLOBAL_CLIENT_KEY;
+    static readonly DEFAULTS: CodiacNatsClientConfig;
+    static bootstrap(ioc: interfaces.Container, settings?: CodiacNatsClientConfig): void;
+    /** This factory method is just for convenience and hasty backward compatibility with consumers not using ioc. */
+    static create(logger: IBetterLogger, configuration?: CodiacNatsClientConfig, codiacJwt?: string | TokenCreds): CodiacNatsClient;
+    private static _nc;
+    static get nc(): Nats.NatsConnection | undefined;
+    constructor(logger: IBetterLogger, _settings: CodiacNatsClientConfig, _tokenCredentials?: TokenCreds | undefined);
+    TokenUtils: TokenUtils;
+    isExpired(token: string, throwOnError?: boolean): boolean;
+    /** Sets the user context to impersonate in requests made to the api. */
+    setUserToken(token: string): void;
+    connect(): Promise<Nats.ServerInfo | undefined>;
+    isConnected(): boolean;
+    disconnect(): Promise<void>;
+    /** Declaration of what messaging protocol to connect with. */
+    private clientType;
+    get tokenCredentials(): TokenCreds | undefined;
+    set tokenCredentials(value: TokenCreds | undefined);
+    get settings(): CodiacNatsClientConfig;
+    private getValues;
+    request<TRequest, TResponse>(subject: string, req?: TRequest, options?: IRepoOptions): Promise<TResponse>;
+    private makeRequest;
+    Auth: AuthOperations;
+    Call: OtherOperations;
+    ActivityBase: ActivityBaseCruds;
+    Asset: AssetCruds;
+    AssetVersionConfig: AssetVersionConfigCruds;
+    AuthRole: AuthRoleCruds;
+    Build: BuildCruds;
+    BuildPipeline: BuildPipelineCruds;
+    Cabinet: CabinetCruds;
+    CabinetCreateActivity: CabinetCreateActivityCruds;
+    Cluster: ClusterCruds;
+    ClusterDef: ClusterDefCruds;
+    ClusterGrant: ClusterGrantCruds;
+    CodiacTenant: CodiacTenantCruds;
+    CodiacUser: CodiacUserCruds;
+    Comment: CommentCruds;
+    ConfigChange: ConfigChangeCruds;
+    ConfigDeploymentActivity: ConfigDeploymentActivityCruds;
+    ContainerFootprint: ContainerFootprintCruds;
+    CspTenantProfile: CspTenantProfileCruds;
+    DefaultChildAcl: DefaultChildAclCruds;
+    DeployAttempt: DeployAttemptCruds;
+    DeployPipeline: DeployPipelineCruds;
+    Deployment: DeploymentCruds;
+    DeploymentActivity: DeploymentActivityCruds;
+    Enterprise: EnterpriseCruds;
+    EnterpriseRunState: EnterpriseRunStateCruds;
+    EnterpriseVersionConfig: EnterpriseVersionConfigCruds;
+    EntityAcl: EntityAclCruds;
+    Environment: EnvironmentCruds;
+    FileStoreDef: FileStoreDefCruds;
+    Image: ImageCruds;
+    ImageRegistry: ImageRegistryCruds;
+    Kit: KitCruds;
+    KvpStoreDef: KvpStoreDefCruds;
+    Label: LabelCruds;
+    NodePoolDef: NodePoolDefCruds;
+    Probe: ProbeCruds;
+    Product: ProductCruds;
+    ProductVersionConfig: ProductVersionConfigCruds;
+    ScopedHostNameConfig: ScopedHostNameConfigCruds;
+    ScopedSetting: ScopedSettingCruds;
+    SetupJournal: SetupJournalCruds;
+    Snapshot: SnapshotCruds;
+    SourceRepo: SourceRepoCruds;
+    Subscription: SubscriptionCruds;
+    Tag: TagCruds;
+    VersionConfig: VersionConfigCruds;
+    VersionCreateActivity: VersionCreateActivityCruds;
+    WorkFlowStrategy: WorkFlowStrategyCruds;
+    ZombiePeriod: ZombiePeriodCruds;
+}
+declare class AuthOperations {
+    private core;
+    constructor(core: CodiacNatsClient);
+    RoleCreate(request: Contracts.AuthRole, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    RoleCreateMany(request: Array<Contracts.AuthRole>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    RoleDelete(request: IdSpecFor<Contracts.AuthRole>, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    RoleDeleteWhere(request: Contracts.AuthRoleCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    RoleGet(request: IdSpecFor<Contracts.AuthRole>, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    RoleList(request: Contracts.AuthRoleCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.AuthRole>>;
+    RolePatch(request: PatchSpecForOne<Contracts.AuthRole>, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    RolePatchWhere(request: PatchSpecForMany<Contracts.AuthRole, Contracts.AuthRoleCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    RoleUpdate(request: Contracts.AuthRole, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    RoleUpdateMany(request: Array<Contracts.AuthRole>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    RoleUpdatePartial(request: Partial<Contracts.AuthRole>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.AuthRole>>>;
+    RoleUpdatePartialMany(request: Array<Contracts.AuthRole>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.AuthRole>>>;
+    RoleUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.AuthRole, Contracts.AuthRoleCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    RoleUpsert(request: Contracts.AuthRole, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    RoleUpsertMany(request: Array<Contracts.AuthRole>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    CodiacUserGet(request: IdSpecFor<Contracts.CodiacUser>, options?: IRepoOptions): Promise<SingleResult<Contracts.CodiacUser>>;
+    CodiacUserList(request: Contracts.CodiacUserCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.CodiacUser>>;
+    DefaultChildAclCreate(request: Contracts.DefaultChildAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclCreateMany(request: Array<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclDelete(request: IdSpecFor<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclDeleteWhere(request: Contracts.DefaultChildAclCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclGet(request: IdSpecFor<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclList(request: Contracts.DefaultChildAclCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclPatch(request: PatchSpecForOne<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclPatchWhere(request: PatchSpecForMany<Contracts.DefaultChildAcl, Contracts.DefaultChildAclCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclUpdate(request: Contracts.DefaultChildAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclUpdateMany(request: Array<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclUpdatePartial(request: Partial<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.DefaultChildAcl>>>;
+    DefaultChildAclUpdatePartialMany(request: Array<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.DefaultChildAcl>>>;
+    DefaultChildAclUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.DefaultChildAcl, Contracts.DefaultChildAclCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclUpsert(request: Contracts.DefaultChildAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    DefaultChildAclUpsertMany(request: Array<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    EntityAclCreate(request: Contracts.EntityAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    EntityAclCreateMany(request: Array<Contracts.EntityAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    EntityAclDelete(request: IdSpecFor<Contracts.EntityAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    EntityAclDeleteWhere(request: Contracts.EntityAclCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    EntityAclGet(request: IdSpecFor<Contracts.EntityAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    EntityAclList(request: Contracts.EntityAclCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.EntityAcl>>;
+    EntityAclPatch(request: PatchSpecForOne<Contracts.EntityAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    EntityAclPatchWhere(request: PatchSpecForMany<Contracts.EntityAcl, Contracts.EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    EntityAclUpdate(request: Contracts.EntityAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    EntityAclUpdateMany(request: Array<Contracts.EntityAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    EntityAclUpdatePartial(request: Partial<Contracts.EntityAcl>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.EntityAcl>>>;
+    EntityAclUpdatePartialMany(request: Array<Contracts.EntityAcl>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.EntityAcl>>>;
+    EntityAclUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.EntityAcl, Contracts.EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    EntityAclUpsert(request: Contracts.EntityAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    EntityAclUpsertMany(request: Array<Contracts.EntityAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    AddTenantUser(request: Contracts.AddTenantUserRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.TenantUser>>;
+    ChangePassword(request: Contracts.ChangePasswordRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.TenantUser>>;
+    ExpelUser(request: IdSpecFor<Contracts.TenantUser>, options?: IRepoOptions): Promise<SingleResult<Contracts.TenantUser>>;
+    Login(request: Contracts.AuthenticationRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.TenantUser>>;
+    MyTenant(request: Contracts.MyTenantRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthTenant>>;
+    PatchUser(request: Contracts.CodiacUserPatch, options?: IRepoOptions): Promise<SingleResult<Contracts.CodiacUser>>;
+    ResetPassword(request: Contracts.ResetPasswordRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.TenantUser>>;
+    RoleAssignment(request: Contracts.RoleAssignmentRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.TenantUser>>;
+    SetDefaultChildPermission(request: Contracts.DefaultChildPermissionRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    SetEntityPermission(request: Contracts.EntityPermissionRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.SecurableEntity>>;
+    SetTenantStatus(request: Contracts.TenantStatusChange, options?: IRepoOptions): Promise<SingleResult<Contracts.SubscriptionStatus>>;
+    SubscriptionCancel(request: Contracts.TenantSubscriptionCancel, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthTenant>>;
+    SubscriptionUpdate(request: Contracts.TenantSubscriptionUpdate, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthTenant>>;
+    SwitchTenant(request: Contracts.SwitchTenantRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.TenantUser>>;
+    TenantRegistration(request: Contracts.TenantRegistrationRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthTenant>>;
+    TokenRefresh(request: Contracts.RefreshTokenRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.TenantUser>>;
+    WhoAmI(request: Contracts.WhoAmIRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.TenantUser>>;
+    /** Determines whether the given token is expired.
+     * @param throwOnError throws any encountered errors, including token parsing errors.
+     */
+    isExpired(token: string, throwOnError?: boolean): boolean;
+    extractTokenExpiration(token: string): Date | undefined;
+}
+declare class ActivityBaseCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing ActivityBase that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ActivityCriteriaBase, options?: IRepoOptions): Promise<BatchResult<Contracts.ActivityBase>>;
+    deleteWhere(request: Contracts.ActivityCriteriaBase, options?: IThrowingRepoOptions): Promise<Contracts.ActivityBase[]>;
+    /** Retrieves all the existing ActivityBase that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ActivityCriteriaBase, options?: IRepoOptions): Promise<ListResult<Contracts.ActivityBase>>;
+    readMany(request: Contracts.ActivityCriteriaBase, options?: IThrowingRepoOptions): Promise<Contracts.ActivityBase[]>;
+    /** Performs the given operations on each existing ActivityBase that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.ActivityBase, Contracts.ActivityCriteriaBase>, options?: IRepoOptions): Promise<BatchResult<Contracts.ActivityBase>>;
+    patchWhere(request: PatchSpecForMany<Contracts.ActivityBase, Contracts.ActivityCriteriaBase>, options?: IThrowingRepoOptions): Promise<Contracts.ActivityBase[]>;
+    /** Saves each given input as a new ActivityBase. */
+    tryCreateMany(request: Array<Contracts.ActivityBase>, options?: IRepoOptions): Promise<BatchResult<Contracts.ActivityBase>>;
+    createMany(request: Array<Contracts.ActivityBase>, options?: IThrowingRepoOptions): Promise<Contracts.ActivityBase[]>;
+    /** Overwrites each existing ActivityBase. */
+    tryUpdateMany(request: Array<Contracts.ActivityBase>, options?: IRepoOptions): Promise<BatchResult<Contracts.ActivityBase>>;
+    updateMany(request: Array<Contracts.ActivityBase>, options?: IThrowingRepoOptions): Promise<Contracts.ActivityBase[]>;
+    /** Deletes the existing ActivityBase. */
+    tryDelete(request: IdSpecFor<Contracts.ActivityBase>, options?: IRepoOptions): Promise<SingleResult<Contracts.ActivityBase>>;
+    delete(request: IdSpecFor<Contracts.ActivityBase>, options?: IThrowingRepoOptions): Promise<Contracts.ActivityBase>;
+    /** Retrieves the single, uniquely identified ActivityBase. */
+    tryRead(request: IdSpecFor<Contracts.ActivityBase>, options?: IRepoOptions): Promise<SingleResult<Contracts.ActivityBase>>;
+    read(request: IdSpecFor<Contracts.ActivityBase>, options?: IThrowingRepoOptions): Promise<Contracts.ActivityBase>;
+    /** Performs the given operations on the existing ActivityBase. */
+    tryPatch(request: PatchSpecForOne<Contracts.ActivityBase>, options?: IRepoOptions): Promise<SingleResult<Contracts.ActivityBase>>;
+    patch(request: PatchSpecForOne<Contracts.ActivityBase>, options?: IThrowingRepoOptions): Promise<Contracts.ActivityBase>;
+    /** Overwrites the existing ActivityBase. */
+    tryUpdate(request: Contracts.ActivityBase, options?: IRepoOptions): Promise<SingleResult<Contracts.ActivityBase>>;
+    update(request: Contracts.ActivityBase, options?: IThrowingRepoOptions): Promise<Contracts.ActivityBase>;
+    /** Overwrites the given properties of the existing ActivityBase. */
+    tryUpdatePartial(request: Partial<Contracts.ActivityBase>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.ActivityBase>>>;
+    updatePartial(request: Partial<Contracts.ActivityBase>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ActivityBase>>;
+    /** Saves the input as a new ActivityBase. */
+    tryCreate(request: Contracts.ActivityBase, options?: IRepoOptions): Promise<SingleResult<Contracts.ActivityBase>>;
+    create(request: Contracts.ActivityBase, options?: IThrowingRepoOptions): Promise<Contracts.ActivityBase>;
+    /** Overwrites the given properties for each existing ActivityBase. */
+    tryUpdatePartialMany(request: Array<Contracts.ActivityBase>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.ActivityBase>>>;
+    updatePartialMany(request: Array<Contracts.ActivityBase>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ActivityBase>[]>;
+    /** Performs the given operation on each existing ActivityBase that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ActivityBase, Contracts.ActivityCriteriaBase>, options?: IRepoOptions): Promise<BatchResult<Contracts.ActivityBase>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ActivityBase, Contracts.ActivityCriteriaBase>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.ActivityBase, options?: IRepoOptions): Promise<SingleResult<Contracts.ActivityBase>>;
+    upsert(request: Contracts.ActivityBase, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.ActivityBase>, options?: IRepoOptions): Promise<BatchResult<Contracts.ActivityBase>>;
+    upsertMany(request: Array<Contracts.ActivityBase>, options?: IThrowingRepoOptions): Promise<Contracts.ActivityBase[]>;
+}
+declare class AssetCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing Asset that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.AssetCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Asset>>;
+    deleteWhere(request: Contracts.AssetCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Asset[]>;
+    /** Retrieves all the existing Asset that satisfy the given criteria. */
+    tryReadMany(request: Contracts.AssetCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Asset>>;
+    readMany(request: Contracts.AssetCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Asset[]>;
+    /** Performs the given operations on each existing Asset that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Asset, Contracts.AssetCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Asset>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Asset, Contracts.AssetCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Asset[]>;
+    /** Saves each given input as a new Asset. */
+    tryCreateMany(request: Array<Contracts.Asset>, options?: IRepoOptions): Promise<BatchResult<Contracts.Asset>>;
+    createMany(request: Array<Contracts.Asset>, options?: IThrowingRepoOptions): Promise<Contracts.Asset[]>;
+    /** Overwrites each existing Asset. */
+    tryUpdateMany(request: Array<Contracts.Asset>, options?: IRepoOptions): Promise<BatchResult<Contracts.Asset>>;
+    updateMany(request: Array<Contracts.Asset>, options?: IThrowingRepoOptions): Promise<Contracts.Asset[]>;
+    /** Deletes the existing Asset. */
+    tryDelete(request: IdSpecFor<Contracts.Asset>, options?: IRepoOptions): Promise<SingleResult<Contracts.Asset>>;
+    delete(request: IdSpecFor<Contracts.Asset>, options?: IThrowingRepoOptions): Promise<Contracts.Asset>;
+    /** Retrieves the single, uniquely identified Asset. */
+    tryRead(request: IdSpecFor<Contracts.Asset>, options?: IRepoOptions): Promise<SingleResult<Contracts.Asset>>;
+    read(request: IdSpecFor<Contracts.Asset>, options?: IThrowingRepoOptions): Promise<Contracts.Asset>;
+    /** Performs the given operations on the existing Asset. */
+    tryPatch(request: PatchSpecForOne<Contracts.Asset>, options?: IRepoOptions): Promise<SingleResult<Contracts.Asset>>;
+    patch(request: PatchSpecForOne<Contracts.Asset>, options?: IThrowingRepoOptions): Promise<Contracts.Asset>;
+    /** Overwrites the existing Asset. */
+    tryUpdate(request: Contracts.Asset, options?: IRepoOptions): Promise<SingleResult<Contracts.Asset>>;
+    update(request: Contracts.Asset, options?: IThrowingRepoOptions): Promise<Contracts.Asset>;
+    /** Overwrites the given properties of the existing Asset. */
+    tryUpdatePartial(request: Partial<Contracts.Asset>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Asset>>>;
+    updatePartial(request: Partial<Contracts.Asset>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Asset>>;
+    /** Saves the input as a new Asset. */
+    tryCreate(request: Contracts.Asset, options?: IRepoOptions): Promise<SingleResult<Contracts.Asset>>;
+    create(request: Contracts.Asset, options?: IThrowingRepoOptions): Promise<Contracts.Asset>;
+    /** Overwrites the given properties for each existing Asset. */
+    tryUpdatePartialMany(request: Array<Contracts.Asset>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Asset>>>;
+    updatePartialMany(request: Array<Contracts.Asset>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Asset>[]>;
+    /** Performs the given operation on each existing Asset that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Asset, Contracts.AssetCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Asset>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Asset, Contracts.AssetCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.Asset, options?: IRepoOptions): Promise<SingleResult<Contracts.Asset>>;
+    upsert(request: Contracts.Asset, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.Asset>, options?: IRepoOptions): Promise<BatchResult<Contracts.Asset>>;
+    upsertMany(request: Array<Contracts.Asset>, options?: IThrowingRepoOptions): Promise<Contracts.Asset[]>;
+}
+declare class AssetVersionConfigCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing AssetVersionConfig that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.AssetVersionConfigCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.AssetVersionConfig>>;
+    deleteWhere(request: Contracts.AssetVersionConfigCriteria, options?: IThrowingRepoOptions): Promise<Contracts.AssetVersionConfig[]>;
+    /** Retrieves all the existing AssetVersionConfig that satisfy the given criteria. */
+    tryReadMany(request: Contracts.AssetVersionConfigCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.AssetVersionConfig>>;
+    readMany(request: Contracts.AssetVersionConfigCriteria, options?: IThrowingRepoOptions): Promise<Contracts.AssetVersionConfig[]>;
+    /** Performs the given operations on each existing AssetVersionConfig that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.AssetVersionConfig, Contracts.AssetVersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.AssetVersionConfig>>;
+    patchWhere(request: PatchSpecForMany<Contracts.AssetVersionConfig, Contracts.AssetVersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.AssetVersionConfig[]>;
+    /** Saves each given input as a new AssetVersionConfig. */
+    tryCreateMany(request: Array<Contracts.AssetVersionConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.AssetVersionConfig>>;
+    createMany(request: Array<Contracts.AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.AssetVersionConfig[]>;
+    /** Overwrites each existing AssetVersionConfig. */
+    tryUpdateMany(request: Array<Contracts.AssetVersionConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.AssetVersionConfig>>;
+    updateMany(request: Array<Contracts.AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.AssetVersionConfig[]>;
+    /** Deletes the existing AssetVersionConfig. */
+    tryDelete(request: IdSpecFor<Contracts.AssetVersionConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.AssetVersionConfig>>;
+    delete(request: IdSpecFor<Contracts.AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.AssetVersionConfig>;
+    /** Retrieves the single, uniquely identified AssetVersionConfig. */
+    tryRead(request: IdSpecFor<Contracts.AssetVersionConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.AssetVersionConfig>>;
+    read(request: IdSpecFor<Contracts.AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.AssetVersionConfig>;
+    /** Performs the given operations on the existing AssetVersionConfig. */
+    tryPatch(request: PatchSpecForOne<Contracts.AssetVersionConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.AssetVersionConfig>>;
+    patch(request: PatchSpecForOne<Contracts.AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.AssetVersionConfig>;
+    /** Overwrites the existing AssetVersionConfig. */
+    tryUpdate(request: Contracts.AssetVersionConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.AssetVersionConfig>>;
+    update(request: Contracts.AssetVersionConfig, options?: IThrowingRepoOptions): Promise<Contracts.AssetVersionConfig>;
+    /** Overwrites the given properties of the existing AssetVersionConfig. */
+    tryUpdatePartial(request: Partial<Contracts.AssetVersionConfig>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.AssetVersionConfig>>>;
+    updatePartial(request: Partial<Contracts.AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.AssetVersionConfig>>;
+    /** Saves the input as a new AssetVersionConfig. */
+    tryCreate(request: Contracts.AssetVersionConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.AssetVersionConfig>>;
+    create(request: Contracts.AssetVersionConfig, options?: IThrowingRepoOptions): Promise<Contracts.AssetVersionConfig>;
+    /** Overwrites the given properties for each existing AssetVersionConfig. */
+    tryUpdatePartialMany(request: Array<Contracts.AssetVersionConfig>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.AssetVersionConfig>>>;
+    updatePartialMany(request: Array<Contracts.AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.AssetVersionConfig>[]>;
+    /** Performs the given operation on each existing AssetVersionConfig that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.AssetVersionConfig, Contracts.AssetVersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.AssetVersionConfig>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.AssetVersionConfig, Contracts.AssetVersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.AssetVersionConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.AssetVersionConfig>>;
+    upsert(request: Contracts.AssetVersionConfig, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.AssetVersionConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.AssetVersionConfig>>;
+    upsertMany(request: Array<Contracts.AssetVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.AssetVersionConfig[]>;
+}
+declare class AuthRoleCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing AuthRole that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.AuthRoleCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    deleteWhere(request: Contracts.AuthRoleCriteria, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole[]>;
+    /** Retrieves all the existing AuthRole that satisfy the given criteria. */
+    tryReadMany(request: Contracts.AuthRoleCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.AuthRole>>;
+    readMany(request: Contracts.AuthRoleCriteria, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole[]>;
+    /** Performs the given operations on each existing AuthRole that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.AuthRole, Contracts.AuthRoleCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    patchWhere(request: PatchSpecForMany<Contracts.AuthRole, Contracts.AuthRoleCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole[]>;
+    /** Saves each given input as a new AuthRole. */
+    tryCreateMany(request: Array<Contracts.AuthRole>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    createMany(request: Array<Contracts.AuthRole>, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole[]>;
+    /** Overwrites each existing AuthRole. */
+    tryUpdateMany(request: Array<Contracts.AuthRole>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    updateMany(request: Array<Contracts.AuthRole>, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole[]>;
+    /** Deletes the existing AuthRole. */
+    tryDelete(request: IdSpecFor<Contracts.AuthRole>, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    delete(request: IdSpecFor<Contracts.AuthRole>, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole>;
+    /** Retrieves the single, uniquely identified AuthRole. */
+    tryRead(request: IdSpecFor<Contracts.AuthRole>, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    read(request: IdSpecFor<Contracts.AuthRole>, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole>;
+    /** Performs the given operations on the existing AuthRole. */
+    tryPatch(request: PatchSpecForOne<Contracts.AuthRole>, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    patch(request: PatchSpecForOne<Contracts.AuthRole>, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole>;
+    /** Overwrites the existing AuthRole. */
+    tryUpdate(request: Contracts.AuthRole, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    update(request: Contracts.AuthRole, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole>;
+    /** Overwrites the given properties of the existing AuthRole. */
+    tryUpdatePartial(request: Partial<Contracts.AuthRole>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.AuthRole>>>;
+    updatePartial(request: Partial<Contracts.AuthRole>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.AuthRole>>;
+    /** Saves the input as a new AuthRole. */
+    tryCreate(request: Contracts.AuthRole, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    create(request: Contracts.AuthRole, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole>;
+    /** Overwrites the given properties for each existing AuthRole. */
+    tryUpdatePartialMany(request: Array<Contracts.AuthRole>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.AuthRole>>>;
+    updatePartialMany(request: Array<Contracts.AuthRole>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.AuthRole>[]>;
+    /** Performs the given operation on each existing AuthRole that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.AuthRole, Contracts.AuthRoleCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.AuthRole, Contracts.AuthRoleCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.AuthRole, options?: IRepoOptions): Promise<SingleResult<Contracts.AuthRole>>;
+    upsert(request: Contracts.AuthRole, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.AuthRole>, options?: IRepoOptions): Promise<BatchResult<Contracts.AuthRole>>;
+    upsertMany(request: Array<Contracts.AuthRole>, options?: IThrowingRepoOptions): Promise<Contracts.AuthRole[]>;
+}
+declare class BuildCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing Build that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.BuildCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Build>>;
+    deleteWhere(request: Contracts.BuildCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Build[]>;
+    /** Retrieves all the existing Build that satisfy the given criteria. */
+    tryReadMany(request: Contracts.BuildCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Build>>;
+    readMany(request: Contracts.BuildCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Build[]>;
+    /** Performs the given operations on each existing Build that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Build, Contracts.BuildCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Build>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Build, Contracts.BuildCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Build[]>;
+    /** Saves each given input as a new Build. */
+    tryCreateMany(request: Array<Contracts.Build>, options?: IRepoOptions): Promise<BatchResult<Contracts.Build>>;
+    createMany(request: Array<Contracts.Build>, options?: IThrowingRepoOptions): Promise<Contracts.Build[]>;
+    /** Overwrites each existing Build. */
+    tryUpdateMany(request: Array<Contracts.Build>, options?: IRepoOptions): Promise<BatchResult<Contracts.Build>>;
+    updateMany(request: Array<Contracts.Build>, options?: IThrowingRepoOptions): Promise<Contracts.Build[]>;
+    /** Deletes the existing Build. */
+    tryDelete(request: IdSpecFor<Contracts.Build>, options?: IRepoOptions): Promise<SingleResult<Contracts.Build>>;
+    delete(request: IdSpecFor<Contracts.Build>, options?: IThrowingRepoOptions): Promise<Contracts.Build>;
+    /** Retrieves the single, uniquely identified Build. */
+    tryRead(request: IdSpecFor<Contracts.Build>, options?: IRepoOptions): Promise<SingleResult<Contracts.Build>>;
+    read(request: IdSpecFor<Contracts.Build>, options?: IThrowingRepoOptions): Promise<Contracts.Build>;
+    /** Performs the given operations on the existing Build. */
+    tryPatch(request: PatchSpecForOne<Contracts.Build>, options?: IRepoOptions): Promise<SingleResult<Contracts.Build>>;
+    patch(request: PatchSpecForOne<Contracts.Build>, options?: IThrowingRepoOptions): Promise<Contracts.Build>;
+    /** Overwrites the existing Build. */
+    tryUpdate(request: Contracts.Build, options?: IRepoOptions): Promise<SingleResult<Contracts.Build>>;
+    update(request: Contracts.Build, options?: IThrowingRepoOptions): Promise<Contracts.Build>;
+    /** Overwrites the given properties of the existing Build. */
+    tryUpdatePartial(request: Partial<Contracts.Build>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Build>>>;
+    updatePartial(request: Partial<Contracts.Build>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Build>>;
+    /** Saves the input as a new Build. */
+    tryCreate(request: Contracts.Build, options?: IRepoOptions): Promise<SingleResult<Contracts.Build>>;
+    create(request: Contracts.Build, options?: IThrowingRepoOptions): Promise<Contracts.Build>;
+    /** Overwrites the given properties for each existing Build. */
+    tryUpdatePartialMany(request: Array<Contracts.Build>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Build>>>;
+    updatePartialMany(request: Array<Contracts.Build>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Build>[]>;
+    /** Performs the given operation on each existing Build that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Build, Contracts.BuildCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Build>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Build, Contracts.BuildCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.Build, options?: IRepoOptions): Promise<SingleResult<Contracts.Build>>;
+    upsert(request: Contracts.Build, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.Build>, options?: IRepoOptions): Promise<BatchResult<Contracts.Build>>;
+    upsertMany(request: Array<Contracts.Build>, options?: IThrowingRepoOptions): Promise<Contracts.Build[]>;
+}
+declare class BuildPipelineCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing BuildPipeline that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.BuildPipelineCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.BuildPipeline>>;
+    deleteWhere(request: Contracts.BuildPipelineCriteria, options?: IThrowingRepoOptions): Promise<Contracts.BuildPipeline[]>;
+    /** Retrieves all the existing BuildPipeline that satisfy the given criteria. */
+    tryReadMany(request: Contracts.BuildPipelineCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.BuildPipeline>>;
+    readMany(request: Contracts.BuildPipelineCriteria, options?: IThrowingRepoOptions): Promise<Contracts.BuildPipeline[]>;
+    /** Performs the given operations on each existing BuildPipeline that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.BuildPipeline, Contracts.BuildPipelineCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.BuildPipeline>>;
+    patchWhere(request: PatchSpecForMany<Contracts.BuildPipeline, Contracts.BuildPipelineCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.BuildPipeline[]>;
+    /** Saves each given input as a new BuildPipeline. */
+    tryCreateMany(request: Array<Contracts.BuildPipeline>, options?: IRepoOptions): Promise<BatchResult<Contracts.BuildPipeline>>;
+    createMany(request: Array<Contracts.BuildPipeline>, options?: IThrowingRepoOptions): Promise<Contracts.BuildPipeline[]>;
+    /** Overwrites each existing BuildPipeline. */
+    tryUpdateMany(request: Array<Contracts.BuildPipeline>, options?: IRepoOptions): Promise<BatchResult<Contracts.BuildPipeline>>;
+    updateMany(request: Array<Contracts.BuildPipeline>, options?: IThrowingRepoOptions): Promise<Contracts.BuildPipeline[]>;
+    /** Deletes the existing BuildPipeline. */
+    tryDelete(request: IdSpecFor<Contracts.BuildPipeline>, options?: IRepoOptions): Promise<SingleResult<Contracts.BuildPipeline>>;
+    delete(request: IdSpecFor<Contracts.BuildPipeline>, options?: IThrowingRepoOptions): Promise<Contracts.BuildPipeline>;
+    /** Retrieves the single, uniquely identified BuildPipeline. */
+    tryRead(request: IdSpecFor<Contracts.BuildPipeline>, options?: IRepoOptions): Promise<SingleResult<Contracts.BuildPipeline>>;
+    read(request: IdSpecFor<Contracts.BuildPipeline>, options?: IThrowingRepoOptions): Promise<Contracts.BuildPipeline>;
+    /** Performs the given operations on the existing BuildPipeline. */
+    tryPatch(request: PatchSpecForOne<Contracts.BuildPipeline>, options?: IRepoOptions): Promise<SingleResult<Contracts.BuildPipeline>>;
+    patch(request: PatchSpecForOne<Contracts.BuildPipeline>, options?: IThrowingRepoOptions): Promise<Contracts.BuildPipeline>;
+    /** Overwrites the existing BuildPipeline. */
+    tryUpdate(request: Contracts.BuildPipeline, options?: IRepoOptions): Promise<SingleResult<Contracts.BuildPipeline>>;
+    update(request: Contracts.BuildPipeline, options?: IThrowingRepoOptions): Promise<Contracts.BuildPipeline>;
+    /** Overwrites the given properties of the existing BuildPipeline. */
+    tryUpdatePartial(request: Partial<Contracts.BuildPipeline>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.BuildPipeline>>>;
+    updatePartial(request: Partial<Contracts.BuildPipeline>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.BuildPipeline>>;
+    /** Saves the input as a new BuildPipeline. */
+    tryCreate(request: Contracts.BuildPipeline, options?: IRepoOptions): Promise<SingleResult<Contracts.BuildPipeline>>;
+    create(request: Contracts.BuildPipeline, options?: IThrowingRepoOptions): Promise<Contracts.BuildPipeline>;
+    /** Overwrites the given properties for each existing BuildPipeline. */
+    tryUpdatePartialMany(request: Array<Contracts.BuildPipeline>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.BuildPipeline>>>;
+    updatePartialMany(request: Array<Contracts.BuildPipeline>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.BuildPipeline>[]>;
+    /** Performs the given operation on each existing BuildPipeline that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.BuildPipeline, Contracts.BuildPipelineCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.BuildPipeline>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.BuildPipeline, Contracts.BuildPipelineCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.BuildPipeline, options?: IRepoOptions): Promise<SingleResult<Contracts.BuildPipeline>>;
+    upsert(request: Contracts.BuildPipeline, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.BuildPipeline>, options?: IRepoOptions): Promise<BatchResult<Contracts.BuildPipeline>>;
+    upsertMany(request: Array<Contracts.BuildPipeline>, options?: IThrowingRepoOptions): Promise<Contracts.BuildPipeline[]>;
+}
+declare class CabinetCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing Cabinet that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.CabinetCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Cabinet>>;
+    deleteWhere(request: Contracts.CabinetCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet[]>;
+    /** Retrieves all the existing Cabinet that satisfy the given criteria. */
+    tryReadMany(request: Contracts.CabinetCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Cabinet>>;
+    readMany(request: Contracts.CabinetCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet[]>;
+    /** Performs the given operations on each existing Cabinet that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Cabinet, Contracts.CabinetCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Cabinet>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Cabinet, Contracts.CabinetCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet[]>;
+    /** Saves each given input as a new Cabinet. */
+    tryCreateMany(request: Array<Contracts.Cabinet>, options?: IRepoOptions): Promise<BatchResult<Contracts.Cabinet>>;
+    createMany(request: Array<Contracts.Cabinet>, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet[]>;
+    /** Overwrites each existing Cabinet. */
+    tryUpdateMany(request: Array<Contracts.Cabinet>, options?: IRepoOptions): Promise<BatchResult<Contracts.Cabinet>>;
+    updateMany(request: Array<Contracts.Cabinet>, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet[]>;
+    /** Deletes the existing Cabinet. */
+    tryDelete(request: IdSpecFor<Contracts.Cabinet>, options?: IRepoOptions): Promise<SingleResult<Contracts.Cabinet>>;
+    delete(request: IdSpecFor<Contracts.Cabinet>, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet>;
+    /** Retrieves the single, uniquely identified Cabinet. */
+    tryRead(request: IdSpecFor<Contracts.Cabinet>, options?: IRepoOptions): Promise<SingleResult<Contracts.Cabinet>>;
+    read(request: IdSpecFor<Contracts.Cabinet>, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet>;
+    /** Performs the given operations on the existing Cabinet. */
+    tryPatch(request: PatchSpecForOne<Contracts.Cabinet>, options?: IRepoOptions): Promise<SingleResult<Contracts.Cabinet>>;
+    patch(request: PatchSpecForOne<Contracts.Cabinet>, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet>;
+    /** Overwrites the existing Cabinet. */
+    tryUpdate(request: Contracts.Cabinet, options?: IRepoOptions): Promise<SingleResult<Contracts.Cabinet>>;
+    update(request: Contracts.Cabinet, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet>;
+    /** Overwrites the given properties of the existing Cabinet. */
+    tryUpdatePartial(request: Partial<Contracts.Cabinet>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Cabinet>>>;
+    updatePartial(request: Partial<Contracts.Cabinet>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Cabinet>>;
+    /** Saves the input as a new Cabinet. */
+    tryCreate(request: Contracts.Cabinet, options?: IRepoOptions): Promise<SingleResult<Contracts.Cabinet>>;
+    create(request: Contracts.Cabinet, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet>;
+    /** Overwrites the given properties for each existing Cabinet. */
+    tryUpdatePartialMany(request: Array<Contracts.Cabinet>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Cabinet>>>;
+    updatePartialMany(request: Array<Contracts.Cabinet>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Cabinet>[]>;
+    /** Performs the given operation on each existing Cabinet that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Cabinet, Contracts.CabinetCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Cabinet>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Cabinet, Contracts.CabinetCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.Cabinet, options?: IRepoOptions): Promise<SingleResult<Contracts.Cabinet>>;
+    upsert(request: Contracts.Cabinet, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.Cabinet>, options?: IRepoOptions): Promise<BatchResult<Contracts.Cabinet>>;
+    upsertMany(request: Array<Contracts.Cabinet>, options?: IThrowingRepoOptions): Promise<Contracts.Cabinet[]>;
+}
+declare class CabinetCreateActivityCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing CabinetCreateActivity that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.CabinetCreateActivityCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.CabinetCreateActivity>>;
+    deleteWhere(request: Contracts.CabinetCreateActivityCriteria, options?: IThrowingRepoOptions): Promise<Contracts.CabinetCreateActivity[]>;
+    /** Retrieves all the existing CabinetCreateActivity that satisfy the given criteria. */
+    tryReadMany(request: Contracts.CabinetCreateActivityCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.CabinetCreateActivity>>;
+    readMany(request: Contracts.CabinetCreateActivityCriteria, options?: IThrowingRepoOptions): Promise<Contracts.CabinetCreateActivity[]>;
+    /** Performs the given operations on each existing CabinetCreateActivity that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.CabinetCreateActivity, Contracts.CabinetCreateActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.CabinetCreateActivity>>;
+    patchWhere(request: PatchSpecForMany<Contracts.CabinetCreateActivity, Contracts.CabinetCreateActivityCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.CabinetCreateActivity[]>;
+    /** Saves each given input as a new CabinetCreateActivity. */
+    tryCreateMany(request: Array<Contracts.CabinetCreateActivity>, options?: IRepoOptions): Promise<BatchResult<Contracts.CabinetCreateActivity>>;
+    createMany(request: Array<Contracts.CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<Contracts.CabinetCreateActivity[]>;
+    /** Overwrites each existing CabinetCreateActivity. */
+    tryUpdateMany(request: Array<Contracts.CabinetCreateActivity>, options?: IRepoOptions): Promise<BatchResult<Contracts.CabinetCreateActivity>>;
+    updateMany(request: Array<Contracts.CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<Contracts.CabinetCreateActivity[]>;
+    /** Deletes the existing CabinetCreateActivity. */
+    tryDelete(request: IdSpecFor<Contracts.CabinetCreateActivity>, options?: IRepoOptions): Promise<SingleResult<Contracts.CabinetCreateActivity>>;
+    delete(request: IdSpecFor<Contracts.CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<Contracts.CabinetCreateActivity>;
+    /** Retrieves the single, uniquely identified CabinetCreateActivity. */
+    tryRead(request: IdSpecFor<Contracts.CabinetCreateActivity>, options?: IRepoOptions): Promise<SingleResult<Contracts.CabinetCreateActivity>>;
+    read(request: IdSpecFor<Contracts.CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<Contracts.CabinetCreateActivity>;
+    /** Performs the given operations on the existing CabinetCreateActivity. */
+    tryPatch(request: PatchSpecForOne<Contracts.CabinetCreateActivity>, options?: IRepoOptions): Promise<SingleResult<Contracts.CabinetCreateActivity>>;
+    patch(request: PatchSpecForOne<Contracts.CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<Contracts.CabinetCreateActivity>;
+    /** Overwrites the existing CabinetCreateActivity. */
+    tryUpdate(request: Contracts.CabinetCreateActivity, options?: IRepoOptions): Promise<SingleResult<Contracts.CabinetCreateActivity>>;
+    update(request: Contracts.CabinetCreateActivity, options?: IThrowingRepoOptions): Promise<Contracts.CabinetCreateActivity>;
+    /** Overwrites the given properties of the existing CabinetCreateActivity. */
+    tryUpdatePartial(request: Partial<Contracts.CabinetCreateActivity>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.CabinetCreateActivity>>>;
+    updatePartial(request: Partial<Contracts.CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.CabinetCreateActivity>>;
+    /** Saves the input as a new CabinetCreateActivity. */
+    tryCreate(request: Contracts.CabinetCreateActivity, options?: IRepoOptions): Promise<SingleResult<Contracts.CabinetCreateActivity>>;
+    create(request: Contracts.CabinetCreateActivity, options?: IThrowingRepoOptions): Promise<Contracts.CabinetCreateActivity>;
+    /** Overwrites the given properties for each existing CabinetCreateActivity. */
+    tryUpdatePartialMany(request: Array<Contracts.CabinetCreateActivity>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.CabinetCreateActivity>>>;
+    updatePartialMany(request: Array<Contracts.CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.CabinetCreateActivity>[]>;
+    /** Performs the given operation on each existing CabinetCreateActivity that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.CabinetCreateActivity, Contracts.CabinetCreateActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.CabinetCreateActivity>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.CabinetCreateActivity, Contracts.CabinetCreateActivityCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.CabinetCreateActivity, options?: IRepoOptions): Promise<SingleResult<Contracts.CabinetCreateActivity>>;
+    upsert(request: Contracts.CabinetCreateActivity, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.CabinetCreateActivity>, options?: IRepoOptions): Promise<BatchResult<Contracts.CabinetCreateActivity>>;
+    upsertMany(request: Array<Contracts.CabinetCreateActivity>, options?: IThrowingRepoOptions): Promise<Contracts.CabinetCreateActivity[]>;
+}
+declare class ClusterCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing Cluster that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ClusterCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Cluster>>;
+    deleteWhere(request: Contracts.ClusterCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Cluster[]>;
+    /** Retrieves all the existing Cluster that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ClusterCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Cluster>>;
+    readMany(request: Contracts.ClusterCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Cluster[]>;
+    /** Performs the given operations on each existing Cluster that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Cluster, Contracts.ClusterCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Cluster>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Cluster, Contracts.ClusterCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Cluster[]>;
+    /** Saves each given input as a new Cluster. */
+    tryCreateMany(request: Array<Contracts.Cluster>, options?: IRepoOptions): Promise<BatchResult<Contracts.Cluster>>;
+    createMany(request: Array<Contracts.Cluster>, options?: IThrowingRepoOptions): Promise<Contracts.Cluster[]>;
+    /** Overwrites each existing Cluster. */
+    tryUpdateMany(request: Array<Contracts.Cluster>, options?: IRepoOptions): Promise<BatchResult<Contracts.Cluster>>;
+    updateMany(request: Array<Contracts.Cluster>, options?: IThrowingRepoOptions): Promise<Contracts.Cluster[]>;
+    /** Deletes the existing Cluster. */
+    tryDelete(request: IdSpecFor<Contracts.Cluster>, options?: IRepoOptions): Promise<SingleResult<Contracts.Cluster>>;
+    delete(request: IdSpecFor<Contracts.Cluster>, options?: IThrowingRepoOptions): Promise<Contracts.Cluster>;
+    /** Retrieves the single, uniquely identified Cluster. */
+    tryRead(request: IdSpecFor<Contracts.Cluster>, options?: IRepoOptions): Promise<SingleResult<Contracts.Cluster>>;
+    read(request: IdSpecFor<Contracts.Cluster>, options?: IThrowingRepoOptions): Promise<Contracts.Cluster>;
+    /** Performs the given operations on the existing Cluster. */
+    tryPatch(request: PatchSpecForOne<Contracts.Cluster>, options?: IRepoOptions): Promise<SingleResult<Contracts.Cluster>>;
+    patch(request: PatchSpecForOne<Contracts.Cluster>, options?: IThrowingRepoOptions): Promise<Contracts.Cluster>;
+    /** Overwrites the existing Cluster. */
+    tryUpdate(request: Contracts.Cluster, options?: IRepoOptions): Promise<SingleResult<Contracts.Cluster>>;
+    update(request: Contracts.Cluster, options?: IThrowingRepoOptions): Promise<Contracts.Cluster>;
+    /** Overwrites the given properties of the existing Cluster. */
+    tryUpdatePartial(request: Partial<Contracts.Cluster>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Cluster>>>;
+    updatePartial(request: Partial<Contracts.Cluster>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Cluster>>;
+    /** Saves the input as a new Cluster. */
+    tryCreate(request: Contracts.Cluster, options?: IRepoOptions): Promise<SingleResult<Contracts.Cluster>>;
+    create(request: Contracts.Cluster, options?: IThrowingRepoOptions): Promise<Contracts.Cluster>;
+    /** Overwrites the given properties for each existing Cluster. */
+    tryUpdatePartialMany(request: Array<Contracts.Cluster>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Cluster>>>;
+    updatePartialMany(request: Array<Contracts.Cluster>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Cluster>[]>;
+    /** Performs the given operation on each existing Cluster that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Cluster, Contracts.ClusterCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Cluster>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Cluster, Contracts.ClusterCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.Cluster, options?: IRepoOptions): Promise<SingleResult<Contracts.Cluster>>;
+    upsert(request: Contracts.Cluster, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.Cluster>, options?: IRepoOptions): Promise<BatchResult<Contracts.Cluster>>;
+    upsertMany(request: Array<Contracts.Cluster>, options?: IThrowingRepoOptions): Promise<Contracts.Cluster[]>;
+}
+declare class ClusterDefCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing ClusterDef that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ClusterDefCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterDef>>;
+    deleteWhere(request: Contracts.ClusterDefCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef[]>;
+    /** Retrieves all the existing ClusterDef that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ClusterDefCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ClusterDef>>;
+    readMany(request: Contracts.ClusterDefCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef[]>;
+    /** Performs the given operations on each existing ClusterDef that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.ClusterDef, Contracts.ClusterDefCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterDef>>;
+    patchWhere(request: PatchSpecForMany<Contracts.ClusterDef, Contracts.ClusterDefCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef[]>;
+    /** Saves each given input as a new ClusterDef. */
+    tryCreateMany(request: Array<Contracts.ClusterDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterDef>>;
+    createMany(request: Array<Contracts.ClusterDef>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef[]>;
+    /** Overwrites each existing ClusterDef. */
+    tryUpdateMany(request: Array<Contracts.ClusterDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterDef>>;
+    updateMany(request: Array<Contracts.ClusterDef>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef[]>;
+    /** Deletes the existing ClusterDef. */
+    tryDelete(request: IdSpecFor<Contracts.ClusterDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterDef>>;
+    delete(request: IdSpecFor<Contracts.ClusterDef>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef>;
+    /** Retrieves the single, uniquely identified ClusterDef. */
+    tryRead(request: IdSpecFor<Contracts.ClusterDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterDef>>;
+    read(request: IdSpecFor<Contracts.ClusterDef>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef>;
+    /** Performs the given operations on the existing ClusterDef. */
+    tryPatch(request: PatchSpecForOne<Contracts.ClusterDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterDef>>;
+    patch(request: PatchSpecForOne<Contracts.ClusterDef>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef>;
+    /** Overwrites the existing ClusterDef. */
+    tryUpdate(request: Contracts.ClusterDef, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterDef>>;
+    update(request: Contracts.ClusterDef, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef>;
+    /** Overwrites the given properties of the existing ClusterDef. */
+    tryUpdatePartial(request: Partial<Contracts.ClusterDef>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.ClusterDef>>>;
+    updatePartial(request: Partial<Contracts.ClusterDef>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ClusterDef>>;
+    /** Saves the input as a new ClusterDef. */
+    tryCreate(request: Contracts.ClusterDef, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterDef>>;
+    create(request: Contracts.ClusterDef, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef>;
+    /** Overwrites the given properties for each existing ClusterDef. */
+    tryUpdatePartialMany(request: Array<Contracts.ClusterDef>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.ClusterDef>>>;
+    updatePartialMany(request: Array<Contracts.ClusterDef>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ClusterDef>[]>;
+    /** Performs the given operation on each existing ClusterDef that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ClusterDef, Contracts.ClusterDefCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterDef>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ClusterDef, Contracts.ClusterDefCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.ClusterDef, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterDef>>;
+    upsert(request: Contracts.ClusterDef, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.ClusterDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterDef>>;
+    upsertMany(request: Array<Contracts.ClusterDef>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterDef[]>;
+}
+declare class ClusterGrantCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing ClusterGrant that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ClusterGrantCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterGrant>>;
+    deleteWhere(request: Contracts.ClusterGrantCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ClusterGrant[]>;
+    /** Retrieves all the existing ClusterGrant that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ClusterGrantCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ClusterGrant>>;
+    readMany(request: Contracts.ClusterGrantCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ClusterGrant[]>;
+    /** Performs the given operations on each existing ClusterGrant that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.ClusterGrant, Contracts.ClusterGrantCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterGrant>>;
+    patchWhere(request: PatchSpecForMany<Contracts.ClusterGrant, Contracts.ClusterGrantCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterGrant[]>;
+    /** Saves each given input as a new ClusterGrant. */
+    tryCreateMany(request: Array<Contracts.ClusterGrant>, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterGrant>>;
+    createMany(request: Array<Contracts.ClusterGrant>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterGrant[]>;
+    /** Overwrites each existing ClusterGrant. */
+    tryUpdateMany(request: Array<Contracts.ClusterGrant>, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterGrant>>;
+    updateMany(request: Array<Contracts.ClusterGrant>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterGrant[]>;
+    /** Deletes the existing ClusterGrant. */
+    tryDelete(request: IdSpecFor<Contracts.ClusterGrant>, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterGrant>>;
+    delete(request: IdSpecFor<Contracts.ClusterGrant>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterGrant>;
+    /** Retrieves the single, uniquely identified ClusterGrant. */
+    tryRead(request: IdSpecFor<Contracts.ClusterGrant>, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterGrant>>;
+    read(request: IdSpecFor<Contracts.ClusterGrant>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterGrant>;
+    /** Performs the given operations on the existing ClusterGrant. */
+    tryPatch(request: PatchSpecForOne<Contracts.ClusterGrant>, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterGrant>>;
+    patch(request: PatchSpecForOne<Contracts.ClusterGrant>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterGrant>;
+    /** Overwrites the existing ClusterGrant. */
+    tryUpdate(request: Contracts.ClusterGrant, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterGrant>>;
+    update(request: Contracts.ClusterGrant, options?: IThrowingRepoOptions): Promise<Contracts.ClusterGrant>;
+    /** Overwrites the given properties of the existing ClusterGrant. */
+    tryUpdatePartial(request: Partial<Contracts.ClusterGrant>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.ClusterGrant>>>;
+    updatePartial(request: Partial<Contracts.ClusterGrant>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ClusterGrant>>;
+    /** Saves the input as a new ClusterGrant. */
+    tryCreate(request: Contracts.ClusterGrant, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterGrant>>;
+    create(request: Contracts.ClusterGrant, options?: IThrowingRepoOptions): Promise<Contracts.ClusterGrant>;
+    /** Overwrites the given properties for each existing ClusterGrant. */
+    tryUpdatePartialMany(request: Array<Contracts.ClusterGrant>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.ClusterGrant>>>;
+    updatePartialMany(request: Array<Contracts.ClusterGrant>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ClusterGrant>[]>;
+    /** Performs the given operation on each existing ClusterGrant that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ClusterGrant, Contracts.ClusterGrantCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterGrant>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ClusterGrant, Contracts.ClusterGrantCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.ClusterGrant, options?: IRepoOptions): Promise<SingleResult<Contracts.ClusterGrant>>;
+    upsert(request: Contracts.ClusterGrant, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.ClusterGrant>, options?: IRepoOptions): Promise<BatchResult<Contracts.ClusterGrant>>;
+    upsertMany(request: Array<Contracts.ClusterGrant>, options?: IThrowingRepoOptions): Promise<Contracts.ClusterGrant[]>;
+}
+declare class CodiacTenantCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing CodiacTenant that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.CodiacTenantCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.CodiacTenant>>;
+    deleteWhere(request: Contracts.CodiacTenantCriteria, options?: IThrowingRepoOptions): Promise<Contracts.CodiacTenant[]>;
+    /** Retrieves all the existing CodiacTenant that satisfy the given criteria. */
+    tryReadMany(request: Contracts.CodiacTenantCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.CodiacTenant>>;
+    readMany(request: Contracts.CodiacTenantCriteria, options?: IThrowingRepoOptions): Promise<Contracts.CodiacTenant[]>;
+    /** Performs the given operations on each existing CodiacTenant that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.CodiacTenant, Contracts.CodiacTenantCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.CodiacTenant>>;
+    patchWhere(request: PatchSpecForMany<Contracts.CodiacTenant, Contracts.CodiacTenantCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.CodiacTenant[]>;
+    /** Saves each given input as a new CodiacTenant. */
+    tryCreateMany(request: Array<Contracts.CodiacTenant>, options?: IRepoOptions): Promise<BatchResult<Contracts.CodiacTenant>>;
+    createMany(request: Array<Contracts.CodiacTenant>, options?: IThrowingRepoOptions): Promise<Contracts.CodiacTenant[]>;
+    /** Overwrites each existing CodiacTenant. */
+    tryUpdateMany(request: Array<Contracts.CodiacTenant>, options?: IRepoOptions): Promise<BatchResult<Contracts.CodiacTenant>>;
+    updateMany(request: Array<Contracts.CodiacTenant>, options?: IThrowingRepoOptions): Promise<Contracts.CodiacTenant[]>;
+    /** Deletes the existing CodiacTenant. */
+    tryDelete(request: IdSpecFor<Contracts.CodiacTenant>, options?: IRepoOptions): Promise<SingleResult<Contracts.CodiacTenant>>;
+    delete(request: IdSpecFor<Contracts.CodiacTenant>, options?: IThrowingRepoOptions): Promise<Contracts.CodiacTenant>;
+    /** Retrieves the single, uniquely identified CodiacTenant. */
+    tryRead(request: IdSpecFor<Contracts.CodiacTenant>, options?: IRepoOptions): Promise<SingleResult<Contracts.CodiacTenant>>;
+    read(request: IdSpecFor<Contracts.CodiacTenant>, options?: IThrowingRepoOptions): Promise<Contracts.CodiacTenant>;
+    /** Performs the given operations on the existing CodiacTenant. */
+    tryPatch(request: PatchSpecForOne<Contracts.CodiacTenant>, options?: IRepoOptions): Promise<SingleResult<Contracts.CodiacTenant>>;
+    patch(request: PatchSpecForOne<Contracts.CodiacTenant>, options?: IThrowingRepoOptions): Promise<Contracts.CodiacTenant>;
+    /** Overwrites the existing CodiacTenant. */
+    tryUpdate(request: Contracts.CodiacTenant, options?: IRepoOptions): Promise<SingleResult<Contracts.CodiacTenant>>;
+    update(request: Contracts.CodiacTenant, options?: IThrowingRepoOptions): Promise<Contracts.CodiacTenant>;
+    /** Overwrites the given properties of the existing CodiacTenant. */
+    tryUpdatePartial(request: Partial<Contracts.CodiacTenant>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.CodiacTenant>>>;
+    updatePartial(request: Partial<Contracts.CodiacTenant>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.CodiacTenant>>;
+    /** Saves the input as a new CodiacTenant. */
+    tryCreate(request: Contracts.CodiacTenant, options?: IRepoOptions): Promise<SingleResult<Contracts.CodiacTenant>>;
+    create(request: Contracts.CodiacTenant, options?: IThrowingRepoOptions): Promise<Contracts.CodiacTenant>;
+    /** Overwrites the given properties for each existing CodiacTenant. */
+    tryUpdatePartialMany(request: Array<Contracts.CodiacTenant>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.CodiacTenant>>>;
+    updatePartialMany(request: Array<Contracts.CodiacTenant>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.CodiacTenant>[]>;
+    /** Performs the given operation on each existing CodiacTenant that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.CodiacTenant, Contracts.CodiacTenantCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.CodiacTenant>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.CodiacTenant, Contracts.CodiacTenantCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.CodiacTenant, options?: IRepoOptions): Promise<SingleResult<Contracts.CodiacTenant>>;
+    upsert(request: Contracts.CodiacTenant, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.CodiacTenant>, options?: IRepoOptions): Promise<BatchResult<Contracts.CodiacTenant>>;
+    upsertMany(request: Array<Contracts.CodiacTenant>, options?: IThrowingRepoOptions): Promise<Contracts.CodiacTenant[]>;
+}
+declare class CodiacUserCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Retrieves all the existing CodiacUser that satisfy the given criteria. */
+    tryReadMany(request: Contracts.CodiacUserCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.CodiacUser>>;
+    readMany(request: Contracts.CodiacUserCriteria, options?: IThrowingRepoOptions): Promise<Contracts.CodiacUser[]>;
+    /** Retrieves the single, uniquely identified CodiacUser. */
+    tryRead(request: IdSpecFor<Contracts.CodiacUser>, options?: IRepoOptions): Promise<SingleResult<Contracts.CodiacUser>>;
+    read(request: IdSpecFor<Contracts.CodiacUser>, options?: IThrowingRepoOptions): Promise<Contracts.CodiacUser>;
+}
+declare class CommentCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing Comment that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.CommentCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Comment>>;
+    deleteWhere(request: Contracts.CommentCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Comment[]>;
+    /** Retrieves all the existing Comment that satisfy the given criteria. */
+    tryReadMany(request: Contracts.CommentCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Comment>>;
+    readMany(request: Contracts.CommentCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Comment[]>;
+    /** Performs the given operations on each existing Comment that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Comment, Contracts.CommentCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Comment>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Comment, Contracts.CommentCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Comment[]>;
+    /** Saves each given input as a new Comment. */
+    tryCreateMany(request: Array<Contracts.Comment>, options?: IRepoOptions): Promise<BatchResult<Contracts.Comment>>;
+    createMany(request: Array<Contracts.Comment>, options?: IThrowingRepoOptions): Promise<Contracts.Comment[]>;
+    /** Overwrites each existing Comment. */
+    tryUpdateMany(request: Array<Contracts.Comment>, options?: IRepoOptions): Promise<BatchResult<Contracts.Comment>>;
+    updateMany(request: Array<Contracts.Comment>, options?: IThrowingRepoOptions): Promise<Contracts.Comment[]>;
+    /** Deletes the existing Comment. */
+    tryDelete(request: IdSpecFor<Contracts.Comment>, options?: IRepoOptions): Promise<SingleResult<Contracts.Comment>>;
+    delete(request: IdSpecFor<Contracts.Comment>, options?: IThrowingRepoOptions): Promise<Contracts.Comment>;
+    /** Retrieves the single, uniquely identified Comment. */
+    tryRead(request: IdSpecFor<Contracts.Comment>, options?: IRepoOptions): Promise<SingleResult<Contracts.Comment>>;
+    read(request: IdSpecFor<Contracts.Comment>, options?: IThrowingRepoOptions): Promise<Contracts.Comment>;
+    /** Performs the given operations on the existing Comment. */
+    tryPatch(request: PatchSpecForOne<Contracts.Comment>, options?: IRepoOptions): Promise<SingleResult<Contracts.Comment>>;
+    patch(request: PatchSpecForOne<Contracts.Comment>, options?: IThrowingRepoOptions): Promise<Contracts.Comment>;
+    /** Overwrites the existing Comment. */
+    tryUpdate(request: Contracts.Comment, options?: IRepoOptions): Promise<SingleResult<Contracts.Comment>>;
+    update(request: Contracts.Comment, options?: IThrowingRepoOptions): Promise<Contracts.Comment>;
+    /** Overwrites the given properties of the existing Comment. */
+    tryUpdatePartial(request: Partial<Contracts.Comment>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Comment>>>;
+    updatePartial(request: Partial<Contracts.Comment>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Comment>>;
+    /** Saves the input as a new Comment. */
+    tryCreate(request: Contracts.Comment, options?: IRepoOptions): Promise<SingleResult<Contracts.Comment>>;
+    create(request: Contracts.Comment, options?: IThrowingRepoOptions): Promise<Contracts.Comment>;
+    /** Overwrites the given properties for each existing Comment. */
+    tryUpdatePartialMany(request: Array<Contracts.Comment>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Comment>>>;
+    updatePartialMany(request: Array<Contracts.Comment>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Comment>[]>;
+    /** Performs the given operation on each existing Comment that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Comment, Contracts.CommentCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Comment>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Comment, Contracts.CommentCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.Comment, options?: IRepoOptions): Promise<SingleResult<Contracts.Comment>>;
+    upsert(request: Contracts.Comment, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.Comment>, options?: IRepoOptions): Promise<BatchResult<Contracts.Comment>>;
+    upsertMany(request: Array<Contracts.Comment>, options?: IThrowingRepoOptions): Promise<Contracts.Comment[]>;
+}
+declare class ConfigChangeCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing ConfigChange that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ConfigChangeCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.ConfigChange>>;
+    deleteWhere(request: Contracts.ConfigChangeCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ConfigChange[]>;
+    /** Retrieves all the existing ConfigChange that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ConfigChangeCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ConfigChange>>;
+    readMany(request: Contracts.ConfigChangeCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ConfigChange[]>;
+    /** Performs the given operations on each existing ConfigChange that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.ConfigChange, Contracts.ConfigChangeCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ConfigChange>>;
+    patchWhere(request: PatchSpecForMany<Contracts.ConfigChange, Contracts.ConfigChangeCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ConfigChange[]>;
+    /** Saves each given input as a new ConfigChange. */
+    tryCreateMany(request: Array<Contracts.ConfigChange>, options?: IRepoOptions): Promise<BatchResult<Contracts.ConfigChange>>;
+    createMany(request: Array<Contracts.ConfigChange>, options?: IThrowingRepoOptions): Promise<Contracts.ConfigChange[]>;
+    /** Overwrites each existing ConfigChange. */
+    tryUpdateMany(request: Array<Contracts.ConfigChange>, options?: IRepoOptions): Promise<BatchResult<Contracts.ConfigChange>>;
+    updateMany(request: Array<Contracts.ConfigChange>, options?: IThrowingRepoOptions): Promise<Contracts.ConfigChange[]>;
+    /** Deletes the existing ConfigChange. */
+    tryDelete(request: IdSpecFor<Contracts.ConfigChange>, options?: IRepoOptions): Promise<SingleResult<Contracts.ConfigChange>>;
+    delete(request: IdSpecFor<Contracts.ConfigChange>, options?: IThrowingRepoOptions): Promise<Contracts.ConfigChange>;
+    /** Retrieves the single, uniquely identified ConfigChange. */
+    tryRead(request: IdSpecFor<Contracts.ConfigChange>, options?: IRepoOptions): Promise<SingleResult<Contracts.ConfigChange>>;
+    read(request: IdSpecFor<Contracts.ConfigChange>, options?: IThrowingRepoOptions): Promise<Contracts.ConfigChange>;
+    /** Performs the given operations on the existing ConfigChange. */
+    tryPatch(request: PatchSpecForOne<Contracts.ConfigChange>, options?: IRepoOptions): Promise<SingleResult<Contracts.ConfigChange>>;
+    patch(request: PatchSpecForOne<Contracts.ConfigChange>, options?: IThrowingRepoOptions): Promise<Contracts.ConfigChange>;
+    /** Overwrites the existing ConfigChange. */
+    tryUpdate(request: Contracts.ConfigChange, options?: IRepoOptions): Promise<SingleResult<Contracts.ConfigChange>>;
+    update(request: Contracts.ConfigChange, options?: IThrowingRepoOptions): Promise<Contracts.ConfigChange>;
+    /** Overwrites the given properties of the existing ConfigChange. */
+    tryUpdatePartial(request: Partial<Contracts.ConfigChange>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.ConfigChange>>>;
+    updatePartial(request: Partial<Contracts.ConfigChange>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ConfigChange>>;
+    /** Saves the input as a new ConfigChange. */
+    tryCreate(request: Contracts.ConfigChange, options?: IRepoOptions): Promise<SingleResult<Contracts.ConfigChange>>;
+    create(request: Contracts.ConfigChange, options?: IThrowingRepoOptions): Promise<Contracts.ConfigChange>;
+    /** Overwrites the given properties for each existing ConfigChange. */
+    tryUpdatePartialMany(request: Array<Contracts.ConfigChange>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.ConfigChange>>>;
+    updatePartialMany(request: Array<Contracts.ConfigChange>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ConfigChange>[]>;
+    /** Performs the given operation on each existing ConfigChange that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ConfigChange, Contracts.ConfigChangeCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ConfigChange>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ConfigChange, Contracts.ConfigChangeCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.ConfigChange, options?: IRepoOptions): Promise<SingleResult<Contracts.ConfigChange>>;
+    upsert(request: Contracts.ConfigChange, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.ConfigChange>, options?: IRepoOptions): Promise<BatchResult<Contracts.ConfigChange>>;
+    upsertMany(request: Array<Contracts.ConfigChange>, options?: IThrowingRepoOptions): Promise<Contracts.ConfigChange[]>;
+}
+declare class ConfigDeploymentActivityCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing ConfigDeploymentActivity that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ConfigDeploymentActivityCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.ConfigDeploymentActivity>>;
+    deleteWhere(request: Contracts.ConfigDeploymentActivityCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ConfigDeploymentActivity[]>;
+    /** Retrieves all the existing ConfigDeploymentActivity that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ConfigDeploymentActivityCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ConfigDeploymentActivity>>;
+    readMany(request: Contracts.ConfigDeploymentActivityCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ConfigDeploymentActivity[]>;
+    /** Performs the given operations on each existing ConfigDeploymentActivity that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.ConfigDeploymentActivity, Contracts.ConfigDeploymentActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ConfigDeploymentActivity>>;
+    patchWhere(request: PatchSpecForMany<Contracts.ConfigDeploymentActivity, Contracts.ConfigDeploymentActivityCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ConfigDeploymentActivity[]>;
+    /** Saves each given input as a new ConfigDeploymentActivity. */
+    tryCreateMany(request: Array<Contracts.ConfigDeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<Contracts.ConfigDeploymentActivity>>;
+    createMany(request: Array<Contracts.ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<Contracts.ConfigDeploymentActivity[]>;
+    /** Overwrites each existing ConfigDeploymentActivity. */
+    tryUpdateMany(request: Array<Contracts.ConfigDeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<Contracts.ConfigDeploymentActivity>>;
+    updateMany(request: Array<Contracts.ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<Contracts.ConfigDeploymentActivity[]>;
+    /** Deletes the existing ConfigDeploymentActivity. */
+    tryDelete(request: IdSpecFor<Contracts.ConfigDeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<Contracts.ConfigDeploymentActivity>>;
+    delete(request: IdSpecFor<Contracts.ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<Contracts.ConfigDeploymentActivity>;
+    /** Retrieves the single, uniquely identified ConfigDeploymentActivity. */
+    tryRead(request: IdSpecFor<Contracts.ConfigDeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<Contracts.ConfigDeploymentActivity>>;
+    read(request: IdSpecFor<Contracts.ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<Contracts.ConfigDeploymentActivity>;
+    /** Performs the given operations on the existing ConfigDeploymentActivity. */
+    tryPatch(request: PatchSpecForOne<Contracts.ConfigDeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<Contracts.ConfigDeploymentActivity>>;
+    patch(request: PatchSpecForOne<Contracts.ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<Contracts.ConfigDeploymentActivity>;
+    /** Overwrites the existing ConfigDeploymentActivity. */
+    tryUpdate(request: Contracts.ConfigDeploymentActivity, options?: IRepoOptions): Promise<SingleResult<Contracts.ConfigDeploymentActivity>>;
+    update(request: Contracts.ConfigDeploymentActivity, options?: IThrowingRepoOptions): Promise<Contracts.ConfigDeploymentActivity>;
+    /** Overwrites the given properties of the existing ConfigDeploymentActivity. */
+    tryUpdatePartial(request: Partial<Contracts.ConfigDeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.ConfigDeploymentActivity>>>;
+    updatePartial(request: Partial<Contracts.ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ConfigDeploymentActivity>>;
+    /** Saves the input as a new ConfigDeploymentActivity. */
+    tryCreate(request: Contracts.ConfigDeploymentActivity, options?: IRepoOptions): Promise<SingleResult<Contracts.ConfigDeploymentActivity>>;
+    create(request: Contracts.ConfigDeploymentActivity, options?: IThrowingRepoOptions): Promise<Contracts.ConfigDeploymentActivity>;
+    /** Overwrites the given properties for each existing ConfigDeploymentActivity. */
+    tryUpdatePartialMany(request: Array<Contracts.ConfigDeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.ConfigDeploymentActivity>>>;
+    updatePartialMany(request: Array<Contracts.ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ConfigDeploymentActivity>[]>;
+    /** Performs the given operation on each existing ConfigDeploymentActivity that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ConfigDeploymentActivity, Contracts.ConfigDeploymentActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ConfigDeploymentActivity>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ConfigDeploymentActivity, Contracts.ConfigDeploymentActivityCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.ConfigDeploymentActivity, options?: IRepoOptions): Promise<SingleResult<Contracts.ConfigDeploymentActivity>>;
+    upsert(request: Contracts.ConfigDeploymentActivity, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.ConfigDeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<Contracts.ConfigDeploymentActivity>>;
+    upsertMany(request: Array<Contracts.ConfigDeploymentActivity>, options?: IThrowingRepoOptions): Promise<Contracts.ConfigDeploymentActivity[]>;
+}
+declare class ContainerFootprintCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing ContainerFootprint that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ContainerFootprintCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.ContainerFootprint>>;
+    deleteWhere(request: Contracts.ContainerFootprintCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ContainerFootprint[]>;
+    /** Retrieves all the existing ContainerFootprint that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ContainerFootprintCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ContainerFootprint>>;
+    readMany(request: Contracts.ContainerFootprintCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ContainerFootprint[]>;
+    /** Performs the given operations on each existing ContainerFootprint that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.ContainerFootprint, Contracts.ContainerFootprintCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ContainerFootprint>>;
+    patchWhere(request: PatchSpecForMany<Contracts.ContainerFootprint, Contracts.ContainerFootprintCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ContainerFootprint[]>;
+    /** Saves each given input as a new ContainerFootprint. */
+    tryCreateMany(request: Array<Contracts.ContainerFootprint>, options?: IRepoOptions): Promise<BatchResult<Contracts.ContainerFootprint>>;
+    createMany(request: Array<Contracts.ContainerFootprint>, options?: IThrowingRepoOptions): Promise<Contracts.ContainerFootprint[]>;
+    /** Overwrites each existing ContainerFootprint. */
+    tryUpdateMany(request: Array<Contracts.ContainerFootprint>, options?: IRepoOptions): Promise<BatchResult<Contracts.ContainerFootprint>>;
+    updateMany(request: Array<Contracts.ContainerFootprint>, options?: IThrowingRepoOptions): Promise<Contracts.ContainerFootprint[]>;
+    /** Deletes the existing ContainerFootprint. */
+    tryDelete(request: IdSpecFor<Contracts.ContainerFootprint>, options?: IRepoOptions): Promise<SingleResult<Contracts.ContainerFootprint>>;
+    delete(request: IdSpecFor<Contracts.ContainerFootprint>, options?: IThrowingRepoOptions): Promise<Contracts.ContainerFootprint>;
+    /** Retrieves the single, uniquely identified ContainerFootprint. */
+    tryRead(request: IdSpecFor<Contracts.ContainerFootprint>, options?: IRepoOptions): Promise<SingleResult<Contracts.ContainerFootprint>>;
+    read(request: IdSpecFor<Contracts.ContainerFootprint>, options?: IThrowingRepoOptions): Promise<Contracts.ContainerFootprint>;
+    /** Performs the given operations on the existing ContainerFootprint. */
+    tryPatch(request: PatchSpecForOne<Contracts.ContainerFootprint>, options?: IRepoOptions): Promise<SingleResult<Contracts.ContainerFootprint>>;
+    patch(request: PatchSpecForOne<Contracts.ContainerFootprint>, options?: IThrowingRepoOptions): Promise<Contracts.ContainerFootprint>;
+    /** Overwrites the existing ContainerFootprint. */
+    tryUpdate(request: Contracts.ContainerFootprint, options?: IRepoOptions): Promise<SingleResult<Contracts.ContainerFootprint>>;
+    update(request: Contracts.ContainerFootprint, options?: IThrowingRepoOptions): Promise<Contracts.ContainerFootprint>;
+    /** Overwrites the given properties of the existing ContainerFootprint. */
+    tryUpdatePartial(request: Partial<Contracts.ContainerFootprint>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.ContainerFootprint>>>;
+    updatePartial(request: Partial<Contracts.ContainerFootprint>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ContainerFootprint>>;
+    /** Saves the input as a new ContainerFootprint. */
+    tryCreate(request: Contracts.ContainerFootprint, options?: IRepoOptions): Promise<SingleResult<Contracts.ContainerFootprint>>;
+    create(request: Contracts.ContainerFootprint, options?: IThrowingRepoOptions): Promise<Contracts.ContainerFootprint>;
+    /** Overwrites the given properties for each existing ContainerFootprint. */
+    tryUpdatePartialMany(request: Array<Contracts.ContainerFootprint>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.ContainerFootprint>>>;
+    updatePartialMany(request: Array<Contracts.ContainerFootprint>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ContainerFootprint>[]>;
+    /** Performs the given operation on each existing ContainerFootprint that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ContainerFootprint, Contracts.ContainerFootprintCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ContainerFootprint>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ContainerFootprint, Contracts.ContainerFootprintCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.ContainerFootprint, options?: IRepoOptions): Promise<SingleResult<Contracts.ContainerFootprint>>;
+    upsert(request: Contracts.ContainerFootprint, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.ContainerFootprint>, options?: IRepoOptions): Promise<BatchResult<Contracts.ContainerFootprint>>;
+    upsertMany(request: Array<Contracts.ContainerFootprint>, options?: IThrowingRepoOptions): Promise<Contracts.ContainerFootprint[]>;
+}
+declare class CspTenantProfileCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing CspTenantProfile that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.CspTenantProfileCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.CspTenantProfile>>;
+    deleteWhere(request: Contracts.CspTenantProfileCriteria, options?: IThrowingRepoOptions): Promise<Contracts.CspTenantProfile[]>;
+    /** Retrieves all the existing CspTenantProfile that satisfy the given criteria. */
+    tryReadMany(request: Contracts.CspTenantProfileCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.CspTenantProfile>>;
+    readMany(request: Contracts.CspTenantProfileCriteria, options?: IThrowingRepoOptions): Promise<Contracts.CspTenantProfile[]>;
+    /** Performs the given operations on each existing CspTenantProfile that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.CspTenantProfile, Contracts.CspTenantProfileCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.CspTenantProfile>>;
+    patchWhere(request: PatchSpecForMany<Contracts.CspTenantProfile, Contracts.CspTenantProfileCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.CspTenantProfile[]>;
+    /** Saves each given input as a new CspTenantProfile. */
+    tryCreateMany(request: Array<Contracts.CspTenantProfile>, options?: IRepoOptions): Promise<BatchResult<Contracts.CspTenantProfile>>;
+    createMany(request: Array<Contracts.CspTenantProfile>, options?: IThrowingRepoOptions): Promise<Contracts.CspTenantProfile[]>;
+    /** Overwrites each existing CspTenantProfile. */
+    tryUpdateMany(request: Array<Contracts.CspTenantProfile>, options?: IRepoOptions): Promise<BatchResult<Contracts.CspTenantProfile>>;
+    updateMany(request: Array<Contracts.CspTenantProfile>, options?: IThrowingRepoOptions): Promise<Contracts.CspTenantProfile[]>;
+    /** Deletes the existing CspTenantProfile. */
+    tryDelete(request: IdSpecFor<Contracts.CspTenantProfile>, options?: IRepoOptions): Promise<SingleResult<Contracts.CspTenantProfile>>;
+    delete(request: IdSpecFor<Contracts.CspTenantProfile>, options?: IThrowingRepoOptions): Promise<Contracts.CspTenantProfile>;
+    /** Retrieves the single, uniquely identified CspTenantProfile. */
+    tryRead(request: IdSpecFor<Contracts.CspTenantProfile>, options?: IRepoOptions): Promise<SingleResult<Contracts.CspTenantProfile>>;
+    read(request: IdSpecFor<Contracts.CspTenantProfile>, options?: IThrowingRepoOptions): Promise<Contracts.CspTenantProfile>;
+    /** Performs the given operations on the existing CspTenantProfile. */
+    tryPatch(request: PatchSpecForOne<Contracts.CspTenantProfile>, options?: IRepoOptions): Promise<SingleResult<Contracts.CspTenantProfile>>;
+    patch(request: PatchSpecForOne<Contracts.CspTenantProfile>, options?: IThrowingRepoOptions): Promise<Contracts.CspTenantProfile>;
+    /** Overwrites the existing CspTenantProfile. */
+    tryUpdate(request: Contracts.CspTenantProfile, options?: IRepoOptions): Promise<SingleResult<Contracts.CspTenantProfile>>;
+    update(request: Contracts.CspTenantProfile, options?: IThrowingRepoOptions): Promise<Contracts.CspTenantProfile>;
+    /** Overwrites the given properties of the existing CspTenantProfile. */
+    tryUpdatePartial(request: Partial<Contracts.CspTenantProfile>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.CspTenantProfile>>>;
+    updatePartial(request: Partial<Contracts.CspTenantProfile>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.CspTenantProfile>>;
+    /** Saves the input as a new CspTenantProfile. */
+    tryCreate(request: Contracts.CspTenantProfile, options?: IRepoOptions): Promise<SingleResult<Contracts.CspTenantProfile>>;
+    create(request: Contracts.CspTenantProfile, options?: IThrowingRepoOptions): Promise<Contracts.CspTenantProfile>;
+    /** Overwrites the given properties for each existing CspTenantProfile. */
+    tryUpdatePartialMany(request: Array<Contracts.CspTenantProfile>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.CspTenantProfile>>>;
+    updatePartialMany(request: Array<Contracts.CspTenantProfile>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.CspTenantProfile>[]>;
+    /** Performs the given operation on each existing CspTenantProfile that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.CspTenantProfile, Contracts.CspTenantProfileCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.CspTenantProfile>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.CspTenantProfile, Contracts.CspTenantProfileCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.CspTenantProfile, options?: IRepoOptions): Promise<SingleResult<Contracts.CspTenantProfile>>;
+    upsert(request: Contracts.CspTenantProfile, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.CspTenantProfile>, options?: IRepoOptions): Promise<BatchResult<Contracts.CspTenantProfile>>;
+    upsertMany(request: Array<Contracts.CspTenantProfile>, options?: IThrowingRepoOptions): Promise<Contracts.CspTenantProfile[]>;
+}
+declare class DefaultChildAclCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing DefaultChildAcl that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.DefaultChildAclCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    deleteWhere(request: Contracts.DefaultChildAclCriteria, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl[]>;
+    /** Retrieves all the existing DefaultChildAcl that satisfy the given criteria. */
+    tryReadMany(request: Contracts.DefaultChildAclCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.DefaultChildAcl>>;
+    readMany(request: Contracts.DefaultChildAclCriteria, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl[]>;
+    /** Performs the given operations on each existing DefaultChildAcl that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.DefaultChildAcl, Contracts.DefaultChildAclCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    patchWhere(request: PatchSpecForMany<Contracts.DefaultChildAcl, Contracts.DefaultChildAclCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl[]>;
+    /** Saves each given input as a new DefaultChildAcl. */
+    tryCreateMany(request: Array<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    createMany(request: Array<Contracts.DefaultChildAcl>, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl[]>;
+    /** Overwrites each existing DefaultChildAcl. */
+    tryUpdateMany(request: Array<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    updateMany(request: Array<Contracts.DefaultChildAcl>, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl[]>;
+    /** Deletes the existing DefaultChildAcl. */
+    tryDelete(request: IdSpecFor<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    delete(request: IdSpecFor<Contracts.DefaultChildAcl>, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl>;
+    /** Retrieves the single, uniquely identified DefaultChildAcl. */
+    tryRead(request: IdSpecFor<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    read(request: IdSpecFor<Contracts.DefaultChildAcl>, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl>;
+    /** Performs the given operations on the existing DefaultChildAcl. */
+    tryPatch(request: PatchSpecForOne<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    patch(request: PatchSpecForOne<Contracts.DefaultChildAcl>, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl>;
+    /** Overwrites the existing DefaultChildAcl. */
+    tryUpdate(request: Contracts.DefaultChildAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    update(request: Contracts.DefaultChildAcl, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl>;
+    /** Overwrites the given properties of the existing DefaultChildAcl. */
+    tryUpdatePartial(request: Partial<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.DefaultChildAcl>>>;
+    updatePartial(request: Partial<Contracts.DefaultChildAcl>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.DefaultChildAcl>>;
+    /** Saves the input as a new DefaultChildAcl. */
+    tryCreate(request: Contracts.DefaultChildAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    create(request: Contracts.DefaultChildAcl, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl>;
+    /** Overwrites the given properties for each existing DefaultChildAcl. */
+    tryUpdatePartialMany(request: Array<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.DefaultChildAcl>>>;
+    updatePartialMany(request: Array<Contracts.DefaultChildAcl>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.DefaultChildAcl>[]>;
+    /** Performs the given operation on each existing DefaultChildAcl that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.DefaultChildAcl, Contracts.DefaultChildAclCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.DefaultChildAcl, Contracts.DefaultChildAclCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl[]>;
+    /** Saves the input as a new DefaultChildAcl, 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: Contracts.DefaultChildAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.DefaultChildAcl>>;
+    upsert(request: Contracts.DefaultChildAcl, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl>;
+    /** Saves each given input as a new DefaultChildAcl, 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<Contracts.DefaultChildAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.DefaultChildAcl>>;
+    upsertMany(request: Array<Contracts.DefaultChildAcl>, options?: IThrowingRepoOptions): Promise<Contracts.DefaultChildAcl[]>;
+}
+declare class DeployAttemptCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing DeployAttempt that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.DeployAttemptCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployAttempt>>;
+    deleteWhere(request: Contracts.DeployAttemptCriteria, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt[]>;
+    /** Retrieves all the existing DeployAttempt that satisfy the given criteria. */
+    tryReadMany(request: Contracts.DeployAttemptCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.DeployAttempt>>;
+    readMany(request: Contracts.DeployAttemptCriteria, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt[]>;
+    /** Performs the given operations on each existing DeployAttempt that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.DeployAttempt, Contracts.DeployAttemptCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployAttempt>>;
+    patchWhere(request: PatchSpecForMany<Contracts.DeployAttempt, Contracts.DeployAttemptCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt[]>;
+    /** Saves each given input as a new DeployAttempt. */
+    tryCreateMany(request: Array<Contracts.DeployAttempt>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployAttempt>>;
+    createMany(request: Array<Contracts.DeployAttempt>, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt[]>;
+    /** Overwrites each existing DeployAttempt. */
+    tryUpdateMany(request: Array<Contracts.DeployAttempt>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployAttempt>>;
+    updateMany(request: Array<Contracts.DeployAttempt>, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt[]>;
+    /** Deletes the existing DeployAttempt. */
+    tryDelete(request: IdSpecFor<Contracts.DeployAttempt>, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployAttempt>>;
+    delete(request: IdSpecFor<Contracts.DeployAttempt>, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt>;
+    /** Retrieves the single, uniquely identified DeployAttempt. */
+    tryRead(request: IdSpecFor<Contracts.DeployAttempt>, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployAttempt>>;
+    read(request: IdSpecFor<Contracts.DeployAttempt>, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt>;
+    /** Performs the given operations on the existing DeployAttempt. */
+    tryPatch(request: PatchSpecForOne<Contracts.DeployAttempt>, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployAttempt>>;
+    patch(request: PatchSpecForOne<Contracts.DeployAttempt>, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt>;
+    /** Overwrites the existing DeployAttempt. */
+    tryUpdate(request: Contracts.DeployAttempt, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployAttempt>>;
+    update(request: Contracts.DeployAttempt, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt>;
+    /** Overwrites the given properties of the existing DeployAttempt. */
+    tryUpdatePartial(request: Partial<Contracts.DeployAttempt>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.DeployAttempt>>>;
+    updatePartial(request: Partial<Contracts.DeployAttempt>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.DeployAttempt>>;
+    /** Saves the input as a new DeployAttempt. */
+    tryCreate(request: Contracts.DeployAttempt, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployAttempt>>;
+    create(request: Contracts.DeployAttempt, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt>;
+    /** Overwrites the given properties for each existing DeployAttempt. */
+    tryUpdatePartialMany(request: Array<Contracts.DeployAttempt>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.DeployAttempt>>>;
+    updatePartialMany(request: Array<Contracts.DeployAttempt>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.DeployAttempt>[]>;
+    /** Performs the given operation on each existing DeployAttempt that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.DeployAttempt, Contracts.DeployAttemptCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployAttempt>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.DeployAttempt, Contracts.DeployAttemptCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.DeployAttempt, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployAttempt>>;
+    upsert(request: Contracts.DeployAttempt, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.DeployAttempt>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployAttempt>>;
+    upsertMany(request: Array<Contracts.DeployAttempt>, options?: IThrowingRepoOptions): Promise<Contracts.DeployAttempt[]>;
+}
+declare class DeployPipelineCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing DeployPipeline that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.DeployPipelineCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployPipeline>>;
+    deleteWhere(request: Contracts.DeployPipelineCriteria, options?: IThrowingRepoOptions): Promise<Contracts.DeployPipeline[]>;
+    /** Retrieves all the existing DeployPipeline that satisfy the given criteria. */
+    tryReadMany(request: Contracts.DeployPipelineCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.DeployPipeline>>;
+    readMany(request: Contracts.DeployPipelineCriteria, options?: IThrowingRepoOptions): Promise<Contracts.DeployPipeline[]>;
+    /** Performs the given operations on each existing DeployPipeline that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.DeployPipeline, Contracts.DeployPipelineCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployPipeline>>;
+    patchWhere(request: PatchSpecForMany<Contracts.DeployPipeline, Contracts.DeployPipelineCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.DeployPipeline[]>;
+    /** Saves each given input as a new DeployPipeline. */
+    tryCreateMany(request: Array<Contracts.DeployPipeline>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployPipeline>>;
+    createMany(request: Array<Contracts.DeployPipeline>, options?: IThrowingRepoOptions): Promise<Contracts.DeployPipeline[]>;
+    /** Overwrites each existing DeployPipeline. */
+    tryUpdateMany(request: Array<Contracts.DeployPipeline>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployPipeline>>;
+    updateMany(request: Array<Contracts.DeployPipeline>, options?: IThrowingRepoOptions): Promise<Contracts.DeployPipeline[]>;
+    /** Deletes the existing DeployPipeline. */
+    tryDelete(request: IdSpecFor<Contracts.DeployPipeline>, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployPipeline>>;
+    delete(request: IdSpecFor<Contracts.DeployPipeline>, options?: IThrowingRepoOptions): Promise<Contracts.DeployPipeline>;
+    /** Retrieves the single, uniquely identified DeployPipeline. */
+    tryRead(request: IdSpecFor<Contracts.DeployPipeline>, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployPipeline>>;
+    read(request: IdSpecFor<Contracts.DeployPipeline>, options?: IThrowingRepoOptions): Promise<Contracts.DeployPipeline>;
+    /** Performs the given operations on the existing DeployPipeline. */
+    tryPatch(request: PatchSpecForOne<Contracts.DeployPipeline>, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployPipeline>>;
+    patch(request: PatchSpecForOne<Contracts.DeployPipeline>, options?: IThrowingRepoOptions): Promise<Contracts.DeployPipeline>;
+    /** Overwrites the existing DeployPipeline. */
+    tryUpdate(request: Contracts.DeployPipeline, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployPipeline>>;
+    update(request: Contracts.DeployPipeline, options?: IThrowingRepoOptions): Promise<Contracts.DeployPipeline>;
+    /** Overwrites the given properties of the existing DeployPipeline. */
+    tryUpdatePartial(request: Partial<Contracts.DeployPipeline>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.DeployPipeline>>>;
+    updatePartial(request: Partial<Contracts.DeployPipeline>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.DeployPipeline>>;
+    /** Saves the input as a new DeployPipeline. */
+    tryCreate(request: Contracts.DeployPipeline, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployPipeline>>;
+    create(request: Contracts.DeployPipeline, options?: IThrowingRepoOptions): Promise<Contracts.DeployPipeline>;
+    /** Overwrites the given properties for each existing DeployPipeline. */
+    tryUpdatePartialMany(request: Array<Contracts.DeployPipeline>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.DeployPipeline>>>;
+    updatePartialMany(request: Array<Contracts.DeployPipeline>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.DeployPipeline>[]>;
+    /** Performs the given operation on each existing DeployPipeline that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.DeployPipeline, Contracts.DeployPipelineCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployPipeline>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.DeployPipeline, Contracts.DeployPipelineCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.DeployPipeline, options?: IRepoOptions): Promise<SingleResult<Contracts.DeployPipeline>>;
+    upsert(request: Contracts.DeployPipeline, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.DeployPipeline>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeployPipeline>>;
+    upsertMany(request: Array<Contracts.DeployPipeline>, options?: IThrowingRepoOptions): Promise<Contracts.DeployPipeline[]>;
+}
+declare class DeploymentCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing Deployment that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.DeploymentCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Deployment>>;
+    deleteWhere(request: Contracts.DeploymentCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Deployment[]>;
+    /** Retrieves all the existing Deployment that satisfy the given criteria. */
+    tryReadMany(request: Contracts.DeploymentCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Deployment>>;
+    readMany(request: Contracts.DeploymentCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Deployment[]>;
+    /** Performs the given operations on each existing Deployment that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Deployment, Contracts.DeploymentCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Deployment>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Deployment, Contracts.DeploymentCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Deployment[]>;
+    /** Saves each given input as a new Deployment. */
+    tryCreateMany(request: Array<Contracts.Deployment>, options?: IRepoOptions): Promise<BatchResult<Contracts.Deployment>>;
+    createMany(request: Array<Contracts.Deployment>, options?: IThrowingRepoOptions): Promise<Contracts.Deployment[]>;
+    /** Overwrites each existing Deployment. */
+    tryUpdateMany(request: Array<Contracts.Deployment>, options?: IRepoOptions): Promise<BatchResult<Contracts.Deployment>>;
+    updateMany(request: Array<Contracts.Deployment>, options?: IThrowingRepoOptions): Promise<Contracts.Deployment[]>;
+    /** Deletes the existing Deployment. */
+    tryDelete(request: IdSpecFor<Contracts.Deployment>, options?: IRepoOptions): Promise<SingleResult<Contracts.Deployment>>;
+    delete(request: IdSpecFor<Contracts.Deployment>, options?: IThrowingRepoOptions): Promise<Contracts.Deployment>;
+    /** Retrieves the single, uniquely identified Deployment. */
+    tryRead(request: IdSpecFor<Contracts.Deployment>, options?: IRepoOptions): Promise<SingleResult<Contracts.Deployment>>;
+    read(request: IdSpecFor<Contracts.Deployment>, options?: IThrowingRepoOptions): Promise<Contracts.Deployment>;
+    /** Performs the given operations on the existing Deployment. */
+    tryPatch(request: PatchSpecForOne<Contracts.Deployment>, options?: IRepoOptions): Promise<SingleResult<Contracts.Deployment>>;
+    patch(request: PatchSpecForOne<Contracts.Deployment>, options?: IThrowingRepoOptions): Promise<Contracts.Deployment>;
+    /** Overwrites the existing Deployment. */
+    tryUpdate(request: Contracts.Deployment, options?: IRepoOptions): Promise<SingleResult<Contracts.Deployment>>;
+    update(request: Contracts.Deployment, options?: IThrowingRepoOptions): Promise<Contracts.Deployment>;
+    /** Overwrites the given properties of the existing Deployment. */
+    tryUpdatePartial(request: Partial<Contracts.Deployment>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Deployment>>>;
+    updatePartial(request: Partial<Contracts.Deployment>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Deployment>>;
+    /** Saves the input as a new Deployment. */
+    tryCreate(request: Contracts.Deployment, options?: IRepoOptions): Promise<SingleResult<Contracts.Deployment>>;
+    create(request: Contracts.Deployment, options?: IThrowingRepoOptions): Promise<Contracts.Deployment>;
+    /** Overwrites the given properties for each existing Deployment. */
+    tryUpdatePartialMany(request: Array<Contracts.Deployment>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Deployment>>>;
+    updatePartialMany(request: Array<Contracts.Deployment>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Deployment>[]>;
+    /** Performs the given operation on each existing Deployment that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Deployment, Contracts.DeploymentCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Deployment>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Deployment, Contracts.DeploymentCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.Deployment, options?: IRepoOptions): Promise<SingleResult<Contracts.Deployment>>;
+    upsert(request: Contracts.Deployment, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.Deployment>, options?: IRepoOptions): Promise<BatchResult<Contracts.Deployment>>;
+    upsertMany(request: Array<Contracts.Deployment>, options?: IThrowingRepoOptions): Promise<Contracts.Deployment[]>;
+}
+declare class DeploymentActivityCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing DeploymentActivity that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.DeploymentActivityCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.DeploymentActivity>>;
+    deleteWhere(request: Contracts.DeploymentActivityCriteria, options?: IThrowingRepoOptions): Promise<Contracts.DeploymentActivity[]>;
+    /** Retrieves all the existing DeploymentActivity that satisfy the given criteria. */
+    tryReadMany(request: Contracts.DeploymentActivityCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.DeploymentActivity>>;
+    readMany(request: Contracts.DeploymentActivityCriteria, options?: IThrowingRepoOptions): Promise<Contracts.DeploymentActivity[]>;
+    /** Performs the given operations on each existing DeploymentActivity that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.DeploymentActivity, Contracts.DeploymentActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeploymentActivity>>;
+    patchWhere(request: PatchSpecForMany<Contracts.DeploymentActivity, Contracts.DeploymentActivityCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.DeploymentActivity[]>;
+    /** Saves each given input as a new DeploymentActivity. */
+    tryCreateMany(request: Array<Contracts.DeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeploymentActivity>>;
+    createMany(request: Array<Contracts.DeploymentActivity>, options?: IThrowingRepoOptions): Promise<Contracts.DeploymentActivity[]>;
+    /** Overwrites each existing DeploymentActivity. */
+    tryUpdateMany(request: Array<Contracts.DeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeploymentActivity>>;
+    updateMany(request: Array<Contracts.DeploymentActivity>, options?: IThrowingRepoOptions): Promise<Contracts.DeploymentActivity[]>;
+    /** Deletes the existing DeploymentActivity. */
+    tryDelete(request: IdSpecFor<Contracts.DeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<Contracts.DeploymentActivity>>;
+    delete(request: IdSpecFor<Contracts.DeploymentActivity>, options?: IThrowingRepoOptions): Promise<Contracts.DeploymentActivity>;
+    /** Retrieves the single, uniquely identified DeploymentActivity. */
+    tryRead(request: IdSpecFor<Contracts.DeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<Contracts.DeploymentActivity>>;
+    read(request: IdSpecFor<Contracts.DeploymentActivity>, options?: IThrowingRepoOptions): Promise<Contracts.DeploymentActivity>;
+    /** Performs the given operations on the existing DeploymentActivity. */
+    tryPatch(request: PatchSpecForOne<Contracts.DeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<Contracts.DeploymentActivity>>;
+    patch(request: PatchSpecForOne<Contracts.DeploymentActivity>, options?: IThrowingRepoOptions): Promise<Contracts.DeploymentActivity>;
+    /** Overwrites the existing DeploymentActivity. */
+    tryUpdate(request: Contracts.DeploymentActivity, options?: IRepoOptions): Promise<SingleResult<Contracts.DeploymentActivity>>;
+    update(request: Contracts.DeploymentActivity, options?: IThrowingRepoOptions): Promise<Contracts.DeploymentActivity>;
+    /** Overwrites the given properties of the existing DeploymentActivity. */
+    tryUpdatePartial(request: Partial<Contracts.DeploymentActivity>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.DeploymentActivity>>>;
+    updatePartial(request: Partial<Contracts.DeploymentActivity>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.DeploymentActivity>>;
+    /** Saves the input as a new DeploymentActivity. */
+    tryCreate(request: Contracts.DeploymentActivity, options?: IRepoOptions): Promise<SingleResult<Contracts.DeploymentActivity>>;
+    create(request: Contracts.DeploymentActivity, options?: IThrowingRepoOptions): Promise<Contracts.DeploymentActivity>;
+    /** Overwrites the given properties for each existing DeploymentActivity. */
+    tryUpdatePartialMany(request: Array<Contracts.DeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.DeploymentActivity>>>;
+    updatePartialMany(request: Array<Contracts.DeploymentActivity>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.DeploymentActivity>[]>;
+    /** Performs the given operation on each existing DeploymentActivity that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.DeploymentActivity, Contracts.DeploymentActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeploymentActivity>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.DeploymentActivity, Contracts.DeploymentActivityCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.DeploymentActivity, options?: IRepoOptions): Promise<SingleResult<Contracts.DeploymentActivity>>;
+    upsert(request: Contracts.DeploymentActivity, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.DeploymentActivity>, options?: IRepoOptions): Promise<BatchResult<Contracts.DeploymentActivity>>;
+    upsertMany(request: Array<Contracts.DeploymentActivity>, options?: IThrowingRepoOptions): Promise<Contracts.DeploymentActivity[]>;
+}
+declare class EnterpriseCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing Enterprise that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.EnterpriseCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Enterprise>>;
+    deleteWhere(request: Contracts.EnterpriseCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Enterprise[]>;
+    /** Retrieves all the existing Enterprise that satisfy the given criteria. */
+    tryReadMany(request: Contracts.EnterpriseCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Enterprise>>;
+    readMany(request: Contracts.EnterpriseCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Enterprise[]>;
+    /** Performs the given operations on each existing Enterprise that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Enterprise, Contracts.EnterpriseCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Enterprise>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Enterprise, Contracts.EnterpriseCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Enterprise[]>;
+    /** Saves each given input as a new Enterprise. */
+    tryCreateMany(request: Array<Contracts.Enterprise>, options?: IRepoOptions): Promise<BatchResult<Contracts.Enterprise>>;
+    createMany(request: Array<Contracts.Enterprise>, options?: IThrowingRepoOptions): Promise<Contracts.Enterprise[]>;
+    /** Overwrites each existing Enterprise. */
+    tryUpdateMany(request: Array<Contracts.Enterprise>, options?: IRepoOptions): Promise<BatchResult<Contracts.Enterprise>>;
+    updateMany(request: Array<Contracts.Enterprise>, options?: IThrowingRepoOptions): Promise<Contracts.Enterprise[]>;
+    /** Deletes the existing Enterprise. */
+    tryDelete(request: IdSpecFor<Contracts.Enterprise>, options?: IRepoOptions): Promise<SingleResult<Contracts.Enterprise>>;
+    delete(request: IdSpecFor<Contracts.Enterprise>, options?: IThrowingRepoOptions): Promise<Contracts.Enterprise>;
+    /** Retrieves the single, uniquely identified Enterprise. */
+    tryRead(request: IdSpecFor<Contracts.Enterprise>, options?: IRepoOptions): Promise<SingleResult<Contracts.Enterprise>>;
+    read(request: IdSpecFor<Contracts.Enterprise>, options?: IThrowingRepoOptions): Promise<Contracts.Enterprise>;
+    /** Performs the given operations on the existing Enterprise. */
+    tryPatch(request: PatchSpecForOne<Contracts.Enterprise>, options?: IRepoOptions): Promise<SingleResult<Contracts.Enterprise>>;
+    patch(request: PatchSpecForOne<Contracts.Enterprise>, options?: IThrowingRepoOptions): Promise<Contracts.Enterprise>;
+    /** Overwrites the existing Enterprise. */
+    tryUpdate(request: Contracts.Enterprise, options?: IRepoOptions): Promise<SingleResult<Contracts.Enterprise>>;
+    update(request: Contracts.Enterprise, options?: IThrowingRepoOptions): Promise<Contracts.Enterprise>;
+    /** Overwrites the given properties of the existing Enterprise. */
+    tryUpdatePartial(request: Partial<Contracts.Enterprise>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Enterprise>>>;
+    updatePartial(request: Partial<Contracts.Enterprise>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Enterprise>>;
+    /** Saves the input as a new Enterprise. */
+    tryCreate(request: Contracts.Enterprise, options?: IRepoOptions): Promise<SingleResult<Contracts.Enterprise>>;
+    create(request: Contracts.Enterprise, options?: IThrowingRepoOptions): Promise<Contracts.Enterprise>;
+    /** Overwrites the given properties for each existing Enterprise. */
+    tryUpdatePartialMany(request: Array<Contracts.Enterprise>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Enterprise>>>;
+    updatePartialMany(request: Array<Contracts.Enterprise>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Enterprise>[]>;
+    /** Performs the given operation on each existing Enterprise that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Enterprise, Contracts.EnterpriseCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Enterprise>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Enterprise, Contracts.EnterpriseCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.Enterprise, options?: IRepoOptions): Promise<SingleResult<Contracts.Enterprise>>;
+    upsert(request: Contracts.Enterprise, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.Enterprise>, options?: IRepoOptions): Promise<BatchResult<Contracts.Enterprise>>;
+    upsertMany(request: Array<Contracts.Enterprise>, options?: IThrowingRepoOptions): Promise<Contracts.Enterprise[]>;
+}
+declare class EnterpriseRunStateCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing EnterpriseRunState that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.EnterpriseRunStateCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseRunState>>;
+    deleteWhere(request: Contracts.EnterpriseRunStateCriteria, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState[]>;
+    /** Retrieves all the existing EnterpriseRunState that satisfy the given criteria. */
+    tryReadMany(request: Contracts.EnterpriseRunStateCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.EnterpriseRunState>>;
+    readMany(request: Contracts.EnterpriseRunStateCriteria, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState[]>;
+    /** Performs the given operations on each existing EnterpriseRunState that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.EnterpriseRunState, Contracts.EnterpriseRunStateCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseRunState>>;
+    patchWhere(request: PatchSpecForMany<Contracts.EnterpriseRunState, Contracts.EnterpriseRunStateCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState[]>;
+    /** Saves each given input as a new EnterpriseRunState. */
+    tryCreateMany(request: Array<Contracts.EnterpriseRunState>, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseRunState>>;
+    createMany(request: Array<Contracts.EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState[]>;
+    /** Overwrites each existing EnterpriseRunState. */
+    tryUpdateMany(request: Array<Contracts.EnterpriseRunState>, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseRunState>>;
+    updateMany(request: Array<Contracts.EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState[]>;
+    /** Deletes the existing EnterpriseRunState. */
+    tryDelete(request: IdSpecFor<Contracts.EnterpriseRunState>, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseRunState>>;
+    delete(request: IdSpecFor<Contracts.EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState>;
+    /** Retrieves the single, uniquely identified EnterpriseRunState. */
+    tryRead(request: IdSpecFor<Contracts.EnterpriseRunState>, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseRunState>>;
+    read(request: IdSpecFor<Contracts.EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState>;
+    /** Performs the given operations on the existing EnterpriseRunState. */
+    tryPatch(request: PatchSpecForOne<Contracts.EnterpriseRunState>, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseRunState>>;
+    patch(request: PatchSpecForOne<Contracts.EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState>;
+    /** Overwrites the existing EnterpriseRunState. */
+    tryUpdate(request: Contracts.EnterpriseRunState, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseRunState>>;
+    update(request: Contracts.EnterpriseRunState, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState>;
+    /** Overwrites the given properties of the existing EnterpriseRunState. */
+    tryUpdatePartial(request: Partial<Contracts.EnterpriseRunState>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.EnterpriseRunState>>>;
+    updatePartial(request: Partial<Contracts.EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.EnterpriseRunState>>;
+    /** Saves the input as a new EnterpriseRunState. */
+    tryCreate(request: Contracts.EnterpriseRunState, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseRunState>>;
+    create(request: Contracts.EnterpriseRunState, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState>;
+    /** Overwrites the given properties for each existing EnterpriseRunState. */
+    tryUpdatePartialMany(request: Array<Contracts.EnterpriseRunState>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.EnterpriseRunState>>>;
+    updatePartialMany(request: Array<Contracts.EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.EnterpriseRunState>[]>;
+    /** Performs the given operation on each existing EnterpriseRunState that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.EnterpriseRunState, Contracts.EnterpriseRunStateCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseRunState>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.EnterpriseRunState, Contracts.EnterpriseRunStateCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.EnterpriseRunState, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseRunState>>;
+    upsert(request: Contracts.EnterpriseRunState, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.EnterpriseRunState>, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseRunState>>;
+    upsertMany(request: Array<Contracts.EnterpriseRunState>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseRunState[]>;
+}
+declare class EnterpriseVersionConfigCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing EnterpriseVersionConfig that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.EnterpriseVersionConfigCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseVersionConfig>>;
+    deleteWhere(request: Contracts.EnterpriseVersionConfigCriteria, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseVersionConfig[]>;
+    /** Retrieves all the existing EnterpriseVersionConfig that satisfy the given criteria. */
+    tryReadMany(request: Contracts.EnterpriseVersionConfigCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.EnterpriseVersionConfig>>;
+    readMany(request: Contracts.EnterpriseVersionConfigCriteria, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseVersionConfig[]>;
+    /** Performs the given operations on each existing EnterpriseVersionConfig that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.EnterpriseVersionConfig, Contracts.EnterpriseVersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseVersionConfig>>;
+    patchWhere(request: PatchSpecForMany<Contracts.EnterpriseVersionConfig, Contracts.EnterpriseVersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseVersionConfig[]>;
+    /** Saves each given input as a new EnterpriseVersionConfig. */
+    tryCreateMany(request: Array<Contracts.EnterpriseVersionConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseVersionConfig>>;
+    createMany(request: Array<Contracts.EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseVersionConfig[]>;
+    /** Overwrites each existing EnterpriseVersionConfig. */
+    tryUpdateMany(request: Array<Contracts.EnterpriseVersionConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseVersionConfig>>;
+    updateMany(request: Array<Contracts.EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseVersionConfig[]>;
+    /** Deletes the existing EnterpriseVersionConfig. */
+    tryDelete(request: IdSpecFor<Contracts.EnterpriseVersionConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseVersionConfig>>;
+    delete(request: IdSpecFor<Contracts.EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseVersionConfig>;
+    /** Retrieves the single, uniquely identified EnterpriseVersionConfig. */
+    tryRead(request: IdSpecFor<Contracts.EnterpriseVersionConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseVersionConfig>>;
+    read(request: IdSpecFor<Contracts.EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseVersionConfig>;
+    /** Performs the given operations on the existing EnterpriseVersionConfig. */
+    tryPatch(request: PatchSpecForOne<Contracts.EnterpriseVersionConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseVersionConfig>>;
+    patch(request: PatchSpecForOne<Contracts.EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseVersionConfig>;
+    /** Overwrites the existing EnterpriseVersionConfig. */
+    tryUpdate(request: Contracts.EnterpriseVersionConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseVersionConfig>>;
+    update(request: Contracts.EnterpriseVersionConfig, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseVersionConfig>;
+    /** Overwrites the given properties of the existing EnterpriseVersionConfig. */
+    tryUpdatePartial(request: Partial<Contracts.EnterpriseVersionConfig>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.EnterpriseVersionConfig>>>;
+    updatePartial(request: Partial<Contracts.EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.EnterpriseVersionConfig>>;
+    /** Saves the input as a new EnterpriseVersionConfig. */
+    tryCreate(request: Contracts.EnterpriseVersionConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseVersionConfig>>;
+    create(request: Contracts.EnterpriseVersionConfig, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseVersionConfig>;
+    /** Overwrites the given properties for each existing EnterpriseVersionConfig. */
+    tryUpdatePartialMany(request: Array<Contracts.EnterpriseVersionConfig>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.EnterpriseVersionConfig>>>;
+    updatePartialMany(request: Array<Contracts.EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.EnterpriseVersionConfig>[]>;
+    /** Performs the given operation on each existing EnterpriseVersionConfig that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.EnterpriseVersionConfig, Contracts.EnterpriseVersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseVersionConfig>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.EnterpriseVersionConfig, Contracts.EnterpriseVersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.EnterpriseVersionConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseVersionConfig>>;
+    upsert(request: Contracts.EnterpriseVersionConfig, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.EnterpriseVersionConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.EnterpriseVersionConfig>>;
+    upsertMany(request: Array<Contracts.EnterpriseVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.EnterpriseVersionConfig[]>;
+}
+declare class EntityAclCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing EntityAcl that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.EntityAclCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    deleteWhere(request: Contracts.EntityAclCriteria, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl[]>;
+    /** Retrieves all the existing EntityAcl that satisfy the given criteria. */
+    tryReadMany(request: Contracts.EntityAclCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.EntityAcl>>;
+    readMany(request: Contracts.EntityAclCriteria, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl[]>;
+    /** Performs the given operations on each existing EntityAcl that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.EntityAcl, Contracts.EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    patchWhere(request: PatchSpecForMany<Contracts.EntityAcl, Contracts.EntityAclCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl[]>;
+    /** Saves each given input as a new EntityAcl. */
+    tryCreateMany(request: Array<Contracts.EntityAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    createMany(request: Array<Contracts.EntityAcl>, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl[]>;
+    /** Overwrites each existing EntityAcl. */
+    tryUpdateMany(request: Array<Contracts.EntityAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    updateMany(request: Array<Contracts.EntityAcl>, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl[]>;
+    /** Deletes the existing EntityAcl. */
+    tryDelete(request: IdSpecFor<Contracts.EntityAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    delete(request: IdSpecFor<Contracts.EntityAcl>, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl>;
+    /** Retrieves the single, uniquely identified EntityAcl. */
+    tryRead(request: IdSpecFor<Contracts.EntityAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    read(request: IdSpecFor<Contracts.EntityAcl>, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl>;
+    /** Performs the given operations on the existing EntityAcl. */
+    tryPatch(request: PatchSpecForOne<Contracts.EntityAcl>, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    patch(request: PatchSpecForOne<Contracts.EntityAcl>, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl>;
+    /** Overwrites the existing EntityAcl. */
+    tryUpdate(request: Contracts.EntityAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    update(request: Contracts.EntityAcl, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl>;
+    /** Overwrites the given properties of the existing EntityAcl. */
+    tryUpdatePartial(request: Partial<Contracts.EntityAcl>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.EntityAcl>>>;
+    updatePartial(request: Partial<Contracts.EntityAcl>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.EntityAcl>>;
+    /** Saves the input as a new EntityAcl. */
+    tryCreate(request: Contracts.EntityAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    create(request: Contracts.EntityAcl, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl>;
+    /** Overwrites the given properties for each existing EntityAcl. */
+    tryUpdatePartialMany(request: Array<Contracts.EntityAcl>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.EntityAcl>>>;
+    updatePartialMany(request: Array<Contracts.EntityAcl>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.EntityAcl>[]>;
+    /** Performs the given operation on each existing EntityAcl that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.EntityAcl, Contracts.EntityAclCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.EntityAcl, Contracts.EntityAclCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.EntityAcl, options?: IRepoOptions): Promise<SingleResult<Contracts.EntityAcl>>;
+    upsert(request: Contracts.EntityAcl, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.EntityAcl>, options?: IRepoOptions): Promise<BatchResult<Contracts.EntityAcl>>;
+    upsertMany(request: Array<Contracts.EntityAcl>, options?: IThrowingRepoOptions): Promise<Contracts.EntityAcl[]>;
+}
+declare class EnvironmentCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing Environment that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.EnvironmentCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Environment>>;
+    deleteWhere(request: Contracts.EnvironmentCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Environment[]>;
+    /** Retrieves all the existing Environment that satisfy the given criteria. */
+    tryReadMany(request: Contracts.EnvironmentCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Environment>>;
+    readMany(request: Contracts.EnvironmentCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Environment[]>;
+    /** Performs the given operations on each existing Environment that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Environment, Contracts.EnvironmentCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Environment>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Environment, Contracts.EnvironmentCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Environment[]>;
+    /** Saves each given input as a new Environment. */
+    tryCreateMany(request: Array<Contracts.Environment>, options?: IRepoOptions): Promise<BatchResult<Contracts.Environment>>;
+    createMany(request: Array<Contracts.Environment>, options?: IThrowingRepoOptions): Promise<Contracts.Environment[]>;
+    /** Overwrites each existing Environment. */
+    tryUpdateMany(request: Array<Contracts.Environment>, options?: IRepoOptions): Promise<BatchResult<Contracts.Environment>>;
+    updateMany(request: Array<Contracts.Environment>, options?: IThrowingRepoOptions): Promise<Contracts.Environment[]>;
+    /** Deletes the existing Environment. */
+    tryDelete(request: IdSpecFor<Contracts.Environment>, options?: IRepoOptions): Promise<SingleResult<Contracts.Environment>>;
+    delete(request: IdSpecFor<Contracts.Environment>, options?: IThrowingRepoOptions): Promise<Contracts.Environment>;
+    /** Retrieves the single, uniquely identified Environment. */
+    tryRead(request: IdSpecFor<Contracts.Environment>, options?: IRepoOptions): Promise<SingleResult<Contracts.Environment>>;
+    read(request: IdSpecFor<Contracts.Environment>, options?: IThrowingRepoOptions): Promise<Contracts.Environment>;
+    /** Performs the given operations on the existing Environment. */
+    tryPatch(request: PatchSpecForOne<Contracts.Environment>, options?: IRepoOptions): Promise<SingleResult<Contracts.Environment>>;
+    patch(request: PatchSpecForOne<Contracts.Environment>, options?: IThrowingRepoOptions): Promise<Contracts.Environment>;
+    /** Overwrites the existing Environment. */
+    tryUpdate(request: Contracts.Environment, options?: IRepoOptions): Promise<SingleResult<Contracts.Environment>>;
+    update(request: Contracts.Environment, options?: IThrowingRepoOptions): Promise<Contracts.Environment>;
+    /** Overwrites the given properties of the existing Environment. */
+    tryUpdatePartial(request: Partial<Contracts.Environment>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Environment>>>;
+    updatePartial(request: Partial<Contracts.Environment>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Environment>>;
+    /** Saves the input as a new Environment. */
+    tryCreate(request: Contracts.Environment, options?: IRepoOptions): Promise<SingleResult<Contracts.Environment>>;
+    create(request: Contracts.Environment, options?: IThrowingRepoOptions): Promise<Contracts.Environment>;
+    /** Overwrites the given properties for each existing Environment. */
+    tryUpdatePartialMany(request: Array<Contracts.Environment>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Environment>>>;
+    updatePartialMany(request: Array<Contracts.Environment>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Environment>[]>;
+    /** Performs the given operation on each existing Environment that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Environment, Contracts.EnvironmentCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Environment>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Environment, Contracts.EnvironmentCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.Environment, options?: IRepoOptions): Promise<SingleResult<Contracts.Environment>>;
+    upsert(request: Contracts.Environment, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.Environment>, options?: IRepoOptions): Promise<BatchResult<Contracts.Environment>>;
+    upsertMany(request: Array<Contracts.Environment>, options?: IThrowingRepoOptions): Promise<Contracts.Environment[]>;
+}
+declare class FileStoreDefCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing FileStoreDef that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.FileStoreDefCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.FileStoreDef>>;
+    deleteWhere(request: Contracts.FileStoreDefCriteria, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef[]>;
+    /** Retrieves all the existing FileStoreDef that satisfy the given criteria. */
+    tryReadMany(request: Contracts.FileStoreDefCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.FileStoreDef>>;
+    readMany(request: Contracts.FileStoreDefCriteria, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef[]>;
+    /** Performs the given operations on each existing FileStoreDef that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.FileStoreDef, Contracts.FileStoreDefCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.FileStoreDef>>;
+    patchWhere(request: PatchSpecForMany<Contracts.FileStoreDef, Contracts.FileStoreDefCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef[]>;
+    /** Saves each given input as a new FileStoreDef. */
+    tryCreateMany(request: Array<Contracts.FileStoreDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.FileStoreDef>>;
+    createMany(request: Array<Contracts.FileStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef[]>;
+    /** Overwrites each existing FileStoreDef. */
+    tryUpdateMany(request: Array<Contracts.FileStoreDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.FileStoreDef>>;
+    updateMany(request: Array<Contracts.FileStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef[]>;
+    /** Deletes the existing FileStoreDef. */
+    tryDelete(request: IdSpecFor<Contracts.FileStoreDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.FileStoreDef>>;
+    delete(request: IdSpecFor<Contracts.FileStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef>;
+    /** Retrieves the single, uniquely identified FileStoreDef. */
+    tryRead(request: IdSpecFor<Contracts.FileStoreDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.FileStoreDef>>;
+    read(request: IdSpecFor<Contracts.FileStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef>;
+    /** Performs the given operations on the existing FileStoreDef. */
+    tryPatch(request: PatchSpecForOne<Contracts.FileStoreDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.FileStoreDef>>;
+    patch(request: PatchSpecForOne<Contracts.FileStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef>;
+    /** Overwrites the existing FileStoreDef. */
+    tryUpdate(request: Contracts.FileStoreDef, options?: IRepoOptions): Promise<SingleResult<Contracts.FileStoreDef>>;
+    update(request: Contracts.FileStoreDef, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef>;
+    /** Overwrites the given properties of the existing FileStoreDef. */
+    tryUpdatePartial(request: Partial<Contracts.FileStoreDef>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.FileStoreDef>>>;
+    updatePartial(request: Partial<Contracts.FileStoreDef>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.FileStoreDef>>;
+    /** Saves the input as a new FileStoreDef. */
+    tryCreate(request: Contracts.FileStoreDef, options?: IRepoOptions): Promise<SingleResult<Contracts.FileStoreDef>>;
+    create(request: Contracts.FileStoreDef, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef>;
+    /** Overwrites the given properties for each existing FileStoreDef. */
+    tryUpdatePartialMany(request: Array<Contracts.FileStoreDef>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.FileStoreDef>>>;
+    updatePartialMany(request: Array<Contracts.FileStoreDef>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.FileStoreDef>[]>;
+    /** Performs the given operation on each existing FileStoreDef that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.FileStoreDef, Contracts.FileStoreDefCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.FileStoreDef>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.FileStoreDef, Contracts.FileStoreDefCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.FileStoreDef, options?: IRepoOptions): Promise<SingleResult<Contracts.FileStoreDef>>;
+    upsert(request: Contracts.FileStoreDef, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.FileStoreDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.FileStoreDef>>;
+    upsertMany(request: Array<Contracts.FileStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.FileStoreDef[]>;
+}
+declare class ImageCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing Image that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ImageCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Image>>;
+    deleteWhere(request: Contracts.ImageCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Image[]>;
+    /** Retrieves all the existing Image that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ImageCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Image>>;
+    readMany(request: Contracts.ImageCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Image[]>;
+    /** Performs the given operations on each existing Image that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Image, Contracts.ImageCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Image>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Image, Contracts.ImageCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Image[]>;
+    /** Saves each given input as a new Image. */
+    tryCreateMany(request: Array<Contracts.Image>, options?: IRepoOptions): Promise<BatchResult<Contracts.Image>>;
+    createMany(request: Array<Contracts.Image>, options?: IThrowingRepoOptions): Promise<Contracts.Image[]>;
+    /** Overwrites each existing Image. */
+    tryUpdateMany(request: Array<Contracts.Image>, options?: IRepoOptions): Promise<BatchResult<Contracts.Image>>;
+    updateMany(request: Array<Contracts.Image>, options?: IThrowingRepoOptions): Promise<Contracts.Image[]>;
+    /** Deletes the existing Image. */
+    tryDelete(request: IdSpecFor<Contracts.Image>, options?: IRepoOptions): Promise<SingleResult<Contracts.Image>>;
+    delete(request: IdSpecFor<Contracts.Image>, options?: IThrowingRepoOptions): Promise<Contracts.Image>;
+    /** Retrieves the single, uniquely identified Image. */
+    tryRead(request: IdSpecFor<Contracts.Image>, options?: IRepoOptions): Promise<SingleResult<Contracts.Image>>;
+    read(request: IdSpecFor<Contracts.Image>, options?: IThrowingRepoOptions): Promise<Contracts.Image>;
+    /** Performs the given operations on the existing Image. */
+    tryPatch(request: PatchSpecForOne<Contracts.Image>, options?: IRepoOptions): Promise<SingleResult<Contracts.Image>>;
+    patch(request: PatchSpecForOne<Contracts.Image>, options?: IThrowingRepoOptions): Promise<Contracts.Image>;
+    /** Overwrites the existing Image. */
+    tryUpdate(request: Contracts.Image, options?: IRepoOptions): Promise<SingleResult<Contracts.Image>>;
+    update(request: Contracts.Image, options?: IThrowingRepoOptions): Promise<Contracts.Image>;
+    /** Overwrites the given properties of the existing Image. */
+    tryUpdatePartial(request: Partial<Contracts.Image>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Image>>>;
+    updatePartial(request: Partial<Contracts.Image>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Image>>;
+    /** Saves the input as a new Image. */
+    tryCreate(request: Contracts.Image, options?: IRepoOptions): Promise<SingleResult<Contracts.Image>>;
+    create(request: Contracts.Image, options?: IThrowingRepoOptions): Promise<Contracts.Image>;
+    /** Overwrites the given properties for each existing Image. */
+    tryUpdatePartialMany(request: Array<Contracts.Image>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Image>>>;
+    updatePartialMany(request: Array<Contracts.Image>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Image>[]>;
+    /** Performs the given operation on each existing Image that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Image, Contracts.ImageCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Image>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Image, Contracts.ImageCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.Image, options?: IRepoOptions): Promise<SingleResult<Contracts.Image>>;
+    upsert(request: Contracts.Image, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.Image>, options?: IRepoOptions): Promise<BatchResult<Contracts.Image>>;
+    upsertMany(request: Array<Contracts.Image>, options?: IThrowingRepoOptions): Promise<Contracts.Image[]>;
+}
+declare class ImageRegistryCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing ImageRegistry that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ImageRegistryCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.ImageRegistry>>;
+    deleteWhere(request: Contracts.ImageRegistryCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ImageRegistry[]>;
+    /** Retrieves all the existing ImageRegistry that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ImageRegistryCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ImageRegistry>>;
+    readMany(request: Contracts.ImageRegistryCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ImageRegistry[]>;
+    /** Performs the given operations on each existing ImageRegistry that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.ImageRegistry, Contracts.ImageRegistryCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ImageRegistry>>;
+    patchWhere(request: PatchSpecForMany<Contracts.ImageRegistry, Contracts.ImageRegistryCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ImageRegistry[]>;
+    /** Saves each given input as a new ImageRegistry. */
+    tryCreateMany(request: Array<Contracts.ImageRegistry>, options?: IRepoOptions): Promise<BatchResult<Contracts.ImageRegistry>>;
+    createMany(request: Array<Contracts.ImageRegistry>, options?: IThrowingRepoOptions): Promise<Contracts.ImageRegistry[]>;
+    /** Overwrites each existing ImageRegistry. */
+    tryUpdateMany(request: Array<Contracts.ImageRegistry>, options?: IRepoOptions): Promise<BatchResult<Contracts.ImageRegistry>>;
+    updateMany(request: Array<Contracts.ImageRegistry>, options?: IThrowingRepoOptions): Promise<Contracts.ImageRegistry[]>;
+    /** Deletes the existing ImageRegistry. */
+    tryDelete(request: IdSpecFor<Contracts.ImageRegistry>, options?: IRepoOptions): Promise<SingleResult<Contracts.ImageRegistry>>;
+    delete(request: IdSpecFor<Contracts.ImageRegistry>, options?: IThrowingRepoOptions): Promise<Contracts.ImageRegistry>;
+    /** Retrieves the single, uniquely identified ImageRegistry. */
+    tryRead(request: IdSpecFor<Contracts.ImageRegistry>, options?: IRepoOptions): Promise<SingleResult<Contracts.ImageRegistry>>;
+    read(request: IdSpecFor<Contracts.ImageRegistry>, options?: IThrowingRepoOptions): Promise<Contracts.ImageRegistry>;
+    /** Performs the given operations on the existing ImageRegistry. */
+    tryPatch(request: PatchSpecForOne<Contracts.ImageRegistry>, options?: IRepoOptions): Promise<SingleResult<Contracts.ImageRegistry>>;
+    patch(request: PatchSpecForOne<Contracts.ImageRegistry>, options?: IThrowingRepoOptions): Promise<Contracts.ImageRegistry>;
+    /** Overwrites the existing ImageRegistry. */
+    tryUpdate(request: Contracts.ImageRegistry, options?: IRepoOptions): Promise<SingleResult<Contracts.ImageRegistry>>;
+    update(request: Contracts.ImageRegistry, options?: IThrowingRepoOptions): Promise<Contracts.ImageRegistry>;
+    /** Overwrites the given properties of the existing ImageRegistry. */
+    tryUpdatePartial(request: Partial<Contracts.ImageRegistry>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.ImageRegistry>>>;
+    updatePartial(request: Partial<Contracts.ImageRegistry>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ImageRegistry>>;
+    /** Saves the input as a new ImageRegistry. */
+    tryCreate(request: Contracts.ImageRegistry, options?: IRepoOptions): Promise<SingleResult<Contracts.ImageRegistry>>;
+    create(request: Contracts.ImageRegistry, options?: IThrowingRepoOptions): Promise<Contracts.ImageRegistry>;
+    /** Overwrites the given properties for each existing ImageRegistry. */
+    tryUpdatePartialMany(request: Array<Contracts.ImageRegistry>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.ImageRegistry>>>;
+    updatePartialMany(request: Array<Contracts.ImageRegistry>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ImageRegistry>[]>;
+    /** Performs the given operation on each existing ImageRegistry that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ImageRegistry, Contracts.ImageRegistryCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ImageRegistry>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ImageRegistry, Contracts.ImageRegistryCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.ImageRegistry, options?: IRepoOptions): Promise<SingleResult<Contracts.ImageRegistry>>;
+    upsert(request: Contracts.ImageRegistry, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.ImageRegistry>, options?: IRepoOptions): Promise<BatchResult<Contracts.ImageRegistry>>;
+    upsertMany(request: Array<Contracts.ImageRegistry>, options?: IThrowingRepoOptions): Promise<Contracts.ImageRegistry[]>;
+}
+declare class KitCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing Kit that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.KitCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Kit>>;
+    deleteWhere(request: Contracts.KitCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Kit[]>;
+    /** Retrieves all the existing Kit that satisfy the given criteria. */
+    tryReadMany(request: Contracts.KitCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Kit>>;
+    readMany(request: Contracts.KitCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Kit[]>;
+    /** Performs the given operations on each existing Kit that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Kit, Contracts.KitCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Kit>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Kit, Contracts.KitCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Kit[]>;
+    /** Saves each given input as a new Kit. */
+    tryCreateMany(request: Array<Contracts.Kit>, options?: IRepoOptions): Promise<BatchResult<Contracts.Kit>>;
+    createMany(request: Array<Contracts.Kit>, options?: IThrowingRepoOptions): Promise<Contracts.Kit[]>;
+    /** Overwrites each existing Kit. */
+    tryUpdateMany(request: Array<Contracts.Kit>, options?: IRepoOptions): Promise<BatchResult<Contracts.Kit>>;
+    updateMany(request: Array<Contracts.Kit>, options?: IThrowingRepoOptions): Promise<Contracts.Kit[]>;
+    /** Deletes the existing Kit. */
+    tryDelete(request: IdSpecFor<Contracts.Kit>, options?: IRepoOptions): Promise<SingleResult<Contracts.Kit>>;
+    delete(request: IdSpecFor<Contracts.Kit>, options?: IThrowingRepoOptions): Promise<Contracts.Kit>;
+    /** Retrieves the single, uniquely identified Kit. */
+    tryRead(request: IdSpecFor<Contracts.Kit>, options?: IRepoOptions): Promise<SingleResult<Contracts.Kit>>;
+    read(request: IdSpecFor<Contracts.Kit>, options?: IThrowingRepoOptions): Promise<Contracts.Kit>;
+    /** Performs the given operations on the existing Kit. */
+    tryPatch(request: PatchSpecForOne<Contracts.Kit>, options?: IRepoOptions): Promise<SingleResult<Contracts.Kit>>;
+    patch(request: PatchSpecForOne<Contracts.Kit>, options?: IThrowingRepoOptions): Promise<Contracts.Kit>;
+    /** Overwrites the existing Kit. */
+    tryUpdate(request: Contracts.Kit, options?: IRepoOptions): Promise<SingleResult<Contracts.Kit>>;
+    update(request: Contracts.Kit, options?: IThrowingRepoOptions): Promise<Contracts.Kit>;
+    /** Overwrites the given properties of the existing Kit. */
+    tryUpdatePartial(request: Partial<Contracts.Kit>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Kit>>>;
+    updatePartial(request: Partial<Contracts.Kit>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Kit>>;
+    /** Saves the input as a new Kit. */
+    tryCreate(request: Contracts.Kit, options?: IRepoOptions): Promise<SingleResult<Contracts.Kit>>;
+    create(request: Contracts.Kit, options?: IThrowingRepoOptions): Promise<Contracts.Kit>;
+    /** Overwrites the given properties for each existing Kit. */
+    tryUpdatePartialMany(request: Array<Contracts.Kit>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Kit>>>;
+    updatePartialMany(request: Array<Contracts.Kit>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Kit>[]>;
+    /** Performs the given operation on each existing Kit that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Kit, Contracts.KitCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Kit>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Kit, Contracts.KitCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.Kit, options?: IRepoOptions): Promise<SingleResult<Contracts.Kit>>;
+    upsert(request: Contracts.Kit, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.Kit>, options?: IRepoOptions): Promise<BatchResult<Contracts.Kit>>;
+    upsertMany(request: Array<Contracts.Kit>, options?: IThrowingRepoOptions): Promise<Contracts.Kit[]>;
+}
+declare class KvpStoreDefCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing KvpStoreDef that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.KvpStoreDefCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.KvpStoreDef>>;
+    deleteWhere(request: Contracts.KvpStoreDefCriteria, options?: IThrowingRepoOptions): Promise<Contracts.KvpStoreDef[]>;
+    /** Retrieves all the existing KvpStoreDef that satisfy the given criteria. */
+    tryReadMany(request: Contracts.KvpStoreDefCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.KvpStoreDef>>;
+    readMany(request: Contracts.KvpStoreDefCriteria, options?: IThrowingRepoOptions): Promise<Contracts.KvpStoreDef[]>;
+    /** Performs the given operations on each existing KvpStoreDef that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.KvpStoreDef, Contracts.KvpStoreDefCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.KvpStoreDef>>;
+    patchWhere(request: PatchSpecForMany<Contracts.KvpStoreDef, Contracts.KvpStoreDefCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.KvpStoreDef[]>;
+    /** Saves each given input as a new KvpStoreDef. */
+    tryCreateMany(request: Array<Contracts.KvpStoreDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.KvpStoreDef>>;
+    createMany(request: Array<Contracts.KvpStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.KvpStoreDef[]>;
+    /** Overwrites each existing KvpStoreDef. */
+    tryUpdateMany(request: Array<Contracts.KvpStoreDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.KvpStoreDef>>;
+    updateMany(request: Array<Contracts.KvpStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.KvpStoreDef[]>;
+    /** Deletes the existing KvpStoreDef. */
+    tryDelete(request: IdSpecFor<Contracts.KvpStoreDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.KvpStoreDef>>;
+    delete(request: IdSpecFor<Contracts.KvpStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.KvpStoreDef>;
+    /** Retrieves the single, uniquely identified KvpStoreDef. */
+    tryRead(request: IdSpecFor<Contracts.KvpStoreDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.KvpStoreDef>>;
+    read(request: IdSpecFor<Contracts.KvpStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.KvpStoreDef>;
+    /** Performs the given operations on the existing KvpStoreDef. */
+    tryPatch(request: PatchSpecForOne<Contracts.KvpStoreDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.KvpStoreDef>>;
+    patch(request: PatchSpecForOne<Contracts.KvpStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.KvpStoreDef>;
+    /** Overwrites the existing KvpStoreDef. */
+    tryUpdate(request: Contracts.KvpStoreDef, options?: IRepoOptions): Promise<SingleResult<Contracts.KvpStoreDef>>;
+    update(request: Contracts.KvpStoreDef, options?: IThrowingRepoOptions): Promise<Contracts.KvpStoreDef>;
+    /** Overwrites the given properties of the existing KvpStoreDef. */
+    tryUpdatePartial(request: Partial<Contracts.KvpStoreDef>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.KvpStoreDef>>>;
+    updatePartial(request: Partial<Contracts.KvpStoreDef>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.KvpStoreDef>>;
+    /** Saves the input as a new KvpStoreDef. */
+    tryCreate(request: Contracts.KvpStoreDef, options?: IRepoOptions): Promise<SingleResult<Contracts.KvpStoreDef>>;
+    create(request: Contracts.KvpStoreDef, options?: IThrowingRepoOptions): Promise<Contracts.KvpStoreDef>;
+    /** Overwrites the given properties for each existing KvpStoreDef. */
+    tryUpdatePartialMany(request: Array<Contracts.KvpStoreDef>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.KvpStoreDef>>>;
+    updatePartialMany(request: Array<Contracts.KvpStoreDef>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.KvpStoreDef>[]>;
+    /** Performs the given operation on each existing KvpStoreDef that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.KvpStoreDef, Contracts.KvpStoreDefCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.KvpStoreDef>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.KvpStoreDef, Contracts.KvpStoreDefCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.KvpStoreDef, options?: IRepoOptions): Promise<SingleResult<Contracts.KvpStoreDef>>;
+    upsert(request: Contracts.KvpStoreDef, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.KvpStoreDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.KvpStoreDef>>;
+    upsertMany(request: Array<Contracts.KvpStoreDef>, options?: IThrowingRepoOptions): Promise<Contracts.KvpStoreDef[]>;
+}
+declare class LabelCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing Label that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.LabelCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Label>>;
+    deleteWhere(request: Contracts.LabelCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Label[]>;
+    /** Retrieves all the existing Label that satisfy the given criteria. */
+    tryReadMany(request: Contracts.LabelCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Label>>;
+    readMany(request: Contracts.LabelCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Label[]>;
+    /** Performs the given operations on each existing Label that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Label, Contracts.LabelCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Label>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Label, Contracts.LabelCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Label[]>;
+    /** Saves each given input as a new Label. */
+    tryCreateMany(request: Array<Contracts.Label>, options?: IRepoOptions): Promise<BatchResult<Contracts.Label>>;
+    createMany(request: Array<Contracts.Label>, options?: IThrowingRepoOptions): Promise<Contracts.Label[]>;
+    /** Overwrites each existing Label. */
+    tryUpdateMany(request: Array<Contracts.Label>, options?: IRepoOptions): Promise<BatchResult<Contracts.Label>>;
+    updateMany(request: Array<Contracts.Label>, options?: IThrowingRepoOptions): Promise<Contracts.Label[]>;
+    /** Deletes the existing Label. */
+    tryDelete(request: IdSpecFor<Contracts.Label>, options?: IRepoOptions): Promise<SingleResult<Contracts.Label>>;
+    delete(request: IdSpecFor<Contracts.Label>, options?: IThrowingRepoOptions): Promise<Contracts.Label>;
+    /** Retrieves the single, uniquely identified Label. */
+    tryRead(request: IdSpecFor<Contracts.Label>, options?: IRepoOptions): Promise<SingleResult<Contracts.Label>>;
+    read(request: IdSpecFor<Contracts.Label>, options?: IThrowingRepoOptions): Promise<Contracts.Label>;
+    /** Performs the given operations on the existing Label. */
+    tryPatch(request: PatchSpecForOne<Contracts.Label>, options?: IRepoOptions): Promise<SingleResult<Contracts.Label>>;
+    patch(request: PatchSpecForOne<Contracts.Label>, options?: IThrowingRepoOptions): Promise<Contracts.Label>;
+    /** Overwrites the existing Label. */
+    tryUpdate(request: Contracts.Label, options?: IRepoOptions): Promise<SingleResult<Contracts.Label>>;
+    update(request: Contracts.Label, options?: IThrowingRepoOptions): Promise<Contracts.Label>;
+    /** Overwrites the given properties of the existing Label. */
+    tryUpdatePartial(request: Partial<Contracts.Label>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Label>>>;
+    updatePartial(request: Partial<Contracts.Label>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Label>>;
+    /** Saves the input as a new Label. */
+    tryCreate(request: Contracts.Label, options?: IRepoOptions): Promise<SingleResult<Contracts.Label>>;
+    create(request: Contracts.Label, options?: IThrowingRepoOptions): Promise<Contracts.Label>;
+    /** Overwrites the given properties for each existing Label. */
+    tryUpdatePartialMany(request: Array<Contracts.Label>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Label>>>;
+    updatePartialMany(request: Array<Contracts.Label>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Label>[]>;
+    /** Performs the given operation on each existing Label that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Label, Contracts.LabelCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Label>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Label, Contracts.LabelCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.Label, options?: IRepoOptions): Promise<SingleResult<Contracts.Label>>;
+    upsert(request: Contracts.Label, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.Label>, options?: IRepoOptions): Promise<BatchResult<Contracts.Label>>;
+    upsertMany(request: Array<Contracts.Label>, options?: IThrowingRepoOptions): Promise<Contracts.Label[]>;
+}
+declare class NodePoolDefCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing NodePoolDef that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.NodePoolDefCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.NodePoolDef>>;
+    deleteWhere(request: Contracts.NodePoolDefCriteria, options?: IThrowingRepoOptions): Promise<Contracts.NodePoolDef[]>;
+    /** Retrieves all the existing NodePoolDef that satisfy the given criteria. */
+    tryReadMany(request: Contracts.NodePoolDefCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.NodePoolDef>>;
+    readMany(request: Contracts.NodePoolDefCriteria, options?: IThrowingRepoOptions): Promise<Contracts.NodePoolDef[]>;
+    /** Performs the given operations on each existing NodePoolDef that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.NodePoolDef, Contracts.NodePoolDefCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.NodePoolDef>>;
+    patchWhere(request: PatchSpecForMany<Contracts.NodePoolDef, Contracts.NodePoolDefCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.NodePoolDef[]>;
+    /** Saves each given input as a new NodePoolDef. */
+    tryCreateMany(request: Array<Contracts.NodePoolDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.NodePoolDef>>;
+    createMany(request: Array<Contracts.NodePoolDef>, options?: IThrowingRepoOptions): Promise<Contracts.NodePoolDef[]>;
+    /** Overwrites each existing NodePoolDef. */
+    tryUpdateMany(request: Array<Contracts.NodePoolDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.NodePoolDef>>;
+    updateMany(request: Array<Contracts.NodePoolDef>, options?: IThrowingRepoOptions): Promise<Contracts.NodePoolDef[]>;
+    /** Deletes the existing NodePoolDef. */
+    tryDelete(request: IdSpecFor<Contracts.NodePoolDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.NodePoolDef>>;
+    delete(request: IdSpecFor<Contracts.NodePoolDef>, options?: IThrowingRepoOptions): Promise<Contracts.NodePoolDef>;
+    /** Retrieves the single, uniquely identified NodePoolDef. */
+    tryRead(request: IdSpecFor<Contracts.NodePoolDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.NodePoolDef>>;
+    read(request: IdSpecFor<Contracts.NodePoolDef>, options?: IThrowingRepoOptions): Promise<Contracts.NodePoolDef>;
+    /** Performs the given operations on the existing NodePoolDef. */
+    tryPatch(request: PatchSpecForOne<Contracts.NodePoolDef>, options?: IRepoOptions): Promise<SingleResult<Contracts.NodePoolDef>>;
+    patch(request: PatchSpecForOne<Contracts.NodePoolDef>, options?: IThrowingRepoOptions): Promise<Contracts.NodePoolDef>;
+    /** Overwrites the existing NodePoolDef. */
+    tryUpdate(request: Contracts.NodePoolDef, options?: IRepoOptions): Promise<SingleResult<Contracts.NodePoolDef>>;
+    update(request: Contracts.NodePoolDef, options?: IThrowingRepoOptions): Promise<Contracts.NodePoolDef>;
+    /** Overwrites the given properties of the existing NodePoolDef. */
+    tryUpdatePartial(request: Partial<Contracts.NodePoolDef>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.NodePoolDef>>>;
+    updatePartial(request: Partial<Contracts.NodePoolDef>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.NodePoolDef>>;
+    /** Saves the input as a new NodePoolDef. */
+    tryCreate(request: Contracts.NodePoolDef, options?: IRepoOptions): Promise<SingleResult<Contracts.NodePoolDef>>;
+    create(request: Contracts.NodePoolDef, options?: IThrowingRepoOptions): Promise<Contracts.NodePoolDef>;
+    /** Overwrites the given properties for each existing NodePoolDef. */
+    tryUpdatePartialMany(request: Array<Contracts.NodePoolDef>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.NodePoolDef>>>;
+    updatePartialMany(request: Array<Contracts.NodePoolDef>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.NodePoolDef>[]>;
+    /** Performs the given operation on each existing NodePoolDef that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.NodePoolDef, Contracts.NodePoolDefCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.NodePoolDef>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.NodePoolDef, Contracts.NodePoolDefCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.NodePoolDef, options?: IRepoOptions): Promise<SingleResult<Contracts.NodePoolDef>>;
+    upsert(request: Contracts.NodePoolDef, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.NodePoolDef>, options?: IRepoOptions): Promise<BatchResult<Contracts.NodePoolDef>>;
+    upsertMany(request: Array<Contracts.NodePoolDef>, options?: IThrowingRepoOptions): Promise<Contracts.NodePoolDef[]>;
+}
+declare class ProbeCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing Probe that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ProbeCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Probe>>;
+    deleteWhere(request: Contracts.ProbeCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Probe[]>;
+    /** Retrieves all the existing Probe that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ProbeCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Probe>>;
+    readMany(request: Contracts.ProbeCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Probe[]>;
+    /** Performs the given operations on each existing Probe that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Probe, Contracts.ProbeCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Probe>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Probe, Contracts.ProbeCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Probe[]>;
+    /** Saves each given input as a new Probe. */
+    tryCreateMany(request: Array<Contracts.Probe>, options?: IRepoOptions): Promise<BatchResult<Contracts.Probe>>;
+    createMany(request: Array<Contracts.Probe>, options?: IThrowingRepoOptions): Promise<Contracts.Probe[]>;
+    /** Overwrites each existing Probe. */
+    tryUpdateMany(request: Array<Contracts.Probe>, options?: IRepoOptions): Promise<BatchResult<Contracts.Probe>>;
+    updateMany(request: Array<Contracts.Probe>, options?: IThrowingRepoOptions): Promise<Contracts.Probe[]>;
+    /** Deletes the existing Probe. */
+    tryDelete(request: IdSpecFor<Contracts.Probe>, options?: IRepoOptions): Promise<SingleResult<Contracts.Probe>>;
+    delete(request: IdSpecFor<Contracts.Probe>, options?: IThrowingRepoOptions): Promise<Contracts.Probe>;
+    /** Retrieves the single, uniquely identified Probe. */
+    tryRead(request: IdSpecFor<Contracts.Probe>, options?: IRepoOptions): Promise<SingleResult<Contracts.Probe>>;
+    read(request: IdSpecFor<Contracts.Probe>, options?: IThrowingRepoOptions): Promise<Contracts.Probe>;
+    /** Performs the given operations on the existing Probe. */
+    tryPatch(request: PatchSpecForOne<Contracts.Probe>, options?: IRepoOptions): Promise<SingleResult<Contracts.Probe>>;
+    patch(request: PatchSpecForOne<Contracts.Probe>, options?: IThrowingRepoOptions): Promise<Contracts.Probe>;
+    /** Overwrites the existing Probe. */
+    tryUpdate(request: Contracts.Probe, options?: IRepoOptions): Promise<SingleResult<Contracts.Probe>>;
+    update(request: Contracts.Probe, options?: IThrowingRepoOptions): Promise<Contracts.Probe>;
+    /** Overwrites the given properties of the existing Probe. */
+    tryUpdatePartial(request: Partial<Contracts.Probe>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Probe>>>;
+    updatePartial(request: Partial<Contracts.Probe>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Probe>>;
+    /** Saves the input as a new Probe. */
+    tryCreate(request: Contracts.Probe, options?: IRepoOptions): Promise<SingleResult<Contracts.Probe>>;
+    create(request: Contracts.Probe, options?: IThrowingRepoOptions): Promise<Contracts.Probe>;
+    /** Overwrites the given properties for each existing Probe. */
+    tryUpdatePartialMany(request: Array<Contracts.Probe>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Probe>>>;
+    updatePartialMany(request: Array<Contracts.Probe>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Probe>[]>;
+    /** Performs the given operation on each existing Probe that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Probe, Contracts.ProbeCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Probe>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Probe, Contracts.ProbeCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.Probe, options?: IRepoOptions): Promise<SingleResult<Contracts.Probe>>;
+    upsert(request: Contracts.Probe, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.Probe>, options?: IRepoOptions): Promise<BatchResult<Contracts.Probe>>;
+    upsertMany(request: Array<Contracts.Probe>, options?: IThrowingRepoOptions): Promise<Contracts.Probe[]>;
+}
+declare class ProductCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing Product that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ProductCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Product>>;
+    deleteWhere(request: Contracts.ProductCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Product[]>;
+    /** Retrieves all the existing Product that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ProductCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Product>>;
+    readMany(request: Contracts.ProductCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Product[]>;
+    /** Performs the given operations on each existing Product that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Product, Contracts.ProductCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Product>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Product, Contracts.ProductCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Product[]>;
+    /** Saves each given input as a new Product. */
+    tryCreateMany(request: Array<Contracts.Product>, options?: IRepoOptions): Promise<BatchResult<Contracts.Product>>;
+    createMany(request: Array<Contracts.Product>, options?: IThrowingRepoOptions): Promise<Contracts.Product[]>;
+    /** Overwrites each existing Product. */
+    tryUpdateMany(request: Array<Contracts.Product>, options?: IRepoOptions): Promise<BatchResult<Contracts.Product>>;
+    updateMany(request: Array<Contracts.Product>, options?: IThrowingRepoOptions): Promise<Contracts.Product[]>;
+    /** Deletes the existing Product. */
+    tryDelete(request: IdSpecFor<Contracts.Product>, options?: IRepoOptions): Promise<SingleResult<Contracts.Product>>;
+    delete(request: IdSpecFor<Contracts.Product>, options?: IThrowingRepoOptions): Promise<Contracts.Product>;
+    /** Retrieves the single, uniquely identified Product. */
+    tryRead(request: IdSpecFor<Contracts.Product>, options?: IRepoOptions): Promise<SingleResult<Contracts.Product>>;
+    read(request: IdSpecFor<Contracts.Product>, options?: IThrowingRepoOptions): Promise<Contracts.Product>;
+    /** Performs the given operations on the existing Product. */
+    tryPatch(request: PatchSpecForOne<Contracts.Product>, options?: IRepoOptions): Promise<SingleResult<Contracts.Product>>;
+    patch(request: PatchSpecForOne<Contracts.Product>, options?: IThrowingRepoOptions): Promise<Contracts.Product>;
+    /** Overwrites the existing Product. */
+    tryUpdate(request: Contracts.Product, options?: IRepoOptions): Promise<SingleResult<Contracts.Product>>;
+    update(request: Contracts.Product, options?: IThrowingRepoOptions): Promise<Contracts.Product>;
+    /** Overwrites the given properties of the existing Product. */
+    tryUpdatePartial(request: Partial<Contracts.Product>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Product>>>;
+    updatePartial(request: Partial<Contracts.Product>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Product>>;
+    /** Saves the input as a new Product. */
+    tryCreate(request: Contracts.Product, options?: IRepoOptions): Promise<SingleResult<Contracts.Product>>;
+    create(request: Contracts.Product, options?: IThrowingRepoOptions): Promise<Contracts.Product>;
+    /** Overwrites the given properties for each existing Product. */
+    tryUpdatePartialMany(request: Array<Contracts.Product>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Product>>>;
+    updatePartialMany(request: Array<Contracts.Product>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Product>[]>;
+    /** Performs the given operation on each existing Product that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Product, Contracts.ProductCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Product>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Product, Contracts.ProductCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.Product, options?: IRepoOptions): Promise<SingleResult<Contracts.Product>>;
+    upsert(request: Contracts.Product, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.Product>, options?: IRepoOptions): Promise<BatchResult<Contracts.Product>>;
+    upsertMany(request: Array<Contracts.Product>, options?: IThrowingRepoOptions): Promise<Contracts.Product[]>;
+}
+declare class ProductVersionConfigCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing ProductVersionConfig that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ProductVersionConfigCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.ProductVersionConfig>>;
+    deleteWhere(request: Contracts.ProductVersionConfigCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ProductVersionConfig[]>;
+    /** Retrieves all the existing ProductVersionConfig that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ProductVersionConfigCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ProductVersionConfig>>;
+    readMany(request: Contracts.ProductVersionConfigCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ProductVersionConfig[]>;
+    /** Performs the given operations on each existing ProductVersionConfig that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.ProductVersionConfig, Contracts.ProductVersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ProductVersionConfig>>;
+    patchWhere(request: PatchSpecForMany<Contracts.ProductVersionConfig, Contracts.ProductVersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ProductVersionConfig[]>;
+    /** Saves each given input as a new ProductVersionConfig. */
+    tryCreateMany(request: Array<Contracts.ProductVersionConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.ProductVersionConfig>>;
+    createMany(request: Array<Contracts.ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ProductVersionConfig[]>;
+    /** Overwrites each existing ProductVersionConfig. */
+    tryUpdateMany(request: Array<Contracts.ProductVersionConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.ProductVersionConfig>>;
+    updateMany(request: Array<Contracts.ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ProductVersionConfig[]>;
+    /** Deletes the existing ProductVersionConfig. */
+    tryDelete(request: IdSpecFor<Contracts.ProductVersionConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.ProductVersionConfig>>;
+    delete(request: IdSpecFor<Contracts.ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ProductVersionConfig>;
+    /** Retrieves the single, uniquely identified ProductVersionConfig. */
+    tryRead(request: IdSpecFor<Contracts.ProductVersionConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.ProductVersionConfig>>;
+    read(request: IdSpecFor<Contracts.ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ProductVersionConfig>;
+    /** Performs the given operations on the existing ProductVersionConfig. */
+    tryPatch(request: PatchSpecForOne<Contracts.ProductVersionConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.ProductVersionConfig>>;
+    patch(request: PatchSpecForOne<Contracts.ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ProductVersionConfig>;
+    /** Overwrites the existing ProductVersionConfig. */
+    tryUpdate(request: Contracts.ProductVersionConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.ProductVersionConfig>>;
+    update(request: Contracts.ProductVersionConfig, options?: IThrowingRepoOptions): Promise<Contracts.ProductVersionConfig>;
+    /** Overwrites the given properties of the existing ProductVersionConfig. */
+    tryUpdatePartial(request: Partial<Contracts.ProductVersionConfig>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.ProductVersionConfig>>>;
+    updatePartial(request: Partial<Contracts.ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ProductVersionConfig>>;
+    /** Saves the input as a new ProductVersionConfig. */
+    tryCreate(request: Contracts.ProductVersionConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.ProductVersionConfig>>;
+    create(request: Contracts.ProductVersionConfig, options?: IThrowingRepoOptions): Promise<Contracts.ProductVersionConfig>;
+    /** Overwrites the given properties for each existing ProductVersionConfig. */
+    tryUpdatePartialMany(request: Array<Contracts.ProductVersionConfig>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.ProductVersionConfig>>>;
+    updatePartialMany(request: Array<Contracts.ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ProductVersionConfig>[]>;
+    /** Performs the given operation on each existing ProductVersionConfig that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ProductVersionConfig, Contracts.ProductVersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ProductVersionConfig>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ProductVersionConfig, Contracts.ProductVersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.ProductVersionConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.ProductVersionConfig>>;
+    upsert(request: Contracts.ProductVersionConfig, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.ProductVersionConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.ProductVersionConfig>>;
+    upsertMany(request: Array<Contracts.ProductVersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ProductVersionConfig[]>;
+}
+declare class ScopedHostNameConfigCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing ScopedHostNameConfig that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ScopedHostNameConfigCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedHostNameConfig>>;
+    deleteWhere(request: Contracts.ScopedHostNameConfigCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig[]>;
+    /** Retrieves all the existing ScopedHostNameConfig that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ScopedHostNameConfigCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ScopedHostNameConfig>>;
+    readMany(request: Contracts.ScopedHostNameConfigCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig[]>;
+    /** Performs the given operations on each existing ScopedHostNameConfig that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.ScopedHostNameConfig, Contracts.ScopedHostNameConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedHostNameConfig>>;
+    patchWhere(request: PatchSpecForMany<Contracts.ScopedHostNameConfig, Contracts.ScopedHostNameConfigCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig[]>;
+    /** Saves each given input as a new ScopedHostNameConfig. */
+    tryCreateMany(request: Array<Contracts.ScopedHostNameConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedHostNameConfig>>;
+    createMany(request: Array<Contracts.ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig[]>;
+    /** Overwrites each existing ScopedHostNameConfig. */
+    tryUpdateMany(request: Array<Contracts.ScopedHostNameConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedHostNameConfig>>;
+    updateMany(request: Array<Contracts.ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig[]>;
+    /** Deletes the existing ScopedHostNameConfig. */
+    tryDelete(request: IdSpecFor<Contracts.ScopedHostNameConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedHostNameConfig>>;
+    delete(request: IdSpecFor<Contracts.ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig>;
+    /** Retrieves the single, uniquely identified ScopedHostNameConfig. */
+    tryRead(request: IdSpecFor<Contracts.ScopedHostNameConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedHostNameConfig>>;
+    read(request: IdSpecFor<Contracts.ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig>;
+    /** Performs the given operations on the existing ScopedHostNameConfig. */
+    tryPatch(request: PatchSpecForOne<Contracts.ScopedHostNameConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedHostNameConfig>>;
+    patch(request: PatchSpecForOne<Contracts.ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig>;
+    /** Overwrites the existing ScopedHostNameConfig. */
+    tryUpdate(request: Contracts.ScopedHostNameConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedHostNameConfig>>;
+    update(request: Contracts.ScopedHostNameConfig, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig>;
+    /** Overwrites the given properties of the existing ScopedHostNameConfig. */
+    tryUpdatePartial(request: Partial<Contracts.ScopedHostNameConfig>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.ScopedHostNameConfig>>>;
+    updatePartial(request: Partial<Contracts.ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ScopedHostNameConfig>>;
+    /** Saves the input as a new ScopedHostNameConfig. */
+    tryCreate(request: Contracts.ScopedHostNameConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedHostNameConfig>>;
+    create(request: Contracts.ScopedHostNameConfig, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig>;
+    /** Overwrites the given properties for each existing ScopedHostNameConfig. */
+    tryUpdatePartialMany(request: Array<Contracts.ScopedHostNameConfig>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.ScopedHostNameConfig>>>;
+    updatePartialMany(request: Array<Contracts.ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ScopedHostNameConfig>[]>;
+    /** Performs the given operation on each existing ScopedHostNameConfig that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ScopedHostNameConfig, Contracts.ScopedHostNameConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedHostNameConfig>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ScopedHostNameConfig, Contracts.ScopedHostNameConfigCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.ScopedHostNameConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedHostNameConfig>>;
+    upsert(request: Contracts.ScopedHostNameConfig, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.ScopedHostNameConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedHostNameConfig>>;
+    upsertMany(request: Array<Contracts.ScopedHostNameConfig>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedHostNameConfig[]>;
+}
+declare class ScopedSettingCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing ScopedSetting that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ScopedSettingCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedSetting>>;
+    deleteWhere(request: Contracts.ScopedSettingCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting[]>;
+    /** Retrieves all the existing ScopedSetting that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ScopedSettingCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ScopedSetting>>;
+    readMany(request: Contracts.ScopedSettingCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting[]>;
+    /** Performs the given operations on each existing ScopedSetting that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.ScopedSetting, Contracts.ScopedSettingCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedSetting>>;
+    patchWhere(request: PatchSpecForMany<Contracts.ScopedSetting, Contracts.ScopedSettingCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting[]>;
+    /** Saves each given input as a new ScopedSetting. */
+    tryCreateMany(request: Array<Contracts.ScopedSetting>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedSetting>>;
+    createMany(request: Array<Contracts.ScopedSetting>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting[]>;
+    /** Overwrites each existing ScopedSetting. */
+    tryUpdateMany(request: Array<Contracts.ScopedSetting>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedSetting>>;
+    updateMany(request: Array<Contracts.ScopedSetting>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting[]>;
+    /** Deletes the existing ScopedSetting. */
+    tryDelete(request: IdSpecFor<Contracts.ScopedSetting>, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedSetting>>;
+    delete(request: IdSpecFor<Contracts.ScopedSetting>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting>;
+    /** Retrieves the single, uniquely identified ScopedSetting. */
+    tryRead(request: IdSpecFor<Contracts.ScopedSetting>, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedSetting>>;
+    read(request: IdSpecFor<Contracts.ScopedSetting>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting>;
+    /** Performs the given operations on the existing ScopedSetting. */
+    tryPatch(request: PatchSpecForOne<Contracts.ScopedSetting>, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedSetting>>;
+    patch(request: PatchSpecForOne<Contracts.ScopedSetting>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting>;
+    /** Overwrites the existing ScopedSetting. */
+    tryUpdate(request: Contracts.ScopedSetting, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedSetting>>;
+    update(request: Contracts.ScopedSetting, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting>;
+    /** Overwrites the given properties of the existing ScopedSetting. */
+    tryUpdatePartial(request: Partial<Contracts.ScopedSetting>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.ScopedSetting>>>;
+    updatePartial(request: Partial<Contracts.ScopedSetting>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ScopedSetting>>;
+    /** Saves the input as a new ScopedSetting. */
+    tryCreate(request: Contracts.ScopedSetting, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedSetting>>;
+    create(request: Contracts.ScopedSetting, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting>;
+    /** Overwrites the given properties for each existing ScopedSetting. */
+    tryUpdatePartialMany(request: Array<Contracts.ScopedSetting>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.ScopedSetting>>>;
+    updatePartialMany(request: Array<Contracts.ScopedSetting>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ScopedSetting>[]>;
+    /** Performs the given operation on each existing ScopedSetting that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ScopedSetting, Contracts.ScopedSettingCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedSetting>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ScopedSetting, Contracts.ScopedSettingCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.ScopedSetting, options?: IRepoOptions): Promise<SingleResult<Contracts.ScopedSetting>>;
+    upsert(request: Contracts.ScopedSetting, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.ScopedSetting>, options?: IRepoOptions): Promise<BatchResult<Contracts.ScopedSetting>>;
+    upsertMany(request: Array<Contracts.ScopedSetting>, options?: IThrowingRepoOptions): Promise<Contracts.ScopedSetting[]>;
+}
+declare class SetupJournalCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing SetupJournal that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.SetupJournalCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.SetupJournal>>;
+    deleteWhere(request: Contracts.SetupJournalCriteria, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal[]>;
+    /** Retrieves all the existing SetupJournal that satisfy the given criteria. */
+    tryReadMany(request: Contracts.SetupJournalCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.SetupJournal>>;
+    readMany(request: Contracts.SetupJournalCriteria, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal[]>;
+    /** Performs the given operations on each existing SetupJournal that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.SetupJournal, Contracts.SetupJournalCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.SetupJournal>>;
+    patchWhere(request: PatchSpecForMany<Contracts.SetupJournal, Contracts.SetupJournalCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal[]>;
+    /** Saves each given input as a new SetupJournal. */
+    tryCreateMany(request: Array<Contracts.SetupJournal>, options?: IRepoOptions): Promise<BatchResult<Contracts.SetupJournal>>;
+    createMany(request: Array<Contracts.SetupJournal>, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal[]>;
+    /** Overwrites each existing SetupJournal. */
+    tryUpdateMany(request: Array<Contracts.SetupJournal>, options?: IRepoOptions): Promise<BatchResult<Contracts.SetupJournal>>;
+    updateMany(request: Array<Contracts.SetupJournal>, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal[]>;
+    /** Deletes the existing SetupJournal. */
+    tryDelete(request: IdSpecFor<Contracts.SetupJournal>, options?: IRepoOptions): Promise<SingleResult<Contracts.SetupJournal>>;
+    delete(request: IdSpecFor<Contracts.SetupJournal>, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal>;
+    /** Retrieves the single, uniquely identified SetupJournal. */
+    tryRead(request: IdSpecFor<Contracts.SetupJournal>, options?: IRepoOptions): Promise<SingleResult<Contracts.SetupJournal>>;
+    read(request: IdSpecFor<Contracts.SetupJournal>, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal>;
+    /** Performs the given operations on the existing SetupJournal. */
+    tryPatch(request: PatchSpecForOne<Contracts.SetupJournal>, options?: IRepoOptions): Promise<SingleResult<Contracts.SetupJournal>>;
+    patch(request: PatchSpecForOne<Contracts.SetupJournal>, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal>;
+    /** Overwrites the existing SetupJournal. */
+    tryUpdate(request: Contracts.SetupJournal, options?: IRepoOptions): Promise<SingleResult<Contracts.SetupJournal>>;
+    update(request: Contracts.SetupJournal, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal>;
+    /** Overwrites the given properties of the existing SetupJournal. */
+    tryUpdatePartial(request: Partial<Contracts.SetupJournal>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.SetupJournal>>>;
+    updatePartial(request: Partial<Contracts.SetupJournal>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.SetupJournal>>;
+    /** Saves the input as a new SetupJournal. */
+    tryCreate(request: Contracts.SetupJournal, options?: IRepoOptions): Promise<SingleResult<Contracts.SetupJournal>>;
+    create(request: Contracts.SetupJournal, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal>;
+    /** Overwrites the given properties for each existing SetupJournal. */
+    tryUpdatePartialMany(request: Array<Contracts.SetupJournal>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.SetupJournal>>>;
+    updatePartialMany(request: Array<Contracts.SetupJournal>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.SetupJournal>[]>;
+    /** Performs the given operation on each existing SetupJournal that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.SetupJournal, Contracts.SetupJournalCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.SetupJournal>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.SetupJournal, Contracts.SetupJournalCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.SetupJournal, options?: IRepoOptions): Promise<SingleResult<Contracts.SetupJournal>>;
+    upsert(request: Contracts.SetupJournal, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.SetupJournal>, options?: IRepoOptions): Promise<BatchResult<Contracts.SetupJournal>>;
+    upsertMany(request: Array<Contracts.SetupJournal>, options?: IThrowingRepoOptions): Promise<Contracts.SetupJournal[]>;
+}
+declare class SnapshotCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing Snapshot that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.SnapshotCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Snapshot>>;
+    deleteWhere(request: Contracts.SnapshotCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Snapshot[]>;
+    /** Retrieves all the existing Snapshot that satisfy the given criteria. */
+    tryReadMany(request: Contracts.SnapshotCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Snapshot>>;
+    readMany(request: Contracts.SnapshotCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Snapshot[]>;
+    /** Performs the given operations on each existing Snapshot that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Snapshot, Contracts.SnapshotCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Snapshot>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Snapshot, Contracts.SnapshotCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Snapshot[]>;
+    /** Saves each given input as a new Snapshot. */
+    tryCreateMany(request: Array<Contracts.Snapshot>, options?: IRepoOptions): Promise<BatchResult<Contracts.Snapshot>>;
+    createMany(request: Array<Contracts.Snapshot>, options?: IThrowingRepoOptions): Promise<Contracts.Snapshot[]>;
+    /** Overwrites each existing Snapshot. */
+    tryUpdateMany(request: Array<Contracts.Snapshot>, options?: IRepoOptions): Promise<BatchResult<Contracts.Snapshot>>;
+    updateMany(request: Array<Contracts.Snapshot>, options?: IThrowingRepoOptions): Promise<Contracts.Snapshot[]>;
+    /** Deletes the existing Snapshot. */
+    tryDelete(request: IdSpecFor<Contracts.Snapshot>, options?: IRepoOptions): Promise<SingleResult<Contracts.Snapshot>>;
+    delete(request: IdSpecFor<Contracts.Snapshot>, options?: IThrowingRepoOptions): Promise<Contracts.Snapshot>;
+    /** Retrieves the single, uniquely identified Snapshot. */
+    tryRead(request: IdSpecFor<Contracts.Snapshot>, options?: IRepoOptions): Promise<SingleResult<Contracts.Snapshot>>;
+    read(request: IdSpecFor<Contracts.Snapshot>, options?: IThrowingRepoOptions): Promise<Contracts.Snapshot>;
+    /** Performs the given operations on the existing Snapshot. */
+    tryPatch(request: PatchSpecForOne<Contracts.Snapshot>, options?: IRepoOptions): Promise<SingleResult<Contracts.Snapshot>>;
+    patch(request: PatchSpecForOne<Contracts.Snapshot>, options?: IThrowingRepoOptions): Promise<Contracts.Snapshot>;
+    /** Overwrites the existing Snapshot. */
+    tryUpdate(request: Contracts.Snapshot, options?: IRepoOptions): Promise<SingleResult<Contracts.Snapshot>>;
+    update(request: Contracts.Snapshot, options?: IThrowingRepoOptions): Promise<Contracts.Snapshot>;
+    /** Overwrites the given properties of the existing Snapshot. */
+    tryUpdatePartial(request: Partial<Contracts.Snapshot>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Snapshot>>>;
+    updatePartial(request: Partial<Contracts.Snapshot>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Snapshot>>;
+    /** Saves the input as a new Snapshot. */
+    tryCreate(request: Contracts.Snapshot, options?: IRepoOptions): Promise<SingleResult<Contracts.Snapshot>>;
+    create(request: Contracts.Snapshot, options?: IThrowingRepoOptions): Promise<Contracts.Snapshot>;
+    /** Overwrites the given properties for each existing Snapshot. */
+    tryUpdatePartialMany(request: Array<Contracts.Snapshot>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Snapshot>>>;
+    updatePartialMany(request: Array<Contracts.Snapshot>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Snapshot>[]>;
+    /** Performs the given operation on each existing Snapshot that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Snapshot, Contracts.SnapshotCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Snapshot>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Snapshot, Contracts.SnapshotCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.Snapshot, options?: IRepoOptions): Promise<SingleResult<Contracts.Snapshot>>;
+    upsert(request: Contracts.Snapshot, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.Snapshot>, options?: IRepoOptions): Promise<BatchResult<Contracts.Snapshot>>;
+    upsertMany(request: Array<Contracts.Snapshot>, options?: IThrowingRepoOptions): Promise<Contracts.Snapshot[]>;
+}
+declare class SourceRepoCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing SourceRepo that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.SourceRepoCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.SourceRepo>>;
+    deleteWhere(request: Contracts.SourceRepoCriteria, options?: IThrowingRepoOptions): Promise<Contracts.SourceRepo[]>;
+    /** Retrieves all the existing SourceRepo that satisfy the given criteria. */
+    tryReadMany(request: Contracts.SourceRepoCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.SourceRepo>>;
+    readMany(request: Contracts.SourceRepoCriteria, options?: IThrowingRepoOptions): Promise<Contracts.SourceRepo[]>;
+    /** Performs the given operations on each existing SourceRepo that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.SourceRepo, Contracts.SourceRepoCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.SourceRepo>>;
+    patchWhere(request: PatchSpecForMany<Contracts.SourceRepo, Contracts.SourceRepoCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.SourceRepo[]>;
+    /** Saves each given input as a new SourceRepo. */
+    tryCreateMany(request: Array<Contracts.SourceRepo>, options?: IRepoOptions): Promise<BatchResult<Contracts.SourceRepo>>;
+    createMany(request: Array<Contracts.SourceRepo>, options?: IThrowingRepoOptions): Promise<Contracts.SourceRepo[]>;
+    /** Overwrites each existing SourceRepo. */
+    tryUpdateMany(request: Array<Contracts.SourceRepo>, options?: IRepoOptions): Promise<BatchResult<Contracts.SourceRepo>>;
+    updateMany(request: Array<Contracts.SourceRepo>, options?: IThrowingRepoOptions): Promise<Contracts.SourceRepo[]>;
+    /** Deletes the existing SourceRepo. */
+    tryDelete(request: IdSpecFor<Contracts.SourceRepo>, options?: IRepoOptions): Promise<SingleResult<Contracts.SourceRepo>>;
+    delete(request: IdSpecFor<Contracts.SourceRepo>, options?: IThrowingRepoOptions): Promise<Contracts.SourceRepo>;
+    /** Retrieves the single, uniquely identified SourceRepo. */
+    tryRead(request: IdSpecFor<Contracts.SourceRepo>, options?: IRepoOptions): Promise<SingleResult<Contracts.SourceRepo>>;
+    read(request: IdSpecFor<Contracts.SourceRepo>, options?: IThrowingRepoOptions): Promise<Contracts.SourceRepo>;
+    /** Performs the given operations on the existing SourceRepo. */
+    tryPatch(request: PatchSpecForOne<Contracts.SourceRepo>, options?: IRepoOptions): Promise<SingleResult<Contracts.SourceRepo>>;
+    patch(request: PatchSpecForOne<Contracts.SourceRepo>, options?: IThrowingRepoOptions): Promise<Contracts.SourceRepo>;
+    /** Overwrites the existing SourceRepo. */
+    tryUpdate(request: Contracts.SourceRepo, options?: IRepoOptions): Promise<SingleResult<Contracts.SourceRepo>>;
+    update(request: Contracts.SourceRepo, options?: IThrowingRepoOptions): Promise<Contracts.SourceRepo>;
+    /** Overwrites the given properties of the existing SourceRepo. */
+    tryUpdatePartial(request: Partial<Contracts.SourceRepo>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.SourceRepo>>>;
+    updatePartial(request: Partial<Contracts.SourceRepo>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.SourceRepo>>;
+    /** Saves the input as a new SourceRepo. */
+    tryCreate(request: Contracts.SourceRepo, options?: IRepoOptions): Promise<SingleResult<Contracts.SourceRepo>>;
+    create(request: Contracts.SourceRepo, options?: IThrowingRepoOptions): Promise<Contracts.SourceRepo>;
+    /** Overwrites the given properties for each existing SourceRepo. */
+    tryUpdatePartialMany(request: Array<Contracts.SourceRepo>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.SourceRepo>>>;
+    updatePartialMany(request: Array<Contracts.SourceRepo>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.SourceRepo>[]>;
+    /** Performs the given operation on each existing SourceRepo that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.SourceRepo, Contracts.SourceRepoCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.SourceRepo>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.SourceRepo, Contracts.SourceRepoCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.SourceRepo, options?: IRepoOptions): Promise<SingleResult<Contracts.SourceRepo>>;
+    upsert(request: Contracts.SourceRepo, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.SourceRepo>, options?: IRepoOptions): Promise<BatchResult<Contracts.SourceRepo>>;
+    upsertMany(request: Array<Contracts.SourceRepo>, options?: IThrowingRepoOptions): Promise<Contracts.SourceRepo[]>;
+}
+declare class SubscriptionCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing Subscription that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.SubscriptionCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Subscription>>;
+    deleteWhere(request: Contracts.SubscriptionCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Subscription[]>;
+    /** Retrieves all the existing Subscription that satisfy the given criteria. */
+    tryReadMany(request: Contracts.SubscriptionCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Subscription>>;
+    readMany(request: Contracts.SubscriptionCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Subscription[]>;
+    /** Performs the given operations on each existing Subscription that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Subscription, Contracts.SubscriptionCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Subscription>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Subscription, Contracts.SubscriptionCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Subscription[]>;
+    /** Saves each given input as a new Subscription. */
+    tryCreateMany(request: Array<Contracts.Subscription>, options?: IRepoOptions): Promise<BatchResult<Contracts.Subscription>>;
+    createMany(request: Array<Contracts.Subscription>, options?: IThrowingRepoOptions): Promise<Contracts.Subscription[]>;
+    /** Overwrites each existing Subscription. */
+    tryUpdateMany(request: Array<Contracts.Subscription>, options?: IRepoOptions): Promise<BatchResult<Contracts.Subscription>>;
+    updateMany(request: Array<Contracts.Subscription>, options?: IThrowingRepoOptions): Promise<Contracts.Subscription[]>;
+    /** Deletes the existing Subscription. */
+    tryDelete(request: IdSpecFor<Contracts.Subscription>, options?: IRepoOptions): Promise<SingleResult<Contracts.Subscription>>;
+    delete(request: IdSpecFor<Contracts.Subscription>, options?: IThrowingRepoOptions): Promise<Contracts.Subscription>;
+    /** Retrieves the single, uniquely identified Subscription. */
+    tryRead(request: IdSpecFor<Contracts.Subscription>, options?: IRepoOptions): Promise<SingleResult<Contracts.Subscription>>;
+    read(request: IdSpecFor<Contracts.Subscription>, options?: IThrowingRepoOptions): Promise<Contracts.Subscription>;
+    /** Performs the given operations on the existing Subscription. */
+    tryPatch(request: PatchSpecForOne<Contracts.Subscription>, options?: IRepoOptions): Promise<SingleResult<Contracts.Subscription>>;
+    patch(request: PatchSpecForOne<Contracts.Subscription>, options?: IThrowingRepoOptions): Promise<Contracts.Subscription>;
+    /** Overwrites the existing Subscription. */
+    tryUpdate(request: Contracts.Subscription, options?: IRepoOptions): Promise<SingleResult<Contracts.Subscription>>;
+    update(request: Contracts.Subscription, options?: IThrowingRepoOptions): Promise<Contracts.Subscription>;
+    /** Overwrites the given properties of the existing Subscription. */
+    tryUpdatePartial(request: Partial<Contracts.Subscription>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Subscription>>>;
+    updatePartial(request: Partial<Contracts.Subscription>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Subscription>>;
+    /** Saves the input as a new Subscription. */
+    tryCreate(request: Contracts.Subscription, options?: IRepoOptions): Promise<SingleResult<Contracts.Subscription>>;
+    create(request: Contracts.Subscription, options?: IThrowingRepoOptions): Promise<Contracts.Subscription>;
+    /** Overwrites the given properties for each existing Subscription. */
+    tryUpdatePartialMany(request: Array<Contracts.Subscription>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Subscription>>>;
+    updatePartialMany(request: Array<Contracts.Subscription>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Subscription>[]>;
+    /** Performs the given operation on each existing Subscription that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Subscription, Contracts.SubscriptionCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Subscription>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Subscription, Contracts.SubscriptionCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.Subscription, options?: IRepoOptions): Promise<SingleResult<Contracts.Subscription>>;
+    upsert(request: Contracts.Subscription, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.Subscription>, options?: IRepoOptions): Promise<BatchResult<Contracts.Subscription>>;
+    upsertMany(request: Array<Contracts.Subscription>, options?: IThrowingRepoOptions): Promise<Contracts.Subscription[]>;
+}
+declare class TagCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing Tag that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.TagCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.Tag>>;
+    deleteWhere(request: Contracts.TagCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Tag[]>;
+    /** Retrieves all the existing Tag that satisfy the given criteria. */
+    tryReadMany(request: Contracts.TagCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.Tag>>;
+    readMany(request: Contracts.TagCriteria, options?: IThrowingRepoOptions): Promise<Contracts.Tag[]>;
+    /** Performs the given operations on each existing Tag that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.Tag, Contracts.TagCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Tag>>;
+    patchWhere(request: PatchSpecForMany<Contracts.Tag, Contracts.TagCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.Tag[]>;
+    /** Saves each given input as a new Tag. */
+    tryCreateMany(request: Array<Contracts.Tag>, options?: IRepoOptions): Promise<BatchResult<Contracts.Tag>>;
+    createMany(request: Array<Contracts.Tag>, options?: IThrowingRepoOptions): Promise<Contracts.Tag[]>;
+    /** Overwrites each existing Tag. */
+    tryUpdateMany(request: Array<Contracts.Tag>, options?: IRepoOptions): Promise<BatchResult<Contracts.Tag>>;
+    updateMany(request: Array<Contracts.Tag>, options?: IThrowingRepoOptions): Promise<Contracts.Tag[]>;
+    /** Deletes the existing Tag. */
+    tryDelete(request: IdSpecFor<Contracts.Tag>, options?: IRepoOptions): Promise<SingleResult<Contracts.Tag>>;
+    delete(request: IdSpecFor<Contracts.Tag>, options?: IThrowingRepoOptions): Promise<Contracts.Tag>;
+    /** Retrieves the single, uniquely identified Tag. */
+    tryRead(request: IdSpecFor<Contracts.Tag>, options?: IRepoOptions): Promise<SingleResult<Contracts.Tag>>;
+    read(request: IdSpecFor<Contracts.Tag>, options?: IThrowingRepoOptions): Promise<Contracts.Tag>;
+    /** Performs the given operations on the existing Tag. */
+    tryPatch(request: PatchSpecForOne<Contracts.Tag>, options?: IRepoOptions): Promise<SingleResult<Contracts.Tag>>;
+    patch(request: PatchSpecForOne<Contracts.Tag>, options?: IThrowingRepoOptions): Promise<Contracts.Tag>;
+    /** Overwrites the existing Tag. */
+    tryUpdate(request: Contracts.Tag, options?: IRepoOptions): Promise<SingleResult<Contracts.Tag>>;
+    update(request: Contracts.Tag, options?: IThrowingRepoOptions): Promise<Contracts.Tag>;
+    /** Overwrites the given properties of the existing Tag. */
+    tryUpdatePartial(request: Partial<Contracts.Tag>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Tag>>>;
+    updatePartial(request: Partial<Contracts.Tag>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Tag>>;
+    /** Saves the input as a new Tag. */
+    tryCreate(request: Contracts.Tag, options?: IRepoOptions): Promise<SingleResult<Contracts.Tag>>;
+    create(request: Contracts.Tag, options?: IThrowingRepoOptions): Promise<Contracts.Tag>;
+    /** Overwrites the given properties for each existing Tag. */
+    tryUpdatePartialMany(request: Array<Contracts.Tag>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.Tag>>>;
+    updatePartialMany(request: Array<Contracts.Tag>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.Tag>[]>;
+    /** Performs the given operation on each existing Tag that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Tag, Contracts.TagCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.Tag>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.Tag, Contracts.TagCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.Tag, options?: IRepoOptions): Promise<SingleResult<Contracts.Tag>>;
+    upsert(request: Contracts.Tag, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.Tag>, options?: IRepoOptions): Promise<BatchResult<Contracts.Tag>>;
+    upsertMany(request: Array<Contracts.Tag>, options?: IThrowingRepoOptions): Promise<Contracts.Tag[]>;
+}
+declare class VersionConfigCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing VersionConfig that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.VersionConfigCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.VersionConfig>>;
+    deleteWhere(request: Contracts.VersionConfigCriteria, options?: IThrowingRepoOptions): Promise<Contracts.VersionConfig[]>;
+    /** Retrieves all the existing VersionConfig that satisfy the given criteria. */
+    tryReadMany(request: Contracts.VersionConfigCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.VersionConfig>>;
+    readMany(request: Contracts.VersionConfigCriteria, options?: IThrowingRepoOptions): Promise<Contracts.VersionConfig[]>;
+    /** Performs the given operations on each existing VersionConfig that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.VersionConfig, Contracts.VersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.VersionConfig>>;
+    patchWhere(request: PatchSpecForMany<Contracts.VersionConfig, Contracts.VersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.VersionConfig[]>;
+    /** Saves each given input as a new VersionConfig. */
+    tryCreateMany(request: Array<Contracts.VersionConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.VersionConfig>>;
+    createMany(request: Array<Contracts.VersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.VersionConfig[]>;
+    /** Overwrites each existing VersionConfig. */
+    tryUpdateMany(request: Array<Contracts.VersionConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.VersionConfig>>;
+    updateMany(request: Array<Contracts.VersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.VersionConfig[]>;
+    /** Deletes the existing VersionConfig. */
+    tryDelete(request: IdSpecFor<Contracts.VersionConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.VersionConfig>>;
+    delete(request: IdSpecFor<Contracts.VersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.VersionConfig>;
+    /** Retrieves the single, uniquely identified VersionConfig. */
+    tryRead(request: IdSpecFor<Contracts.VersionConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.VersionConfig>>;
+    read(request: IdSpecFor<Contracts.VersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.VersionConfig>;
+    /** Performs the given operations on the existing VersionConfig. */
+    tryPatch(request: PatchSpecForOne<Contracts.VersionConfig>, options?: IRepoOptions): Promise<SingleResult<Contracts.VersionConfig>>;
+    patch(request: PatchSpecForOne<Contracts.VersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.VersionConfig>;
+    /** Overwrites the existing VersionConfig. */
+    tryUpdate(request: Contracts.VersionConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.VersionConfig>>;
+    update(request: Contracts.VersionConfig, options?: IThrowingRepoOptions): Promise<Contracts.VersionConfig>;
+    /** Overwrites the given properties of the existing VersionConfig. */
+    tryUpdatePartial(request: Partial<Contracts.VersionConfig>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.VersionConfig>>>;
+    updatePartial(request: Partial<Contracts.VersionConfig>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.VersionConfig>>;
+    /** Saves the input as a new VersionConfig. */
+    tryCreate(request: Contracts.VersionConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.VersionConfig>>;
+    create(request: Contracts.VersionConfig, options?: IThrowingRepoOptions): Promise<Contracts.VersionConfig>;
+    /** Overwrites the given properties for each existing VersionConfig. */
+    tryUpdatePartialMany(request: Array<Contracts.VersionConfig>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.VersionConfig>>>;
+    updatePartialMany(request: Array<Contracts.VersionConfig>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.VersionConfig>[]>;
+    /** Performs the given operation on each existing VersionConfig that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.VersionConfig, Contracts.VersionConfigCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.VersionConfig>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.VersionConfig, Contracts.VersionConfigCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.VersionConfig, options?: IRepoOptions): Promise<SingleResult<Contracts.VersionConfig>>;
+    upsert(request: Contracts.VersionConfig, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.VersionConfig>, options?: IRepoOptions): Promise<BatchResult<Contracts.VersionConfig>>;
+    upsertMany(request: Array<Contracts.VersionConfig>, options?: IThrowingRepoOptions): Promise<Contracts.VersionConfig[]>;
+}
+declare class VersionCreateActivityCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing VersionCreateActivity that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.VersionCreateActivityCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.VersionCreateActivity>>;
+    deleteWhere(request: Contracts.VersionCreateActivityCriteria, options?: IThrowingRepoOptions): Promise<Contracts.VersionCreateActivity[]>;
+    /** Retrieves all the existing VersionCreateActivity that satisfy the given criteria. */
+    tryReadMany(request: Contracts.VersionCreateActivityCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.VersionCreateActivity>>;
+    readMany(request: Contracts.VersionCreateActivityCriteria, options?: IThrowingRepoOptions): Promise<Contracts.VersionCreateActivity[]>;
+    /** Performs the given operations on each existing VersionCreateActivity that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.VersionCreateActivity, Contracts.VersionCreateActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.VersionCreateActivity>>;
+    patchWhere(request: PatchSpecForMany<Contracts.VersionCreateActivity, Contracts.VersionCreateActivityCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.VersionCreateActivity[]>;
+    /** Saves each given input as a new VersionCreateActivity. */
+    tryCreateMany(request: Array<Contracts.VersionCreateActivity>, options?: IRepoOptions): Promise<BatchResult<Contracts.VersionCreateActivity>>;
+    createMany(request: Array<Contracts.VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<Contracts.VersionCreateActivity[]>;
+    /** Overwrites each existing VersionCreateActivity. */
+    tryUpdateMany(request: Array<Contracts.VersionCreateActivity>, options?: IRepoOptions): Promise<BatchResult<Contracts.VersionCreateActivity>>;
+    updateMany(request: Array<Contracts.VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<Contracts.VersionCreateActivity[]>;
+    /** Deletes the existing VersionCreateActivity. */
+    tryDelete(request: IdSpecFor<Contracts.VersionCreateActivity>, options?: IRepoOptions): Promise<SingleResult<Contracts.VersionCreateActivity>>;
+    delete(request: IdSpecFor<Contracts.VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<Contracts.VersionCreateActivity>;
+    /** Retrieves the single, uniquely identified VersionCreateActivity. */
+    tryRead(request: IdSpecFor<Contracts.VersionCreateActivity>, options?: IRepoOptions): Promise<SingleResult<Contracts.VersionCreateActivity>>;
+    read(request: IdSpecFor<Contracts.VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<Contracts.VersionCreateActivity>;
+    /** Performs the given operations on the existing VersionCreateActivity. */
+    tryPatch(request: PatchSpecForOne<Contracts.VersionCreateActivity>, options?: IRepoOptions): Promise<SingleResult<Contracts.VersionCreateActivity>>;
+    patch(request: PatchSpecForOne<Contracts.VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<Contracts.VersionCreateActivity>;
+    /** Overwrites the existing VersionCreateActivity. */
+    tryUpdate(request: Contracts.VersionCreateActivity, options?: IRepoOptions): Promise<SingleResult<Contracts.VersionCreateActivity>>;
+    update(request: Contracts.VersionCreateActivity, options?: IThrowingRepoOptions): Promise<Contracts.VersionCreateActivity>;
+    /** Overwrites the given properties of the existing VersionCreateActivity. */
+    tryUpdatePartial(request: Partial<Contracts.VersionCreateActivity>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.VersionCreateActivity>>>;
+    updatePartial(request: Partial<Contracts.VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.VersionCreateActivity>>;
+    /** Saves the input as a new VersionCreateActivity. */
+    tryCreate(request: Contracts.VersionCreateActivity, options?: IRepoOptions): Promise<SingleResult<Contracts.VersionCreateActivity>>;
+    create(request: Contracts.VersionCreateActivity, options?: IThrowingRepoOptions): Promise<Contracts.VersionCreateActivity>;
+    /** Overwrites the given properties for each existing VersionCreateActivity. */
+    tryUpdatePartialMany(request: Array<Contracts.VersionCreateActivity>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.VersionCreateActivity>>>;
+    updatePartialMany(request: Array<Contracts.VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.VersionCreateActivity>[]>;
+    /** Performs the given operation on each existing VersionCreateActivity that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.VersionCreateActivity, Contracts.VersionCreateActivityCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.VersionCreateActivity>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.VersionCreateActivity, Contracts.VersionCreateActivityCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.VersionCreateActivity, options?: IRepoOptions): Promise<SingleResult<Contracts.VersionCreateActivity>>;
+    upsert(request: Contracts.VersionCreateActivity, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.VersionCreateActivity>, options?: IRepoOptions): Promise<BatchResult<Contracts.VersionCreateActivity>>;
+    upsertMany(request: Array<Contracts.VersionCreateActivity>, options?: IThrowingRepoOptions): Promise<Contracts.VersionCreateActivity[]>;
+}
+declare class WorkFlowStrategyCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing WorkFlowStrategy that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.WorkFlowStrategyCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.WorkFlowStrategy>>;
+    deleteWhere(request: Contracts.WorkFlowStrategyCriteria, options?: IThrowingRepoOptions): Promise<Contracts.WorkFlowStrategy[]>;
+    /** Retrieves all the existing WorkFlowStrategy that satisfy the given criteria. */
+    tryReadMany(request: Contracts.WorkFlowStrategyCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.WorkFlowStrategy>>;
+    readMany(request: Contracts.WorkFlowStrategyCriteria, options?: IThrowingRepoOptions): Promise<Contracts.WorkFlowStrategy[]>;
+    /** Performs the given operations on each existing WorkFlowStrategy that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.WorkFlowStrategy, Contracts.WorkFlowStrategyCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.WorkFlowStrategy>>;
+    patchWhere(request: PatchSpecForMany<Contracts.WorkFlowStrategy, Contracts.WorkFlowStrategyCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.WorkFlowStrategy[]>;
+    /** Saves each given input as a new WorkFlowStrategy. */
+    tryCreateMany(request: Array<Contracts.WorkFlowStrategy>, options?: IRepoOptions): Promise<BatchResult<Contracts.WorkFlowStrategy>>;
+    createMany(request: Array<Contracts.WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<Contracts.WorkFlowStrategy[]>;
+    /** Overwrites each existing WorkFlowStrategy. */
+    tryUpdateMany(request: Array<Contracts.WorkFlowStrategy>, options?: IRepoOptions): Promise<BatchResult<Contracts.WorkFlowStrategy>>;
+    updateMany(request: Array<Contracts.WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<Contracts.WorkFlowStrategy[]>;
+    /** Deletes the existing WorkFlowStrategy. */
+    tryDelete(request: IdSpecFor<Contracts.WorkFlowStrategy>, options?: IRepoOptions): Promise<SingleResult<Contracts.WorkFlowStrategy>>;
+    delete(request: IdSpecFor<Contracts.WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<Contracts.WorkFlowStrategy>;
+    /** Retrieves the single, uniquely identified WorkFlowStrategy. */
+    tryRead(request: IdSpecFor<Contracts.WorkFlowStrategy>, options?: IRepoOptions): Promise<SingleResult<Contracts.WorkFlowStrategy>>;
+    read(request: IdSpecFor<Contracts.WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<Contracts.WorkFlowStrategy>;
+    /** Performs the given operations on the existing WorkFlowStrategy. */
+    tryPatch(request: PatchSpecForOne<Contracts.WorkFlowStrategy>, options?: IRepoOptions): Promise<SingleResult<Contracts.WorkFlowStrategy>>;
+    patch(request: PatchSpecForOne<Contracts.WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<Contracts.WorkFlowStrategy>;
+    /** Overwrites the existing WorkFlowStrategy. */
+    tryUpdate(request: Contracts.WorkFlowStrategy, options?: IRepoOptions): Promise<SingleResult<Contracts.WorkFlowStrategy>>;
+    update(request: Contracts.WorkFlowStrategy, options?: IThrowingRepoOptions): Promise<Contracts.WorkFlowStrategy>;
+    /** Overwrites the given properties of the existing WorkFlowStrategy. */
+    tryUpdatePartial(request: Partial<Contracts.WorkFlowStrategy>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.WorkFlowStrategy>>>;
+    updatePartial(request: Partial<Contracts.WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.WorkFlowStrategy>>;
+    /** Saves the input as a new WorkFlowStrategy. */
+    tryCreate(request: Contracts.WorkFlowStrategy, options?: IRepoOptions): Promise<SingleResult<Contracts.WorkFlowStrategy>>;
+    create(request: Contracts.WorkFlowStrategy, options?: IThrowingRepoOptions): Promise<Contracts.WorkFlowStrategy>;
+    /** Overwrites the given properties for each existing WorkFlowStrategy. */
+    tryUpdatePartialMany(request: Array<Contracts.WorkFlowStrategy>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.WorkFlowStrategy>>>;
+    updatePartialMany(request: Array<Contracts.WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.WorkFlowStrategy>[]>;
+    /** Performs the given operation on each existing WorkFlowStrategy that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.WorkFlowStrategy, Contracts.WorkFlowStrategyCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.WorkFlowStrategy>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.WorkFlowStrategy, Contracts.WorkFlowStrategyCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.WorkFlowStrategy, options?: IRepoOptions): Promise<SingleResult<Contracts.WorkFlowStrategy>>;
+    upsert(request: Contracts.WorkFlowStrategy, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.WorkFlowStrategy>, options?: IRepoOptions): Promise<BatchResult<Contracts.WorkFlowStrategy>>;
+    upsertMany(request: Array<Contracts.WorkFlowStrategy>, options?: IThrowingRepoOptions): Promise<Contracts.WorkFlowStrategy[]>;
+}
+declare class ZombiePeriodCruds {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Deletes each existing ZombiePeriod that satisfies the given criteria. */
+    tryDeleteWhere(request: Contracts.ZombiePeriodCriteria, options?: IRepoOptions): Promise<BatchResult<Contracts.ZombiePeriod>>;
+    deleteWhere(request: Contracts.ZombiePeriodCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod[]>;
+    /** Retrieves all the existing ZombiePeriod that satisfy the given criteria. */
+    tryReadMany(request: Contracts.ZombiePeriodCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ZombiePeriod>>;
+    readMany(request: Contracts.ZombiePeriodCriteria, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod[]>;
+    /** Performs the given operations on each existing ZombiePeriod that satisfies the given criteria. */
+    tryPatchWhere(request: PatchSpecForMany<Contracts.ZombiePeriod, Contracts.ZombiePeriodCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ZombiePeriod>>;
+    patchWhere(request: PatchSpecForMany<Contracts.ZombiePeriod, Contracts.ZombiePeriodCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod[]>;
+    /** Saves each given input as a new ZombiePeriod. */
+    tryCreateMany(request: Array<Contracts.ZombiePeriod>, options?: IRepoOptions): Promise<BatchResult<Contracts.ZombiePeriod>>;
+    createMany(request: Array<Contracts.ZombiePeriod>, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod[]>;
+    /** Overwrites each existing ZombiePeriod. */
+    tryUpdateMany(request: Array<Contracts.ZombiePeriod>, options?: IRepoOptions): Promise<BatchResult<Contracts.ZombiePeriod>>;
+    updateMany(request: Array<Contracts.ZombiePeriod>, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod[]>;
+    /** Deletes the existing ZombiePeriod. */
+    tryDelete(request: IdSpecFor<Contracts.ZombiePeriod>, options?: IRepoOptions): Promise<SingleResult<Contracts.ZombiePeriod>>;
+    delete(request: IdSpecFor<Contracts.ZombiePeriod>, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod>;
+    /** Retrieves the single, uniquely identified ZombiePeriod. */
+    tryRead(request: IdSpecFor<Contracts.ZombiePeriod>, options?: IRepoOptions): Promise<SingleResult<Contracts.ZombiePeriod>>;
+    read(request: IdSpecFor<Contracts.ZombiePeriod>, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod>;
+    /** Performs the given operations on the existing ZombiePeriod. */
+    tryPatch(request: PatchSpecForOne<Contracts.ZombiePeriod>, options?: IRepoOptions): Promise<SingleResult<Contracts.ZombiePeriod>>;
+    patch(request: PatchSpecForOne<Contracts.ZombiePeriod>, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod>;
+    /** Overwrites the existing ZombiePeriod. */
+    tryUpdate(request: Contracts.ZombiePeriod, options?: IRepoOptions): Promise<SingleResult<Contracts.ZombiePeriod>>;
+    update(request: Contracts.ZombiePeriod, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod>;
+    /** Overwrites the given properties of the existing ZombiePeriod. */
+    tryUpdatePartial(request: Partial<Contracts.ZombiePeriod>, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.ZombiePeriod>>>;
+    updatePartial(request: Partial<Contracts.ZombiePeriod>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ZombiePeriod>>;
+    /** Saves the input as a new ZombiePeriod. */
+    tryCreate(request: Contracts.ZombiePeriod, options?: IRepoOptions): Promise<SingleResult<Contracts.ZombiePeriod>>;
+    create(request: Contracts.ZombiePeriod, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod>;
+    /** Overwrites the given properties for each existing ZombiePeriod. */
+    tryUpdatePartialMany(request: Array<Contracts.ZombiePeriod>, options?: IRepoOptions): Promise<BatchResult<Partial<Contracts.ZombiePeriod>>>;
+    updatePartialMany(request: Array<Contracts.ZombiePeriod>, options?: IThrowingRepoOptions): Promise<Partial<Contracts.ZombiePeriod>[]>;
+    /** Performs the given operation on each existing ZombiePeriod that satisfies the given criteria. */
+    tryUpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ZombiePeriod, Contracts.ZombiePeriodCriteria>, options?: IRepoOptions): Promise<BatchResult<Contracts.ZombiePeriod>>;
+    UpdatePartialWhere(request: UpdatePartialWhereRequest<Contracts.ZombiePeriod, Contracts.ZombiePeriodCriteria>, options?: IThrowingRepoOptions): Promise<Contracts.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: Contracts.ZombiePeriod, options?: IRepoOptions): Promise<SingleResult<Contracts.ZombiePeriod>>;
+    upsert(request: Contracts.ZombiePeriod, options?: IThrowingRepoOptions): Promise<Contracts.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<Contracts.ZombiePeriod>, options?: IRepoOptions): Promise<BatchResult<Contracts.ZombiePeriod>>;
+    upsertMany(request: Array<Contracts.ZombiePeriod>, options?: IThrowingRepoOptions): Promise<Contracts.ZombiePeriod[]>;
+}
+declare class OtherOperations {
+    private core;
+    constructor(core: CodiacNatsClient);
+    /** Includes the given cluster within the given environment. */
+    EnvironmentClusterAttach(request: Contracts.ClusterAttachRequest, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Environment>>>;
+    /** Removes the linkage between the given environment and the given cluster. */
+    EnvironmentClusterDetach(request: Contracts.ClusterDetachRequest, options?: IRepoOptions): Promise<SingleResult<Partial<Contracts.Environment>>>;
+    /** Assembles (via smashMerge) the host naming strategy configuration for each applicable cabinet. Allows deeper filtering on domain names and types of host name strategies. */
+    GetCabinetHostNameConfig(request: Contracts.CabinetHostNameConfigCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.CabinetHostNameConfig>>;
+    /** Shows the cabinets to which the given asset is currently deployed and which version is where. */
+    assetWhere(request: Contracts.AssetWhereRequest, options?: IRepoOptions): Promise<ListResult<Contracts.CabinetAssetVersion>>;
+    /** Retrieves the enterprise configuration currently in play in a single given cabinet,
+        in terms of versions of the enterprise and its assets.
+        This is a composite/hybrid object made up of a Cabinet, EnterpriseVersionConfig and an EnterpriseRunState.
+        Compares versions of each asset between the version specified in the assigned enterprise version config
+        and the version that is actually physically running in the cabinet. */
+    getCabinetConfigState(request: Contracts.CabinetConfigStateRequest, options?: IRepoOptions): Promise<Contracts.CabinetConfigState>;
+    /** Retrieves all available enterprises, environments, cabinets, and clusters for the given tenant. */
+    getCabinetScopes(request: Contracts.CabinetScopesCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.EnterpriseScope>>;
+    /** Retrieves the list of currently declared config files for the given enterprise asset. */
+    getConfigDefs(request: Contracts.ConfigDefCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ConfigDef>>;
+    getConfigDoc(request: Contracts.ConfigDocSpecForOne, options?: IRepoOptions): Promise<Contracts.ConfigDoc>;
+    /** Retrieves a manifest of all versions and configs currently deployed within the given enterprise. */
+    getDeployedState(request: Contracts.EnterpriseStateRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseState>>;
+    /** All the enterprises, assets, cabinets, environments, and clusters for the current tenant. That is, retrieves a semi-detailed list of all the primary entities of a tenant's software organization.  Originally designed for use in ingress routing. */
+    getRootMap(request: Contracts.RootMapCriteria, options?: IRepoOptions): Promise<SingleResult<Contracts.RootMap>>;
+    /** Assembles (via smashMerge) a single config doc for the given enterprise asset, scoped for the given cabinet. */
+    getScopedConfigs(request: Contracts.ScopedConfigCriteria, options?: IRepoOptions): Promise<ListResult<Contracts.ScopedConfig>>;
+    /** (generated operationId) */
+    getSwaggerUiPath(request: Contracts.FileRequest, options?: IRepoOptions): Promise<Buffer>;
+    /** Assembles an enterprise version configuration by overlaying the given assets onto an optional existing enterprise version, and either creates a new version record for it or retrieves one if that configuration already exists.  Assets are automatically placed within their respective products if applicable. */
+    getsertVersion(request: Contracts.VersionGetsertRequest, options?: IRepoOptions): Promise<SingleResult<Contracts.EnterpriseVersionConfig>>;
+    /** Lightweight endpoint returning the last heartbeat as a UTC standard format date string (retrieves from ENV variable: HEARTBEAT_LAST). */
+    heartbeat(request: Object, options?: IRepoOptions): Promise<void>;
+    /** Lightweight endpoint returning the last heartbeat object as a JSON string (retrieves from ENV variable: HEARTBEAT_JSON). */
+    heartbeatJson(request: Object, options?: IRepoOptions): Promise<Contracts.HeartbeatRecord>;
+    readyState(request: Contracts.ReadyStateRequest, options?: IRepoOptions): Promise<Contracts.ApiReadyState>;
+    /** File serve for the relay service. */
+    relayResources(request: Contracts.FileRequest, options?: IRepoOptions): Promise<Buffer>;
+}
+export {};