### Python Example for DoorLockSettingsResponseSchema Usage

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/DoorLockSettingsResponseSchema.md

Demonstrates how to instantiate, serialize, and deserialize the DoorLockSettingsResponseSchema object in Python. This example covers creating an instance from a JSON string, printing its JSON representation, converting it to a dictionary, and creating an instance from a dictionary.

```python
from cloudbeds_pms.models.door_lock_settings_response_schema import DoorLockSettingsResponseSchema

# TODO update the JSON string below
json = "{}"
# create an instance of DoorLockSettingsResponseSchema from a JSON string
door_lock_settings_response_schema_instance = DoorLockSettingsResponseSchema.from_json(json)
# print the JSON string representation of the object
print(DoorLockSettingsResponseSchema.to_json())

# convert the object into a dict
door_lock_settings_response_schema_dict = door_lock_settings_response_schema_instance.to_dict()
# create an instance of DoorLockSettingsResponseSchema from a dict
door_lock_settings_response_schema_from_dict = DoorLockSettingsResponseSchema.from_dict(door_lock_settings_response_schema_dict)
```

--------------------------------

### Python Example: Create a New Doorlock Key (Partial)

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/DoorlockKeysApi.md

Provides a partial Python example for setting up the API client to create a new doorlock key using the `door_lock_key_controller_create` method. It shows the necessary imports and configuration for OAuth authentication.

```python
import cloudbeds_pms
from cloudbeds_pms.models.door_lock_key_create_request_schema import DoorLockKeyCreateRequestSchema
from cloudbeds_pms.models.door_lock_key_response_schema import DoorLockKeyResponseSchema
from cloudbeds_pms.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://api.cloudbeds.com
# See configuration.py for a list of all supported configuration parameters.
configuration = cloudbeds_pms.Configuration(
    host = "https://api.cloudbeds.com"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

configuration.access_token = os.environ["ACCESS_TOKEN"]
```

--------------------------------

### Python Example: Enable Market Segmentation Segment

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/MarketSegmentationSegmentsApi.md

Demonstrates how to use the Cloudbeds PMS Python SDK to enable a Market Segmentation Segment. The example shows API client configuration, OAuth authentication, and calling the `segment_controller_enable` method with required property and segment IDs.

```python
import cloudbeds_pms
from cloudbeds_pms.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://api.cloudbeds.com
# See configuration.py for a list of all supported configuration parameters.
configuration = cloudbeds_pms.Configuration(
    host = "https://api.cloudbeds.com"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

configuration.access_token = os.environ["ACCESS_TOKEN"]

# Enter a context with an instance of the API client
with cloudbeds_pms.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = cloudbeds_pms.MarketSegmentationSegmentsApi(api_client)
    x_property_id = '1,2,3' # str | A numeric, comma-separated string representing the property IDs, sent in the header.
    id = cloudbeds_pms.Id() # Id | Segment ID.

    try:
        # Enable a Market Segmentation Segment.
        api_response = api_instance.segment_controller_enable(x_property_id, id)
        print("The response of MarketSegmentationSegmentsApi->segment_controller_enable:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling MarketSegmentationSegmentsApi->segment_controller_enable: %s\n" % e)
```

--------------------------------

### Python Example: Create Market Segmentation Segment

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/MarketSegmentationSegmentsApi.md

Demonstrates how to use the cloudbeds_pms Python client to create a new Market Segmentation Segment. This example includes setting up OAuth authentication and handling API responses.

```python
import cloudbeds_pms
from cloudbeds_pms.models.segment_create_request_schema import SegmentCreateRequestSchema
from cloudbeds_pms.models.segment_response_schema import SegmentResponseSchema
from cloudbeds_pms.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://api.cloudbeds.com
# See configuration.py for a list of all supported configuration parameters.
configuration = cloudbeds_pms.Configuration(
    host = "https://api.cloudbeds.com"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

configuration.access_token = os.environ["ACCESS_TOKEN"]

# Enter a context with an instance of the API client
with cloudbeds_pms.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = cloudbeds_pms.MarketSegmentationSegmentsApi(api_client)
    x_property_id = '1,2,3' # str | A numeric, comma-separated string representing the property IDs, sent in the header.
    segment_create_request_schema = cloudbeds_pms.SegmentCreateRequestSchema() # SegmentCreateRequestSchema | Segment data.

    try:
        # Create a new Market Segmentation Segment.
        api_response = api_instance.segment_controller_create(x_property_id, segment_create_request_schema)
        print("The response of MarketSegmentationSegmentsApi->segment_controller_create:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling MarketSegmentationSegmentsApi->segment_controller_create: %s\n" % e)
```

--------------------------------

### Python Example: Get Single Market Segmentation Segment Data

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/MarketSegmentationSegmentsApi.md

This Python code snippet illustrates the initial setup for retrieving data for a single Market Segmentation Segment. It shows how to configure the API client with the host and set up OAuth authentication using an access token from environment variables.

```python
import cloudbeds_pms
from cloudbeds_pms.models.segment_response_schema import SegmentResponseSchema
from cloudbeds_pms.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://api.cloudbeds.com
# See configuration.py for a list of all supported configuration parameters.
configuration = cloudbeds_pms.Configuration(
    host = "https://api.cloudbeds.com"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

configuration.access_token = os.environ["ACCESS_TOKEN"]
```

--------------------------------

### Python Example: DoorLockSettingsEncoderRequestSchema Operations

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/DoorLockSettingsEncoderRequestSchema.md

This Python example demonstrates how to instantiate the DoorLockSettingsEncoderRequestSchema from a JSON string, convert the object to a dictionary, and print its JSON string representation. It illustrates basic object serialization and deserialization using the provided model methods.

