@huaweicloud/huaweicloud-sdk-cbr 3.1.36

package/v1/model/VaultGet.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultGet = void 0;
+var VaultGet = /** @class */ (function () {
+    function VaultGet(billing, id, name, projectId, providerId, resources, updatedAt) {
+        this['billing'] = billing;
+        this['id'] = id;
+        this['name'] = name;
+        this['project_id'] = projectId;
+        this['provider_id'] = providerId;
+        this['resources'] = resources;
+        this['updated_at'] = updatedAt;
+    }
+    VaultGet.prototype.withBilling = function (billing) {
+        this['billing'] = billing;
+        return this;
+    };
+    VaultGet.prototype.withDescription = function (description) {
+        this['description'] = description;
+        return this;
+    };
+    VaultGet.prototype.withId = function (id) {
+        this['id'] = id;
+        return this;
+    };
+    VaultGet.prototype.withName = function (name) {
+        this['name'] = name;
+        return this;
+    };
+    VaultGet.prototype.withProjectId = function (projectId) {
+        this['project_id'] = projectId;
+        return this;
+    };
+    Object.defineProperty(VaultGet.prototype, "projectId", {
+        get: function () {
+            return this['project_id'];
+        },
+        set: function (projectId) {
+            this['project_id'] = projectId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultGet.prototype.withProviderId = function (providerId) {
+        this['provider_id'] = providerId;
+        return this;
+    };
+    Object.defineProperty(VaultGet.prototype, "providerId", {
+        get: function () {
+            return this['provider_id'];
+        },
+        set: function (providerId) {
+            this['provider_id'] = providerId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultGet.prototype.withResources = function (resources) {
+        this['resources'] = resources;
+        return this;
+    };
+    VaultGet.prototype.withTags = function (tags) {
+        this['tags'] = tags;
+        return this;
+    };
+    VaultGet.prototype.withEnterpriseProjectId = function (enterpriseProjectId) {
+        this['enterprise_project_id'] = enterpriseProjectId;
+        return this;
+    };
+    Object.defineProperty(VaultGet.prototype, "enterpriseProjectId", {
+        get: function () {
+            return this['enterprise_project_id'];
+        },
+        set: function (enterpriseProjectId) {
+            this['enterprise_project_id'] = enterpriseProjectId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultGet.prototype.withAutoBind = function (autoBind) {
+        this['auto_bind'] = autoBind;
+        return this;
+    };
+    Object.defineProperty(VaultGet.prototype, "autoBind", {
+        get: function () {
+            return this['auto_bind'];
+        },
+        set: function (autoBind) {
+            this['auto_bind'] = autoBind;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultGet.prototype.withBindRules = function (bindRules) {
+        this['bind_rules'] = bindRules;
+        return this;
+    };
+    Object.defineProperty(VaultGet.prototype, "bindRules", {
+        get: function () {
+            return this['bind_rules'];
+        },
+        set: function (bindRules) {
+            this['bind_rules'] = bindRules;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultGet.prototype.withUserId = function (userId) {
+        this['user_id'] = userId;
+        return this;
+    };
+    Object.defineProperty(VaultGet.prototype, "userId", {
+        get: function () {
+            return this['user_id'];
+        },
+        set: function (userId) {
+            this['user_id'] = userId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultGet.prototype.withCreatedAt = function (createdAt) {
+        this['created_at'] = createdAt;
+        return this;
+    };
+    Object.defineProperty(VaultGet.prototype, "createdAt", {
+        get: function () {
+            return this['created_at'];
+        },
+        set: function (createdAt) {
+            this['created_at'] = createdAt;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultGet.prototype.withAutoExpand = function (autoExpand) {
+        this['auto_expand'] = autoExpand;
+        return this;
+    };
+    Object.defineProperty(VaultGet.prototype, "autoExpand", {
+        get: function () {
+            return this['auto_expand'];
+        },
+        set: function (autoExpand) {
+            this['auto_expand'] = autoExpand;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultGet.prototype.withSmnNotify = function (smnNotify) {
+        this['smn_notify'] = smnNotify;
+        return this;
+    };
+    Object.defineProperty(VaultGet.prototype, "smnNotify", {
+        get: function () {
+            return this['smn_notify'];
+        },
+        set: function (smnNotify) {
+            this['smn_notify'] = smnNotify;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultGet.prototype.withThreshold = function (threshold) {
+        this['threshold'] = threshold;
+        return this;
+    };
+    VaultGet.prototype.withUpdatedAt = function (updatedAt) {
+        this['updated_at'] = updatedAt;
+        return this;
+    };
+    Object.defineProperty(VaultGet.prototype, "updatedAt", {
+        get: function () {
+            return this['updated_at'];
+        },
+        set: function (updatedAt) {
+            this['updated_at'] = updatedAt;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultGet.prototype.withVersion = function (version) {
+        this['version'] = version;
+        return this;
+    };
+    return VaultGet;
+}());
+exports.VaultGet = VaultGet;

package/v1/model/VaultMigrateResourceReq.d.ts

@@ -0,0 +1,11 @@
+export declare class VaultMigrateResourceReq {
+    private 'destination_vault_id';
+    private 'resource_ids';
+    constructor(destinationVaultId?: any, resourceIds?: any);
+    withDestinationVaultId(destinationVaultId: string): VaultMigrateResourceReq;
+    set destinationVaultId(destinationVaultId: string | undefined);
+    get destinationVaultId(): string | undefined;
+    withResourceIds(resourceIds: Array<string>): VaultMigrateResourceReq;
+    set resourceIds(resourceIds: Array<string> | undefined);
+    get resourceIds(): Array<string> | undefined;
+}

package/v1/model/VaultMigrateResourceReq.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultMigrateResourceReq = void 0;
+var VaultMigrateResourceReq = /** @class */ (function () {
+    function VaultMigrateResourceReq(destinationVaultId, resourceIds) {
+        this['destination_vault_id'] = destinationVaultId;
+        this['resource_ids'] = resourceIds;
+    }
+    VaultMigrateResourceReq.prototype.withDestinationVaultId = function (destinationVaultId) {
+        this['destination_vault_id'] = destinationVaultId;
+        return this;
+    };
+    Object.defineProperty(VaultMigrateResourceReq.prototype, "destinationVaultId", {
+        get: function () {
+            return this['destination_vault_id'];
+        },
+        set: function (destinationVaultId) {
+            this['destination_vault_id'] = destinationVaultId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultMigrateResourceReq.prototype.withResourceIds = function (resourceIds) {
+        this['resource_ids'] = resourceIds;
+        return this;
+    };
+    Object.defineProperty(VaultMigrateResourceReq.prototype, "resourceIds", {
+        get: function () {
+            return this['resource_ids'];
+        },
+        set: function (resourceIds) {
+            this['resource_ids'] = resourceIds;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return VaultMigrateResourceReq;
+}());
+exports.VaultMigrateResourceReq = VaultMigrateResourceReq;

package/v1/model/VaultPolicyResp.d.ts

@@ -0,0 +1,15 @@
+export declare class VaultPolicyResp {
+    private 'destination_vault_id'?;
+    private 'policy_id';
+    private 'vault_id';
+    constructor(policyId?: any, vaultId?: any);
+    withDestinationVaultId(destinationVaultId: string): VaultPolicyResp;
+    set destinationVaultId(destinationVaultId: string | undefined);
+    get destinationVaultId(): string | undefined;
+    withPolicyId(policyId: string): VaultPolicyResp;
+    set policyId(policyId: string | undefined);
+    get policyId(): string | undefined;
+    withVaultId(vaultId: string): VaultPolicyResp;
+    set vaultId(vaultId: string | undefined);
+    get vaultId(): string | undefined;
+}

package/v1/model/VaultPolicyResp.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultPolicyResp = void 0;
+var VaultPolicyResp = /** @class */ (function () {
+    function VaultPolicyResp(policyId, vaultId) {
+        this['policy_id'] = policyId;
+        this['vault_id'] = vaultId;
+    }
+    VaultPolicyResp.prototype.withDestinationVaultId = function (destinationVaultId) {
+        this['destination_vault_id'] = destinationVaultId;
+        return this;
+    };
+    Object.defineProperty(VaultPolicyResp.prototype, "destinationVaultId", {
+        get: function () {
+            return this['destination_vault_id'];
+        },
+        set: function (destinationVaultId) {
+            this['destination_vault_id'] = destinationVaultId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultPolicyResp.prototype.withPolicyId = function (policyId) {
+        this['policy_id'] = policyId;
+        return this;
+    };
+    Object.defineProperty(VaultPolicyResp.prototype, "policyId", {
+        get: function () {
+            return this['policy_id'];
+        },
+        set: function (policyId) {
+            this['policy_id'] = policyId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultPolicyResp.prototype.withVaultId = function (vaultId) {
+        this['vault_id'] = vaultId;
+        return this;
+    };
+    Object.defineProperty(VaultPolicyResp.prototype, "vaultId", {
+        get: function () {
+            return this['vault_id'];
+        },
+        set: function (vaultId) {
+            this['vault_id'] = vaultId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return VaultPolicyResp;
+}());
+exports.VaultPolicyResp = VaultPolicyResp;

package/v1/model/VaultRemoveResourceReq.d.ts

@@ -0,0 +1,7 @@
+export declare class VaultRemoveResourceReq {
+    private 'resource_ids';
+    constructor(resourceIds?: any);
+    withResourceIds(resourceIds: Array<string>): VaultRemoveResourceReq;
+    set resourceIds(resourceIds: Array<string> | undefined);
+    get resourceIds(): Array<string> | undefined;
+}

package/v1/model/VaultRemoveResourceReq.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultRemoveResourceReq = void 0;
+var VaultRemoveResourceReq = /** @class */ (function () {
+    function VaultRemoveResourceReq(resourceIds) {
+        this['resource_ids'] = resourceIds;
+    }
+    VaultRemoveResourceReq.prototype.withResourceIds = function (resourceIds) {
+        this['resource_ids'] = resourceIds;
+        return this;
+    };
+    Object.defineProperty(VaultRemoveResourceReq.prototype, "resourceIds", {
+        get: function () {
+            return this['resource_ids'];
+        },
+        set: function (resourceIds) {
+            this['resource_ids'] = resourceIds;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return VaultRemoveResourceReq;
+}());
+exports.VaultRemoveResourceReq = VaultRemoveResourceReq;

package/v1/model/VaultResourceInstancesReq.d.ts

@@ -0,0 +1,60 @@
+import { Match } from './Match';
+import { SysTags } from './SysTags';
+import { TagsReq } from './TagsReq';
+export declare class VaultResourceInstancesReq {
+    private 'without_any_tag'?;
+    tags?: Array<TagsReq>;
+    private 'tags_any'?;
+    private 'not_tags'?;
+    private 'not_tags_any'?;
+    private 'sys_tags'?;
+    limit?: string;
+    offset?: string;
+    action: string;
+    matches?: Array<Match>;
+    private 'cloud_type'?;
+    private 'object_type'?;
+    constructor(action?: any);
+    withWithoutAnyTag(withoutAnyTag: boolean): VaultResourceInstancesReq;
+    set withoutAnyTag(withoutAnyTag: boolean | undefined);
+    get withoutAnyTag(): boolean | undefined;
+    withTags(tags: Array<TagsReq>): VaultResourceInstancesReq;
+    withTagsAny(tagsAny: Array<TagsReq>): VaultResourceInstancesReq;
+    set tagsAny(tagsAny: Array<TagsReq> | undefined);
+    get tagsAny(): Array<TagsReq> | undefined;
+    withNotTags(notTags: Array<TagsReq>): VaultResourceInstancesReq;
+    set notTags(notTags: Array<TagsReq> | undefined);
+    get notTags(): Array<TagsReq> | undefined;
+    withNotTagsAny(notTagsAny: Array<TagsReq>): VaultResourceInstancesReq;
+    set notTagsAny(notTagsAny: Array<TagsReq> | undefined);
+    get notTagsAny(): Array<TagsReq> | undefined;
+    withSysTags(sysTags: Array<SysTags>): VaultResourceInstancesReq;
+    set sysTags(sysTags: Array<SysTags> | undefined);
+    get sysTags(): Array<SysTags> | undefined;
+    withLimit(limit: string): VaultResourceInstancesReq;
+    withOffset(offset: string): VaultResourceInstancesReq;
+    withAction(action: string): VaultResourceInstancesReq;
+    withMatches(matches: Array<Match>): VaultResourceInstancesReq;
+    withCloudType(cloudType: VaultResourceInstancesReqCloudTypeEnum): VaultResourceInstancesReq;
+    set cloudType(cloudType: VaultResourceInstancesReqCloudTypeEnum | undefined);
+    get cloudType(): VaultResourceInstancesReqCloudTypeEnum | undefined;
+    withObjectType(objectType: VaultResourceInstancesReqObjectTypeEnum): VaultResourceInstancesReq;
+    set objectType(objectType: VaultResourceInstancesReqObjectTypeEnum | undefined);
+    get objectType(): VaultResourceInstancesReqObjectTypeEnum | undefined;
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum VaultResourceInstancesReqCloudTypeEnum {
+    PUBLIC = "public",
+    HYBRID = " hybrid"
+}
+/**
+    * @export
+    * @enum {string}
+    */
+export declare enum VaultResourceInstancesReqObjectTypeEnum {
+    SERVER = "server",
+    DISK = "disk"
+}

package/v1/model/VaultResourceInstancesReq.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultResourceInstancesReqObjectTypeEnum = exports.VaultResourceInstancesReqCloudTypeEnum = exports.VaultResourceInstancesReq = void 0;
+var VaultResourceInstancesReq = /** @class */ (function () {
+    function VaultResourceInstancesReq(action) {
+        this['action'] = action;
+    }
+    VaultResourceInstancesReq.prototype.withWithoutAnyTag = function (withoutAnyTag) {
+        this['without_any_tag'] = withoutAnyTag;
+        return this;
+    };
+    Object.defineProperty(VaultResourceInstancesReq.prototype, "withoutAnyTag", {
+        get: function () {
+            return this['without_any_tag'];
+        },
+        set: function (withoutAnyTag) {
+            this['without_any_tag'] = withoutAnyTag;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultResourceInstancesReq.prototype.withTags = function (tags) {
+        this['tags'] = tags;
+        return this;
+    };
+    VaultResourceInstancesReq.prototype.withTagsAny = function (tagsAny) {
+        this['tags_any'] = tagsAny;
+        return this;
+    };
+    Object.defineProperty(VaultResourceInstancesReq.prototype, "tagsAny", {
+        get: function () {
+            return this['tags_any'];
+        },
+        set: function (tagsAny) {
+            this['tags_any'] = tagsAny;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultResourceInstancesReq.prototype.withNotTags = function (notTags) {
+        this['not_tags'] = notTags;
+        return this;
+    };
+    Object.defineProperty(VaultResourceInstancesReq.prototype, "notTags", {
+        get: function () {
+            return this['not_tags'];
+        },
+        set: function (notTags) {
+            this['not_tags'] = notTags;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultResourceInstancesReq.prototype.withNotTagsAny = function (notTagsAny) {
+        this['not_tags_any'] = notTagsAny;
+        return this;
+    };
+    Object.defineProperty(VaultResourceInstancesReq.prototype, "notTagsAny", {
+        get: function () {
+            return this['not_tags_any'];
+        },
+        set: function (notTagsAny) {
+            this['not_tags_any'] = notTagsAny;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultResourceInstancesReq.prototype.withSysTags = function (sysTags) {
+        this['sys_tags'] = sysTags;
+        return this;
+    };
+    Object.defineProperty(VaultResourceInstancesReq.prototype, "sysTags", {
+        get: function () {
+            return this['sys_tags'];
+        },
+        set: function (sysTags) {
+            this['sys_tags'] = sysTags;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultResourceInstancesReq.prototype.withLimit = function (limit) {
+        this['limit'] = limit;
+        return this;
+    };
+    VaultResourceInstancesReq.prototype.withOffset = function (offset) {
+        this['offset'] = offset;
+        return this;
+    };
+    VaultResourceInstancesReq.prototype.withAction = function (action) {
+        this['action'] = action;
+        return this;
+    };
+    VaultResourceInstancesReq.prototype.withMatches = function (matches) {
+        this['matches'] = matches;
+        return this;
+    };
+    VaultResourceInstancesReq.prototype.withCloudType = function (cloudType) {
+        this['cloud_type'] = cloudType;
+        return this;
+    };
+    Object.defineProperty(VaultResourceInstancesReq.prototype, "cloudType", {
+        get: function () {
+            return this['cloud_type'];
+        },
+        set: function (cloudType) {
+            this['cloud_type'] = cloudType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultResourceInstancesReq.prototype.withObjectType = function (objectType) {
+        this['object_type'] = objectType;
+        return this;
+    };
+    Object.defineProperty(VaultResourceInstancesReq.prototype, "objectType", {
+        get: function () {
+            return this['object_type'];
+        },
+        set: function (objectType) {
+            this['object_type'] = objectType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return VaultResourceInstancesReq;
+}());
+exports.VaultResourceInstancesReq = VaultResourceInstancesReq;
+/**
+    * @export
+    * @enum {string}
+    */
+var VaultResourceInstancesReqCloudTypeEnum;
+(function (VaultResourceInstancesReqCloudTypeEnum) {
+    VaultResourceInstancesReqCloudTypeEnum["PUBLIC"] = "public";
+    VaultResourceInstancesReqCloudTypeEnum["HYBRID"] = " hybrid";
+})(VaultResourceInstancesReqCloudTypeEnum = exports.VaultResourceInstancesReqCloudTypeEnum || (exports.VaultResourceInstancesReqCloudTypeEnum = {}));
+/**
+    * @export
+    * @enum {string}
+    */
+var VaultResourceInstancesReqObjectTypeEnum;
+(function (VaultResourceInstancesReqObjectTypeEnum) {
+    VaultResourceInstancesReqObjectTypeEnum["SERVER"] = "server";
+    VaultResourceInstancesReqObjectTypeEnum["DISK"] = "disk";
+})(VaultResourceInstancesReqObjectTypeEnum = exports.VaultResourceInstancesReqObjectTypeEnum || (exports.VaultResourceInstancesReqObjectTypeEnum = {}));

package/v1/model/VaultTagsCreateReq.d.ts

@@ -0,0 +1,6 @@
+import { Tag } from './Tag';
+export declare class VaultTagsCreateReq {
+    tag?: Tag;
+    constructor();
+    withTag(tag: Tag): VaultTagsCreateReq;
+}

package/v1/model/VaultTagsCreateReq.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultTagsCreateReq = void 0;
+var VaultTagsCreateReq = /** @class */ (function () {
+    function VaultTagsCreateReq() {
+    }
+    VaultTagsCreateReq.prototype.withTag = function (tag) {
+        this['tag'] = tag;
+        return this;
+    };
+    return VaultTagsCreateReq;
+}());
+exports.VaultTagsCreateReq = VaultTagsCreateReq;

package/v1/model/VaultUpdate.d.ts

@@ -0,0 +1,27 @@
+import { BillingUpdate } from './BillingUpdate';
+import { VaultBindRules } from './VaultBindRules';
+export declare class VaultUpdate {
+    billing?: BillingUpdate;
+    name?: string;
+    private 'auto_bind'?;
+    private 'bind_rules'?;
+    private 'auto_expand'?;
+    private 'smn_notify'?;
+    threshold?: number;
+    constructor();
+    withBilling(billing: BillingUpdate): VaultUpdate;
+    withName(name: string): VaultUpdate;
+    withAutoBind(autoBind: boolean): VaultUpdate;
+    set autoBind(autoBind: boolean | undefined);
+    get autoBind(): boolean | undefined;
+    withBindRules(bindRules: VaultBindRules): VaultUpdate;
+    set bindRules(bindRules: VaultBindRules | undefined);
+    get bindRules(): VaultBindRules | undefined;
+    withAutoExpand(autoExpand: boolean): VaultUpdate;
+    set autoExpand(autoExpand: boolean | undefined);
+    get autoExpand(): boolean | undefined;
+    withSmnNotify(smnNotify: boolean): VaultUpdate;
+    set smnNotify(smnNotify: boolean | undefined);
+    get smnNotify(): boolean | undefined;
+    withThreshold(threshold: number): VaultUpdate;
+}

package/v1/model/VaultUpdate.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultUpdate = void 0;
+var VaultUpdate = /** @class */ (function () {
+    function VaultUpdate() {
+    }
+    VaultUpdate.prototype.withBilling = function (billing) {
+        this['billing'] = billing;
+        return this;
+    };
+    VaultUpdate.prototype.withName = function (name) {
+        this['name'] = name;
+        return this;
+    };
+    VaultUpdate.prototype.withAutoBind = function (autoBind) {
+        this['auto_bind'] = autoBind;
+        return this;
+    };
+    Object.defineProperty(VaultUpdate.prototype, "autoBind", {
+        get: function () {
+            return this['auto_bind'];
+        },
+        set: function (autoBind) {
+            this['auto_bind'] = autoBind;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultUpdate.prototype.withBindRules = function (bindRules) {
+        this['bind_rules'] = bindRules;
+        return this;
+    };
+    Object.defineProperty(VaultUpdate.prototype, "bindRules", {
+        get: function () {
+            return this['bind_rules'];
+        },
+        set: function (bindRules) {
+            this['bind_rules'] = bindRules;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultUpdate.prototype.withAutoExpand = function (autoExpand) {
+        this['auto_expand'] = autoExpand;
+        return this;
+    };
+    Object.defineProperty(VaultUpdate.prototype, "autoExpand", {
+        get: function () {
+            return this['auto_expand'];
+        },
+        set: function (autoExpand) {
+            this['auto_expand'] = autoExpand;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultUpdate.prototype.withSmnNotify = function (smnNotify) {
+        this['smn_notify'] = smnNotify;
+        return this;
+    };
+    Object.defineProperty(VaultUpdate.prototype, "smnNotify", {
+        get: function () {
+            return this['smn_notify'];
+        },
+        set: function (smnNotify) {
+            this['smn_notify'] = smnNotify;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VaultUpdate.prototype.withThreshold = function (threshold) {
+        this['threshold'] = threshold;
+        return this;
+    };
+    return VaultUpdate;
+}());
+exports.VaultUpdate = VaultUpdate;

package/v1/model/VaultUpdateReq.d.ts

@@ -0,0 +1,6 @@
+import { VaultUpdate } from './VaultUpdate';
+export declare class VaultUpdateReq {
+    vault: VaultUpdate;
+    constructor(vault?: any);
+    withVault(vault: VaultUpdate): VaultUpdateReq;
+}