geonode.geoserver.acl.gsauth_client.api ======================================= .. py:module:: geonode.geoserver.acl.gsauth_client.api Submodules ---------- .. toctree:: :maxdepth: 1 /autoapi/geonode/geoserver/acl/gsauth_client/api/admin_rules_api/index /autoapi/geonode/geoserver/acl/gsauth_client/api/authorization_api/index /autoapi/geonode/geoserver/acl/gsauth_client/api/rules_api/index Classes ------- .. autoapisummary:: geonode.geoserver.acl.gsauth_client.api.AdminRulesApi geonode.geoserver.acl.gsauth_client.api.AuthorizationApi geonode.geoserver.acl.gsauth_client.api.RulesApi Package Contents ---------------- .. py:class:: AdminRulesApi(api_client=None) Bases: :py:obj:`object` NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech Do not edit the class manually. .. py:attribute:: api_client .. py:method:: admin_rule_exists_by_id(id, **kwargs) admin_rule_exists_by_id # noqa: E501 Returns whether the AdminRule with the given identifier exists # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.admin_rule_exists_by_id(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: bool .. py:method:: admin_rule_exists_by_id_with_http_info(id, **kwargs) admin_rule_exists_by_id # noqa: E501 Returns whether the AdminRule with the given identifier exists # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.admin_rule_exists_by_id_with_http_info(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(bool, status_code(int), headers(HTTPHeaderDict)) .. py:method:: count_admin_rules(admin_rule_filter, **kwargs) count_admin_rules # noqa: E501 Returns the number of rules that matches the search criteria # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count_admin_rules(admin_rule_filter, async_req=True) >>> result = thread.get() :param admin_rule_filter: (required) :type admin_rule_filter: AdminRuleFilter :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: int .. py:method:: count_admin_rules_with_http_info(admin_rule_filter, **kwargs) count_admin_rules # noqa: E501 Returns the number of rules that matches the search criteria # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count_admin_rules_with_http_info(admin_rule_filter, async_req=True) >>> result = thread.get() :param admin_rule_filter: (required) :type admin_rule_filter: AdminRuleFilter :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(int, status_code(int), headers(HTTPHeaderDict)) .. py:method:: count_all_admin_rules(**kwargs) count_all_admin_rules # noqa: E501 Returns the total number of rules # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count_all_admin_rules(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: int .. py:method:: count_all_admin_rules_with_http_info(**kwargs) count_all_admin_rules # noqa: E501 Returns the total number of rules # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count_all_admin_rules_with_http_info(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(int, status_code(int), headers(HTTPHeaderDict)) .. py:method:: create_admin_rule(admin_rule, **kwargs) create_admin_rule # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_admin_rule(admin_rule, async_req=True) >>> result = thread.get() :param admin_rule: (required) :type admin_rule: AdminRule :param position: Displacement option related to how to interpret the Rule's priority :type position: InsertPosition :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: AdminRule .. py:method:: create_admin_rule_with_http_info(admin_rule, **kwargs) create_admin_rule # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_admin_rule_with_http_info(admin_rule, async_req=True) >>> result = thread.get() :param admin_rule: (required) :type admin_rule: AdminRule :param position: Displacement option related to how to interpret the Rule's priority :type position: InsertPosition :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(AdminRule, status_code(int), headers(HTTPHeaderDict)) .. py:method:: delete_admin_rule_by_id(id, **kwargs) delete_admin_rule_by_id # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete_admin_rule_by_id(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None .. py:method:: delete_admin_rule_by_id_with_http_info(id, **kwargs) delete_admin_rule_by_id # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete_admin_rule_by_id_with_http_info(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None .. py:method:: find_admin_rules(**kwargs) find_admin_rules # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.find_admin_rules(async_req=True) >>> result = thread.get() :param limit: Maximum number of rules to return from the query. If there are more rules, the response will return an X-ACL-NEXTCURSOR header with a value that can be used for the nextCursor parameter on a subsequent request, until X-ACL-NEXTCURSOR is null :type limit: int :param next_cursor: The next cursor identifier when doing cursor paging, as returned by the X-ACL-NEXTCURSOR response header :type next_cursor: str :param admin_rule_filter: :type admin_rule_filter: AdminRuleFilter :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: list[AdminRule] .. py:method:: find_admin_rules_with_http_info(**kwargs) find_admin_rules # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.find_admin_rules_with_http_info(async_req=True) >>> result = thread.get() :param limit: Maximum number of rules to return from the query. If there are more rules, the response will return an X-ACL-NEXTCURSOR header with a value that can be used for the nextCursor parameter on a subsequent request, until X-ACL-NEXTCURSOR is null :type limit: int :param next_cursor: The next cursor identifier when doing cursor paging, as returned by the X-ACL-NEXTCURSOR response header :type next_cursor: str :param admin_rule_filter: :type admin_rule_filter: AdminRuleFilter :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(list[AdminRule], status_code(int), headers(HTTPHeaderDict)) .. py:method:: find_all_admin_rules(**kwargs) find_all_admin_rules # noqa: E501 Returns an (optionally) paginated list of admin rules. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.find_all_admin_rules(async_req=True) >>> result = thread.get() :param limit: Maximum number of rules to return from the query. If there are more rules, the response will return an X-ACL-NEXTCURSOR header with a value that can be used for the nextCursor parameter on a subsequent request, until X-ACL-NEXTCURSOR is null :type limit: int :param next_cursor: The next cursor identifier when doing cursor paging, as returned by the X-ACL-NEXTCURSOR response header :type next_cursor: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: list[AdminRule] .. py:method:: find_all_admin_rules_with_http_info(**kwargs) find_all_admin_rules # noqa: E501 Returns an (optionally) paginated list of admin rules. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.find_all_admin_rules_with_http_info(async_req=True) >>> result = thread.get() :param limit: Maximum number of rules to return from the query. If there are more rules, the response will return an X-ACL-NEXTCURSOR header with a value that can be used for the nextCursor parameter on a subsequent request, until X-ACL-NEXTCURSOR is null :type limit: int :param next_cursor: The next cursor identifier when doing cursor paging, as returned by the X-ACL-NEXTCURSOR response header :type next_cursor: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(list[AdminRule], status_code(int), headers(HTTPHeaderDict)) .. py:method:: find_first_admin_rule(admin_rule_filter, **kwargs) find_first_admin_rule # noqa: E501 Finds the first rule that satisfies the query criteria # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.find_first_admin_rule(admin_rule_filter, async_req=True) >>> result = thread.get() :param admin_rule_filter: (required) :type admin_rule_filter: AdminRuleFilter :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: AdminRule .. py:method:: find_first_admin_rule_with_http_info(admin_rule_filter, **kwargs) find_first_admin_rule # noqa: E501 Finds the first rule that satisfies the query criteria # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.find_first_admin_rule_with_http_info(admin_rule_filter, async_req=True) >>> result = thread.get() :param admin_rule_filter: (required) :type admin_rule_filter: AdminRuleFilter :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(AdminRule, status_code(int), headers(HTTPHeaderDict)) .. py:method:: find_one_admin_rule_by_priority(priority, **kwargs) find_one_admin_rule_by_priority # noqa: E501 Finds the AdminRule with the given priority # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.find_one_admin_rule_by_priority(priority, async_req=True) >>> result = thread.get() :param priority: The rule priority to search for (required) :type priority: int :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: AdminRule .. py:method:: find_one_admin_rule_by_priority_with_http_info(priority, **kwargs) find_one_admin_rule_by_priority # noqa: E501 Finds the AdminRule with the given priority # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.find_one_admin_rule_by_priority_with_http_info(priority, async_req=True) >>> result = thread.get() :param priority: The rule priority to search for (required) :type priority: int :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(AdminRule, status_code(int), headers(HTTPHeaderDict)) .. py:method:: get_admin_rule_by_id(id, **kwargs) get_admin_rule_by_id # noqa: E501 Returns the AdminRule with the given identifier # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_admin_rule_by_id(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: AdminRule .. py:method:: get_admin_rule_by_id_with_http_info(id, **kwargs) get_admin_rule_by_id # noqa: E501 Returns the AdminRule with the given identifier # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_admin_rule_by_id_with_http_info(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(AdminRule, status_code(int), headers(HTTPHeaderDict)) .. py:method:: shift_admin_rules_by_piority(priority_start, offset, **kwargs) shift_admin_rules_by_piority # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.shift_admin_rules_by_piority(priority_start, offset, async_req=True) >>> result = thread.get() :param priority_start: The minimum priority to start shifting at (inclusive) (required) :type priority_start: int :param offset: The priority offset to apply to all rules from priorityStart onwards (required) :type offset: int :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: int .. py:method:: shift_admin_rules_by_piority_with_http_info(priority_start, offset, **kwargs) shift_admin_rules_by_piority # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.shift_admin_rules_by_piority_with_http_info(priority_start, offset, async_req=True) >>> result = thread.get() :param priority_start: The minimum priority to start shifting at (inclusive) (required) :type priority_start: int :param offset: The priority offset to apply to all rules from priorityStart onwards (required) :type offset: int :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(int, status_code(int), headers(HTTPHeaderDict)) .. py:method:: swap_admin_rules(id, id2, **kwargs) swap_admin_rules # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.swap_admin_rules(id, id2, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param id2: The admin rule identifier to swap priorities with (required) :type id2: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None .. py:method:: swap_admin_rules_with_http_info(id, id2, **kwargs) swap_admin_rules # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.swap_admin_rules_with_http_info(id, id2, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param id2: The admin rule identifier to swap priorities with (required) :type id2: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None .. py:method:: update_admin_rule(id, admin_rule, **kwargs) update_admin_rule # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update_admin_rule(id, admin_rule, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param admin_rule: (required) :type admin_rule: AdminRule :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: AdminRule .. py:method:: update_admin_rule_with_http_info(id, admin_rule, **kwargs) update_admin_rule # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update_admin_rule_with_http_info(id, admin_rule, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param admin_rule: (required) :type admin_rule: AdminRule :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(AdminRule, status_code(int), headers(HTTPHeaderDict)) .. py:class:: AuthorizationApi(api_client=None) Bases: :py:obj:`object` NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech Do not edit the class manually. .. py:attribute:: api_client .. py:method:: get_access_info(access_request, **kwargs) get_access_info # noqa: E501 Computes the grant access info for the given request # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_access_info(access_request, async_req=True) >>> result = thread.get() :param access_request: (required) :type access_request: AccessRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: AccessInfo .. py:method:: get_access_info_with_http_info(access_request, **kwargs) get_access_info # noqa: E501 Computes the grant access info for the given request # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_access_info_with_http_info(access_request, async_req=True) >>> result = thread.get() :param access_request: (required) :type access_request: AccessRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(AccessInfo, status_code(int), headers(HTTPHeaderDict)) .. py:method:: get_admin_authorization(admin_access_request, **kwargs) get_admin_authorization # noqa: E501 Computes info about admin authorization on a given workspace. Returned AccessInfo will always be ALLOW, with the computed adminRights. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_admin_authorization(admin_access_request, async_req=True) >>> result = thread.get() :param admin_access_request: (required) :type admin_access_request: AdminAccessRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: AdminAccessInfo .. py:method:: get_admin_authorization_with_http_info(admin_access_request, **kwargs) get_admin_authorization # noqa: E501 Computes info about admin authorization on a given workspace. Returned AccessInfo will always be ALLOW, with the computed adminRights. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_admin_authorization_with_http_info(admin_access_request, async_req=True) >>> result = thread.get() :param admin_access_request: (required) :type admin_access_request: AdminAccessRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(AdminAccessInfo, status_code(int), headers(HTTPHeaderDict)) .. py:method:: get_matching_rules(access_request, **kwargs) get_matching_rules # noqa: E501 Obtains the plain list of matching rules that are applied to the given AccessRequest when computing the AccessInfo # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_matching_rules(access_request, async_req=True) >>> result = thread.get() :param access_request: (required) :type access_request: AccessRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: list[Rule] .. py:method:: get_matching_rules_with_http_info(access_request, **kwargs) get_matching_rules # noqa: E501 Obtains the plain list of matching rules that are applied to the given AccessRequest when computing the AccessInfo # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_matching_rules_with_http_info(access_request, async_req=True) >>> result = thread.get() :param access_request: (required) :type access_request: AccessRequest :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(list[Rule], status_code(int), headers(HTTPHeaderDict)) .. py:class:: RulesApi(api_client=None) Bases: :py:obj:`object` NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech Do not edit the class manually. .. py:attribute:: api_client .. py:method:: count_all_rules(**kwargs) count_all_rules # noqa: E501 Returns the total number of rules # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count_all_rules(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: int .. py:method:: count_all_rules_with_http_info(**kwargs) count_all_rules # noqa: E501 Returns the total number of rules # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count_all_rules_with_http_info(async_req=True) >>> result = thread.get() :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(int, status_code(int), headers(HTTPHeaderDict)) .. py:method:: count_rules(rule_filter, **kwargs) count_rules # noqa: E501 Returns the number of rules that matches the search criteria # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count_rules(rule_filter, async_req=True) >>> result = thread.get() :param rule_filter: (required) :type rule_filter: RuleFilter :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: int .. py:method:: count_rules_with_http_info(rule_filter, **kwargs) count_rules # noqa: E501 Returns the number of rules that matches the search criteria # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.count_rules_with_http_info(rule_filter, async_req=True) >>> result = thread.get() :param rule_filter: (required) :type rule_filter: RuleFilter :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(int, status_code(int), headers(HTTPHeaderDict)) .. py:method:: create_rule(rule, **kwargs) create_rule # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_rule(rule, async_req=True) >>> result = thread.get() :param rule: (required) :type rule: Rule :param position: Displacement option related to how to interpret the Rule's priority :type position: InsertPosition :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: Rule .. py:method:: create_rule_with_http_info(rule, **kwargs) create_rule # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.create_rule_with_http_info(rule, async_req=True) >>> result = thread.get() :param rule: (required) :type rule: Rule :param position: Displacement option related to how to interpret the Rule's priority :type position: InsertPosition :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(Rule, status_code(int), headers(HTTPHeaderDict)) .. py:method:: delete_rule_by_id(id, **kwargs) delete_rule_by_id # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete_rule_by_id(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None .. py:method:: delete_rule_by_id_with_http_info(id, **kwargs) delete_rule_by_id # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.delete_rule_by_id_with_http_info(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None .. py:method:: find_one_rule_by_priority(priority, **kwargs) find_one_rule_by_priority # noqa: E501 Finds the Rule with the given priority # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.find_one_rule_by_priority(priority, async_req=True) >>> result = thread.get() :param priority: The rule priority to search for (required) :type priority: int :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: Rule .. py:method:: find_one_rule_by_priority_with_http_info(priority, **kwargs) find_one_rule_by_priority # noqa: E501 Finds the Rule with the given priority # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.find_one_rule_by_priority_with_http_info(priority, async_req=True) >>> result = thread.get() :param priority: The rule priority to search for (required) :type priority: int :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(Rule, status_code(int), headers(HTTPHeaderDict)) .. py:method:: get_layer_details_by_rule_id(id, **kwargs) get_layer_details_by_rule_id # noqa: E501 Returns the LayerDetails for the Rule with the given identifier # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_layer_details_by_rule_id(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: LayerDetails .. py:method:: get_layer_details_by_rule_id_with_http_info(id, **kwargs) get_layer_details_by_rule_id # noqa: E501 Returns the LayerDetails for the Rule with the given identifier # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_layer_details_by_rule_id_with_http_info(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(LayerDetails, status_code(int), headers(HTTPHeaderDict)) .. py:method:: get_rule_by_id(id, **kwargs) get_rule_by_id # noqa: E501 Returns the Rule with the given identifier # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_rule_by_id(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: Rule .. py:method:: get_rule_by_id_with_http_info(id, **kwargs) get_rule_by_id # noqa: E501 Returns the Rule with the given identifier # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_rule_by_id_with_http_info(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(Rule, status_code(int), headers(HTTPHeaderDict)) .. py:method:: get_rules(**kwargs) get_rules # noqa: E501 Returns an (optionally) paginated list of rules. See also the count operation. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_rules(async_req=True) >>> result = thread.get() :param limit: Maximum number of rules to return from the query. If there are more rules, the response will return an X-ACL-NEXTCURSOR header with a value that can be used for the nextCursor parameter on a subsequent request, until X-ACL-NEXTCURSOR is null :type limit: int :param next_cursor: The next cursor identifier when doing cursor paging, as returned by the X-ACL-NEXTCURSOR response header :type next_cursor: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: list[Rule] .. py:method:: get_rules_with_http_info(**kwargs) get_rules # noqa: E501 Returns an (optionally) paginated list of rules. See also the count operation. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.get_rules_with_http_info(async_req=True) >>> result = thread.get() :param limit: Maximum number of rules to return from the query. If there are more rules, the response will return an X-ACL-NEXTCURSOR header with a value that can be used for the nextCursor parameter on a subsequent request, until X-ACL-NEXTCURSOR is null :type limit: int :param next_cursor: The next cursor identifier when doing cursor paging, as returned by the X-ACL-NEXTCURSOR response header :type next_cursor: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(list[Rule], status_code(int), headers(HTTPHeaderDict)) .. py:method:: query_rules(**kwargs) query_rules # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.query_rules(async_req=True) >>> result = thread.get() :param limit: Maximum number of rules to return from the query. If there are more rules, the response will return an X-ACL-NEXTCURSOR header with a value that can be used for the nextCursor parameter on a subsequent request, until X-ACL-NEXTCURSOR is null :type limit: int :param next_cursor: The next cursor identifier when doing cursor paging, as returned by the X-ACL-NEXTCURSOR response header :type next_cursor: str :param rule_filter: :type rule_filter: RuleFilter :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: list[Rule] .. py:method:: query_rules_with_http_info(**kwargs) query_rules # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.query_rules_with_http_info(async_req=True) >>> result = thread.get() :param limit: Maximum number of rules to return from the query. If there are more rules, the response will return an X-ACL-NEXTCURSOR header with a value that can be used for the nextCursor parameter on a subsequent request, until X-ACL-NEXTCURSOR is null :type limit: int :param next_cursor: The next cursor identifier when doing cursor paging, as returned by the X-ACL-NEXTCURSOR response header :type next_cursor: str :param rule_filter: :type rule_filter: RuleFilter :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(list[Rule], status_code(int), headers(HTTPHeaderDict)) .. py:method:: rule_exists_by_id(id, **kwargs) rule_exists_by_id # noqa: E501 Returns the Rule with the given identifier # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.rule_exists_by_id(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: bool .. py:method:: rule_exists_by_id_with_http_info(id, **kwargs) rule_exists_by_id # noqa: E501 Returns the Rule with the given identifier # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.rule_exists_by_id_with_http_info(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(bool, status_code(int), headers(HTTPHeaderDict)) .. py:method:: set_rule_allowed_styles(id, **kwargs) set_rule_allowed_styles # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.set_rule_allowed_styles(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param request_body: :type request_body: list[str] :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None .. py:method:: set_rule_allowed_styles_with_http_info(id, **kwargs) set_rule_allowed_styles # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.set_rule_allowed_styles_with_http_info(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param request_body: :type request_body: list[str] :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None .. py:method:: set_rule_layer_details(id, **kwargs) set_rule_layer_details # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.set_rule_layer_details(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param layer_details: :type layer_details: LayerDetails :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None .. py:method:: set_rule_layer_details_with_http_info(id, **kwargs) set_rule_layer_details # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.set_rule_layer_details_with_http_info(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param layer_details: :type layer_details: LayerDetails :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None .. py:method:: set_rule_limits(id, **kwargs) set_rule_limits # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.set_rule_limits(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param rule_limits: :type rule_limits: RuleLimits :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None .. py:method:: set_rule_limits_with_http_info(id, **kwargs) set_rule_limits # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.set_rule_limits_with_http_info(id, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param rule_limits: :type rule_limits: RuleLimits :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None .. py:method:: shift_rules_by_priority(priority_start, offset, **kwargs) shift_rules_by_priority # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.shift_rules_by_priority(priority_start, offset, async_req=True) >>> result = thread.get() :param priority_start: The minimum priority to start shifting at (inclusive) (required) :type priority_start: int :param offset: The priority offset to apply to all rules from priorityStart onwards (required) :type offset: int :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: int .. py:method:: shift_rules_by_priority_with_http_info(priority_start, offset, **kwargs) shift_rules_by_priority # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.shift_rules_by_priority_with_http_info(priority_start, offset, async_req=True) >>> result = thread.get() :param priority_start: The minimum priority to start shifting at (inclusive) (required) :type priority_start: int :param offset: The priority offset to apply to all rules from priorityStart onwards (required) :type offset: int :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(int, status_code(int), headers(HTTPHeaderDict)) .. py:method:: swap_rules(id, id2, **kwargs) swap_rules # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.swap_rules(id, id2, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param id2: The rule identifier to swap priorities with (required) :type id2: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None .. py:method:: swap_rules_with_http_info(id, id2, **kwargs) swap_rules # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.swap_rules_with_http_info(id, id2, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param id2: The rule identifier to swap priorities with (required) :type id2: str :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: None .. py:method:: update_rule_by_id(id, rule, **kwargs) update_rule_by_id # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update_rule_by_id(id, rule, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param rule: (required) :type rule: Rule :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: Rule .. py:method:: update_rule_by_id_with_http_info(id, rule, **kwargs) update_rule_by_id # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.update_rule_by_id_with_http_info(id, rule, async_req=True) >>> result = thread.get() :param id: The rule identifier (required) :type id: str :param rule: (required) :type rule: Rule :param async_req: Whether to execute the request asynchronously. :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :type _content_type: string, optional: force content-type for the request :return: Returns the result object. If the method is called asynchronously, returns the request thread. :rtype: tuple(Rule, status_code(int), headers(HTTPHeaderDict))