oci-cli 3.64.0__py3-none-any.whl → 3.65.0__py3-none-any.whl

services/cims/src/oci_cli_incident/cims_cli_extended.py

@@ -13,7 +13,7 @@ from services.cims.src.oci_cli_incident.generated.incident_cli import incident_g
 from oci_cli import custom_types
 from oci_cli import json_skeleton_utils
 
-from src.oci_cli import cli_exceptions
+from oci_cli import cli_exceptions
 
 # remove update-incident stand-alone command
 # incident_cli.incident_root_group.commands.pop(incident_cli.update_incident_group.name)

services/core/src/oci_cli_virtual_network/generated/virtualnetwork_cli.py

@@ -3254,6 +3254,7 @@ Example: `{\"Department\": \"Finance\"}`""" + custom_types.cli_complex_type.COMP
 @cli_util.option('--ip-address', help=u"""An IPv6 address of your choice. Must be an available IP address within the subnet's CIDR. If you don't specify a value, Oracle automatically assigns an IPv6 address from the subnet. The subnet is the one that contains the VNIC you specify in `vnicId`.
 
 Example: `2001:DB8::`""")
+@cli_util.option('--cidr-prefix-length', type=click.INT, help=u"""Length of cidr range. Optional field to specify flexible cidr.""")
 @cli_util.option('--vnic-id', help=u"""The [OCID] of the VNIC to assign the IPv6 to. The IPv6 will be in the VNIC's subnet.""")
 @cli_util.option('--subnet-id', help=u"""The [OCID] of the subnet from which the IPv6 is to be drawn. The IP address, *if supplied*, must be valid for the given subnet, only valid for reserved IPs currently.""")
 @cli_util.option('--lifetime', type=custom_types.CliCaseInsensitiveChoice(["EPHEMERAL", "RESERVED"]), help=u"""Lifetime of the IP address. There are two types of IPs:  - Ephemeral  - Reserved""")