```python
from cloudbeds_pms.models.door_lock_settings_encoder_request_schema import DoorLockSettingsEncoderRequestSchema

# TODO update the JSON string below
json = "{}"
# create an instance of DoorLockSettingsEncoderRequest_schema from a JSON string
door_lock_settings_encoder_request_schema_instance = DoorLockSettingsEncoderRequestSchema.from_json(json)
# print the JSON string representation of the object
print(DoorLockSettingsEncoderRequestSchema.to_json())

# convert the object into a dict
door_lock_settings_encoder_request_schema_dict = door_lock_settings_encoder_request_schema_instance.to_dict()
# create an instance of DoorLockSettingsEncoderRequestSchema from a dict
door_lock_settings_encoder_request_schema_from_dict = DoorLockSettingsEncoderRequestSchema.from_dict(door_lock_settings_encoder_request_schema_dict)
```

--------------------------------

### Python: GroupSingleRequestSchema Instantiation and Conversion Example

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/GroupSingleRequestSchema.md

This Python example demonstrates how to work with the GroupSingleRequestSchema model. It covers creating an instance from a JSON string, printing its JSON representation, converting the object to a dictionary, and then re-instantiating from that dictionary.

```python
from cloudbeds_pms.models.group_single_request_schema import GroupSingleRequestSchema

# TODO update the JSON string below
json = "{}"
# create an instance of GroupSingleRequestSchema from a JSON string
group_single_request_schema_instance = GroupSingleRequestSchema.from_json(json)
# print the JSON string representation of the object
print(GroupSingleRequestSchema.to_json())

# convert the object into a dict
group_single_request_schema_dict = group_single_request_schema_instance.to_dict()
# create an instance of GroupSingleRequestSchema from a dict
group_single_request_schema_from_dict = GroupSingleRequestSchema.from_dict(group_single_request_schema_dict)
```

--------------------------------

### Python Example for DoorLockKeyListResponseSchema Usage

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/DoorLockKeyListResponseSchema.md

Demonstrates how to interact with the DoorLockKeyListResponseSchema in Python, including creating an instance from JSON, converting to JSON, converting to a dictionary, and creating an instance from a dictionary.

```python
from cloudbeds_pms.models.door_lock_key_list_response_schema import DoorLockKeyListResponseSchema

# TODO update the JSON string below
json = "{}"
# create an instance of DoorLockKeyListResponseSchema from a JSON string
door_lock_key_list_response_schema_instance = DoorLockKeyListResponseSchema.from_json(json)
# print the JSON string representation of the object
print(DoorLockKeyListResponseSchema.to_json())

# convert the object into a dict
door_lock_key_list_response_schema_dict = door_lock_key_list_response_schema_instance.to_dict()
# create an instance of DoorLockKeyListResponseSchema from a dict
door_lock_key_list_response_schema_from_dict = DoorLockKeyListResponseSchema.from_dict(door_lock_key_list_response_schema_dict)
```

--------------------------------

### Python Example: Using IntegrationEventUpdateRequestSchema

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/IntegrationEventUpdateRequestSchema.md

Demonstrates how to instantiate the IntegrationEventUpdateRequestSchema from a JSON string, convert it to a dictionary, and then back to an object. This example showcases basic serialization and deserialization operations for the schema.

```python
from cloudbeds_pms.models.integration_event_update_request_schema import IntegrationEventUpdateRequestSchema

# TODO update the JSON string below
json = "{}"
# create an instance of IntegrationEventUpdateRequestSchema from a JSON string
integration_event_update_request_schema_instance = IntegrationEventUpdateRequestSchema.from_json(json)
# print the JSON string representation of the object
print(IntegrationEventUpdateRequestSchema.to_json())

# convert the object into a dict
integration_event_update_request_schema_dict = integration_event_update_request_schema_instance.to_dict()
# create an instance of IntegrationEventUpdateRequestSchema from a dict
integration_event_update_request_schema_from_dict = IntegrationEventUpdateRequestSchema.from_dict(integration_event_update_request_schema_dict)
```

--------------------------------

### Python Example for BodyDynamicFilterSchemaFilters

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/BodyDynamicFilterSchemaFilters.md

Demonstrates how to create an instance of `BodyDynamicFilterSchemaFilters` from a JSON string, print its JSON representation, convert it to a dictionary, and instantiate it from a dictionary using the `cloudbeds_pms` library.

```python
from cloudbeds_pms.models.body_dynamic_filter_schema_filters import BodyDynamicFilterSchemaFilters

# TODO update the JSON string below
json = "{}"
# create an instance of BodyDynamicFilterSchemaFilters from a JSON string
body_dynamic_filter_schema_filters_instance = BodyDynamicFilterSchemaFilters.from_json(json)
# print the JSON string representation of the object
print(BodyDynamicFilterSchemaFilters.to_json())

# convert the object into a dict
body_dynamic_filter_schema_filters_dict = body_dynamic_filter_schema_filters_instance.to_dict()
# create an instance of BodyDynamicFilterSchemaFilters from a dict
body_dynamic_filter_schema_filters_from_dict = BodyDynamicFilterSchemaFilters.from_dict(body_dynamic_filter_schema_filters_dict)
```

--------------------------------

### Python Example: InternalServerErrorResponseSchema Usage

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/InternalServerErrorResponseSchema.md

Demonstrates how to create an instance of InternalServerErrorResponseSchema from a JSON string, convert it to a dictionary, and then back to an object using the cloudbeds_pms library. This example shows basic serialization and deserialization.