@@ -3267,7 +3268,7 @@ Example: `2001:DB8::`""")
 @click.pass_context
 @json_skeleton_utils.json_skeleton_generation_handler(input_params_to_complex_types={'defined-tags': {'module': 'core', 'class': 'dict(str, dict(str, object))'}, 'freeform-tags': {'module': 'core', 'class': 'dict(str, string)'}}, output_type={'module': 'core', 'class': 'Ipv6'})
 @cli_util.wrap_exceptions
-def create_ipv6(ctx, from_json, wait_for_state, max_wait_seconds, wait_interval_seconds, defined_tags, display_name, freeform_tags, ip_address, vnic_id, subnet_id, lifetime, route_table_id, ipv6_subnet_cidr):
+def create_ipv6(ctx, from_json, wait_for_state, max_wait_seconds, wait_interval_seconds, defined_tags, display_name, freeform_tags, ip_address, cidr_prefix_length, vnic_id, subnet_id, lifetime, route_table_id, ipv6_subnet_cidr):
 
     kwargs = {}
     kwargs['opc_request_id'] = cli_util.use_or_generate_request_id(ctx.obj['request_id'])
@@ -3286,6 +3287,9 @@ def create_ipv6(ctx, from_json, wait_for_state, max_wait_seconds, wait_interval_
     if ip_address is not None:
         _details['ipAddress'] = ip_address
 
+    if cidr_prefix_length is not None:
+        _details['cidrPrefixLength'] = cidr_prefix_length
+
     if vnic_id is not None:
         _details['vnicId'] = vnic_id
 

services/core/src/oci_cli_virtual_network/virtualnetwork_cli_extended.py

@@ -291,7 +291,7 @@ def unassign_private_ip(ctx, from_json, vnic_id, ip_address):
 @click.pass_context
 @json_skeleton_utils.json_skeleton_generation_handler(input_params_to_complex_types={'defined-tags': {'module': 'core', 'class': 'dict(str, dict(str, object))'}, 'freeform-tags': {'module': 'core', 'class': 'dict(str, string)'}}, output_type={'module': 'core', 'class': 'PrivateIp'})
 @cli_util.wrap_exceptions
-def assign_ipv6(ctx, from_json, vnic_id, defined_tags, display_name, freeform_tags, ip_address, unassign_if_already_assigned, ipv6_subnet_cidr, route_table_id, lifetime):
+def assign_ipv6(ctx, from_json, vnic_id, defined_tags, display_name, freeform_tags, ip_address, unassign_if_already_assigned, ipv6_subnet_cidr, route_table_id, lifetime, cidr_prefix_length):
     networking_client = cli_util.build_client('core', 'virtual_network', ctx)
 
     # First we get the VNIC because we need to know the subnet OCID for the ListIpv6s call
@@ -355,6 +355,10 @@ def assign_ipv6(ctx, from_json, vnic_id, defined_tags, display_name, freeform_ta
     if not is_ip_reassignment:
         if ip_address is not None:
             assign_ip_request_body['ipAddress'] = ip_address
+        if cidr_prefix_length is not None:
+            assign_ip_request_body['cidrPrefixLength'] = cidr_prefix_length
+        if subnet_id is not None:
+            assign_ip_request_body['subnetId'] = subnet_id
 
         result = networking_client.create_ipv6(assign_ip_request_body)
     else:

services/data_safe/src/oci_cli_data_safe/generated/datasafe_cli.py

@@ -13849,6 +13849,11 @@ When you perform the ListFindingAnalytics operation, if the parameter compartmen
 @cli_util.option('--target-ids', multiple=True, help=u"""An optional filter to return only findings that match the specified target ids. Use this parameter to filter by multiple target ids.""")
 @cli_util.option('--category', help=u"""The category of the finding.""")
 @cli_util.option('--contains-severity', type=custom_types.CliCaseInsensitiveChoice(["HIGH", "MEDIUM", "LOW", "EVALUATE", "ADVISORY", "PASS", "DEFERRED"]), multiple=True, help=u"""A filter to return only findings that match the specified risk level(s). Use containsSeverity parameter if need to filter by multiple risk levels.""")
+@cli_util.option('--scim-query', help=u"""The scimQuery query parameter accepts filter expressions that use the syntax described in Section 3.2.2.2 of the System for Cross-Domain Identity Management (SCIM) specification, which is available at [RFC3339]. In SCIM filtering expressions, text, date, and time values must be enclosed in quotation marks, with date and time values using ISO-8601 format. (Numeric and boolean values should not be quoted.)
+
+**Example:** | scimQuery=(severity eq 'high') scimQuery=(category eq \"Users\") and (reference eq 'CIS')
+
+Supported fields: severity reference title category""")
 @cli_util.option('--all', 'all_pages', is_flag=True, help="""Fetches all pages of results. If you provide this option, then you cannot provide the --limit option.""")
 @cli_util.option('--page-size', type=click.INT, help="""When fetching results, the number of results to fetch per call. Only valid when used with --all or --limit, and ignored otherwise.""")
 @json_skeleton_utils.get_cli_json_input_option({'target-ids': {'module': 'data_safe', 'class': 'list[string]'}})
@@ -13856,7 +13861,7 @@ When you perform the ListFindingAnalytics operation, if the parameter compartmen
 @click.pass_context
 @json_skeleton_utils.json_skeleton_generation_handler(input_params_to_complex_types={'target-ids': {'module': 'data_safe', 'class': 'list[string]'}}, output_type={'module': 'data_safe', 'class': 'FindingAnalyticsCollection'})
 @cli_util.wrap_exceptions
-def list_finding_analytics(ctx, from_json, all_pages, page_size, compartment_id, compartment_id_in_subtree, access_level, is_top_finding, group_by, top_finding_status, severity, finding_key, limit, page, target_database_group_id, contains_references, target_ids, category, contains_severity):
+def list_finding_analytics(ctx, from_json, all_pages, page_size, compartment_id, compartment_id_in_subtree, access_level, is_top_finding, group_by, top_finding_status, severity, finding_key, limit, page, target_database_group_id, contains_references, target_ids, category, contains_severity, scim_query):
 
     if all_pages and limit:
         raise click.UsageError('If you provide the --all option you cannot provide the --limit option')
@@ -13890,6 +13895,8 @@ def list_finding_analytics(ctx, from_json, all_pages, page_size, compartment_id,
         kwargs['category'] = category
     if contains_severity is not None and len(contains_severity) > 0:
         kwargs['contains_severity'] = contains_severity
+    if scim_query is not None:
+        kwargs['scim_query'] = scim_query
     kwargs['opc_request_id'] = cli_util.use_or_generate_request_id(ctx.obj['request_id'])
     client = cli_util.build_client('data_safe', 'data_safe', ctx)
     if all_pages:
@@ -13939,6 +13946,7 @@ def list_finding_analytics(ctx, from_json, all_pages, page_size, compartment_id,
 Supported fields: severity findingKey reference targetId isTopFinding title category remarks details summary isRiskModified""")
 @cli_util.option('--field', type=custom_types.CliCaseInsensitiveChoice(["severity", "findingKey", "reference", "targetId", "isTopFinding", "title", "category", "remarks", "details", "summary", "isRiskModified"]), multiple=True, help=u"""Specifies a subset of fields to be returned in the response.""")
 @cli_util.option('--sort-by', type=custom_types.CliCaseInsensitiveChoice(["category", "findingKey", "severity"]), help=u"""The field to sort by. You can specify only one sort order(sortOrder). The default order for category is alphabetical.""")
+@cli_util.option('--sort-order', type=custom_types.CliCaseInsensitiveChoice(["ASC", "DESC"]), help=u"""The sort order to use, either ascending (ASC) or descending (DESC).""")
 @cli_util.option('--finding-key', help=u"""Each finding in security assessment has an associated key (think of key as a finding's name). For a given finding, the key will be the same across targets. The user can use these keys to filter the findings.""")
 @cli_util.option('--all', 'all_pages', is_flag=True, help="""Fetches all pages of results. If you provide this option, then you cannot provide the --limit option.""")
 @cli_util.option('--page-size', type=click.INT, help="""When fetching results, the number of results to fetch per call. Only valid when used with --all or --limit, and ignored otherwise.""")
@@ -13947,7 +13955,7 @@ Supported fields: severity findingKey reference targetId isTopFinding title cate
 @click.pass_context
 @json_skeleton_utils.json_skeleton_generation_handler(input_params_to_complex_types={'target-ids': {'module': 'data_safe', 'class': 'list[string]'}}, output_type={'module': 'data_safe', 'class': 'list[FindingSummary]'})
 @cli_util.wrap_exceptions
-def list_findings(ctx, from_json, all_pages, page_size, security_assessment_id, is_top_finding, severity, contains_severity, category, lifecycle_state, references, contains_references, limit, page, compartment_id_in_subtree, access_level, target_id, target_ids, scim_query, field, sort_by, finding_key):
+def list_findings(ctx, from_json, all_pages, page_size, security_assessment_id, is_top_finding, severity, contains_severity, category, lifecycle_state, references, contains_references, limit, page, compartment_id_in_subtree, access_level, target_id, target_ids, scim_query, field, sort_by, sort_order, finding_key):
 
     if all_pages and limit:
         raise click.UsageError('If you provide the --all option you cannot provide the --limit option')