```python
from cloudbeds_pms.models.internal_server_error_response_schema import InternalServerErrorResponseSchema

# TODO update the JSON string below
json = "{}"
# create an instance of InternalServerErrorResponseSchema from a JSON string
internal_server_error_response_schema_instance = InternalServerErrorResponseSchema.from_json(json)
# print the JSON string representation of the object
print(InternalServerErrorResponseSchema.to_json())

# convert the object into a dict
internal_server_error_response_schema_dict = internal_server_error_response_schema_instance.to_dict()
# create an instance of InternalServerErrorResponseSchema from a dict
internal_server_error_response_schema_from_dict = InternalServerErrorResponseSchema.from_dict(internal_server_error_response_schema_dict)
```

--------------------------------

### Python Example for DoorLockSettingsKeyTypeResponseSchema Usage

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/DoorLockSettingsKeyTypeResponseSchema.md

This Python code demonstrates how to instantiate the DoorLockSettingsKeyTypeResponseSchema from a JSON string, convert it to and from a dictionary, and print its JSON representation. It illustrates basic object serialization and deserialization.

```python
from cloudbeds_pms.models.door_lock_settings_key_type_response_schema import DoorLockSettingsKeyTypeResponseSchema

# TODO update the JSON string below
json = "{}"
# create an instance of DoorLockSettingsKeyTypeResponseSchema from a JSON string
door_lock_settings_key_type_response_schema_instance = DoorLockSettingsKeyTypeResponseSchema.from_json(json)
# print the JSON string representation of the object
print(DoorLockSettingsKeyTypeResponseSchema.to_json())

# convert the object into a dict
door_lock_settings_key_type_response_schema_dict = door_lock_settings_key_type_response_schema_instance.to_dict()
# create an instance of DoorLockSettingsKeyTypeResponseSchema from a dict
door_lock_settings_key_type_response_schema_from_dict = DoorLockSettingsKeyTypeResponseSchema.from_dict(door_lock_settings_key_type_response_schema_dict)
```

--------------------------------

### Python Example: Get Market Segmentation Segment Reservations

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/MarketSegmentationSegmentsApi.md

This Python code demonstrates how to authenticate with the Cloudbeds API using OAuth and retrieve a list of reservations linked to a specific Market Segmentation Segment. It initializes the API client, sets up authentication, and calls the `segment_controller_reservations` method with required parameters like property ID, segment ID, and active status, along with optional offset and limit for pagination.

```python
import cloudbeds_pms
from cloudbeds_pms.models.limit_offset_pagination_schema import LimitOffsetPaginationSchema
from cloudbeds_pms.models.segment_list_reservations_response_schema import SegmentListReservationsResponseSchema
from cloudbeds_pms.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://api.cloudbeds.com
# See configuration.py for a list of all supported configuration parameters.
configuration = cloudbeds_pms.Configuration(
    host = "https://api.cloudbeds.com"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

configuration.access_token = os.environ["ACCESS_TOKEN"]

# Enter a context with an instance of the API client
with cloudbeds_pms.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = cloudbeds_pms.MarketSegmentationSegmentsApi(api_client)
    x_property_id = '1,2,3' # str | A numeric, comma-separated string representing the property IDs, sent in the header.
    id = '1-b' # str | Segment ID.
    active = False # bool | List only active reservations.
    offset = cloudbeds_pms.LimitOffsetPaginationSchema() # LimitOffsetPaginationSchema | The number of items to skip before starting to collect the result set. Used for pagination. (optional)
    limit = cloudbeds_pms.LimitOffsetPaginationSchema() # LimitOffsetPaginationSchema | The maximum number of items to return in the response. Default is 100. (optional)

    try:
        # Get a list of reservations linked to a Market Segmentation Segment.
        api_response = api_instance.segment_controller_reservations(x_property_id, id, active, offset=offset, limit=limit)
        print("The response of MarketSegmentationSegmentsApi->segment_controller_reservations:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling MarketSegmentationSegmentsApi->segment_controller_reservations: %s\n" % e)
```

--------------------------------

### Python Example for LimitOffsetPaginationSchema Usage

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/LimitOffsetPaginationSchema.md

Demonstrates how to interact with the LimitOffsetPaginationSchema in Python. This includes creating an instance from a JSON string, printing its JSON representation, converting it to a dictionary, and re-instantiating it from a dictionary.

```python
from cloudbeds_pms.models.limit_offset_pagination_schema import LimitOffsetPaginationSchema

# TODO update the JSON string below
json = "{}"
# create an instance of LimitOffsetPaginationSchema from a JSON string
limit_offset_pagination_schema_instance = LimitOffsetPaginationSchema.from_json(json)
# print the JSON string representation of the object
print(LimitOffsetPaginationSchema.to_json())

# convert the object into a dict
limit_offset_pagination_schema_dict = limit_offset_pagination_schema_instance.to_dict()
# create an instance of LimitOffsetPaginationSchema from a dict
limit_offset_pagination_schema_from_dict = LimitOffsetPaginationSchema.from_dict(limit_offset_pagination_schema_dict)
```

--------------------------------

### Python Usage Example for DoorLockKeyFailedToGenerateResponseSchema

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/DoorLockKeyFailedToGenerateResponseSchema.md

Illustrates how to interact with the DoorLockKeyFailedToGenerateResponseSchema in Python. This example covers creating an instance from a JSON string, converting the object to and from a dictionary, and printing its JSON representation using the cloudbeds_pms library.

```python
from cloudbeds_pms.models.door_lock_key_failed_to_generate_response_schema import DoorLockKeyFailedToGenerateResponseSchema

# TODO update the JSON string below
json = "{}"
# create an instance of DoorLockKeyFailedToGenerateResponseSchema from a JSON string
door_lock_key_failed_to_generate_response_schema_instance = DoorLockKeyFailedToGenerateResponseSchema.from_json(json)
# print the JSON string representation of the object
print(DoorLockKeyFailedToGenerateResponseSchema.to_json())

# convert the object into a dict
door_lock_key_failed_to_generate_response_schema_dict = door_lock_key_failed_to_generate_response_schema_instance.to_dict()
# create an instance of DoorLockKeyFailedToGenerateResponseSchema from a dict
door_lock_key_failed_to_generate_response_schema_from_dict = DoorLockKeyFailedToGenerateResponseSchema.from_dict(door_lock_key_failed_to_generate_response_schema_dict)
```

--------------------------------

### Python Example for QueryParameterSortSchema Usage

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/QueryParameterSortSchema.md

Demonstrates how to create an instance of QueryParameterSortSchema from a JSON string, convert it to JSON, convert it to a dictionary, and create an instance from a dictionary using the cloudbeds_pms library.

```python
from cloudbeds_pms.models.query_parameter_sort_schema import QueryParameterSortSchema

# TODO update the JSON string below
json = "{}"
# create an instance of QueryParameterSortSchema from a JSON string
query_parameter_sort_schema_instance = QueryParameterSortSchema.from_json(json)
# print the JSON string representation of the object
print(QueryParameterSortSchema.to_json())

# convert the object into a dict
query_parameter_sort_schema_dict = query_parameter_sort_schema_instance.to_dict()
# create an instance of QueryParameterSortSchema from a dict
query_parameter_sort_schema_from_dict = QueryParameterSortSchema.from_dict(query_parameter_sort_schema_dict)
```

--------------------------------

### Python Example: Get List of Integration Events

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/IntegrationEventsApi.md

Demonstrates how to use the `integration_event_controller_index` method in Python to retrieve integration events.

```python
import cloudbeds_pms
from cloudbeds_pms.models.integration_event_list_response_schema import IntegrationEventListResponseSchema
from cloudbeds_pms.models.limit_offset_pagination_schema import LimitOffsetPaginationSchema
from cloudbeds_pms.models.query_parameter_dynamic_filter_schema import QueryParameterDynamicFilterSchema
from cloudbeds_pms.models.query_parameter_sort_schema import QueryParameterSortSchema
from cloudbeds_pms.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://api.cloudbeds.com
```

--------------------------------

### Python Example for Updating Cloudbeds Integration Event

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/IntegrationEventsApi.md

Provides a Python code example demonstrating how to use the `cloudbeds_pms` library to update an integration event, including API client configuration and error handling.

```python
import cloudbeds_pms
from cloudbeds_pms.models.integration_event_response_schema import IntegrationEventResponseSchema
from cloudbeds_pms.models.integration_event_update_request_schema import IntegrationEventUpdateRequestSchema
from cloudbeds_pms.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://api.cloudbeds.com
# See configuration.py for a list of all supported configuration parameters.
configuration = cloudbeds_pms.Configuration(
    host = "https://api.cloudbeds.com"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

configuration.access_token = os.environ["ACCESS_TOKEN"]

# Enter a context with an instance of the API client
with cloudbeds_pms.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = cloudbeds_pms.IntegrationEventsApi(api_client)
    id = 'id_example' # str |
    x_property_id = '1,2,3' # str | A numeric, comma-separated string representing the property IDs, sent in the header.
    integration_event_update_request_schema = cloudbeds_pms.IntegrationEventUpdateRequestSchema() # IntegrationEventUpdateRequestSchema | Integration event data

    try:
        # Update an integration event.
        api_response = api_instance.integration_event_controller_update(id, x_property_id, integration_event_update_request_schema)
        print("The response of IntegrationEventsApi->integration_event_controller_update:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling IntegrationEventsApi->integration_event_controller_update: %s\n" % e)
```

--------------------------------

### Python Example for DoorLockKeyCreateRequestSchema Usage

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/DoorLockKeyCreateRequestSchema.md

Demonstrates how to instantiate DoorLockKeyCreateRequestSchema from JSON or a dictionary, and convert it back to JSON or a dictionary in Python.

```python
from cloudbeds_pms.models.door_lock_key_create_request_schema import DoorLockKeyCreateRequestSchema

# TODO update the JSON string below
json = "{}"
# create an instance of DoorLockKeyCreateRequestSchema from a JSON string
door_lock_key_create_request_schema_instance = DoorLockKeyCreateRequestSchema.from_json(json)
# print the JSON string representation of the object
print(DoorLockKeyCreateRequestSchema.to_json())

# convert the object into a dict
door_lock_key_create_request_schema_dict = door_lock_key_create_request_schema_instance.to_dict()
# create an instance of DoorLockKeyCreateRequestSchema from a dict
door_lock_key_create_request_schema_from_dict = DoorLockKeyCreateRequestSchema.from_dict(door_lock_key_create_request_schema_dict)
```

--------------------------------

### Python: ImportTaskListRequestSchema Usage Example

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/ImportTaskListRequestSchema.md

Demonstrates how to create an instance of `ImportTaskListRequestSchema` from a JSON string, convert it to a dictionary, and then back to an object using the `cloudbeds_pms` library. This example shows basic serialization and deserialization.

```python
from cloudbeds_pms.models.import_task_list_request_schema import ImportTaskListRequestSchema

# TODO update the JSON string below
json = "{}"
# create an instance of ImportTaskListRequestSchema from a JSON string
import_task_list_request_schema_instance = ImportTaskListRequestSchema.from_json(json)
# print the JSON string representation of the object
print(ImportTaskListRequestSchema.to_json())

# convert the object into a dict
import_task_list_request_schema_dict = import_task_list_request_schema_instance.to_dict()
# create an instance of ImportTaskListRequestSchema from a dict
import_task_list_request_schema_from_dict = ImportTaskListRequestSchema.from_dict(import_task_list_request_schema_dict)
```

--------------------------------

### Python Example for DoorLockSettingsCreateRequestSchema Usage

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/DoorLockSettingsCreateRequestSchema.md