@@ -13988,6 +13996,8 @@ def list_findings(ctx, from_json, all_pages, page_size, security_assessment_id,
         kwargs['field'] = field
     if sort_by is not None:
         kwargs['sort_by'] = sort_by
+    if sort_order is not None:
+        kwargs['sort_order'] = sort_order
     if finding_key is not None:
         kwargs['finding_key'] = finding_key
     kwargs['opc_request_id'] = cli_util.use_or_generate_request_id(ctx.obj['request_id'])

services/database/src/oci_cli_database/database_cli_extended.py

@@ -665,6 +665,8 @@ def launch_db_system_from_database_extended(ctx, **kwargs):
 @cli_util.option('--backup-destination', required=False, type=custom_types.CLI_COMPLEX_TYPE, help="""backup destination list""")
 @cli_util.option('--vault-id', required=False, help="""The OCID of the Oracle Cloud Infrastructure vault.""")
 @cli_util.option('--hsm-password', required=False, help=u"""Provide the HSM password as you would in RDBMS for External HSM.""")
+@cli_util.option('--data-storage-size-in-gbs', type=click.INT, help=u"""Provide the DATA storage size, in gigabytes, that is applicable for the database.""")
+@cli_util.option('--reco-storage-size-in-gbs', type=click.INT, help=u"""Provide the RECO storage size, in gigabytes, that is applicable for the database.""")
 @click.pass_context
 @json_skeleton_utils.json_skeleton_generation_handler(input_params_to_complex_types={'backup-destination': {'module': 'database', 'class': 'list[BackupDestinationDetails]'}, 'freeform-tags': {'module': 'database', 'class': 'dict(str, string)'}, 'defined-tags': {'module': 'database', 'class': 'dict(str, dict(str, object))'}}, output_type={'module': 'database', 'class': 'DatabaseSummary'})
 @cli_util.wrap_exceptions
@@ -739,6 +741,20 @@ def create_database(ctx, wait_for_state, max_wait_seconds, wait_interval_seconds
     if 'kms_key_version_id' in kwargs and kwargs['kms_key_version_id']:
         create_database_details['kmsKeyVersionId'] = kwargs['kms_key_version_id']
 
+    database_storage_size_details = oci.database.models.DatabaseStorageSizeDetails()
+    include_storage_details = False
+
+    if 'data_storage_size_in_gbs' in kwargs and kwargs['data_storage_size_in_gbs']:
+        database_storage_size_details.data_storage_size_in_gbs = kwargs['data_storage_size_in_gbs']
+        include_storage_details = True
+
+    if 'reco_storage_size_in_gbs' in kwargs and kwargs['reco_storage_size_in_gbs']:
+        database_storage_size_details.reco_storage_size_in_gbs = kwargs['reco_storage_size_in_gbs']
+        include_storage_details = True
+
+    if include_storage_details:
+        create_database_details.storage_size_details = database_storage_size_details
+
     _encryption_key_location_details = {}
     if 'hsm_password' in kwargs and kwargs['hsm_password']:
         _encryption_key_location_details['providerType'] = 'EXTERNAL'
@@ -842,6 +858,8 @@ def create_database(ctx, wait_for_state, max_wait_seconds, wait_interval_seconds
 @cli_util.option('--db-name', required=False, help="""The display name of the database to be created from the backup. It must begin with an alphabetic character and can contain a maximum of eight alphanumeric characters. Special characters are not permitted.""")
 @cli_util.option('--db-unique-name', required=False, help="""The database unique name. It must be greater than 3 characters, but at most 30 characters, begin with a letter, and contain only letters, numbers, and underscores. The first eight characters must also be unique within a Database Domain and within a Database System or VM Cluster. In addition, if it is not on a VM Cluster it might either be identical to the database name or prefixed by the datbase name and followed by an underscore.""")
 @cli_util.option('--sid-prefix', required=False, help="""Specifies a prefix for the `Oracle SID` of the database to be created.""")
+@cli_util.option('--data-storage-size-in-gbs', type=click.INT, help=u"""Provide the DATA storage size, in gigabytes, that is applicable for the database.""")
+@cli_util.option('--reco-storage-size-in-gbs', type=click.INT, help=u"""Provide the RECO storage size, in gigabytes, that is applicable for the database.""")
 @click.pass_context
 @json_skeleton_utils.json_skeleton_generation_handler(input_params_to_complex_types={'freeform-tags': {'module': 'database', 'class': 'dict(str, string)'}, 'defined-tags': {'module': 'database', 'class': 'dict(str, dict(str, object))'}}, output_type={'module': 'database', 'class': 'DatabaseSummary'})
 @cli_util.wrap_exceptions
@@ -893,6 +911,20 @@ def create_database_from_backup(ctx, wait_for_state, max_wait_seconds, wait_inte
     if 'is_desupported_version' in kwargs and kwargs['is_desupported_version']:
         create_db_home_with_system_details.is_desupported_version = kwargs['is_desupported_version']
 
+    database_storage_size_details = oci.database.models.DatabaseStorageSizeDetails()
+    include_storage_details = False
+
+    if 'data_storage_size_in_gbs' in kwargs and kwargs['data_storage_size_in_gbs']:
+        database_storage_size_details.data_storage_size_in_gbs = kwargs['data_storage_size_in_gbs']
+        include_storage_details = True
+
+    if 'reco_storage_size_in_gbs' in kwargs and kwargs['reco_storage_size_in_gbs']:
+        database_storage_size_details.reco_storage_size_in_gbs = kwargs['reco_storage_size_in_gbs']
+        include_storage_details = True
+
+    if include_storage_details:
+        create_database_details.storage_size_details = database_storage_size_details
+
     create_db_home_with_system_details.database = create_database_details
 
     client = cli_util.build_client('database', 'database', ctx)
@@ -1479,6 +1511,8 @@ All Oracle Cloud Infrastructue resources, including Data Guard associations, get
 @cli_util.option('--availability-domain', required=True, help="""The name of the Availability Domain that the standby database DB System will be located in.""")
 @cli_util.option('--storage-performance', type=custom_types.CliCaseInsensitiveChoice(["BALANCED", "HIGH_PERFORMANCE"]), help=u"""The block storage volume performance level. Valid values are `BALANCED` and `HIGH_PERFORMANCE`. See [Block Volume Performance] for more information.""")
 @cli_util.option('--cpu-core-count', type=click.INT, help=u"""The number of OCPU cores available for AMD-based virtual machine DB systems.""")
+@cli_util.option('--compute-model', type=custom_types.CliCaseInsensitiveChoice(["ECPU", "OCPU"]), help=u"""The compute model for Base Database Service. This is required if using the `computeCount` parameter. If using `cpuCoreCount` then it is an error to specify `computeModel` to a non-null value. The ECPU compute model is the recommended model, and the OCPU compute model is legacy.""")
+@cli_util.option('--compute-count', type=click.INT, help=u"""The number of compute servers for the DB system.""")
 @cli_util.option('--shape', help=u"""The shape of the DB system to launch to set up the Data Guard association. The shape determines the number of CPU cores and the amount of memory available for the DB system. Only virtual machine shapes are valid shapes. If you do not supply this parameter, the default shape is the shape of the primary DB system. To get a list of all shapes, use the [ListDbSystemShapes] operation.""")
 @cli_util.option('--subnet-id', required=True, help="""The OCID of the subnet the DB System is associated with. **Subnet Restrictions:** - For 1- and 2-node RAC DB Systems, do not use a subnet that overlaps with 192.168.16.16/28
 
@@ -1500,7 +1534,7 @@ These subnets are used by the Oracle Clusterware private interconnect on the dat
 @click.pass_context
 @json_skeleton_utils.json_skeleton_generation_handler(input_params_to_complex_types={'fault-domains': {'module': 'database', 'class': 'list[string]'}, 'db-system-freeform-tags': {'module': 'database', 'class': 'dict(str, string)'}, 'db-system-defined-tags': {'module': 'database', 'class': 'dict(str, dict(str, object))'}, 'database-freeform-tags': {'module': 'database', 'class': 'dict(str, string)'}, 'database-defined-tags': {'module': 'database', 'class': 'dict(str, dict(str, object))'}}, output_type={'module': 'database', 'class': 'DataGuardAssociation'})
 @cli_util.wrap_exceptions
-def create_data_guard_association_with_new_db_system(ctx, from_json, database_id, creation_type, database_admin_password, protection_mode, transport_type, availability_domain, display_name, hostname, shape, subnet_id, database_software_image_id, is_active_data_guard_enabled, storage_performance, cpu_core_count, node_count, time_zone, fault_domains, private_ip, license_model, db_system_freeform_tags, db_system_defined_tags, database_freeform_tags, database_defined_tags, is_diagnostics_events_enabled, is_health_monitoring_enabled, is_incident_logs_enabled, domain, **kwargs):
+def create_data_guard_association_with_new_db_system(ctx, from_json, database_id, creation_type, database_admin_password, protection_mode, transport_type, availability_domain, display_name, hostname, shape, subnet_id, database_software_image_id, is_active_data_guard_enabled, storage_performance, cpu_core_count, compute_model, compute_count, node_count, time_zone, fault_domains, private_ip, license_model, db_system_freeform_tags, db_system_defined_tags, database_freeform_tags, database_defined_tags, is_diagnostics_events_enabled, is_health_monitoring_enabled, is_incident_logs_enabled, domain, **kwargs):
     kwargs = {}
 
     details = {}
@@ -1525,6 +1559,10 @@ def create_data_guard_association_with_new_db_system(ctx, from_json, database_id
         details['isActiveDataGuardEnabled'] = is_active_data_guard_enabled
     if cpu_core_count is not None:
         details['cpuCoreCount'] = cpu_core_count
+    if compute_model is not None:
+        details['computeModel'] = compute_model
+    if compute_count is not None:
+        details['computeCount'] = compute_count
     if storage_performance is not None:
         details['storageVolumePerformanceMode'] = storage_performance
     if node_count is not None:
@@ -3647,7 +3685,7 @@ def convert_to_regular_pluggable_database_extended(ctx, **kwargs):
     ctx.invoke(database_cli.convert_to_regular_pluggable_database, **kwargs)
 
 
-@cli_util.copy_params_from_generated_command(database_cli.create_pluggable_database, params_to_exclude=['container_database_id', 'pdb_creation_type_details_source_pluggable_database_id', 'should_create_pdb_backup', 'should_pdb_admin_account_be_locked', 'container_database_admin_password', 'pdb_creation_type_details', 'pdb_creation_type_details_is_thin_clone'])
+@cli_util.copy_params_from_generated_command(database_cli.create_pluggable_database, params_to_exclude=['container_database_id', 'pdb_creation_type_details_source_pluggable_database_id', 'should_create_pdb_backup', 'should_pdb_admin_account_be_locked', 'container_database_admin_password', 'pdb_creation_type_details', 'pdb_creation_type_details_is_thin_clone', 'pdb_creation_type_details_source_pluggable_database_snapshot_id'])
 @database_cli.pluggable_database_group.command(name=database_cli.create_pluggable_database_create_pluggable_database_from_local_clone_details.name, help=database_cli.create_pluggable_database_create_pluggable_database_from_local_clone_details.help)
 @cli_util.option('--cdb-id', required=True, help=u"""The [OCID] of the CDB [required]""")
 @cli_util.option('--source-pdb-id', required=True, help=u"""The OCID of the Source Pluggable Database. [required]""")
@@ -3655,6 +3693,7 @@ def convert_to_regular_pluggable_database_extended(ctx, **kwargs):
 @cli_util.option('--lock-pdb-admin-account', type=click.BOOL, help=u"""The locked mode of the pluggable database admin account. If false, the user needs to provide the PDB Admin Password to connect to it. If true, the pluggable database will be locked and user cannot login to it.""")
 @cli_util.option('--cdb-admin-password', help=u"""The DB system administrator password of the Container Database.""")
 @cli_util.option('--is-thin-clone', type=click.BOOL, help=u"""True if Pluggable Database needs to be thin cloned and false if Pluggable Database needs to be thick cloned.""")
+@cli_util.option('--source-pdb-snapshot-id', help=u"""The OCID of the Source Pluggable Database Snapshot id.""")
 @click.pass_context
 @json_skeleton_utils.json_skeleton_generation_handler(input_params_to_complex_types={'freeform-tags': {'module': 'database', 'class': 'dict(str, string)'}, 'defined-tags': {'module': 'database', 'class': 'dict(str, dict(str, object))'}}, output_type={'module': 'database', 'class': 'PluggableDatabase'})
 @cli_util.wrap_exceptions
@@ -3684,6 +3723,10 @@ def create_pluggable_database_create_pluggable_database_from_local_clone_details
         kwargs['pdb_creation_type_details_is_thin_clone'] = kwargs['is_thin_clone']
         kwargs.pop('is_thin_clone')
 
+    if 'source_pdb_snapshot_id' in kwargs:
+        kwargs['pdb_creation_type_details_source_pluggable_database_snapshot_id'] = kwargs['source_pdb_snapshot_id']
+        kwargs.pop('source_pdb_snapshot_id')
+
     ctx.invoke(database_cli.create_pluggable_database_create_pluggable_database_from_local_clone_details, **kwargs)
 
 
@@ -3737,7 +3780,7 @@ def create_pluggable_database_create_pluggable_database_from_relocate_details_ex
     ctx.invoke(database_cli.create_pluggable_database_create_pluggable_database_from_relocate_details, **kwargs)
 
 
-@cli_util.copy_params_from_generated_command(database_cli.create_pluggable_database, params_to_exclude=['container_database_id', 'pdb_creation_type_details_source_container_database_admin_password', 'pdb_creation_type_details_source_pluggable_database_id', 'pdb_creation_type_details_dblink_user_password', 'pdb_creation_type_details_dblink_username', 'pdb_creation_type_details_refreshable_clone_details', 'should_create_pdb_backup', 'should_pdb_admin_account_be_locked', 'container_database_admin_password', 'pdb_creation_type_details', 'pdb_creation_type_details_is_thin_clone'])
+@cli_util.copy_params_from_generated_command(database_cli.create_pluggable_database, params_to_exclude=['container_database_id', 'pdb_creation_type_details_source_container_database_admin_password', 'pdb_creation_type_details_source_pluggable_database_id', 'pdb_creation_type_details_dblink_user_password', 'pdb_creation_type_details_dblink_username', 'pdb_creation_type_details_refreshable_clone_details', 'should_create_pdb_backup', 'should_pdb_admin_account_be_locked', 'container_database_admin_password', 'pdb_creation_type_details', 'pdb_creation_type_details_is_thin_clone', 'pdb_creation_type_details_source_pluggable_database_snapshot_id'])
 @database_cli.pluggable_database_group.command(name=database_cli.create_pluggable_database_create_pluggable_database_from_remote_clone_details.name, help=database_cli.create_pluggable_database_create_pluggable_database_from_remote_clone_details.help)
 @cli_util.option('--cdb-id', required=True, help=u"""The [OCID] of the CDB [required]""")
 @cli_util.option('--source-cdb-admin-password', required=True, help=u"""The DB system administrator password of the source Container Database. [required]""")
@@ -3749,6 +3792,7 @@ def create_pluggable_database_create_pluggable_database_from_relocate_details_ex
 @cli_util.option('--lock-pdb-admin-account', type=click.BOOL, help=u"""The locked mode of the pluggable database admin account. If false, the user needs to provide the PDB Admin Password to connect to it. If true, the pluggable database will be locked and user cannot login to it.""")
 @cli_util.option('--cdb-admin-password', help=u"""The DB system administrator password of the Container Database.""")
 @cli_util.option('--is-thin-clone', type=click.BOOL, help=u"""True if Pluggable Database needs to be thin cloned and false if Pluggable Database needs to be thick cloned.""")
+@cli_util.option('--source-pdb-snapshot-id', help=u"""The OCID of the Source Pluggable Database Snapshot id.""")
 @click.pass_context
 @json_skeleton_utils.json_skeleton_generation_handler(input_params_to_complex_types={'freeform-tags': {'module': 'database', 'class': 'dict(str, string)'}, 'defined-tags': {'module': 'database', 'class': 'dict(str, dict(str, object))'}}, output_type={'module': 'database', 'class': 'PluggableDatabase'})
 @cli_util.wrap_exceptions
@@ -3790,6 +3834,10 @@ def create_pluggable_database_create_pluggable_database_from_remote_clone_detail
         kwargs['pdb_creation_type_details_is_thin_clone'] = kwargs['is_thin_clone']
         kwargs.pop('is_thin_clone')
 
+    if 'source_pdb_snapshot_id' in kwargs:
+        kwargs['pdb_creation_type_details_source_pluggable_database_snapshot_id'] = kwargs['source_pdb_snapshot_id']
+        kwargs.pop('source_pdb_snapshot_id')
+
     pdb_creation_type_details_refreshable_clone_details = {}
     if 'is_refreshable_clone' in kwargs:
         pdb_creation_type_details_refreshable_clone_details['isRefreshableClone'] = kwargs['is_refreshable_clone']
@@ -4084,6 +4132,9 @@ For more information, see [Redo Transport Services] in the Oracle Data Guard doc
 @cli_util.option('--sid-prefix', help=u"""Specifies a prefix for the `Oracle SID` of the standby database to be created.""")
 @cli_util.option('--freeform-tags', type=custom_types.CLI_COMPLEX_TYPE, help=u"""Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags].\n\nExample: `{\"Department\": \"Finance\"}`""" + custom_types.cli_complex_type.COMPLEX_TYPE_HELP)
 @cli_util.option('--defined-tags', type=custom_types.CLI_COMPLEX_TYPE, help=u"""Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags].""" + custom_types.cli_complex_type.COMPLEX_TYPE_HELP)
+@cli_util.option('--hsm-password', help=u"""Provide the HSM password as you would in RDBMS for External HSM.""")
+@cli_util.option('--data-storage-size-in-gbs', type=click.INT, help=u"""Provide the DATA storage size, in gigabytes, that is applicable for the database.""")
+@cli_util.option('--reco-storage-size-in-gbs', type=click.INT, help=u"""Provide the RECO storage size, in gigabytes, that is applicable for the database.""")
 @cli_util.help_option
 @click.pass_context
 @json_skeleton_utils.json_skeleton_generation_handler(input_params_to_complex_types={'freeform-tags': {'module': 'database', 'class': 'dict(str, string)'}, 'defined-tags': {'module': 'database', 'class': 'dict(str, dict(str, object))'}}, output_type={'module': 'database', 'class': 'DatabaseSummary'})
@@ -4127,6 +4178,20 @@ def create_standby_database_for_multiple_standby(ctx, wait_for_state, max_wait_s
     if 'defined_tags' in kwargs and kwargs['defined_tags']:
         create_standby_details.defined_tags = cli_util.parse_json_parameter('defined_tags', kwargs['defined_tags'])
 
+    database_storage_size_details = oci.database.models.DatabaseStorageSizeDetails()
+    include_storage_details = False
+
+    if 'data_storage_size_in_gbs' in kwargs and kwargs['data_storage_size_in_gbs']:
+        database_storage_size_details.data_storage_size_in_gbs = kwargs['data_storage_size_in_gbs']
+        include_storage_details = True
+
+    if 'reco_storage_size_in_gbs' in kwargs and kwargs['reco_storage_size_in_gbs']:
+        database_storage_size_details.reco_storage_size_in_gbs = kwargs['reco_storage_size_in_gbs']
+        include_storage_details = True
+
+    if include_storage_details:
+        create_standby_details.storage_size_details = database_storage_size_details
+
     _details['database'] = create_standby_details
 
     if 'db_version' in kwargs and kwargs['db_version']:
@@ -4181,3 +4246,44 @@ cli_util.rename_command(database_cli, database_cli.system_version_minor_version_
 
 # oci db system-version-minor-version-collection -> oci db system-minor-version
 cli_util.rename_command(database_cli, database_cli.db_root_group, database_cli.system_version_minor_version_collection_group, "system-minor-version")
+
+# move sanpshot operations to pdb group
+# oci db pluggable-database-snapshot create -> oci db pluggable-database create-snapshot
+# oci db pluggable-database-snapshot delete -> oci db pluggable-database delete-snapshot
+# oci db pluggable-database-snapshot get -> oci db pluggable-database get-snapshot
+# oci db pluggable-database-snapshot list -> oci db pluggable-database list-snapshots
+cli_util.rename_command(database_cli, database_cli.pluggable_database_snapshot_group, database_cli.create_pluggable_database_snapshot, "create-snapshot")
+cli_util.rename_command(database_cli, database_cli.pluggable_database_snapshot_group, database_cli.delete_pluggable_database_snapshot, "delete-snapshot")
+cli_util.rename_command(database_cli, database_cli.pluggable_database_snapshot_group, database_cli.get_pluggable_database_snapshot, "get-snapshot")
+cli_util.rename_command(database_cli, database_cli.pluggable_database_snapshot_group, database_cli.list_pluggable_database_snapshots, "list-snapshots")
+database_cli.pluggable_database_group.add_command(database_cli.create_pluggable_database_snapshot)
+database_cli.pluggable_database_group.add_command(database_cli.delete_pluggable_database_snapshot)
+database_cli.pluggable_database_group.add_command(database_cli.get_pluggable_database_snapshot)
+database_cli.pluggable_database_group.add_command(database_cli.list_pluggable_database_snapshots)
+database_cli.db_root_group.commands.pop(database_cli.pluggable_database_snapshot_group.name)
+
+
+# Renaming the pluggable-database-snapshot-id to pdb-snapshot-id
+@cli_util.copy_params_from_generated_command(database_cli.get_pluggable_database_snapshot, params_to_exclude=['pluggable_database_snapshot_id'])
+@database_cli.pluggable_database_group.command('get-snapshot', help=database_cli.get_pluggable_database_snapshot.help)
+@cli_util.option('--pdb-snapshot-id', required=True, help=u"""The Exadata Pluggable Database Snapshot [OCID].""")
+@click.pass_context
+@json_skeleton_utils.json_skeleton_generation_handler(input_params_to_complex_types={}, output_type={'module': 'database', 'class': 'PluggableDatabaseSnapshot'})
+@cli_util.wrap_exceptions
+def get_pluggable_database_snapshot_extended(ctx, **kwargs):
+    kwargs['pluggable_database_snapshot_id'] = kwargs['pdb_snapshot_id']
+    kwargs.pop('pdb_snapshot_id')
+    ctx.invoke(database_cli.get_pluggable_database_snapshot, **kwargs)
+
+
+# Renaming the pluggable-database-snapshot-id to pdb-snapshot-id
+@cli_util.copy_params_from_generated_command(database_cli.delete_pluggable_database_snapshot, params_to_exclude=['pluggable_database_snapshot_id'])
+@database_cli.pluggable_database_group.command('delete-snapshot', help=database_cli.delete_pluggable_database_snapshot.help)
+@cli_util.option('--pdb-snapshot-id', required=True, help=u"""The Exadata Pluggable Database Snapshot [OCID].""")
+@click.pass_context
+@json_skeleton_utils.json_skeleton_generation_handler(input_params_to_complex_types={})
+@cli_util.wrap_exceptions
+def delete_pluggable_database_snapshot_extended(ctx, **kwargs):
+    kwargs['pluggable_database_snapshot_id'] = kwargs['pdb_snapshot_id']
+    kwargs.pop('pdb_snapshot_id')
+    ctx.invoke(database_cli.delete_pluggable_database_snapshot, **kwargs)