Demonstrates how to create an instance of DoorLockSettingsCreateRequestSchema from a JSON string, print its JSON representation, convert it to a dictionary, and then create an instance from a dictionary using the cloudbeds_pms library.

```python
from cloudbeds_pms.models.door_lock_settings_create_request_schema import DoorLockSettingsCreateRequestSchema

# TODO update the JSON string below
json = "{}"
# create an instance of DoorLockSettingsCreateRequestSchema from a JSON string
door_lock_settings_create_request_schema_instance = DoorLockSettingsCreateRequestSchema.from_json(json)
# print the JSON string representation of the object
print(DoorLockSettingsCreateRequestSchema.to_json())

# convert the object into a dict
door_lock_settings_create_request_schema_dict = door_lock_settings_create_request_schema_instance.to_dict()
# create an instance of DoorLockSettingsCreateRequestSchema from a dict
door_lock_settings_create_request_schema_from_dict = DoorLockSettingsCreateRequestSchema.from_dict(door_lock_settings_create_request_schema_dict)
```

--------------------------------

### Python Example for DoorLockKeyListRequestSchema Usage

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/DoorLockKeyListRequestSchema.md

Demonstrates how to instantiate the DoorLockKeyListRequestSchema from a JSON string, print its JSON representation, convert it to a dictionary, and create an instance from a dictionary using the cloudbeds_pms library.

```python
from cloudbeds_pms.models.door_lock_key_list_request_schema import DoorLockKeyListRequestSchema

# TODO update the JSON string below
json = "{}"
# create an instance of DoorLockKeyListRequestSchema from a JSON string
door_lock_key_list_request_schema_instance = DoorLockKeyListRequestSchema.from_json(json)
# print the JSON string representation of the object
print(DoorLockKeyListRequestSchema.to_json())

# convert the object into a dict
door_lock_key_list_request_schema_dict = door_lock_key_list_request_schema_instance.to_dict()
# create an instance of DoorLockKeyListRequestSchema from a dict
door_lock_key_list_request_schema_from_dict = DoorLockKeyListRequestSchema.from_dict(door_lock_key_list_request_schema_dict)
```

--------------------------------

### Python SortSchema Usage Example

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/SortSchema.md

Demonstrates how to interact with the SortSchema model in Python. This example covers creating an instance from a JSON string, converting it to a dictionary, and then back to an object, showcasing serialization and deserialization methods.

```python
from cloudbeds_pms.models.sort_schema import SortSchema

# TODO update the JSON string below
json = "{}"
# create an instance of SortSchema from a JSON string
sort_schema_instance = SortSchema.from_json(json)
# print the JSON string representation of the object
print(SortSchema.to_json())

# convert the object into a dict
sort_schema_dict = sort_schema_instance.to_dict()
# create an instance of SortSchema from a dict
sort_schema_from_dict = SortSchema.from_dict(sort_schema_dict)
```

--------------------------------

### Python: GroupEnableRequestSchema Serialization and Deserialization Example

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/GroupEnableRequestSchema.md

Provides a Python example demonstrating how to instantiate, serialize to JSON, and deserialize from JSON or dictionary representations of the `GroupEnableRequestSchema` model. This snippet illustrates common usage patterns for interacting with API models.

```python
from cloudbeds_pms.models.group_enable_request_schema import GroupEnableRequestSchema

# TODO update the JSON string below
json = "{}"
# create an instance of GroupEnableRequestSchema from a JSON string
group_enable_request_schema_instance = GroupEnableRequestSchema.from_json(json)
# print the JSON string representation of the object
print(GroupEnableRequestSchema.to_json())

# convert the object into a dict
group_enable_request_schema_dict = group_enable_request_schema_instance.to_dict()
# create an instance of GroupEnableRequestSchema from a dict
group_enable_request_schema_from_dict = GroupEnableRequestSchema.from_dict(group_enable_request_schema_dict)
```

--------------------------------

### Python Example: Get Doorlock Settings

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/DoorlockSettingsApi.md

Demonstrates how to use the `door_lock_settings_controller_single` method in Python to retrieve doorlock settings for a given property ID using OAuth authentication.

```python
import cloudbeds_pms
from cloudbeds_pms.models.door_lock_settings_response_schema import DoorLockSettingsResponseSchema
from cloudbeds_pms.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://api.cloudbeds.com
# See configuration.py for a list of all supported configuration parameters.
configuration = cloudbeds_pms.Configuration(
    host = "https://api.cloudbeds.com"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

configuration.access_token = os.environ["ACCESS_TOKEN"]

# Enter a context with an instance of the API client
with cloudbeds_pms.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = cloudbeds_pms.DoorlockSettingsApi(api_client)
    property_id = 1 # int | The property ID

    try:
        # Get doorlock settings for property for specific application client.
        api_response = api_instance.door_lock_settings_controller_single(property_id)
        print("The response of DoorlockSettingsApi->door_lock_settings_controller_single:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DoorlockSettingsApi->door_lock_settings_controller_single: %s\n" % e)
```

--------------------------------

### Python Example: InspectionItemSchema Object Handling

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/InspectionItemSchema.md

Demonstrates how to create, convert, and print instances of the InspectionItemSchema object in Python, including conversion from/to JSON strings and dictionary formats.

```python
from cloudbeds_pms.models.inspection_item_schema import InspectionItemSchema

# TODO update the JSON string below
json = "{}"
# create an instance of InspectionItemSchema from a JSON string
inspection_item_schema_instance = InspectionItemSchema.from_json(json)
# print the JSON string representation of the object
print(InspectionItemSchema.to_json())

# convert the object into a dict
inspection_item_schema_dict = inspection_item_schema_instance.to_dict()
# create an instance of InspectionItemSchema from a dict
inspection_item_schema_from_dict = InspectionItemSchema.from_dict(inspection_item_schema_dict)
```

--------------------------------

### Create Market Segmentation Group API Call and Python Example

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/MarketSegmentationGroupsApi.md

This section details the `group_controller_create` API endpoint, which allows for the creation of a new Market Segmentation Group. It includes a Python code example demonstrating how to make the API call, along with comprehensive documentation on required parameters, expected return types, authorization methods, and possible HTTP response details.

```python
import cloudbeds_pms
from cloudbeds_pms.models.group_create_request_schema import GroupCreateRequestSchema
from cloudbeds_pms.models.group_response_schema import GroupResponseSchema
from cloudbeds_pms.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://api.cloudbeds.com
# See configuration.py for a list of all supported configuration parameters.
configuration = cloudbeds_pms.Configuration(
    host = "https://api.cloudbeds.com"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

configuration.access_token = os.environ["ACCESS_TOKEN"]

# Enter a context with an instance of the API client
with cloudbeds_pms.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = cloudbeds_pms.MarketSegmentationGroupsApi(api_client)
    x_property_id = '1,2,3' # str | A numeric, comma-separated string representing the property IDs, sent in the header.
    group_create_request_schema = cloudbeds_pms.GroupCreateRequestSchema() # GroupCreateRequestSchema | Group data.

    try:
        # Create a new Market Segmentation Group.
        api_response = api_instance.group_controller_create(x_property_id, group_create_request_schema)
        print("The response of MarketSegmentationGroupsApi->group_controller_create:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling MarketSegmentationGroupsApi->group_controller_create: %s\n" % e)
```

```APIDOC
Endpoint: group_controller_create
Description: Create a new Market Segmentation Group.
Method: POST
URI: /market-segmentation/v1/groups

Parameters:
- Name: x_property_id
  Type: str
  Description: A numeric, comma-separated string representing the property IDs, sent in the header.
  Notes: Required
- Name: group_create_request_schema
  Type: GroupCreateRequestSchema
  Description: Group data.
  Notes: Required

Return Type: GroupResponseSchema

Authorization: OAuth Authentication (default)

HTTP Request Headers:
- Content-Type: application/json
- Accept: application/json

HTTP Response Details:
- Status Code: 201
  Description: Created Market Segmentation Group.
- Status Code: 400
  Description: Bad request response.
- Status Code: 403
  Description: Forbidden response.
- Status Code: 404
  Description: Not found response.
- Status Code: 500
  Description: Internal server error.
```

--------------------------------

### Python Example: Using InspectionListRequestSchema

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/InspectionListRequestSchema.md

Demonstrates how to create an instance of InspectionListRequestSchema from a JSON string, convert it to and from a dictionary, and print its JSON representation using the cloudbeds_pms library. This example showcases basic object serialization and deserialization.

```python
from cloudbeds_pms.models.inspection_list_request_schema import InspectionListRequestSchema

# TODO update the JSON string below
json = "{}"
# create an instance of InspectionListRequestSchema from a JSON string
inspection_list_request_schema_instance = InspectionListRequestSchema.from_json(json)
# print the JSON string representation of the object
print(InspectionListRequestSchema.to_json())

# convert the object into a dict
inspection_list_request_schema_dict = inspection_list_request_schema_instance.to_dict()
# create an instance of InspectionListRequestSchema from a dict
inspection_list_request_schema_from_dict = InspectionListRequestSchema.from_dict(inspection_list_request_schema_dict)
```

--------------------------------

### Python: Example Usage of BadRequestResponseSchema Model

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/BadRequestResponseSchema.md

Illustrates how to interact with the BadRequestResponseSchema model in Python. This example demonstrates creating an instance from a JSON string, converting it to JSON and dictionary formats, and reconstructing it from a dictionary.

```python
from cloudbeds_pms.models.bad_request_response_schema import BadRequestResponseSchema

# TODO update the JSON string below
json = "{}"
# create an instance of BadRequestResponseSchema from a JSON string
bad_request_response_schema_instance = BadRequestResponseSchema.from_json(json)
# print the JSON string representation of the object
print(BadRequestResponseSchema.to_json())

# convert the object into a dict
bad_request_response_schema_dict = bad_request_response_schema_instance.to_dict()
# create an instance of BadRequestResponseSchema from a dict
bad_request_response_schema_from_dict = BadRequestResponseSchema.from_dict(bad_request_response_schema_dict)
```

--------------------------------

### Python Example: Create Integration Event

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/IntegrationEventsApi.md

Demonstrates how to use the `integration_event_controller_create` method in Python, including setting up authentication and handling the API response.

```python
import cloudbeds_pms
from cloudbeds_pms.models.integration_event_create_request_schema import IntegrationEventCreateRequestSchema
from cloudbeds_pms.models.integration_event_response_schema import IntegrationEventResponseSchema
from cloudbeds_pms.rest import ApiException
from pprint import pprint

# Defining the host is optional and defaults to https://api.cloudbeds.com
# See configuration.py for a list of all supported configuration parameters.
configuration = cloudbeds_pms.Configuration(
    host = "https://api.cloudbeds.com"
)

# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.

configuration.access_token = os.environ["ACCESS_TOKEN"]

# Enter a context with an instance of the API client
with cloudbeds_pms.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = cloudbeds_pms.IntegrationEventsApi(api_client)
    x_property_id = '1,2,3' # str | A numeric, comma-separated string representing the property IDs, sent in the header.
    integration_event_create_request_schema = cloudbeds_pms.IntegrationEventCreateRequestSchema() # IntegrationEventCreateRequestSchema | Integration event data

    try:
        # Create a new integration event.
        api_response = api_instance.integration_event_controller_create(x_property_id, integration_event_create_request_schema)
        print("The response of IntegrationEventsApi->integration_event_controller_create:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling IntegrationEventsApi->integration_event_controller_create: %s\n" % e)
```

--------------------------------

### Python Example for BadRequestErrorItemSchema Operations

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/BadRequestErrorItemSchema.md

Illustrates how to interact with the `BadRequestErrorItemSchema` model in Python, covering instantiation from JSON, conversion to JSON string, conversion to dictionary, and instantiation from a dictionary.

```python
from cloudbeds_pms.models.bad_request_error_item_schema import BadRequestErrorItemSchema

# TODO update the JSON string below
json = "{}"
# create an instance of BadRequestErrorItemSchema from a JSON string
bad_request_error_item_schema_instance = BadRequestErrorItemSchema.from_json(json)
# print the JSON string representation of the object
print(BadRequestErrorItemSchema.to_json())

# convert the object into a dict
bad_request_error_item_schema_dict = bad_request_error_item_schema_instance.to_dict()
# create an instance of BadRequestErrorItemSchema from a dict
bad_request_error_item_schema_from_dict = BadRequestErrorItemSchema.from_dict(bad_request_error_item_schema_dict)
```

--------------------------------

### Python Example for IntegrationEventCreateRequestSchema Usage

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/IntegrationEventCreateRequestSchema.md

Demonstrates how to instantiate `IntegrationEventCreateRequestSchema` from a JSON string, convert it to a JSON string, convert it to a dictionary, and create an instance from a dictionary using the `cloudbeds_pms` library.

```python
from cloudbeds_pms.models.integration_event_create_request_schema import IntegrationEventCreateRequestSchema

# TODO update the JSON string below
json = "{}"
# create an instance of IntegrationEventCreateRequestSchema from a JSON string
integration_event_create_request_schema_instance = IntegrationEventCreateRequestSchema.from_json(json)
# print the JSON string representation of the object
print(integration_event_create_request_schema_instance.to_json())

# convert the object into a dict
integration_event_create_request_schema_dict = integration_event_create_request_schema_instance.to_dict()
# create an instance of IntegrationEventCreateRequestSchema from a dict
integration_event_create_request_schema_from_dict = IntegrationEventCreateRequestSchema.from_dict(integration_event_create_request_schema_dict)
```

--------------------------------

### Python Example for GroupListResponseSchema Object Manipulation

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/GroupListResponseSchema.md

This Python example demonstrates how to work with the GroupListResponseSchema object. It shows how to create an instance from a JSON string, convert the object back to a JSON string, convert it to a dictionary, and then create a new instance from that dictionary, illustrating common serialization and deserialization patterns.

```python
from cloudbeds_pms.models.group_list_response_schema import GroupListResponseSchema

# TODO update the JSON string below
json = "{}"
# create an instance of GroupListResponseSchema from a JSON string
group_list_response_schema_instance = GroupListResponseSchema.from_json(json)
# print the JSON string representation of the object
print(GroupListResponseSchema.to_json())

# convert the object into a dict
group_list_response_schema_dict = group_list_response_schema_instance.to_dict()
# create an instance of GroupListResponseSchema from a dict
group_list_response_schema_from_dict = GroupListResponseSchema.from_dict(group_list_response_schema_dict)
```

--------------------------------

### Python Example: GroupCreateRequestSchema Serialization and Deserialization

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/GroupCreateRequestSchema.md

This Python example demonstrates how to interact with the `GroupCreateRequestSchema` model from the `cloudbeds_pms` library. It covers deserializing a JSON string into an object, converting the object to a JSON string, converting the object to a dictionary, and then re-creating an object from that dictionary.

```python
from cloudbeds_pms.models.group_create_request_schema import GroupCreateRequestSchema

# TODO update the JSON string below
json = "{}"
# create an instance of GroupCreateRequestSchema from a JSON string
group_create_request_schema_instance = GroupCreateRequestSchema.from_json(json)
# print the JSON string representation of the object
print(GroupCreateRequestSchema.to_json())

# convert the object into a dict
group_create_request_schema_dict = group_create_request_schema_instance.to_dict()
# create an instance of GroupCreateRequestSchema from a dict
group_create_request_schema_from_dict = GroupCreateRequestSchema.from_dict(group_create_request_schema_dict)
```

--------------------------------

### Python Example for SortFieldSchema Model Usage

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/SortFieldSchema.md

Demonstrates how to instantiate the SortFieldSchema model from JSON, convert it to a dictionary, and print its JSON representation using the cloudbeds_pms library in Python.

```python
from cloudbeds_pms.models.sort_field_schema import SortFieldSchema

# TODO update the JSON string below
json = "{}"
# create an instance of SortFieldSchema from a JSON string
sort_field_schema_instance = SortFieldSchema.from_json(json)
# print the JSON string representation of the object
print(SortFieldSchema.to_json())

# convert the object into a dict
sort_field_schema_dict = sort_field_schema_instance.to_dict()
# create an instance of SortFieldSchema from a dict
sort_field_schema_from_dict = SortFieldSchema.from_dict(sort_field_schema_dict)
```

--------------------------------

### Python: Example Usage of DoorLockSettingsCommonRoomResponseSchema

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/DoorLockSettingsCommonRoomResponseSchema.md

This Python snippet demonstrates how to interact with the DoorLockSettingsCommonRoomResponseSchema model. It shows how to create an instance from a JSON string, convert the object to its JSON string representation, convert it to a dictionary, and create an instance from a dictionary.

```python
from cloudbeds_pms.models.door_lock_settings_common_room_response_schema import DoorLockSettingsCommonRoomResponseSchema

# TODO update the JSON string below
json = "{}"
# create an instance of DoorLockSettingsCommonRoomResponseSchema from a JSON string
door_lock_settings_common_room_response_schema_instance = DoorLockSettingsCommonRoomResponseSchema.from_json(json)
# print the JSON string representation of the object
print(DoorLockSettingsCommonRoomResponseSchema.to_json())

# convert the object into a dict
door_lock_settings_common_room_response_schema_dict = door_lock_settings_common_room_response_schema_instance.to_dict()
# create an instance of DoorLockSettingsCommonRoomResponseSchema from a dict
door_lock_settings_common_room_response_schema_from_dict = DoorLockSettingsCommonRoomResponseSchema.from_dict(door_lock_settings_common_room_response_schema_dict)
```

--------------------------------

### Python Example for NotFoundResponseSchema

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/NotFoundResponseSchema.md

Demonstrates how to instantiate, serialize, and deserialize the NotFoundResponseSchema object in Python using its `from_json`, `to_json`, `to_dict`, and `from_dict` methods.

```python
from cloudbeds_pms.models.not_found_response_schema import NotFoundResponseSchema

# TODO update the JSON string below
json = "{}"
# create an instance of NotFoundResponseSchema from a JSON string
not_found_response_schema_instance = NotFoundResponseSchema.from_json(json)
# print the JSON string representation of the object
print(NotFoundResponseSchema.to_json())

# convert the object into a dict
not_found_response_schema_dict = not_found_response_schema_instance.to_dict()
# create an instance of NotFoundResponseSchema from a dict
not_found_response_schema_from_dict = NotFoundResponseSchema.from_dict(not_found_response_schema_dict)
```

--------------------------------

### Python Example for ImportTaskGetResponseSchema Usage

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/ImportTaskGetResponseSchema.md

Demonstrates how to create an instance of ImportTaskGetResponseSchema from a JSON string or dictionary, and how to convert the object back to JSON or a dictionary in Python.

```python
from cloudbeds_pms.models.import_task_get_response_schema import ImportTaskGetResponseSchema

# TODO update the JSON string below
json = "{}"
# create an instance of ImportTaskGetResponseSchema from a JSON string
import_task_get_response_schema_instance = ImportTaskGetResponseSchema.from_json(json)
# print the JSON string representation of the object
print(ImportTaskGetResponseSchema.to_json())

# convert the object into a dict
import_task_get_response_schema_dict = import_task_get_response_schema_instance.to_dict()
# create an instance of ImportTaskGetResponseSchema from a dict
import_task_get_response_schema_from_dict = ImportTaskGetResponseSchema.from_dict(import_task_get_response_schema_dict)
```

--------------------------------

### Python Example for SegmentResponseSchema Usage

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/SegmentResponseSchema.md

Demonstrates how to create, convert, and print instances of the `SegmentResponseSchema` model in Python, including JSON and dictionary conversions.

```python
from cloudbeds_pms.models.segment_response_schema import SegmentResponseSchema

# TODO update the JSON string below
json = "{}"
# create an instance of SegmentResponseSchema from a JSON string
segment_response_schema_instance = SegmentResponseSchema.from_json(json)
# print the JSON string representation of the object
print(SegmentResponseSchema.to_json())

# convert the object into a dict
segment_response_schema_dict = segment_response_schema_instance.to_dict()
# create an instance of SegmentResponseSchema from a dict
segment_response_schema_from_dict = SegmentResponseSchema.from_dict(segment_response_schema_dict)
```

--------------------------------

### Python Example for ImportTaskGetRecordListRequestSchema Usage

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/ImportTaskGetRecordListRequestSchema.md

Demonstrates how to import, instantiate, and convert the ImportTaskGetRecordListRequestSchema object in Python, including conversion from/to JSON and dictionary formats.

```python
from cloudbeds_pms.models.import_task_get_record_list_request_schema import ImportTaskGetRecordListRequestSchema

# TODO update the JSON string below
json = "{}"
# create an instance of ImportTaskGetRecordListRequestSchema from a JSON string
import_task_get_record_list_request_schema_instance = ImportTaskGetRecordListRequestSchema.from_json(json)
# print the JSON string representation of the object
print(ImportTaskGetRecordListRequestSchema.to_json())

# convert the object into a dict
import_task_get_record_list_request_schema_dict = import_task_get_record_list_request_schema_instance.to_dict()
# create an instance of ImportTaskGetRecordListRequestSchema from a dict
import_task_get_record_list_request_schema_from_dict = ImportTaskGetRecordListRequestSchema.from_dict(import_task_get_record_list_request_schema_dict)
```

--------------------------------

### Python Example for DoorLockKeyResponseSchema Serialization and Deserialization

Source: https://github.com/cloudbeds/cloudbeds-api-python/blob/main/cloudbeds_pms/docs/DoorLockKeyResponseSchema.md

This Python snippet demonstrates how to instantiate the DoorLockKeyResponseSchema from a JSON string, convert it back to JSON, convert it to a dictionary, and then re-instantiate it from a dictionary, showcasing common data manipulation patterns.

```python
from cloudbeds_pms.models.door_lock_key_response_schema import DoorLockKeyResponseSchema

# TODO update the JSON string below
json = "{}"
# create an instance of DoorLockKeyResponseSchema from a JSON string
door_lock_key_response_schema_instance = DoorLockKeyResponseSchema.from_json(json)
# print the JSON string representation of the object
print(DoorLockKeyResponseSchema.to_json())

# convert the object into a dict
door_lock_key_response_schema_dict = door_lock_key_response_schema_instance.to_dict()
# create an instance of DoorLockKeyResponseSchema from a dict
door_lock_key_response_schema_from_dict = DoorLockKeyResponseSchema.from_dict(door_lock_key_response_schema_dict)
```